Range expansion: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

L(r) txt.split(‘,’)

I ‘-’ C r[1..]

E

lst.append(Int(r))

R lst

 

 

=={{header|8th}}==

\ range, inclusive:

: n:gen-range \ low hi -- a

n:range-expand

\ print the expanded list:

{{out}}

<pre>

[-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20]

</pre>

=={{header|Ada}}==

The function Expand takes a string and returns a corresponding array of integers.

Upon syntax errors Constraint_Error is propagated:

procedure Test_Range_Expansion is

type Sequence is array (Positive range <>) of Integer;

begin

Put (Expand ("-6,-3--1,3-5,7-11,14,15,17-20"));

{{out}}

<pre>

-6,-3,-2,-1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20

</pre>

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny] - string parsing and formatting code tested with 2.6.win32}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

 

MODE RANGE = STRUCT(INT lwb, upb);

print( ( TOSTRING range expand( TORANGE "-6,-3--1,3-5,7-11,14,15,17-20" ), newline ) )

)

{{out}}

<pre>

</pre>

 

 

=={{header|AppleScript}}==

{{Trans|JavaScript}} (Functional ES5 version)

-- and these integer lists are concatenated together into a single list

 

-- expansion :: String -> [Int]

-- signedIntegerAppended:: [Int] -> String -> Int -> [Int] -> [Int]

if strNum ≠ "" then

if iPosn > 1 then

else

set strSign to "+"

end if

else

end if

end signedIntegerAppended

 

 

on run

 

 

 

-- concatMap :: (a -> [b]) -> [a] -> [b]

item 1 of tuple

end if

{{Out}}

 

=={{header|AutoHotkey}}==

 

expand( range ) {

ret .= "," (A_Index-1) + f1

return SubStr(ret, 2)

 

=={{header|AWK}}==

 

BEGIN { FS=","; }

 

}

return;

 

<pre>

 

=={{header|BBC BASIC}}==

END

ENDIF

UNTIL i% = 0

{{out}}

<pre>

 

=={{header|Bracmat}}==

= a b L

. @( !arg

)

& out$(str$(expandRanges$"-6,-3--1,3-5,7-11,14,15,17-20"))

{{out}}

<pre>-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20</pre>

=={{header|C}}==

Recursive descent parser.

#include <stdlib.h>

#include <ctype.h>

 

return 0;

{{out}}

<pre>-6 -3 -2 -1 3 4 5 7 8 9 10 11 14 15 17 18 19 20

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

{{works with|C sharp|3.0}}

using System.Collections.Generic;

using System.Linq;

Console.WriteLine(string.Join(", ", values));

}

 

{{works with|C sharp|3.5+}}

using System.Collections.Generic;

using System.Linq;

}

}

 

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

#include <sstream>

#include <iterator>

else

std::cout << "an error occured.";

{{out}}

-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20

=={{header|Clojure}}==

There is a split method in clojure.contrib, but I don't know if it is able to skip first character to so that <code>(split "-8--8") => (-8 -8)</code>.

