Brace expansion: Difference between revisions

Brace expansion is a type of parameter expansion [[wp:Bash_%28Unix_shell%29#Brace_expansion|made popular by Unix shells]], where it allows users to specify multiple similar string parameters without having to type them all out. E.g. the parameter <code>enable_{audio,video}</code> would be interpreted as if both <code>enable_audio</code> and <code>enable_video</code> had been specified.

 

 

Write a function that can perform brace expansion on any input string, according to the following specification.<br>

{{task heading|Test Cases}}

 

|-

! Input<br><small style="font-weight:normal">''(single string)''</small>

<hr style="clear:both; margin-bottom:1em;"/>

 

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

{{trans|Python}}

V out = [‘’]

L s != ‘’

R ([‘’] * 0, ‘’)

 

{{out}}

<pre>

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

</pre>

 

 

 

~/Downloads/*.gif

~/Downloads/*.png

~/Pictures/*.gif

~/Pictures/*.png

 

Itemized, please.

Itemize, please.

Iterated, please.

Iterate, please.

 

cowbell!

gotta have\, again\, more cowbell!

 

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

C++11 solution:

 

#include <iterator>

#include <string>

return 0;

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

(alternatives nil :type list))

 

(dolist (output (expand input))

(format t " ~A~%" output))

{{out}}

<pre>~/{Downloads,Pictures}/*.{jpg,gif,png}

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

</pre>

=={{header|D}}==

{{trans|Python}}

This code is not UTF-corrected, because it uses slicing instead of front, popFront, etc.

 

Nullable!(Tuple!(string[], string)) getGroup(string s, in uint depth)

foreach (const s; testCases.splitLines)

writefln("%s\n%-( %s\n%)\n", s, s.getItems[0]);

{{out}}

<pre>~/{Downloads,Pictures}/*.{jpg,gif,png}

{a,b{2e}f

</pre>

=={{header|Elixir}}==

{{trans|Ruby}}

def getitem(s), do: getitem(String.codepoints(s), 0, [""])

|> Enum.each(fn str -> IO.puts "\t#{str}" end)

IO.puts ""

 

{{out}}

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

</pre>

=={{header|Go}}==

<code>expand.go</code>:

 

// Expander is anything that can be expanded into a slice of strings.

alt = append(alt, sub)

return alt

<code>expand_test.go</code>

 

import (

Expand(input)

}

{{out}}

<pre>

ok rosetta_code/Brace_expansion 3.347s

</pre>

 

=={{header|J}}==

 

Implementation:

 

NB. legit { , and } do not follow a legit backslash:

legit=: 1,_1}.4>(3;(_2[\"1".;._2]0 :0);('\';a.);0 _1 0 1)&;:&.(' '&,)

options=. }:mask <;._1 y

prefix,each options,each suffix

 

Examples:

 

~/Downloads/*.jpg

~/Downloads/*.gif

>expand t4

{}} some {\\edge }{ cases, here\\\}

 

Explanation:

 

Finally, for each integer that we've used to mark delimiter locations, split out each of the marked options (each with a copy of that group's prefix and suffix). (Then when all that is done, take the absolute values convert back to unicode for the final result.)

=={{header|Java}}==

Should be able to handle all printable Unicode.

 

public static void main(String[] args) {

}

}

 

<pre>Itemized, please.

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}</pre>

=={{header|JavaScript}}==

 

Each node of the parse tree consists of one of two simple functions (AND: syntagmatic concatenation, OR: flattening of paradigms) with a set of arguments, each of which may be a plain string or an AND or OR subtree. The expansions are derived by evaluating the parse tree as an expression.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Value returned by function:

Sample of parse trees logged to the console:

 

"fn": "[function and]",

"args": [

" please."

]

 

 

=={{header|Julia}}==

out = [""]

while s != ""

println(ans)

end

~/{Downloads,Pictures}/*.{jpg,gif,png}

--------------------------------------------

=={{header|Kotlin}}==

{{trans|Java}}

 

object BraceExpansion {

BraceExpansion.expand(s)

}

 

{{out}}

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

</pre>

 

=={{header|Perl}}==

 

So here is a manual solution that implements the specification precisely:

 

my $input = shift;

my @stack = ([my $current = ['']]);

return @$current;

 

Usage demonstration:

chomp($input);

print "$input\n";

It{{em,alic}iz,erat}e{d,}, please.

{,{,gotta have{ ,\, again\, }}more }cowbell!

{{out}}

<pre>

 

</pre>

 

}

 

}

 

 

}

{{out}}

~/Downloads/*.jpg

~/Downloads/*.gif

gotta have\, again\, more cowbell!

 

</pre>

=={{header|PicoLisp}}==

(let Lst

(make

(if (pair (car Lst))

(mapcan recurse (car Lst))

Test:

(quote

"~/Downloads/*.jpg"

"{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}"

"{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}" )

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

function Expand-Braces ( [string]$String )

{

}

}

$TestStrings = @(

'It{{em,alic}iz,erat}e{d,}, please.'

Expand-Braces $String

}

{{out}}

<pre>

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

</pre>

 

=={{header|Python}}==

out = [""]

while s:

return None

 

for s in '''~/{Downloads,Pictures}/*.{jpg,gif,png}

It{{em,alic}iz,erat}e{d,}, please.

{,{,gotta have{ ,\, again\, }}more }cowbell!

{}} some }{,{\\\\{ edge, edge} \,}{ cases, {here} \\\\\\\\\}'''.split('\n'):

 

{{out}}

 

</pre>

=={{header|Racket}}==

{{trans|Python}}

(require racket/match)

(define (merge-lists as . bss)

))

(for ((s (in-list patterns)) #:when (printf "expand: ~a~%" s) (x (in-list (brace-expand s))))

{{out}}

<pre>expand: ~/{Downloads,Pictures}/*.{jpg,gif,png}

{}} some }{,{\\ edge ,}{ cases, {here} \\\\}

{}} some }{,{\\ edge ,}{ cases, {here} \\\\}</pre>

 

=={{header|REXX}}==

* Brace expansion

* 26.07.2016

Say arg(1) /* show on screen */

Call lineout oid,arg(1) /* write to file */

{{out}}

<pre>J:\>rexx braces

{}

1 {}</pre>

=={{header|Ruby}}==

{{trans|Python}}

out = [""]

until s.empty?

puts getitem(s)[0].map{|str| "\t"+str}

puts

 

{{out}}

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

</pre>

=={{header|Rust}}==

const CLOSE_CHAR: char = '}';

const SEPARATOR: char = ',';

println!("{}", line);

}

 

 

 

{{trans|Python}}

fn main() {

let input = "~/{Downloads,Pictures}/*.{jpg,gif,png}

None

}

 

{{out}}

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

</pre>

=={{header|Scala}}==

{{works with|Scala|2.11}}

import collection.mutable.ListBuffer

case class State(isChild: Boolean, alts: ListBuffer[String], rem: List[Char])

parseElem(State(false, ListBuffer(""), s.toList)).alts

}

