Range consolidation: Difference between revisions

{{trans|Python}}

 

F normalize(s)

R sorted(s.filter(bounds -> !bounds.empty).map(bounds -> sorted(bounds)))

[[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]]]

 

{{out}}

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

DEFINE PTR="CARD"

PutE() PutE()

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Range_consolidation.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Containers.Vectors;

 

Show (Set_4);

Show (Set_5);

 

{{out}}

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

arr1 := [], arr2 := [], result := []

result[i-1, 2] := stop > result[i-1, 2] ? stop : result[i-1, 2]

return result

test2 := [[6.1, 7.2], [7.2, 8.3]]

test3 := [[4, 3], [2, 1]]

}

MsgBox % result

{{out}}

<pre>[1.1, 2.2]

 

=={{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#}}

 

let rng = [

[ Pt(1.1, 2.2) ],

[ Pt(1.0, 3.0), Pt(-6, -1), Pt(-4, -5), Pt(8, 2), Pt(-6, -6) ]

]

func overlap(left, right) =>

for list in rng {

while z >= 1 {

for y in (z - 1)^-1..0 when overlap(list[z], list[y]) {

list[y] = consolidate(list[z], list[y])

}

z -= 1

}

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

}

print(list)

 

{{out}}

=={{header|Factor}}==

{{works with|Factor|0.99 2021-06-02}}

math.order math.statistics sequences sets sorting ;

 

{ { 4 3 } { 2 1 } { -1 -2 } { 3.9 10 } }

{ { 1 3 } { -6 -1 } { -4 -5 } { 8 2 } { -6 -6 } }

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{trans|Yabasic}}

Dim Shared As Integer i

Dim Shared As Single items, temp = 10^30

Next j

Sleep

 

 

=={{header|Go}}==

 

import (

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

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.Ord (comparing)

 

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:

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

def consolidate:

;

{{out}}

<pre>

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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Using the Wolfram Language's built-in Interval operations:

{{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}}};

{{out}}

<pre>Interval[{1.1,2.2}]

 

=={{header|Nim}}==

 

# Definition of a range of values of type T.

test([4, 3], [2, 1])

test([4.0, 3.0], [2.0, 1.0], [-1.0, -2.0], [3.9, 10.0])

 

{{out}}

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>

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

 

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

 

{{out}}

 

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

</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.

construct new(r) {

if (r.type != Range || !r.isInclusive) Fiber.abort("Argument must be an inclusive range.")

if (_high < r.low) return [this, r]

if (r.high < _low) return [r, this]

}

 

System.print(spanList.toString[1..-2])

}

 

{{out}}

 

=={{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>