Range consolidation

Range consolidation is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Define a range of numbers R, with bounds b0 and b1 covering all numbers between and including both bounds. That range can be shown as:

[b0, b1]

or equally as:

[b1, b0].

Given two ranges, the act of consolidation between them compares the two ranges:

• If one range covers all of the other then the result is that encompassing range.
• If the ranges touch or intersect then the result is one new single range covering the overlapping ranges.
• Otherwise the act of consolidation is to return the two non-touching ranges.

Given N ranges where N>2 then the result is the same as repeatedly replacing all combinations of two ranges by their consolidation until no further consolidation between range pairs is possible. If N<2 then range consolidation has no strict meaning and the input can be returned.

Example 1:

Given the two ranges [1, 2.5] and [3, 4.2] then there is no

common element between the ranges and the result is the same as the input.

Example 2:

Given the two ranges [1, 2.5] and [1.8, 4.7] then there is

an overlap [2.5, 1.8] between the ranges and the result is the single

range [1, 4.7]. Note that order of bounds in a range is not, (yet), stated.

Example 3:

Given the two ranges [6.1, 7.2] and [7.2, 8.3] then they

touch at 7.2 and the result is the single range [6.1, 8.3].

Example 4:

Given the three ranges [1, 2] and [4, 8] and [2, 5]

then there is no intersection of the ranges [1, 2] and [4, 8]

but the ranges [1, 2] and [2, 5] overlap and consolidate to

produce the range [1, 5]. This range, in turn, overlaps the other range

[4, 8], and so consolidates to the final output of the single range

[1, 8]

Task:

Let a normalized range display show the smaller bound to the left; and show the range with the smaller lower bound to the left of other ranges when showing multiple ranges.

Output the normalised result of applying consolidation to these five sets of ranges:

        [1.1, 2.2]
        [6.1, 7.2], [7.2, 8.3]
        [4, 3], [2, 1]
        [4, 3], [2, 1], [-1, -2], [3.9, 10]
        [1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]

Show output here.

Python

<lang python>def normalize(s):

   return sorted(sorted(bounds) for bounds in s if bounds)

def consolidate(ranges):

   norm = normalize(ranges)
   for i, r1 in enumerate(norm):
       if r1:
           for r2 in norm[i+1:]:
               if r2 and r1[-1] >= r2[0]:     # intersect?
                   r1[:] = [r1[0], max(r1[-1], r2[-1])]
                   r2.clear()
   return [rnge for rnge in norm if rnge]

if __name__ == '__main__':

   for s in [
           1.1, 2.2,
           [[6.1, 7.2], [7.2, 8.3]],
           [[4, 3], [2, 1]],
           [[4, 3], [2, 1], [-1, -2], [3.9, 10]],
           [[1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]],
           ]:
       print(f"{str(s)[1:-1]} => {str(consolidate(s))[1:-1]}")

</lang>

Output:

[1.1, 2.2] => [1.1, 2.2]
[6.1, 7.2], [7.2, 8.3] => [6.1, 8.3]
[4, 3], [2, 1] => [1, 2], [3, 4]
[4, 3], [2, 1], [-1, -2], [3.9, 10] => [-2, -1], [1, 2], [3, 10]
[1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6] => [-6, -1], [1, 8]