Demonstrating:

println(expand("""~/{Downloads,Pictures}/*.{jpg,gif,png}""") mkString "\n")

println(expand("It{{em,alic}iz,erat}e{d,}, please.") mkString "\n")

println(expand("""{,{,gotta have{ ,\, again\, }}more }cowbell!""") mkString "\n")

println(expand("""{}} some }{,{\\{ edge, edge} \,}{ cases, {here} \\\\\}""") mkString "\n")

{{out}}

<pre>

{}} some }{,\\ edge \,{ cases, {here} \\\\\}

</pre>

=={{header|Scheme}}==

(define (parse-brackets str)

;; We parse the bracketed strings using an accumulator and a stack

(bracket-expand "It{{em,alic}iz,erat}e{d,}")

;; '("Ited" "Ite" "Itemed" "Iteme" "Italiced" "Italice" "Itized" "Itize" "Iterated" "Iterate")

=={{header|Seed7}}==

 

const proc: expandBraces (in string: stri) is func

expandBraces(stri);

end for;

 

{{out}}

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

</pre>

=={{header|Sidef}}==

{{trans|Perl}}

var current = ['']

var stack = [[current]]

It{{em,alic}iz,erat}e{d,}, please.

{,{,gotta have{ ,\, again\, }}more }cowbell!

{{out}}

<pre>

=={{header|Simula}}==

{{trans|Python}}

BEGIN

 

END;

 

ARRAYLISTS

BEGIN

 

END

{{out}}

<pre>~/{Downloads,Pictures}/*.{jpg,gif,png}

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

 

</pre>

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

proc combine {cases1 cases2 {insert ""}} {

}

return $current

Demonstrating:

"~/{Downloads,Pictures}/*.{jpg,gif,png}"

"It{{em,alic}iz,erat}e{d,}, please."

} {

puts $testcase\n\t[join [commatize $testcase] \n\t]

{{out}}

<pre>

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}

</pre>

 

=={{header|zkl}}==

This is a two pass algorithm (2*length(string)), one pass to find valid {} pairs, the next pass to expand them.

cs:=L();

foreach c in (code){ // start fresh or continue (if recursing)

}

strings

"It{{em,alic}iz,erat}e{d,}, please.", "a{2,1}b{X,Y,X}c", 0'|a\\{\\\{b,c\,d}|,

"{a,b{c{,{d}}e}f", 0'|{,{,gotta have{ ,\, again\, }}more }cowbell!|,

{

"%s expands to\n %s".fmt(bs,expando(bs)).println();

{{out}}

<pre>