Range consolidation: Difference between revisions
Content deleted Content added
m →{{header|Haskell}}: Tidied |
Added Easylang |
||
(21 intermediate revisions by 15 users not shown) | |||
Line 1:
{{task}}
Define a range of numbers
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 region 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 ''normalized'' result of applying consolidation to these five sets of ranges: <big>
[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] </big>
Show all output here.
;See also:
* [[Set consolidation]]
* [[Set of real numbers]]
Line 55 ⟶ 69:
{{trans|Python}}
<
F normalize(s)
R sorted(s.filter(bounds -> !bounds.empty).map(bounds -> sorted(bounds)))
Line 75 ⟶ 89:
[[4.0, 3.0], [2.0, 1.0], [-1.0, -2.0], [3.9, 10.0]],
[[1.0, 3.0], [-6.0, -1.0], [-4.0, -5.0], [8.0, 2.0], [-6.0, -6.0]]]
print(String(s)[1 .< (len)-1]‘ => ’String(consolidate(s))[1 .< (len)-1])</
{{out}}
Line 84 ⟶ 98:
[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]
</pre>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
{{libheader|Action! Real Math}}
<syntaxhighlight lang="action!">INCLUDE "H6:REALMATH.ACT"
DEFINE PTR="CARD"
DEFINE RANGESIZE="12"
DEFINE LOW_="+0"
DEFINE HIGH_="+6"
TYPE Range=[CARD l1,l2,l3,h1,h2,h3]
PROC Inverse(Range POINTER r)
REAL tmp
RealAssign(r LOW_,tmp)
RealAssign(r HIGH_,r LOW_)
RealAssign(tmp,r HIGH_)
RETURN
PROC Normalize(Range POINTER r)
IF RealLess(r HIGH_,r LOW_) THEN
Inverse(r)
FI
RETURN
INT FUNC Compare(Range Pointer r1,r2)
IF RealLess(r1 LOW_,r2 LOW_) THEN
RETURN (-1)
ELSEIF RealLess(r2 LOW_,r1 LOW_) THEN
RETURN (1)
ELSEIF RealLess(r1 HIGH_,r2 HIGH_) THEN
RETURN (-1)
ELSEIF RealLess(r2 HIGH_,r1 HIGH_) THEN
RETURN (1)
FI
RETURN (0)
PTR FUNC GetItemAddr(PTR data INT index)
RETURN (data+index*RANGESIZE)
PROC Swap(Range POINTER r1,r2)
REAL tmp
RealAssign(r1 LOW_,tmp)
RealAssign(r2 LOW_,r1 LOW_)
RealAssign(tmp, r2 LOW_)
RealAssign(r1 HIGH_,tmp)
RealAssign(r2 HIGH_,r1 HIGH_)
RealAssign(tmp, r2 HIGH_)
RETURN
PROC Sort(PTR data INT count)
INT i,j,minpos
Range POINTER r1,r2
FOR i=0 TO count-2
DO
minpos=i
FOR j=i+1 TO count-1
DO
r1=GetItemAddr(data,minpos)
r2=GetItemAddr(data,j)
IF Compare(r1,r2)>0 THEN
minpos=j
FI
OD
IF minpos#i THEN
r1=GetItemAddr(data,minpos)
r2=GetItemAddr(data,i)
Swap(r1,r2)
FI
OD
RETURN
PROC Consolidate(PTR data INT POINTER count)
INT i,j,newCount
Range POINTER r1,r2
FOR i=0 TO count^-1
DO
r1=GetItemAddr(data,i)
Normalize(r1)
OD
Sort(data,count^)
newCount=0 i=0
WHILE i<count^
DO
j=i+1
WHILE j<count^
DO
r1=GetItemAddr(data,i)
r2=GetItemAddr(data,j)
IF RealLess(r1 HIGH_,r2 LOW_) THEN
EXIT
ELSEIF RealLess(r1 HIGH_,r2 HIGH_) THEN
RealAssign(r2 HIGH_,r1 HIGH_)
FI
j==+1
OD
r1=GetItemAddr(data,i)
r2=GetItemAddr(data,newCount)
RealAssign(r1 LOW_,r2 LOW_)
RealAssign(r1 HIGH_,r2 HIGH_)
newCount==+1
i=j
OD
count^=newCount
RETURN
PROC PrintRanges(PTR data INT count)
INT i
Range POINTER r
FOR i=0 TO count-1
DO
IF i>0 THEN Put(' ) FI
r=GetItemAddr(data,i)
Put('[) PrintR(r LOW_)
Put(',) PrintR(r HIGH_) Put('])
OD
RETURN
PROC Append(PTR data INT POINTER count
CHAR ARRAY sLow,sHigh)
Range POINTER r
r=GetItemAddr(data,count^)
ValR(sLow,r LOW_)
ValR(sHigh,r High_)
count^=count^+1
RETURN
INT FUNC InitData(BYTE case PTR data)
INT count
count=0
IF case=0 THEN
Append(data,@count,"1.1","2.2")
ELSEIF case=1 THEN
Append(data,@count,"6.1","7.2")
Append(data,@count,"7.2","8.3")
ELSEIF case=2 THEN
Append(data,@count,"4","3")
Append(data,@count,"2","1")
ELSEIF case=3 THEN
Append(data,@count,"4","3")
Append(data,@count,"2","1")
Append(data,@count,"-1","-2")
Append(data,@count,"3.9","10")
ELSEIF case=4 THEN
Append(data,@count,"1","3")
Append(data,@count,"-6","-1")
Append(data,@count,"-4","-5")
Append(data,@count,"8","2")
Append(data,@count,"-6","-6")
FI
RETURN (count)
PROC Main()
BYTE ARRAY data(100)
INT count
BYTE i
Put(125) PutE() ;clear the screen
FOR i=0 TO 4
DO
count=InitData(i,data)
PrintRanges(data,count)
Print(" -> ")
Consolidate(data,@count)
PrintRanges(data,count)
PutE() PutE()
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Range_consolidation.png Screenshot from Atari 8-bit computer]
<pre>
[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]
</pre>
=={{header|Ada}}==
<
with Ada.Containers.Vectors;
Line 173 ⟶ 377:
Show (Set_4);
Show (Set_5);
end Range_Consolidation;</
{{out}}
Line 182 ⟶ 386:
( 4.0 3.0) ( 2.0 1.0) ( -1.0 -2.0) ( 3.9 10.0) ( -2.0 -1.0) ( 1.0 2.0) ( 3.0 10.0)
( 1.0 3.0) ( -6.0 -1.0) ( -4.0 -5.0) ( 8.0 2.0) ( -6.0 -6.0) ( -6.0 -1.0) ( 1.0 8.0)
</pre>
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">
BEGIN # range consolidation #
MODE RANGE = STRUCT( REAL lb, ub );
# returns a with the bounds swapped if necessary, so lb OF a <= ub OF a #
OP NORMALISE = ( RANGE a )RANGE:
( IF lb OF a < ub OF a THEN lb OF a ELSE ub OF a FI
, IF ub OF a > lb OF a THEN ub OF a ELSE lb OF a FI
) # NORMALISE # ;
# returns a with each element normalised #
OP NORMALISE = ( []RANGE a )[]RANGE:
BEGIN
[ LWB a : UPB a ]RANGE result;
FOR a pos FROM LWB a TO UPB a DO result[ a pos ] := NORMALISE a[ a pos ] OD;
result
END # NORMALISE # ;
OP < = ( RANGE a, b )BOOL: lb OF a < lb OF b;
OP > = ( RANGE a, b )BOOL: lb OF a > lb OF b;
# sorts a into order of each element's lb #
OP SORT = ( []RANGE a )[]RANGE:
BEGIN
# in-place quick sort an array of RANGEs from element lb #
# to element ub #
PROC quicksort = ( REF[]RANGE a, INT lb, ub )REF[]RANGE:
IF ub <= lb
THEN
# empty array or only 1 element #
a
ELSE
# more than one element, so must sort #
INT left := lb;
INT right := ub;
# choosing the middle element of the array as the pivot #
RANGE pivot := a[ left + ( ( right + 1 ) - left ) OVER 2 ];
WHILE
WHILE IF left <= ub THEN a[ left ] < pivot ELSE FALSE FI DO left +:= 1 OD;
WHILE IF right >= lb THEN a[ right ] > pivot ELSE FALSE FI DO right -:= 1 OD;
left <= right
DO
RANGE t := a[ left ];
a[ left ] := a[ right ];
a[ right ] := t;
left +:= 1;
right -:= 1
OD;
quicksort( a, lb, right );
quicksort( a, left, ub );
a
FI # quicksort # ;
quicksort( HEAP[ LWB a : UPB a ]RANGE := a, LWB a, UPB a )
END # SORT # ;
# returns the consolidation of the ranges in a in #
OP CONSOLIDATE = ( []RANGE a in )[]RANGE:
IF UPB a in <= LWB a in
THEN a in # 0 or 1 range #
ELSE # multiple ranges #
[]RANGE a = SORT NORMALISE a in;
[ 1 : 2 * ( ( UPB a - LWB a ) + 1 ) ]RANGE result;
INT r max := 1;
result[ r max ] := a[ LWB a ];
FOR a pos FROM LWB a + 1 TO UPB a DO
RANGE m = result[ r max ], n = a[ a pos ];
IF ub OF m < lb OF n THEN
result[ r max +:= 1 ] := n # distinct ranges #
ELSE
result[ r max ] # overlapping ranges #
:= ( IF lb OF m < lb OF n THEN lb OF m ELSE lb OF n FI
, IF ub OF m > ub OF n THEN ub OF m ELSE ub OF n FI
)
FI
OD;
result[ : r max ]
FI # CONSOLIDATE # ;
OP FMT = ( REAL v )STRING: # prints v with at most 3 decimal places #
BEGIN
STRING result := fixed( ABS v, 0, 3 );
IF result[ LWB result ] = "." THEN "0" +=: result FI;
WHILE result[ UPB result ] = "0" DO result := result[ : UPB result - 1 ] OD;
IF result[ UPB result ] = "." THEN result := result[ : UPB result - 1 ] FI;
IF v < 0 THEN "-" ELSE "" FI + result
END # FMT # ;
OP TOSTRING = ( RANGE a )STRING: "[ " + FMT lb OF a + ", " + FMT ub OF a + " ]";
OP TOSTRING = ( []RANGE a )STRING:
BEGIN
STRING result := "[";
STRING prefix := " ";
FOR r pos FROM LWB a TO UPB a DO
result +:= prefix + TOSTRING a[ r pos ];
prefix := ", "
OD;
result + " ]"
END # TOSTRING # ;
PRIO PAD = 8; # right pads s with blanks to w characters #
OP PAD = ( STRING s, INT w )STRING:
IF INT len = ( UPB s - LWB s ) + 1;
len >= w
THEN s
ELSE s + ( ( w - len ) * " " )
FI # PAD # ;
# task test cases #
PROC test = ( []RANGE a )VOID:
BEGIN print( ( ( TOSTRING a PAD 60 ), " -> ", TOSTRING CONSOLIDATE a, newline ) ) END;
test( []RANGE( RANGE( 1.1, 2.2 ) ) );
test( ( ( 6.1, 7.2 ), ( 7.2, 8.3 ) ) );
test( ( ( 4, 3 ), ( 2, 1 ) ) );
test( ( ( 4, 3 ), ( 2, 1 ), ( -1, -2 ), ( 3.9, 10 ) ) );
test( ( ( 1, 3 ), ( -6, -1 ), ( -4, -5 ), ( 8, 2 ), ( -6, -6 ) ) )
END
</syntaxhighlight>
{{out}}
<pre>
[ [ 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 ] ]
</pre>
=={{header|AutoHotkey}}==
<
arr1 := [], arr2 := [], result := []
Line 202 ⟶ 533:
result[i-1, 2] := stop > result[i-1, 2] ? stop : result[i-1, 2]
return result
}</
Examples:<
test2 := [[6.1, 7.2], [7.2, 8.3]]
test3 := [[4, 3], [2, 1]]
Line 218 ⟶ 549:
}
MsgBox % result
return</
{{out}}
<pre>[1.1, 2.2]
Line 227 ⟶ 558:
=={{header|C}}==
<
#include <stdlib.h>
Line 316 ⟶ 647:
test_consolidate_ranges(test5, LENGTHOF(test5));
return 0;
}</
{{out}}
Line 329 ⟶ 660:
=={{header|C sharp}}==
{{works with|C sharp|7}}
<
using System.Linq;
using System;
Line 367 ⟶ 698:
private static (double s, double e) Normalize((double s, double e) range) =>
(Min(range.s, range.e), Max(range.s, range.e));
}</
{{out}}
<pre>
Line 377 ⟶ 708:
=={{header|C++}}==
<
#include <iostream>
#include <utility>
Line 446 ⟶ 777:
}
return 0;
}</
{{out}}
Line 459 ⟶ 790:
=={{header|Clojure}}==
<
(let [[n1 n2] r]
[(min n1 n2) (max n1 n2)]))
Line 484 ⟶ 815:
(remove #(contains? (set used) %) rs))]
(recur (conj res (consolidate-touching-ranges touching))
(remove-used (rest rs) touching))))))</
{{out}}
Line 506 ⟶ 837:
{{trans|C#}}
<
func Pt.
func Pt.
func Pt.
let rng = [
[ Pt(1.1, 2.2) ],
Line 519 ⟶ 850:
[ Pt(1.0, 3.0), Pt(-6, -1), Pt(-4, -5), Pt(8, 2), Pt(-6, -6) ]
]
func overlap(left, right) =>
left.Max() > right.Max() ? right.
func consolidate(left, right) => Pt(min(left.
func normalize(range) => Pt(range.
for list in rng {
var z = list.
while z >= 1 {
for y in (z - 1)^-1..0 when overlap(list[z], list[y]) {
list[y] = consolidate(list[z], list[y])
break list.
}
z -= 1
}
for i in list.
list[i] = normalize(list[i])
}
list.
print(list)
}</
{{out}}
Line 555 ⟶ 885:
[(-1, 2), (3, 10)]
[(-6, -1), (1, 8)]</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang=text>
proc sort . d[][] .
n = len d[][]
for i = 1 to n - 1
for j = i + 1 to n
if d[j][1] < d[i][1]
swap d[j][] d[i][]
.
.
.
.
func[][] consolidate a[][] .
for i to len a[][]
if a[i][1] > a[i][2]
swap a[i][1] a[i][2]
.
.
sort a[][]
r[][] &= a[1][]
b = a[1][2]
for i = 2 to len a[][]
if a[i][1] > b
r[$][2] = b
r[][] &= a[i][]
b = a[i][2]
else
b = higher b a[i][2]
.
.
r[$][2] = b
return r[][]
.
print consolidate [ [ 1.1 2.2 ] ]
print consolidate [ [ 6.1 7.2 ] [ 7.2 8.3 ] ]
print consolidate [ [ 4 3 ] [ 2 1 ] ]
print consolidate [ [ 4 3 ] [ 2 1 ] [ -1 -2 ] [ 3.9 10 ] ]
print consolidate [ [ 1 3 ] [ -6 -1 ] [ -4 -5 ] [ 8 2 ] [ -6 -6 ] ]
</syntaxhighlight>
{{out}}
<pre>
[
[ 1.10 2.20 ]
]
[
[ 6.10 8.30 ]
]
[
[ 1 2 ]
[ 3 4 ]
]
[
[ -2 -1 ]
[ 1 2 ]
[ 3 10 ]
]
[
[ -6 -1 ]
[ 1 8 ]
]
</pre>
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<syntaxhighlight lang="factor">USING: arrays combinators formatting kernel math.combinatorics
math.order math.statistics sequences sets sorting ;
: overlaps? ( pair pair -- ? )
2dup swap [ [ first2 between? ] curry any? ] 2bi@ or ;
: merge ( seq -- newseq ) concat minmax 2array 1array ;
: merge1 ( seq -- newseq )
dup 2 [ first2 overlaps? ] find-combination
[ [ without ] keep merge append ] when* ;
: normalize ( seq -- newseq ) [ natural-sort ] map ;
: consolidate ( seq -- newseq )
normalize [ merge1 ] to-fixed-point natural-sort ;
{
{ { 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 } }
} [ dup consolidate "%49u => %u\n" printf ] each</syntaxhighlight>
{{out}}
<pre>
{ { 1.1 2.2 } } => { { 1.1 2.2 } }
{ { 6.1 7.2 } { 7.2 8.300000000000001 } } => { { 6.1 8.300000000000001 } }
{ { 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 } }
</pre>
=={{header|FreeBASIC}}==
{{trans|Yabasic}}
<syntaxhighlight lang="freebasic">
Dim Shared As Integer i
Dim Shared As Single items, temp = 10^30
Sub ordenar(tabla() As Single)
Dim As Integer t1, t2
Dim As Boolean s
Do
s = True
For i = 1 To Ubound(tabla)-1
If tabla(i, 1) > tabla(i+1, 1) Then
t1 = tabla(i, 1) : t2 = tabla(i, 2)
tabla(i, 1) = tabla(i + 1, 1) : tabla(i, 2) = tabla(i + 1, 2)
tabla(i + 1, 1) = t1 : tabla(i + 1, 2) = t2
s = False
End If
Next i
Loop Until(s)
End Sub
Sub normalizar(tabla() As Single)
Dim As Integer t
For i = 1 To Ubound(tabla)
If tabla(i, 1) > tabla(i, 2) Then
t = tabla(i, 1)
tabla(i, 1) = tabla(i, 2)
tabla(i, 2) = t
End If
Next i
ordenar(tabla())
End Sub
Sub consolidar(tabla() As Single)
normalizar(tabla())
For i = 1 To Ubound(tabla)-1
If tabla(i + 1, 1) <= tabla(i, 2) Then
tabla(i + 1, 1) = tabla(i, 1)
If tabla(i + 1, 2) <= tabla(i, 2) Then
tabla(i + 1, 2) = tabla(i, 2)
End If
tabla(i, 1) = temp : tabla(i, 2) = temp
End If
Next i
End Sub
Data 1, 1.1, 2.2
Data 2, 6.1, 7.2, 7.2, 8.3
Data 2, 4, 3, 2, 1
Data 4, 4, 3, 2, 1, -1, -2, 3.9, 10
Data 5, 1,3, -6,-1, -4,-5, 8,2, -6,-6
For j As Byte = 1 To 5
Read items
Dim As Single tabla(items, 2)
For i = 1 To items
Read tabla(i, 1), tabla(i, 2)
Next i
consolidar(tabla())
For i = 1 To items
If tabla(i, 1) <> temp Then Print "[";tabla(i, 1); ", "; tabla(i, 2); "] ";
Next i
Print
Next j
Sleep
</syntaxhighlight>
=={{header|Go}}==
<
import (
Line 631 ⟶ 1,135:
fmt.Println(s[1 : len(s)-1])
}
}</
{{out}}
Line 643 ⟶ 1,147:
=={{header|Haskell}}==
<
import Data.Ord (comparing)
Line 649 ⟶ 1,153:
consolidated :: [(Float, Float)] -> [(Float, Float)]
consolidated
where
go
| y
| a
Line 727 ⟶ 1,231:
showNum n
| 0 == (n - fromIntegral (round n)) = show (round n)
| otherwise = show n</
{{Out}}
<pre>Range consolidations:
Line 739 ⟶ 1,243:
=={{header|J}}==
'''Solution:'''
<
normalise=: ([: /:~ /:~"1)@ensure2D NB. normalises list of ranges
merge=: ,:`(<.&{. , >.&{:)@.(>:/&{: |.) NB. merge ranges x and y
consolidate=: (}.@] ,~ (merge {.)) ensure2D</
'''Required Examples:'''
<
1.1 2.2
6.1 7.2 ,: 7.2 8.3
Line 757 ⟶ 1,261:
| | |3 4| 1 2| 1 8|
| | | | 3 10| |
+-------+-------+---+-----+-----+</
=={{header|Java}}==
<
import java.util.ArrayList;
import java.util.Arrays;
Line 870 ⟶ 1,374:
}
</syntaxhighlight>
{{out}}
Line 888 ⟶ 1,392:
{{Trans|Haskell}}
{{Trans|Python}}
<
'use strict';
Line 1,064 ⟶ 1,568:
// MAIN ---
return main();
})();</
{{Out}}
<pre>Range consolidations:
Line 1,072 ⟶ 1,576:
[[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]]</pre>
=={{header|jq}}==
{{trans|Julia}}
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">def normalize: map(sort) | sort;
def consolidate:
normalize
| length as $length
| reduce range(0; $length) as $i (.;
.[$i] as $r1
| if $r1 != []
then reduce range($i+1; $length) as $j (.;
.[$j] as $r2
| if $r2 != [] and ($r1[-1] >= $r2[0]) # intersect?
then .[$i] = [$r1[0], ([$r1[-1], $r2[-1]]|max)]
| .[$j] = []
else .
end )
else .
end )
| map(select(. != [])) ;
def testranges:
[[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]]
| "\(.) => \(consolidate)"
;
testranges</syntaxhighlight>
{{out}}
<pre>
[[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],[-5,-4],[1,8]]
</pre>
=={{header|Julia}}==
Line 1,079 ⟶ 1,626:
of the Python code is done, rather than using a native Julia Range.
{{trans|Python}}
<
function consolidate(ranges)
Line 1,105 ⟶ 1,652:
testranges()
</
<pre>
Array{Float64,1}[[1.1, 2.2]] => Array{Float64,1}[[1.1, 2.2]]
Line 1,115 ⟶ 1,662:
=={{header|Kotlin}}==
<
{
return ranges
Line 1,180 ⟶ 1,727:
inputRanges.associateBy(Any::toString, ::consolidateDoubleRanges).forEach({ println("${it.key} => ${it.value}") })
}</
{{Out}}
Line 1,190 ⟶ 1,737:
[[1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]] => [[-6.0, -1.0], [1.0, 8.0]]
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Using the Wolfram Language's built-in Interval operations:
<syntaxhighlight lang="mathematica">data={{{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}}};
Column[IntervalUnion@@@Map[Interval,data,{2}]]</syntaxhighlight>
{{out}}
<pre>Interval[{1.1,2.2}]
Interval[{6.1,8.3}]
Interval[{1,2},{3,4}]
Interval[{-2,-1},{1,2},{3,10}]
Interval[{-6,-1},{1,8}]</pre>
=={{header|newLISP}}==
<syntaxhighlight lang="newlisp">
(define (norm range) (sort range))
(define (overlap? a b) (>= (a 1) (b 0)))
(define (combine)
(list ($args 0 0) (max ($args 1 1) ($args 0 1))))
(define (foo ranges)
(set 'ranges (map norm ranges))
(set 'ranges (sort ranges))
(let (accum '() item)
(dolist (r ranges)
(set 'item (cond ((empty? accum) r)
((overlap? (accum 0) r)
(combine (pop accum) r))
(true r)))
(push item accum))
(reverse accum)))
(foo '((1.1 2.2)))
((1.1 2.2))
(foo '((6.1 7.2) (7.2 8.3)))
((6.1 8.300000000000001))
(foo '((4 3) (2 1)))
((1 2) (3 4))
(foo '((4 3) (2 1) (-1 -2) (3.9 10)))
((-2 -1) (1 2) (3 10))
(foo '((1 3) (-6 -1) (-4 -5) (8 2) (-6 -6)))
((-6 -1) (1 8))
</syntaxhighlight>
=={{header|Nim}}==
<
# Definition of a range of values of type T.
Line 1,246 ⟶ 1,848:
test([4, 3], [2, 1])
test([4.0, 3.0], [2.0, 1.0], [-1.0, -2.0], [3.9, 10.0])
test([1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6])</
{{out}}
Line 1,259 ⟶ 1,861:
Note: the output is shown in the standard [https://perldoc.perl.org/perlop.html#Range-Operators Perl notation for Ranges].
<
use warnings;
Line 1,289 ⟶ 1,891:
$out .= join('..', @$_). ' ' for consolidate($intervals);
printf "%44s => %s\n", $in, $out;
}</
{{out}}
<pre> [1.1, 2.2] => 1.1..2.2
Line 1,298 ⟶ 1,900:
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">consolidate</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">sets</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sets</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">l</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">l</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">atom</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">rs</span><span style="color: #0000FF;">,</span><span style="color: #000000;">re</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sets</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rs</span><span style="color: #0000FF;">></span><span style="color: #000000;">re</span><span style="color: #0000FF;">?{</span><span style="color: #000000;">re</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rs</span><span style="color: #0000FF;">}:{</span><span style="color: #000000;">rs</span><span style="color: #0000FF;">,</span><span style="color: #000000;">re</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">l</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">atom</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">il</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ih</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">l</span> <span style="color: #008080;">to</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">atom</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">jl</span><span style="color: #0000FF;">,</span><span style="color: #000000;">jh</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span>
<span style="color: #004080;">bool</span> <span style="color: #000000;">overlap</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">il</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">jl</span><span style="color: #0000FF;">?</span><span style="color: #000000;">jl</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">ih</span><span style="color: #0000FF;">:</span><span style="color: #000000;">il</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">jh</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">overlap</span> <span style="color: #008080;">then</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">il</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ih</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">min</span><span style="color: #0000FF;">(</span><span style="color: #000000;">il</span><span style="color: #0000FF;">,</span><span style="color: #000000;">jl</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">max</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ih</span><span style="color: #0000FF;">,</span><span style="color: #000000;">jh</span><span style="color: #0000FF;">)}</span>
<span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">l</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">l</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">il</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ih</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">l</span><span style="color: #0000FF;">])</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">set</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%40v => %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">set</span><span style="color: #0000FF;">,</span><span style="color: #000000;">consolidate</span><span style="color: #0000FF;">(</span><span style="color: #000000;">set</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">1.1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2.2</span><span style="color: #0000FF;">}})</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">6.1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7.2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">7.2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8.3</span><span style="color: #0000FF;">}})</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}})</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},{-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">3.9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">}})</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">},{-</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},{-</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">5</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">},{-</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">6</span><span style="color: #0000FF;">}})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,334 ⟶ 1,947:
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<
normalize(Ranges, Normalized),
sort(Normalized, Sorted),
Line 1,376 ⟶ 1,989:
(consolidate_ranges(Ranges, Consolidated),
write_ranges(Ranges), write(' -> '),
write_ranges(Consolidated), nl)).</
{{out}}
Line 1,389 ⟶ 2,002:
=={{header|Python}}==
===Procedural===
<
return sorted(sorted(bounds) for bounds in s if bounds)
Line 1,411 ⟶ 2,024:
]:
print(f"{str(s)[1:-1]} => {str(consolidate(s))[1:-1]}")
</syntaxhighlight>
{{out}}
Line 1,426 ⟶ 2,039:
{{Trans|Haskell}}
{{Works with|Python|3.7}}
<
from functools import reduce
Line 1,513 ⟶ 2,126:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>Consolidation of numeric ranges:
Line 1,524 ⟶ 2,137:
=={{header|Racket}}==
<
;; Racket's max and min allow inexact numbers to contaminate exact numbers
Line 1,551 ⟶ 2,164:
([1 3] [-6 -1] [-4 -5] [8 2] [-6 -6])))
(for ([xs (in-list inputs)]) (printf "~a => ~a\n" xs (solve xs)))</
{{out}}
Line 1,569 ⟶ 2,182:
Note: the output is in standard [https://docs.raku.org/type/Range Raku notation for Ranges].
<syntaxhighlight lang="raku"
sub infix:<∪> (Range $a, Range $b) { Range.new($a.min,max($a.max,$b.max)) }
Line 1,595 ⟶ 2,208:
printf "%46s => ", @intervals.raku;
say reverse consolidate |@intervals.grep(*.elems)».sort.sort({ [.[0], .[*-1]] }).map: { Range.new(.[0], .[*-1]) }
}</
{{out}}
<pre> [[1.1, 2.2],] => (1.1..2.2)
Line 1,608 ⟶ 2,221:
The actual logic for the range consolidation is marked with the comments: <big> <tt> /*■■■■►*/ </tt> </big>
<
#.= /*define the default for range sets. */
parse arg #.1 /*obtain optional arguments from the CL*/
Line 1,662 ⟶ 2,275:
do k=j+1 to n; if word(@.k,1)>=word(_,1) then iterate; @.j=@.k; @.k=_; _=@.j
end /*k*/
end /*j*/; return</
{{out|output|text= when using the default inputs:}}
<pre>
Line 1,683 ⟶ 2,296:
original ranges: []
consolidated ranges: []
</pre>
=={{header|RPL}}==
{{works with|RPL|HP-48R}}
« 1 OVER SIZE '''FOR''' j
j DUP2 GET V→
'''IF''' DUP2 > '''THEN''' SWAP '''END'''
→V2 PUT
'''NEXT'''
» <span style="color:blue">RNGNORM</span>' STO
« LIST→ → len
« len 1 '''FOR''' n
1 n 1 - '''START'''
DUP2 - DUP 1 GET
SWAP V→ IFTE
'''IF''' 0 > '''THEN''' SWAP '''END'''
n ROLLD
'''NEXT''' n ROLLD
-1 '''STEP'''
len →LIST
» » '<span style="color:blue">RNGSORT</span>' STO
« <span style="color:blue">RNGNORM</span>
'''IF''' DUP SIZE 2 ≥ '''THEN'''
<span style="color:blue">RNGSORT</span> → ranges
« { } ranges 1 GET
2 ranges SIZE '''FOR''' j
ranges j GET
'''IF''' OVER 2 GET OVER 1 GET ≥
'''THEN''' SWAP V→ ROT V→ SWAP DROP MAX →V2
'''ELSE''' ROT ROT + SWAP END
'''NEXT''' +
» '''END'''
» '<span style="color:blue">RNGCONSO</span>' STO
{ { [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]} }
1 « <span style="color:blue">RNGCONSO</span> » DOLIST
{{out}}
<pre>
1: { { [ 1.1 2.2 ] }
{ [ 6.1 8.3 ] }
{ [ 1 2 ] [ 3 4 ] }
{ [ -2 -1 ] [ 1 2 ] [ 3 10 ] }
{ [ -6 -1 ] [ 1 8 ] } }
</pre>
Line 1,690 ⟶ 2,353:
The algorithm relies on normalizing the ranges and folding a sorted sequence of them.
<
// We could use std::ops::RangeInclusive, but we would have to extend it to
Line 1,843 ⟶ 2,506:
println!("Run: cargo test -- --nocapture");
}</
{{out}}
Line 1,860 ⟶ 2,523:
test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
</pre>
=={{header|SQL}}==
{{works with|ORACLE 19c}}
This is not a particularly efficient solution, but it gets the job done.
<syntaxhighlight lang="sql">
/*
This code is an implementation of "Range consolidation" in SQL ORACLE 19c
p_list_of_sets -- input string
delimeter by default "|"
*/
with
function range_consolidation(p_list_of_sets in varchar2)
return varchar2 is
--
v_list_of_sets varchar2(32767) := p_list_of_sets;
v_output varchar2(32767);
v_set_1 varchar2(2000);
v_set_2 varchar2(2000);
v_pos_set_1 pls_integer;
v_pos_set_2 pls_integer;
v_set_1_min number;
v_set_1_max number;
v_set_2_min number;
v_set_2_max number;
--
function sort_set(p_in_str varchar2)
return varchar2 is
v_out varchar2(32767) := p_in_str;
begin
--
with out_tab as
(select to_number(regexp_substr(str, '[^,]+', 1, rownum, 'c', 0)) elem
from
(select p_in_str as str
from dual
)
connect by level <= regexp_count(str, '[^,]+')
)
select min(elem)||','||max(elem) end
into v_out
from out_tab;
--
return v_out;
end;
--
function sort_output(p_in_str varchar2)
return varchar2 is
v_out varchar2(32767) := p_in_str;
begin
--
with out_tab as
(select to_number(regexp_substr(regexp_substr(str, '[^|]+', 1, rownum, 'c', 0), '[^,]+', 1, 1)) low_range
, regexp_substr(str, '[^|]+', 1, rownum, 'c', 0) range_def
from
(select p_in_str as str
from dual
)
connect by level <= regexp_count(str, '[^|]+')
)
select listagg(range_def, '|') within group(order by low_range)
into v_out
from out_tab;
--
return v_out;
end;
--
begin
--
execute immediate ('alter session set NLS_NUMERIC_CHARACTERS = ''.,''');
--
--cleaning
v_list_of_sets := ltrim(v_list_of_sets, '[');
v_list_of_sets := rtrim(v_list_of_sets, ']');
v_list_of_sets := replace(v_list_of_sets, ' ', '');
--set delimeter "|"
v_list_of_sets := regexp_replace(v_list_of_sets, '\]\,\[', '|', 1, 0);
--
<<loop_through_sets>>
while regexp_count(v_list_of_sets, '[^|]+') > 0
loop
v_set_1 := regexp_substr(v_list_of_sets, '[^|]+', 1, 1);
v_list_of_sets := regexp_replace(v_list_of_sets, v_set_1, sort_set(v_set_1), 1, 1);
v_set_1 := sort_set(v_set_1);
v_pos_set_1 := regexp_instr(v_list_of_sets, '[^|]+', 1, 1);
--
v_set_1_min := least(to_number(regexp_substr(v_set_1, '[^,]+', 1, 1)),to_number(regexp_substr(v_set_1, '[^,]+', 1, 2)));
v_set_1_max := greatest(to_number(regexp_substr(v_set_1, '[^,]+', 1, 1)),to_number(regexp_substr(v_set_1, '[^,]+', 1, 2)));
--
<<loop_for>>
for i in 1..regexp_count(v_list_of_sets, '[^|]+')-1
loop
--
v_set_2 := regexp_substr(v_list_of_sets, '[^|]+', 1, i+1);
v_list_of_sets := regexp_replace(v_list_of_sets, v_set_2, sort_set(v_set_2), 1, 1);
v_set_2 := sort_set(v_set_2);
v_pos_set_2 := regexp_instr(v_list_of_sets, '[^|]+', 1, i+1);
v_set_2_min := least(to_number(regexp_substr(v_set_2, '[^,]+', 1, 1)),to_number(regexp_substr(v_set_2, '[^,]+', 1, 2)));
v_set_2_max := greatest(to_number(regexp_substr(v_set_2, '[^,]+', 1, 1)),to_number(regexp_substr(v_set_2, '[^,]+', 1, 2)));
--
if greatest(v_set_1_min,v_set_2_min)-least(v_set_1_max,v_set_2_max) <= 0 then --overlapping
v_list_of_sets := regexp_replace(v_list_of_sets, v_set_1, ''||least(v_set_1_min,v_set_2_min)||','||greatest(v_set_1_max,v_set_2_max),v_pos_set_1,1);
v_list_of_sets := regexp_replace(v_list_of_sets, v_set_2, '', v_pos_set_2, 1);
continue loop_through_sets;
end if;
--
end loop loop_for;
--
v_output := ltrim(v_output||'|'||least(v_set_1_min,v_set_1_max)||', '||greatest(v_set_1_min,v_set_1_max),'|');
--
v_output := sort_output(v_output);
v_list_of_sets := regexp_replace(v_list_of_sets,v_set_1,'',1,1);
--
end loop loop_through_sets;
--
return '['||replace(v_output,'|','], [')||']';
end;
--Test
select lpad('[]',50) || ' ==> ' || range_consolidation('[]') as output from dual
union all
select lpad('[],[]',50) || ' ==> ' || range_consolidation('[],[]') as output from dual
union all
select lpad('[],[1,1]',50) || ' ==> ' || range_consolidation('[],[1,1]') as output from dual
union all
select lpad('[1.3]',50) || ' ==> ' || range_consolidation('[1.3]') as output from dual
union all
select lpad('[2,2],[1]',50) || ' ==> ' || range_consolidation('[2,2],[1]') as output from dual
union all
select lpad('[4,-1,0,1,5,7,7,7],[9,6,9,6,9]',50) || ' ==> ' || range_consolidation('[4,-1,0,1,5,7,7,7],[9,6,9,6,9]') as output from dual
union all
--Test RosettaCode
select '-- Test RosettaCode' as output from dual
union all
select lpad('[1.1, 2.2]',50) || ' ==> ' || range_consolidation('[1.1, 2.2]') as output from dual
union all
select lpad('[6.1, 7.2], [7.2, 8.3]',50) || ' ==> ' || range_consolidation('[6.1, 7.2], [7.2, 8.3]') as output from dual
union all
select lpad('[4, 3], [2, 1]',50) || ' ==> ' || range_consolidation('[4, 3], [2, 1]') as output from dual
union all
select lpad('[4, 3], [2, 1], [-1, -2], [3.9, 10]',50) || ' ==> ' || range_consolidation('[4, 3], [2, 1], [-1, -2], [3.9, 10]') as output from dual
union all
select lpad('[1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]',50) || ' ==> ' || range_consolidation('[1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]') as output from dual
union all
select lpad('1,3|-6,-1|-4,-5|8,2|-6,-6',50) || ' ==> ' || range_consolidation('1,3|-6,-1|-4,-5|8,2|-6,-6') as output from dual
/
;
/
</syntaxhighlight>
{{out}}
<pre>
[] ==> []
[],[] ==> []
[],[1,1] ==> [1, 1]
[1.3] ==> [1.3, 1.3]
[2,2],[1] ==> [1, 1], [2, 2]
[4,-1,0,1,5,7,7,7],[9,6,9,6,9] ==> [-1, 9]
-- Test RosettaCode
[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]
1,3|-6,-1|-4,-5|8,2|-6,-6 ==> [-6, -1], [1, 8]
</pre>
=={{header|Wren}}==
As Wren already has a built-in Range class (which is not quite the same as what's required here), we create a Span class instead.
<syntaxhighlight lang="wren">class Span {
construct new(r) {
if (r.type != Range || !r.isInclusive) Fiber.abort("Argument must be an inclusive range.")
Line 1,885 ⟶ 2,711:
if (_high < r.low) return [this, r]
if (r.high < _low) return [r, this]
return [Span.new(
}
Line 1,922 ⟶ 2,748:
System.print(spanList.toString[1..-2])
}
}</
{{out}}
Line 1,934 ⟶ 2,760:
=={{header|Yabasic}}==
<
local items, i, t1, t2, s
Line 2,004 ⟶ 2,830:
for i = 1 to items
if tabla(i, 1) <> void print tabla(i, 1), "..", tabla(i, 2);
next</
=={{header|zkl}}==
<
(s:=List()).append(
normalize(rs).reduce('wrap(ab,cd){
Line 2,014 ⟶ 2,840:
}) )
}
fcn normalize(s){ s.apply("sort").sort(fcn(a,b){ a[0]<b[0] }) }</
<
L(L(1.1, 2.2)), L(L(6.1, 7.2), L(7.2, 8.3)), L(L(4, 3), L(2, 1)),
L(L(4.0, 3.0), L(2.0, 1.0), L(-1.0, -2.0), L(3.9, 10.0)),
L(L(1, 3), L(-6, -1), L(-4, -5), L(8, 2), L(-6, -6)),
)){ println(ppp(rs),"--> ",ppp(consolidate(rs))) }
fcn ppp(ll){ ll.pump(String,fcn(list){ list.concat(", ", "[", "] ") }) }</
{{out}}
<pre>
|