Range expansion: Difference between revisions

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

{{trans|Python}}

[Int] lst

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

R lst

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

\ range, inclusive:

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

n:range-expand

\ print the expanded list:

{{out}}

<pre>

=={{header|Action!}}==

BYTE i

RangeExtraction("-6,-3--1,3-5,7-11,14,15,17-20",res,@size)

PrintArray(res,size)

{{out}}

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

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>

=={{header|Aime}}==

{{incorrect|Aime|Needs "a comma separated list" without the trailing comma}}

file().b_affix("-6,-3--1,3-5,7-11,14,15,17-20").news(l, 0, 0, ",");

}

or:

list l;

}

{{out}}

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

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

=={{header|APL}}==

{{works with|Dyalog APL}}

aplnum←{⍎('¯',⎕D)[('-',⎕D)⍳⍵]}

∊{ 0::('Invalid range: ''',⍵,'''')⎕SIGNAL 11

(s+(⍳e-s-1))-1

}¨(⍵≠',')⊆⍵

{{out}}

===Functional===

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

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

item 1 of tuple

end if

{{Out}}

----

===Idiomatic===

-- Split the expression at the commas, if any.

set astid to AppleScript's text item delimiters

-- Demo code:

set rangeExpression to "-6,-3--1,3-5,7-11,14,15,17-20"

{{output}}

=={{header|Arturo}}==

flatten @ to :block

join.with:" " map split.by:"," rng 'x ->

]

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

# Callback interface

# Try it on a couple of wrong ones

PrintExpansion("-6-3--1,3-5,7-11,14,15,17-20"); # misformatted range

{{out}}

=={{header|Crystal}}==

{{trans|Ruby}}

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

match = /^(-?\d+)-(-?\d+)$/.match(part)

end

{{out}}

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

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

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Range_expansion;

end;

readln;

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

{{trans|Go}}

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

print("range: \(input)")

}

{{out}}

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

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

"use strict";

// MAIN ---

return JSON.stringify(main());

{{Out}}

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

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

{{trans|Javascript}}

"use strict";

rangeExpand('-6,-3--1,3-5,7-11,14,15,17-20') ==> [ -6, -3, -2, -1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20 ]

=!EXPECTEND!=

{{out}}

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

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

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

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>

=={{header|MiniScript}}==

numstr = chars.pull

while chars and chars[0] != "," and chars[0] != "-"

end function

{{out}}

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

return output.join(",")

{{out}}

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

Oxford Oberon-2

MODULE LIVector;

IMPORT SYSTEM;

END ExpandRange.

{{out}}

<pre>

=={{header|OCaml}}==

let range a b =

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">range_expansion</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">range</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">range_expansion</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"-6,-3-1,3-5,7-11,14,15,17-20"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">range_expansion</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"-6,-3--1,3-5,7-11,14,15,17-20"</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|Phixmonti}}==

Require Phixmonti 1.1

def append

endfor

r

Other solution

def append

endfor

r

A bit more understandable

def append

endfor

r

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

===Procedural===

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

===Functional===

As a fold/catamorphism:

{{Works with|Python|3.7}}

from functools import (reduce)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Range expansion:

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

{{works with|Rakudo|2016.07}}

my token number { '-'? \d+ }

my token range { (<&number>) '-' (<&number>) }

}

{{out}}

Alternatively, using a grammar:

token TOP { <term>* % ',' { make $<term>.map(*.made) } }

token term { [<range>|<num>] { make ($<num> // $<range>).made } }

}

{{out}}

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