Range extraction: Difference between revisions

*   [[Range expansion]]

<br><br>

 

=={{header|Ada}}==

the iterative solution uses Unbounded_Strings.

 

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

37, 38, 39

) ) );

 

 

The recursive solution avoids the usage of unbounded strings.

 

 

procedure Range_Extract is

17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 28, 29,

30, 31, 32, 33, 35, 36, 37, 38, 39) ));

 

{{out}}

=={{header|Aime}}==

 

{

integer a, i;

 

0;

 

{{out}}

* The closest concept that ''Algol 68'' has to [[wp:duck typing|duck typing]] is the [[wp:tagged union|tagged union]]. This is used to define '''mode''' '''urange''' = '''union'''('''int''', '''struct'''('''int''' lwb, upb)). If ''duck typing'' was available it could reduced the size of the code specimen, but would have lost some of <i>Algol 68</i>'s strong type ''data security''.

'''File: Template_Range_extraction_Base.a68'''

REQUIRES(MODE SCALAR, OP(SCALAR,SCALAR)BOOL =, OP(SCALAR,SCALAR)SCALAR +);

###

);

 

REQUIRES(MODE SCALAR, OP(SCALAR,SCALAR)BOOL =, OP(SCALAR,SCALAR)SCALAR +);

###

 

out unirange list[:upb out unirange list]

############################

# some simple test cases: #

REPR list c

))

 

{{out}}

# Finally iterate with ''unirange list init'' '''exiting''' with an array of '''union''' of '''int''' and '''range'''.

'''File: Template_Range_extraction_Generative.a68'''

REQUIRES(MODE SCALAR, OP(SCALAR,SCALAR)BOOL =, OP(SCALAR,SCALAR)SCALAR +);

###

);

 

{{out}}

<pre style="height:15ex;overflow:scroll">

===Functional===

{{Trans|JavaScript}}

 

-- rangeFormat :: [Int] -> String

item 1 of lstParts & {item 2 of lstParts}

end if

{{Out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

===Straightforward===

 

The task description doesn't explicitly state that the integers are unique or what to do if they're not.

This script treats runs of equal integers as single instances of those integers.

-- Test code:

set listOfIntegers to {0, 1, 2, 4, 6, 7, 8, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39}

 

{{output}}

 

=={{header|AutoHotkey}}==

 

extract( list ) {

}

return SubStr(ret (f!=p ? (p>f+1 ? "-" : ",") p : ""), 2)

{{out}}

<pre>---------------------------

by convention, separated from the expected ones by extra space.

 

 

BEGIN {

sequence[s] = a[s]

}

 

{{out}}

</pre>

 

{{works with|BBC BASIC for Windows}}

\ "15, 16, 17, 18, 19, 20, 21, 22, 23, 24, " + \

\ "25, 27, 28, 29, 30, 31, 32, 33, 35, 36, " + \

ENDIF

UNTIL i% = 0

{{out}}

<pre>

0-2,4,6-8,11,12,14-25,27-33,35-39

</pre>

 

=={{header|Bracmat}}==

= accumulator firstInRange nextInRange

, accumulate fasten rangePattern

15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

{{out}}

<pre>(0,1,2,4,6,7,8,11,12,14,15,16,17,18,19,20,21,22,23,24,25,27,28,29,30,31,32,33,35,36,37,38,39) ==>

but always returns the output length sans the terminating null,

so caller can allocate buffer.

#include <stdlib.h>

 

 

return 0;

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

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

using System.Collections.Generic;

using System.Linq;

}

}

 

{{out}}

 

===C#: Alternate Version===

using System.Collections.Generic;

using System.Linq;

}

{{out}}

<pre>

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

 

#include <iostream>

#include <iterator>

std::cout << std::endl;

}

{{out}}

<pre>

 

=={{header|Ceylon}}==

