Range consolidation: Difference between revisions

{{task}}

 

 

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

 

 

 

 

* [[Set consolidation]]

* [[Set of real numbers]]

<br><br>

 

=={{header|Ada}}==

with Ada.Containers.Vectors;

 

Show (Set_4);

Show (Set_5);

 

{{out}}

( 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|C}}==

#include <stdlib.h>

 

test_consolidate_ranges(test5, LENGTHOF(test5));

return 0;

 

{{out}}

=={{header|C sharp}}==

{{works with|C sharp|7}}

using System.Linq;

using System;

private static (double s, double e) Normalize((double s, double e) range) =>

(Min(range.s, range.e), Max(range.s, range.e));

{{out}}

<pre>

 

=={{header|C++}}==

#include <iostream>

#include <utility>

}

return 0;

 

{{out}}

 

=={{header|Clojure}}==

(let [[n1 n2] r]

[(min n1 n2) (max n1 n2)]))

(remove #(contains? (set used) %) rs))]

(recur (conj res (consolidate-touching-ranges touching))

 

{{out}}

{{trans|C#}}

 

while z >= 1 {

}

z -= 1

}

list[i] = normalize(list[i])

}

print(list)

 

{{out}}

 

 

=={{header|Go}}==

 

import (

fmt.Println(s[1 : len(s)-1])

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.Ord (comparing)

 

consolidated :: [(Float, Float)] -> [(Float, Float)]

 

 

tests :: [[(Float, Float)]]

tests =

]

 

main =

putStrLn $

 

 

tabulated s xShow fxShow f xs =

 

showPairs :: [(Float, Float)] -> String

showPairs xs

| null xs = "[]"

 

showPair :: (Float, Float) -> String

 

showNum :: Float -> String

showNum n

| 0 == (n - fromIntegral (round n)) = show (round n)

{{Out}}

<pre>Range consolidations:

=={{header|J}}==

'''Solution:'''

normalise=: ([: /:~ /:~"1)@ensure2D NB. normalises list of ranges

merge=: ,:`(<.&{. , >.&{:)@.(>:/&{: |.) NB. merge ranges x and y

'''Required Examples:'''

1.1 2.2

6.1 7.2 ,: 7.2 8.3

| | |3 4| 1 2| 1 8|

| | | | 3 10| |

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.Arrays;

 

}

 

{{out}}

{{Trans|Haskell}}

{{Trans|Python}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Range consolidations:

[[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|Julia}}==

of the Python code is done, rather than using a native Julia Range.

{{trans|Python}}

 

function consolidate(ranges)

 

testranges()

<pre>

Array{Float64,1}[[1.1, 2.2]] => Array{Float64,1}[[1.1, 2.2]]

 

=={{header|Kotlin}}==

{

return ranges

 

inputRanges.associateBy(Any::toString, ::consolidateDoubleRanges).forEach({ println("${it.key} => ${it.value}") })

 

{{Out}}

[[1, 3], [-6, -1], [-4, -5], [8, 2], [-6, -6]] => [[-6.0, -1.0], [1.0, 8.0]]

</pre>

 

=={{header|Perl}}==

Note: the output is shown in the standard [https://perldoc.perl.org/perlop.html#Range-Operators Perl notation for Ranges].

 

use warnings;

 

$out .= join('..', @$_). ' ' for consolidate($intervals);

printf "%44s => %s\n", $in, $out;

{{out}}

<pre> [1.1, 2.2] => 1.1..2.2

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI Prolog}}

normalize(Ranges, Normalized),

sort(Normalized, Sorted),

(consolidate_ranges(Ranges, Consolidated),

write_ranges(Ranges), write(' -> '),

 

{{out}}

=={{header|Python}}==

===Procedural===

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

 

]:

print(f"{str(s)[1:-1]} => {str(consolidate(s))[1:-1]}")

 

{{out}}

{{Trans|Haskell}}

{{Works with|Python|3.7}}

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Consolidation of numeric ranges:

=={{header|Racket}}==

 

 

;; Racket's max and min allow inexact numbers to contaminate exact numbers

([1 3] [-6 -1] [-4 -5] [8 2] [-6 -6])))

 

 

{{out}}

Note: the output is in standard [https://docs.raku.org/type/Range Raku notation for Ranges].

 

sub infix:<∪> (Range $a, Range $b) { Range.new($a.min,max($a.max,$b.max)) }

 

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)

 

The actual logic for the range consolidation is marked with the comments: &nbsp; &nbsp; <big> <tt> /*■■■■►*/ </tt> </big>

#.= /*define the default for range sets. */

parse arg #.1 /*obtain optional arguments from the CL*/

do k=j+1 to n; if word(@.k,1)>=word(_,1) then iterate; @.j=@.k; @.k=_; _=@.j

end /*k*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

Most of the implementation below belongs to the test and formatting support.

If the output might be more arbitrary, the source would be quite small.

 

 

// We could use std::ops::RangeInclusive, but we would have to extend it to

 

println!("Run: cargo test -- --nocapture");

 

{{out}}

 

test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

</pre>

 

=={{header|Yabasic}}==

local items, i, t1, t2, s

for i = 1 to items

if tabla(i, 1) <> void print tabla(i, 1), "..", tabla(i, 2);

 

=={{header|zkl}}==

(s:=List()).append(

normalize(rs).reduce('wrap(ab,cd){

}) )

}

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))) }

{{out}}

<pre>