(defn skipFirst [[x & xs :as s]]

(cond (empty? s) [nil nil]

 

> (rangeexpand "-6,-3--1,3-5,7-11,14,15,17-20")

 

=={{header|COBOL}}==

{{works with|GNU Cobol|2.0}}

IDENTIFICATION DIVISION.

PROGRAM-ID. expand-range.

END-IF

.

 

Setup:

 

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

(loop

with prevnum = nil

 

CL-USER> (expand-ranges "-6,-3--1,3-5,7-11,14,15,17-20")

 

=={{header|D}}==

 

enum rangeEx = (string s) /*pure*/ => s.matchAll(`(-?\d+)-?(-?\d+)?,?`)

void main() {

"-6,-3--1,3-5,7-11,14,15,17-20".rangeEx.writeln;

{{out}}

<pre>[-6, -3, -2, -1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20]</pre>

 

=={{header|DWScript}}==

function ExpandRanges(ranges : String) : array of Integer;

begin

var expanded := ExpandRanges('-6,-3--1,3-5,7-11,14,15,17-20');

PrintLn(JSON.Stringify(expanded));

{{out}}

<pre>[-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20]</pre>

 

=={{header|EchoLisp}}==

;; parsing [spaces][-]digit(s)-[-]digit(s)[spaces]

(define R (make-regexp "^ *(\-?\\d+)\-(\-?\\d+) *$" ))

(ranges task)

→ (-6 -3 -2 -1 3 4 5 7 8 9 10 11 14 15 17 18 19 20)

 

=={{header|Elixir}}==

{{trans|Ruby}}

def expansion(range) do

Enum.flat_map(String.split(range, ","), fn part ->

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module( range ).

 

expansion_individual( {ok, [N], []} ) -> N;

expansion_individual( {ok, [Start], "-" ++ Stop_string} ) -> lists:seq( Start, erlang:list_to_integer(Stop_string) ).

 

{{out}}

 

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

 

// simplify regex matching with an active pattern

|> List.collect parseRange

 

{{out}}

<pre>[-6; -3; -2; -1; 3; 4; 5; 7; 8; 9; 10; 11; 14; 15; 17; 18; 19; 20]</pre>

=={{header|Factor}}==

<code>R/ (?<=\d)-/ re-split</code> says: ''split only on hyphens immediately preceded by a digit.''

sequences sequences.extras splitting ;

 

] map-concat ;

 

{{out}}

<pre>

 

=={{header|Forth}}==

0. 2swap

over c@ [char] - = if

repeat 2drop ;

 

 

=={{header|Fortran}}==

A frustrating problem with many modern computer languages is the absence of a "shortcut" evaluation praxis for logical expressions; in Fortran's case the modern standard is that there is no standard. So a test <code>I<=LEN(TEXT) & TEXT(I:I)''etc.''</code> can't be relied upon to dodge out-of-bounds errors, and a flabby two-statement sequence is required instead. Similarly, few Fortran compilers allow for a function being evaluated via a WRITE statement to itself succeed in using a WRITE statement internally, though some do if one usage is free-format and the other formatted. If necessary, subroutine SPLOT could be re-written to convert an integer to a digit string without a WRITE statement, even for negative integers. And some compilers have difficulty with the use of the function name as a variable within the function so that it is safest to develop the result in an ordinary variable and then remember to assign its value to the function name just before exit.

 

CONTAINS !The key function.

CHARACTER*200 FUNCTION ERANGE(TEXT) !Expands integer ranges in a list.

SOME = ERANGE(SOME)

WRITE (6,*) SOME !If ERANGE(SOME) then the function usually can't write output also.

 

Output: <pre> -6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20</pre>

 

=={{header|FreeBASIC}}==

 

Sub split (s As Const String, sepList As Const String, result() As String)

Print

Print "Press any key to quit"

 

{{out}}

=={{header|Go}}==

A version rather strict with input

 

import (

}

fmt.Println("expanded:", r)

 

=={{header|Groovy}}==

# express as a string

# unwrap the list delimiters

Eval.me('['+compressed.replaceAll(~/(\d)-/, '$1..')+']').flatten().toString()[1..-2]

Test:

{{out}}

<pre>-6, -3, -2, -1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20</pre>

=={{header|Haskell}}==

Given either of the below implementations of <code>expandRange</code>:

===With conventional list processing===

expandRange = concatMap f . split ','

where f str@(c : cs) | '-' `elem` cs = [read (c : a) .. read b]

split delim [] = []

split delim l = a : split delim (dropWhile (== delim) b)

===With a parser===

 

import Text.Parsec

 

expandRange :: String -> Maybe [Int]

 

rangeParser = concat <$> (item `sepBy` char ',')

where

n2 <- option n1 (char '-' *> num)

return [n1 .. n2]

dot = (.) . (.)

 

main :: IO ()

{{Out}}

<pre>Just [-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20]</pre>

 

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

s := "-6,-3--1,3-5,7-11,14,15,17-20"

write("Input string := ",s)

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

return s || "]"

{{out}}

<pre>Input string := -6,-3--1,3-5,7-11,14,15,17-20

 

=={{header|J}}==

thru=: <. + i.@(+*)@-~

num=: _&".

normaliz=: rplc&(',-';',_';'--';'-_')@,~&','

subranges=:<@(thru/)@(num;._2)@,&'-';._1

{{out|Example}}

 

Notes:

 

=={{header|Java}}==

 

class RangeExpander implements Iterator<Integer>, Iterable<Integer> {

}

}

 

=={{header|JavaScript}}==

===Imperative (Spidermonkey)===

 

 

function main() {

 

main();

 

{{out}}

====ES5====

 

'use strict';

 

return expansion(strTest);

 

 

{{Out}}

 

 

 

====ES6====

 

 

 

 

 

 

 

 

 

 

 

 

 

{{Out}}

 

=={{header|jq}}==

{{works with|jq|with regex support}}

def number: "-?[0-9]+";

def expand: [range(.[0]; .[1] + 1)];

else sub( "(?<x>\(number))-(?<y>\(number))"; "\(.x):\(.y)")

| split(":") | map(tonumber) | expand

'''Example''':

{{out}}$ jq -c -n -f Range_expansion.jq

[-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20]

 

=={{header|Julia}}==

 

conv(s)= colon(map(x->parse(Int,x),match(r"^(-?\d+)-(-?\d+)$", s).captures)...)

 

{{out}}

<pre>julia> show(expand("-6,-3--1,3-5,7-11,14,15,17-20"))

 

=={{header|K}}==

pos : {:[3=l:#p:&"-"=x;0,p@1;2=l;p;0=*p;,0;0,p]}

conv: 0${(x;1_ y)}/'{(pos x)_ x}'

expd: {,/@[x;&2=#:'x;{(*x)+!1+,/-':x}]}

{{out|Example}}

 

=={{header|Kotlin}}==

 

fun expandRange(s: String): MutableList<Int> {

val s = "-6,-3--1,3-5,7-11,14,15,17-20"

println(expandRange(s))

 

{{out}}

 

=={{header|Lasso}}==

local(parts) = regexp(`^(-?\d+)-(-?\d+)$`)

}

 

 

{{out}}

<pre>-6, -3, -2, -1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20</pre>

 

=={{header|Liberty BASIC}}==

end

 

ItemCount = ItemCount + 1

wend

{{out}}

<pre>-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20</pre>

 

=={{header|Lingo}}==

on expandRange (str)

res = ""

delete the last char of res

return res

 

=={{header|LiveCode}}==

local tRange, tBegin, tEnd, tstep

if stepping is empty or stepping is 0 then

end repeat

return z

 

Test

 

=={{header|Lua}}==

 

local t = {}

for n = i, j, i<j and 1 or -1 do

 

local ranges = "-6,-3--1,3-5,7-11,14,15,17-20"

 

Due to the way Lua's <code>tonumber</code> function works and the way the string pattern to parse ranges is written, whitespace is allowed around commas and the dash separating the range start and end (but not between the plus/minus sign and the number).

 

=={{header|Maple}}==

ExpandRanges := proc( s :: string )

uses StringTools;

map( DoOne, map( Trim, Split( s, "," ) ) )

end proc:

Running this on the example input we get the following.

> rng := "-6,-3--1,3-5,7-11,14,15,17-20":

> ExpandRanges( rng );

[-6, -3, -2, -1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20]

Here is an additional example which my first attempt got wrong.

> rng := "-6,-3-1,3-5,7-11,14,15,17-20":

> ExpandRanges( rng );

[-6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20]

 

step1 = StringSplit[StringReplacePart[rng,"S",StringPosition[ rng,DigitCharacter~~"-"] /. {x_,y_} -> {y,y}],","];

{{out|Example}}

<pre>rangeexpand["-6,-3--1,3-5,7-11,14,15,17-20"]

 

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

% Range expansion

if nargin < 1;

S(ixr)=':';

S=['[',S,']'];

Usage:

<pre>

 

</pre>

 

=={{header|MUMPS}}==

NEW Y,I,J,X1,H SET Y=""

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

.IF '(H<0) FOR J=+$EXTRACT(X1,1,(H-1)):1:+$EXTRACT(X1,(H+1),$LENGTH(X1)) SET Y=$SELECT($LENGTH(Y)=0:J,1:Y_","_J)

KILL I,J,X1,H

{{out|Example}}

<pre>USER>SET U="-6,-3--1,3-5,7-11,14,15,17-20"

=={{header|NetRexx}}==

Translation of: [[Range_expansion#Version_2_somewhat_simplified_.21.3F.21|Rexx Version 2]]

* 09.08.2012 Walter Pachl derived from my Rexx version

* Changes: translate(old,' ',',') -> old.translate(' ',',')

End

Say 'new='new /*show the expanded list */

{{out}}

<pre>

 

=={{header|Nim}}==

 

proc expandRange(input: string): string =

for range in input.split(','):

var sep = range.find('-', 1)

return output.join(",")

 

 

{{out}}

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

Oxford Oberon-2

MODULE LIVector;

IMPORT SYSTEM;

END ExpandRange.

 

{{out}}

<pre>

 

=={{header|OCaml}}==

 

let range a b =

if b < a then invalid_arg "range";

let rec aux i acc =

else aux (succ i) (i::acc)

in

let exp = range_expand rng in

List.iter (Printf.printf " %d") exp;

 

=={{header|Oforth}}==

| i n |

s asInteger dup ifNotNull: [ res add return ] drop

 

: rangeExpand ( s -- [ n ] )

 

=={{header|ooRexx}}==

list = '-6,-3--1,3-5,7-11,14,15,17-20'

expanded = expandRanges(list)

end

return expanded

{{out}}

<pre>

 

=={{header|Oz}}==

fun {Expand RangeDesc}

{Flatten

in

{System.showInfo

{{out|Sample output}}

 

=={{header|Perl}}==

One-liner:

map { /^(.*\d)-(.+)$/ ? $1..$2 : $_ } split /,/, shift

}

 

# Test and display

{{out}}

<pre>-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20</pre>

 

Alternative:

(my $range = shift) =~ s/(?<=\d)-/../g;

eval $range;

 

 

 

 

 

 

 

 

 

 

=={{header|PHP}}==

{{trans|Python}}

$lst = array();

foreach (explode(',', $str) as $e) {

}

return $lst;

 

=={{header|PicoLisp}}==

(make

(for S (split (chop Str) ",")

(format (head @ S))

(format (tail (- -1 @) S)) ) )

{{out}}

<pre>: (rangeexpand "-6,-3--1,3-5,7-11,14,15,17-20")

 

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

procedure options (main);

 

delimiter = ',';

end;

{{out}}

<pre>

 

=={{header|PowerShell}}==

function range-expansion($array) {

function expansion($arr) {

}

range-expansion "-6,-3--1,3-5,7-11,14,15,17-20"

<b>Output:</b>

<pre>

===Alternate Half-Assed Regex Version===

Ten times faster (only minimally tested).

function Expand-Range

{

$output

}

(Expand-Range "-6,-3--1,3-5,7-11,14,15,17-20") -join ", "

{{Out}}

<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 expansion''' and '''Range extraction''' work with the same predicates but in reverse order.

L = '-6,-3--1,3-5,7-11,14,15,17-20',

writeln(L),

run(Var1,LRest,[Deb, Fin], RRest).

 

{{out}}

<pre> ?- range_expand.

 

=={{header|PureBasic}}==

Protected rangesCount = CountString(txt, ",") + 1

Protected subTxt.s, r, rangeMarker, rangeStart, rangeFinish, rangeIncrement, i

Input()

CloseConsole()

{{out}}

<pre>[ -6 -3 -2 -1 3 4 5 7 8 9 10 11 14 15 17 18 19 20 ]</pre>

 

=={{header|Python}}==

lst = []

for r in txt.split(','):

return lst

 

 

another variant, using [[regular expressions]] to parse the ranges,

 

def rangeexpand(txt):

else:

lst.append(int(start))

 

 

 

)

 

 

 

# breakOn :: String -> String -> (String, String)

 

 

# enumFromTo :: Int -> Int -> [Int]

def enumFromTo(m):

return lambda n: list(range(m, 1 + n))

 

 

 

 

 

 

 

 

 

=={{header|R}}==

rangeExpand <- function(text) {

lst <- gsub("(\\d)-", "\\1:", unlist(strsplit(text, ",")))

rangeExpand("-6,-3--1,3-5,7-11,14,15,17-20")

[1] -6 -3 -2 -1 3 4 5 7 8 9 10 11 14 15 17 18 19 20

 

=={{header|Racket}}==

#lang racket

 

 

(range-expand "-6,-3--1,3-5,7-11,14,15,17-20")

{{out}}

<pre>

rather than 3 followed by - followed by -4,

a readtable is installed that makes - a delimiter.

#lang racket

 

(range-expand (open-input-string "-6,-3--1,3-5,7-11,14,15,17-20"))

Note that one can use the full number syntax in this alternative version:

<pre>

'(1 2 30.0 31.0 32.0)

</pre>

 

=={{header|Raven}}==

Based loosely on Ruby

# "-22" split by "-" is [ "", "22" ] so check if

# first list item is "" -> a negative number

"\n" print

 

{{out}}

<pre>-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20</pre>

===version 1===

Extra imbedded blanks were added to the &nbsp; old &nbsp; list (which are ignored) to make the &nbsp; ''over/under'' &nbsp; comparison easier &nbsp; (in the output).

old= '-6,-3--1, 3-5, 7-11, 14,15,17-20'; a=translate(old,,',')

new= /*translate [↑] commas (,) ───► blanks*/

new=translate( strip(new), ',', " ") /*remove the first blank, add commas. */

say 'old list: ' old /*show the old list of numbers/ranges.*/

'''output'''

<pre>

 

===Version 2 somewhat simplified !?!===

* 09.08.2012 Walter Pachl

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

End

End

{{out}}

<pre>

 

=={{header|Ring}}==

# Project : Range expansion

 

see svect

see "]" + nl

Output:

<pre>

 

=={{header|Ruby}}==

rng.split(',').flat_map do |part|

if part =~ /^(-?\d+)-(-?\d+)$/

end

 

{{out}}

<pre>[-6, -3, -2, -1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20]</pre>

 

=={{header|Run BASIC}}==

end

 

if i <> 0 then goto [loop]

rangeExpand$ = range$

{{out}}

<pre>-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20</pre>

Rust doesn't have regex in standard library yet.

 

 

// Precondition: range doesn't contain multibyte UTF-8 characters

println!("{:?}", range_expand("-6,-3--1,3-5,7-11,14,15,17-20"));

}

 

{{out}}

 

=={{header|S-lang}}==

 

foreach s (strchop(r_expres, ',', 0))

list_append(r_expan, s);

}

 

=={{header|Scala}}==

str split "," flatMap { (s) =>

val r = """(-?\d+)(?:-(-?\d+))?""".r

val r(a,b) = s

if (b == null) Seq(a.toInt) else a.toInt to b.toInt

 

{{out}}

 

=={{header|Scheme}}==

(lambda (str char skip count)

(let ((len (string-length str)))

(display ","))))))

(split str #\, 0 0))

{{out}}

<pre>

The library [http://seed7.sourceforge.net/libraries/scanstri.htm scanstri.s7i] defines the function [http://seed7.sourceforge.net/libraries/scanstri.htm#getInteger%28inout_string%29 getInteger] to extract substrings with integer literals (optional sign followed by a sequence of digits) from a string.

The integer literals are converted to the type [http://seed7.sourceforge.net/libraries/integer.htm integer] with the [http://seed7.sourceforge.net/libraries/integer.htm#%28attr_integer%29parse%28in_string%29 parse] operator.

include "scanstri.s7i";

 

end for;

writeln;

{{out}}

<pre>

 

=={{header|Sidef}}==

str.split(',').map { |r|

var m = r.match(/^

}

 

{{out}}

<pre>-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20</pre>

 

=={{header|SNOBOL4}}==

define('range(n1,n2)') :(range_end)

range range = range n1 ','; n1 = lt(n1,n2) n1 + 1 :s(range)

* # Test and display

output = rangex('-6,-3--1,3-5,7-11,14,15,17-20')

{{out}}

<pre>-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20</pre>

 

=={{header|Tcl}}==

set result {}

foreach term [split $desc ","] {

}

 

{{out}}

<pre>-6 -3 -2 -1 3 4 5 7 8 9 10 11 14 15 17 18 19 20</pre>

 

=={{header|TUSCRIPT}}==

rangednrs="-6,-3--1,3-5,7-11,14,15,17-20"

expandnrs=SPLIT (rangednrs,":,:")

expandnrs= JOIN (expandnrs,",")

 

{{out}}

<pre>

Code:

 

@(define entry (e))@\

@(local n1 n2)@\

your junk: @{trailing-junk}

@(end)

 

{{out|Run}}

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

{{works with|bash}}

 

range_expand () (

)

 

{{out}}

<pre>-6 -3 -2 -1 3 4 5 7 8 9 10 11 14 15 17 18 19 20</pre>

 

=={{header|Ursala}}==

#import int

 

#cast %zL

 

{{out}}

<pre><-6,-3,-2,-1,3,4,5,7,8,9,10,11,14,15,17,18,19,20></pre>

 

=={{header|VBA}}==

' return a list with the numbers expressed in AString

Dim Splits() As String

Next

Debug.Print

{{out}}

<pre>

</pre>

 

 

 

 

];

 

{{out}}

<pre>

 

=={{header|Yabasic}}==

 

sub RangeExpand$(s$)

return left$(r$, len(r$) - 1)

end sub

 

=={{header|zkl}}==

fcn(s,re){

if (re.search(s)){

s.split(",").pump(List, _.fp1(RegExp(0'|(.*\d+)-(.*\d+)|)))

.flatten().concat(",");

rangex(ns).println();

 

ns="-6,-3--1,3-5,7-11,14,15,17-20";

 

{{out}}