value numbers = [

assert(rangeString == "0-2,4,6-8,11,12,14-25,27-33,35-39");

print(rangeString);

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

=={{header|Clojure}}==

{{libheader|org.flatland/useful}}

 

(defn nonconsecutive? [[x y]]

(defn format-with-ranges [coll]

(println (clojure.string/join ","

 

{{out}}

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. extract-range-task.

END PROGRAM find-num-trailing-spaces.

 

nums-table.cpy:

03 num-nums PIC 999.

03 nums-area.

05 nums PIC S999 OCCURS 1 TO 100 TIMES

DEPENDING ON num-nums

 

{{out}}

 

=={{header|Common Lisp}}==

(unless list (return ""))

(with-output-to-string (s)

37 38 39))

"0-2,4,6-8,11,12,14-25,27-33,35-39"

 

=={{header|D}}==

 

string rangeExtraction(in int[] items)

32, 33, 35, 36, 37, 38, 39]])

data.rangeExtraction.writeln;

{{out}}

<pre>-8--6,-3-1,3-5,7-11,14,15,17-20

0,0,0,1,1

0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

=={{header|DWScript}}==

begin

var i:=0;

15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

{{trans|Go}}

 

return ""

}

while true {

var n2 = n1 + 1

n2 += 1

}

if n2 == n1+2 {

s += "," + a[n2-1]

s += "-" + a[n2-1]

}

break

}

n1 = n2

}

}

37, 38, 39

])

 

{{out}}

and just formatting them ourselves.

 

var region := 0..!0

for n in numbers { region |= n..n }

}

return ",".rjoin(ranges)

 

> 0, 1, 2, 4, 6, 7, 8, 11, 12, 14,

> 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

> 37, 38, 39])

# value: "0-2,4,6-8,11,12,14-25,27-33,35-39"

 

=={{header|EchoLisp}}==

(define task '(0 1 2 4 6 7 8 11 12 14 15 16 17 18 19 20 21 22 23 24 25 27 28 29 30 31 32 33 35 36 37 38 39))

 

(string-join (map range->string (reverse (foldl group-range () task))) ",")

→ "0-2 ,4 ,6-8 ,11, 12 ,14-25 ,27-33 ,35-39 "

 

=={{header|Eiffel}}==

class

RANGE

end

end

{{Out}}

<pre>

=={{header|Elixir}}==

{{trans|Ruby}}

def range_extract(list) do

max = Enum.max(list) + 2

37, 38, 39

]

 

{{out}}

 

=={{header|Emacs Lisp}}==

(defun rangext (lst)

(mapconcat (lambda (item)

(if (consp item)

(format "%d" item)))

(gnus-compress-sequence lst)

","))

 

15 16 17 18 19 20 21 22 23 24

25 27 28 29 30 31 32 33 35 36

 

 

 

 

15 16 17 18 19 20 21 22 23 24

25 27 28 29 30 31 32 33 35 36

 

=={{header|Erlang}}==

-module( range ).

 

extraction_acc( {Start, Stop, Acc} ) when Stop > Start + 1 -> [erlang:integer_to_list(Start) ++ "-" ++ erlang:integer_to_list(Stop) | Acc];

extraction_acc( {Start, Stop, Acc} ) -> [erlang:integer_to_list(Stop), erlang:integer_to_list(Start) | Acc]. % Reversed

{{out}}

<pre>

 

=={{header|Euphoria}}==

integer first

sequence out

 

puts(1, extract_ranges({0, 1, 2, 4, 6, 7, 8, 11, 12, 14, 15, 16, 17, 18, 19,

 

{{out}}

 

=={{header|F_Sharp|F#}}==

| [] -> Seq.empty

| x::xr ->

 

printfn "%s" (extract [ 0; 1; 2; 4; 6; 7; 8; 11; 12; 14; 15; 16; 17; 18; 19; 20; 21;

 

{{out}}

=={{header|Factor}}==

The <code>monotonic-split</code> word enables us to split the input sequence into sub-sequences of contiguous integers. From there, we make ranges out of sequences greater than 2 in length and list members of sequences less than or equal to 2 in length.

splitting.monotonic ;

IN: rosetta-code.range-extraction

0 1 2 4 6 7 8 11 12 14 15 16 17 18 19 20 21 22

23 24 25 27 28 29 30 31 32 33 35 36 37 38 39

{{out}}

<pre>

 

=={{header|Forth}}==

here

0 , 1 , 2 , 4 , 6 , 7 , 8 , 11 , 12 , 14 ,

;

 

 

{{out}}

Although Pascal offers a Str procedure for converting a variable to a text string, maddeningly, it is a procedure not a function and so cannot be used within a compound statement. Fortran could offer access to the FORMAT facility via something like a function FMT(x) which returns the text representation of variable x with no leading or trailing spaces (whereby FMT(-6) would return "-6" and so forth) but alas, does not. Such a function cannot be written in ordinary Fortran until such time as it is possible to return varying-sized character results. The I0 format code standardised in F90 comes close but of course it must be used in a complex environment. All in all, it is easier to devise a subroutine SPLOT(n) to write the value of an integer (with possible leading hyphen if negative) to a scratchpad and then EMIT its text character by character to the output variable character until stopped by a space. Subroutines EMIT and SPLOT could be normal separate subroutines, but as servants of IRANGE it is easier to take advantage of the F90 facility whereby they can be "contained" inside IRANGE and thereby gain access to its internal context. Otherwise, there would have to be additional parameters or usage of COMMON variables for such communication.

 

Could make this a function, but then a maximum text length returned would have to be specified.

CHARACTER*(*) TEXT !The list on input, the list with ranges on output.

CALL IRANGE(SOME)

WRITE (6,*) SOME

 

Output: spaces after the commas could be added easily enough.<pre> 0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

=={{header|Go}}==

 

import (

}

return strings.Join(parts, ","), nil

{{out}}

<pre>

=={{header|Groovy}}==

Ad Hoc Solution:

 

def compressList = { list ->

}

 

 

Test:

0, 1, 2, 4, 6, 7, 8, 11, 12, 14,

15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

37, 38, 39

'''

 

{{out}}

=={{header|Haskell}}==

===direct recursion===

 

extractRange :: [Int] -> String

g a [] = (a - 1, [])

f (x : xs) = show x : f xs

 

 

===splitBy===

Delegating to splitBy allows a reasonably clean definition of range formatting:

 

import Data.Function (on)

 

rangeFormat :: [Int] -> String

rangeFormat = intercalate "," . fmap rangeString . splitBy ((/=) . succ)

ps@(x:t) = show <$> xs

 

-- Split wherever a supplied predicate matches the

-- relationship between two consecutive items.

splitBy _ [] = []

splitBy _ [x] = [[x]]

where

 

main :: IO ()

main =

, 38

, 39

{{Out}}

<pre>"0-2,4,6-8,11,12,14-25,27-33,35-39"</pre>

Or, we can pass a span-chopping function to Data.List.Split '''chop'''.

 

import Data.List.Split (chop)

import Data.Bool (bool)

15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

{{Out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

 

R := [ 0, 1, 2, 4, 6, 7, 8, 11, 12, 14,

every (s := "[ ") ||:= !L || " "

return s || "]"

{{out}}

<pre>Input list := [ 0 1 2 4 6 7 8 11 12 14 15 16 17 18 19 20 21 22 23 24 25 27

Older versions of J will also need <code> require 'strings'</code>.

 

group=: <@fmt;.1~ 1 ~: 0 , 2 -~/\ ]

 

Example use:

 

 

and

 

 

Other examples:

 

 

The first 101 non-negative integers

 

extractRange (-. p:) i.101

 

Excluding those which are prime

 

extractRange 2}. (-. p:) i.101

 

Also excluding the first two non-negative integers (which are neither prime nor the product of non-empty lists of primes).

 

=={{header|Java}}==

 

public static void main(String[] args) {

}

}

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39,</pre>

===ES5===

====Imperative====

var len = list.length;

var out = [];

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

37, 38, 39

 

====Functional====

{{Trans|ES6}}

{{Trans|Haskell}}

'use strict';

 

33, 35, 36, 37, 38, 39

]);

 

{{Out}}

 

===ES6===

====Idiomatic====

function toRange(arr) {

const ranges = [];

console.log(`expected output : '${expected}'.`);

console.log(`Correct? ${ actual === expected ? 'Yes' : 'No'}`);

{{Out}}

<pre>

actual output : '0-2,4,6-8,11,12,14-25,27-33,35-39'.

expected output : '0-2,4,6-8,11,12,14-25,27-33,35-39'.

 

=={{header|jq}}==

def extract:

reduce .[] as $i

then "\(.[0]),\(.[1])" # satisfy special requirement

else "\(.[0])-\(.[1])" end )

 

{{out|Command and output}}

=={{header|Jsish}}==

From Javascript ES5 Imperative solution.

function rangeExtraction(list) {

var len = list.length;

 

puts(arr);

 

{{out}}

=={{header|Julia}}==

This is perhaps an idiosyncratic solution. Numbers inside of runs are replaced with Xs, the list is converted into a comma separated string, and then Xs and extra commas are replaced with the range character via a regular expression.

function sprintfrange{T<:Integer}(a::Array{T,1})

len = length(a)

println("Testing range-style formatting.")

println(" ", testa, "\n =>\n ", sprintfrange(testa))

 

{{out}}

 

=={{header|K}}==

fmt : {:[1=#s:$x;s;(*s),:[3>#s;",";"-"],*|s]}

 

{{out|Example}}

 

=={{header|Kotlin}}==

 

fun extractRange(list: List<Int>): String {

37, 38, 39)

println(extractRange(list2))

 

{{out}}

 

0-2,4,6-8,11,12,14-25,27-33,35-39

</pre>

 

=={{header|LiveCode}}==

Inefficient as it takes 2 passes

local prevNum, znums, rangedNums

set itemDelimiter to ", "

return char 1 to -2 of rangedNums --strip off trailing comma

end rangeExtract

Test

local numbers

put "0, 1, 2, 4, 6, 7, 8, 11, 12, 14," \

&& "37, 38, 39" into numbers

put rangeExtract(numbers)

 

=={{header|Lua}}==

local rExpr, startVal = ""

for k, v in pairs(rList) do

37, 38, 39

}

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

=={{header|Maple}}==

25, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39]:

r1,r2:= lst[1],lst[1]:

fi:

od:

{{Out|Output}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

Flatten[Split[Sort[data], #2 - #1 == 1 &] /. {a_Integer, __, b_} :> Row[{a, "-", b}]],

 

=={{header|MATLAB}} / {{header|Octave}}==

% Range extraction

L(end+1) = NaN;

disp(range_extraction([0, 1, 2, 4, 6, 7, 8, 11, 12, 14, 15, ...

16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, ...

 

{{Out|Output (Octave)}}

 

=={{header|Mercury}}==

:- interface.

 

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

37, 38, 39].

 

=={{header|MiniScript}}==

result = []

idx = 0

end if

end while

end function

 

test = [ 0, 1, 2, 4, 6, 7, 8, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

25, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39]

 

{{out}}

 

=={{header|MUMPS}}==

NEW Y,I,CONT,NOTFIRST,CURR,PREV,NEXT,SEQ SET Y="",SEQ=0,PREV="",CONT=0

FOR I=1:1:$LENGTH(X,",") DO

IF CONT SET Y=Y_PREV

K I,CONT,NOTFIRST,CURR,PREV,NEXT,SEQ

Example:

<pre>USER>SET S="0,1,2,4,6,7,8,11,12,14,15,16,17,18,19,20,21,22,23,24,25,27,28,29,30,31,32,33,35,36,37,38,39"

=={{header|NetRexx}}==

===NetRexx Ver. 1===

* 07.08.2012 Walter Pachl derived from my Rexx Version

* Changes: line continuation in aaa assignment changed

End

End

{{out}}

<pre>

===NetRexx Ver. 2===

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

end r_

return

{{out}}

<pre>

 

=={{header|Nim}}==

 

proc extractRange(input: string): string =

var list = input.replace(re"\s+").split(',').map(parseInt)

var i = 0

while i < list.len:

case last - first

of 0: ranges.add($first)

i.inc

return ranges.join(",")

15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

 

{{out}}

=={{header|Oberon-2}}==

Oxford Oberon-2

MODULE RangeExtraction;

IMPORT Out;

Range(seq1)

END RangeExtraction.

{{out}}

<pre>

=={{header|Objeck}}==

{{trans|Java}}

function : Main(args : String[]) ~ Nil {

Compress2Range("-6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20")->PrintLine();

}

}

 

=={{header|Objective-C}}==

{{works with|Mac OS X|10.7+}}

{{works with|iOS|5+}}

 

NSString *extractRanges(NSArray *nums) {

}

return 0;

{{out}}

<pre>

 

=={{header|OCaml}}==

| [] -> []

| x::xs ->

in

let rng = range_extract li in

 

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

=={{header|ooRexx}}==

{{trans|NetRexx Ver. 2}}

{{trans|Java}}

 

parse arg userInput

end r_

return

{{out}}

<pre>

Compacted: -4--2,0-2,4,6-8,11,12,14-25,27-33,35-39

</pre>

 

=={{header|Oz}}==

fun {Extract Xs}

{CommaSeparated

15 16 17 18 19 20 21 22 23 24

25 27 28 29 30 31 32 33 35 36

 

{{out}}

 

{{works with|Free Pascal|2.6.2}}

 

 

 

uses

{$ENDIF}{$ENDIF}

SysUtils;

function RangeExtraction(const Seq: array of integer): String;

const

var

i, j: Integer;

begin

Result := '';

i := Low(Seq);

end;

End;

procedure DisplayRange(const Seq: array of integer);

var

WriteLn;

End;

begin

DisplayRange([0]);

DisplayRange([0,1,2,3,4,5,6,7,9]);

DisplayRange([0,1,2,3,4,6,9,10,11,12]);

DisplayRange([

0, 1, 2, 4, 6, 7, 8, 11, 12, 14,

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

37, 38, 39]);

 

{{out}}

Using regexes. Also handles +/- and negative integer ranges.

 

my $str = join ' ', @_;

1 while $str =~ s{([+-]?\d+) ([+-]?\d+)}

25 27 28 29 30 31 32 33 35 36

37 38 39);

 

{{out}}

{{libheader|Set&#58;&#58;IntSpan}}

 

 

{{libheader|Set&#58;&#58;IntSpan&#58;&#58;Fast}}

 

 

<code>Set::IntSpan</code> and <code>Set::IntSpan::Fast</code> are similar. "Fast" does a binary search for member testing (not part of the task here). Both accept negatives.

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

( ) var res

clear

 

The same result in all examples.

{{out}}

A bit less ugly

 

 

( 0 1 2 4 6 7 8 11 12 14

endif

endfor

 

Short version

 

 

( 0 1 2 4 6 7 8 11 12 14

act inf == not

endwhile

 

 

PicoLisp like version

 

 

def glue /# l o -- l #/

ob swap put

endfor

enddef

 

endfor

 

 

=={{header|PicoLisp}}==

(glue ","

(make

((= N M) (link N))

((= (inc N) M) (link N M))

{{out}}

<pre>: (rangeextract

 

=={{header|PL/I}}==

/* least 3 items in a run. */

range_extraction: /* 17 August 2010 */

c, d = ',';

end;

 

OUTPUT 17/8/2010:

0-2,4,6-8,11-12,14-25,27-33,35-39

{{out}}

<pre>

 

=={{header|PowerShell}}==

function range-extraction($arr) {

if($arr.Count -gt 2) {

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

37, 38, 39)

<b>Output:</b>

<pre>

The code uses three predicates '''extract_Range/2''', '''study_Range/2''' and '''pack_Range/2'''.<BR>

Every predicate works in both directions arg1 towards arg2 and arg2 towards arg1, so that '''Range extraction''' and '''Range expansion''' work with the same predicates but in reverse order.

L = [0, 1, 2, 4, 6, 7, 8, 11, 12, 14,

15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

 

run(Val,[Other|RRest], [Val, Val],[Other|RRest]).

 

{{out}}

0-2,4,6-8,11,12,14-25,27-33,35-39

true</pre>

 

=={{header|Python}}==

===Procedural===

====Python: for ordered sequences====

'Yield 2-tuple ranges or 1-tuple single elements from list of increasing ints'

lenlst = len(lst)

23, 24, 25, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39]]:

#print(list(range_extract(lst)))

 

{{out}}

A more general method that works on any sequential [https://docs.python.org/3/library/collections.abc.html?highlight=iterable#collections.abc.Iterable Iterable] of integers, not only [https://docs.python.org/3/library/collections.abc.html?highlight=iterable#collections.abc.Sequence Sequences]:

 

'''Assumes iterable is sorted sequentially. Returns iterator of range tuples.'''

it = iter(iterable)

23, 24, 25, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39]]:

#print(list(range_extract(lst)))

 

{{out}}

Note that for an iterable yielding <code>1,2,3,6,7,8</code> the only way to determine the end of the first section of incremented numbers, <code>1,2,3</code> is to read the next number <code>6</code>, This next example defines an iterator where the <code>6</code> can be pushed back and so more cleanly made available for inclusion in detrmining the next sub-sequence of <code>6,7,8</code>.

 

"Can push items back on iterable"

def __init__(self, it):

yield (hi,)

else:

{{out}}

When substituted for function <code>range_extract</code> in the first Python example it gives the same results.

{{Trans|AppleScript}}

{{Works with|Python|3.7}}

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Range extraction:

 

=={{header|Qi}}==

(define make-range

Start Start -> ["," Start]

25 27 28 29 30 31 32 33 35 36

37 38 39])

 

{{out}}

=={{header|R}}==

 

r <- c(1, which(diff(v) != 1) + 1, length(v) + 1)

paste0(collapse=",",

print(extract.range(c(

0, 1, 2, 4, 6, 7, 8, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22,

 

=={{header|Racket}}==

#lang racket

 

24 25 27 28 29 30 31 32 33 35 36 37 38 39))

;; -> "0-2,4,6-8,11,12,14-25,27-33,35-39"

 

=={{header|Raku}}==

(formerly Perl 6)

my $prev = NaN;

my @ranges;

15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

 

{{out}}

Note that the two numbers &nbsp; '''11''' &nbsp; and &nbsp; '''12''' &nbsp; are not considered a range.

===version 1===

old=0 1 2 4 6 7 8 11 12 14 15 16 17 18 19 20 21 22 23 24 25 27 28 29 30 31 32 33 35 36 37 38 39

#= words(old) /*number of integers in the number list*/

new= /*the new list, possibly with ranges. */

do k=j+1 to #; y= word(old, k) /*get the Kth number in the number list*/

inc= inc + 1; g= y /*increase the range, assign G (good).*/

end /*k*/

new= new'-'g; j= k - 1 /*indicate a range of #s; change index*/

end /*j*/

/*stick a fork in it, we're all done. */

<pre>

old: 0 1 2 4 6 7 8 11 12 14 15 16 17 18 19 20 21 22 23 24 25 27 28 29 30 31 32 33 35 36 37 38 39

new: 0-2,4,6-8,11,12,14-25,27-33,35-39

</pre>

===version 1a===

old=0 1 2 4 6 7 8 11 12 14 15 16 17 18 19 20 21 22 23 24 25 27 28 29 30 31 32 33 35 36 37 38 39

#= words(old); j= 0 /*number of integers in the number list*/

new= /*the new list, possibly with ranges. */

do k=j+1 to #; y= word(old, k) /*get the Kth number in the number list*/

inc= inc + 1; g= y /*increase the range, assign G (good).*/

end /*k*/

new= new'-'g; j= k - 1 /*indicate a range of numbers; change J*/

end /*while*/

/*stick a fork in it, we're all done. */

 

===version 2===

Somewhat simplified !?!

* 07.08.2012 Walter Pachl

**********************************************************************/

End

Say 'new='ol

 

=={{header|Ring}}==

# Project : Range extraction

 

see svect

see "]" + nl

Output:

<pre>

 

=={{header|Ruby}}==

# pad the list with a big value, so that the last loop iteration will

# append something to the range

]

 

 

{{out}}

{{works with|Ruby|2.2}}

Enumerable#slice_when method became usable.

 

{{out}}

=={{header|Rust}}==

Iterators are very Rustic. This solution is generic for all numeric types.

struct RangeFinder<'a, T: 'a> {

}

println!("");

 

{{out}}

 

Add this to the top of the file:

 

Changing this line:

to this:

 

And this line:

to this:

 

=={{header|Scala}}==

def spanRange(ls:List[Int])={

var last=ls.head

println(toRangeString(toRangeList(l)))

}

 

{{out}}

=={{header|Scheme}}==

{{trans|Qi}}

(define (make-range start end)

(cond ((= start end)

25 27 28 29 30 31 32 33 35 36

37 38 39))

 

{{out}}

 

=={{header|Seed7}}==

 

const func string: rangeExtraction (in array integer: numbers) is func

writeln(rangeExtraction([] (0, 1, 2, 4, 6, 7, 8, 11, 12, 14, 15, 16, 17, 18, 19,

20, 21, 22, 23, 24, 25, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39)));

 

{{out}}

Handles +/- and negative ranges.

 

define('abs(n)') :(abs_end)

abs abs = ~(abs = lt(n,0) -n) n :(return)

+ '37, 38, 39'

output = rangext(test)

 

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

=={{header|Swift}}==

{{works with|Swift|3}}

 

import Darwin

 

print(description(from: ranges(from: ex)))

print(description(from: ranges(from: longer)))

 

{{out}}

 

=={{header|Tailspin}}==

templates extract

templates out

otherwise '$.start;-$.end;' !

end out

@: {start: $(1), end: $(1)};

[ $(2..last)... -> #, $@ -> out ] -> '$...;' !

otherwise $@ -> out !

',' !

25, 27, 28, 29, 30, 31, 32, 33, 35, 36,

37, 38, 39] -> extract -> !OUT::write

{{out}}

<pre>

 

=={{header|Tcl}}==

set result [lindex $list 0]

set first [set last [lindex $list 0]]

25 27 28 29 30 31 32 33 35 36

37 38 39

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

MODE DATA

rangednrs=EXCHANGE (rangednrs,":':,:")

PRINT rangednrs

Output:

<pre>

 

Solution without COMBINE

$$ MODE TUSCRIPT

MODE DATA

rangednrs=EXCHANGE (rangednrs,":':,:")

PRINT rangednrs

{{out}}

<pre>

=={{header|TXR}}==

 

`@{(mapcar [iff [callf > length (ret 2)]

(ret `@[@1 0]-@[@1 -1]`)

(op list @2 (- @2 @1))

(sort (uniq numbers))]

 

{{out|Run}}

=={{header|UNIX Shell}}==

{{works with|bash}}

 

range_contract () (

)

 

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

=={{header|Ursala}}==

#import int

 

#show+

 

{{out}}

<pre>0-2,4,6-8,11,12,14-25,27-33,35-39</pre>

 

 

 

 

 

{{out}}

<pre>

</pre>

 

{{out}}

 

=={{header|zkl}}==

fcn(w){

if (w.atEnd) return(Void.Stop);

} :

(0).pump(*,List,_.fp(ns.walker().tweak(Void,Void))).concat(",");

The trick here is to use a modified iterator,

one that can look past the end of the sequence without puking.

The function gathers three or more successive ints (saved as a "a-b" string list element) or just returns the first one (as a number) if it can't.

The resulting list is converted to strings separated by commas.

range(ns).println();

 

range(ns).println();

 

 

{{out}}