Brace expansion: Difference between revisions

 

 

 

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

:* &nbsp; [[Brace_expansion_using_ranges]]

<br><br>

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

{{trans|Python}}

V out = [‘’]

L s != ‘’

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

 

{{out}}

<pre>

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

</pre>

=={{header|AppleScript}}==

 

This may seem like a cheat, but it ''is'' a legitimate and obvious way to tackle the problem with AppleScript in the unlikely event that the need should arise. It adjusts the escape levels in the input text, feeds it as a shell script to macOS's sh shell, and lets ''it'' handle the expansion.

 

use framework "Foundation"

use scripting additions

set AppleScript's text item delimiters to astid

 

 

{{output}}

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

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

=={{header|AutoHotkey}}==

 

 

{{out}}

 

 

 

=={{header|C}}==

Handles only properly formed input.

#include <stdio.h>

#include <stdlib.h>

 

return 0;

{{out}}

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

gotta have more cowbell!

gotta have\, again\, more cowbell!</pre>

This approach turns the string into a tree structure, with Tokens that are either text, a concatenation or an alteration.

{{works with|C sharp|8}}

using System.Collections;

using System.Collections.Generic;

return result;

}

 

{{trans|Python}}

{

const char L = '{', R = '}', S = ',';

return (null, "");

}

{{out}}

<pre>

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

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

 

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

{{trans|Java}}

static void main(String[] args) {

for (String s : [

}

}

{{out}}

<pre>Itemized, please.

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

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

=={{header|Haskell}}==

[http://www.reddit.com/r/readablecode/comments/1w6exe/p6_crosswalk_braceexpansionparses/cf229at "Here is a direct translation to Haskell using parsec"] (of [http://rosettacode.org/mw/index.php?title=Brace_expansion&oldid=175567#Raku an earlier version of the Raku solution]):

 

 

showExpansion :: String -> String

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

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

{{out}}

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

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

{}} some }{\\ edge \,{ cases, {here} \\\\\}</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.

 

'use strict'

 

}).join('\n\n');

 

 

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

{{trans|Seed7}}

 

var

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

echo "\nExpansions of \"", str, "\":"

 

{{out}}

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

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

=={{header|Phix}}==

Fairly straightforward recursive solution

{{Out}}

<pre>

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

</pre>

=={{header|PHP}}==

{{trans|Python}}

$out = [''];

while ($s) {

printf(" %s\n", $expansion);

}

{{out}}

<pre>

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

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

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

(formerly Perl 6)

 

On the other end, we recursively walk the parse tree returning expanded sublists, and we do the cartesian concatenation of sublists at each level by use of the <tt>X~</tt> operator, which is a "cross" metaoperator used on a simple <tt>~</tt> concatenation. As a list infix operator, <tt>X~</tt> does not care how many items are on either side, which is just what you want in this case, since some of the arguments are strings and some are lists. Here we use a fold or reduction form in square brackets to interpose the cross-concat between each value generated by the map, which returns a mixture of lists and literal strings. One other thing that might not be obvious: if we bind to the match variable, <tt>$/</tt>, we automatically get all the syntactic sugar for its submatches. In this case, <tt>$0</tt> is short for <tt>$/[0]</tt>, and represents all the submatches captured by 0th set of parens in either <tt>TOP</tt> or <tt>alt</tt>. <tt>$&lt;meta&gt;</tt> is likewise short for <tt>$/&lt;meta&gt;</tt>, and retrieves what was captured by that named submatch.

token TOP { ( <meta> | . )* }

token meta { '{' <alts> '}' | \\ . }

a{b,{{c}}

{a{\}b,c}d

{{out}}

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

{a\}bd

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

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

</pre>

=={{header|Simula}}==

{{trans|Python}}

BEGIN

 

END;

 

ARRAYLISTS

BEGIN

 

END

{{out}}

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

 

</pre>

=={{header|Tailspin}}==

templates braceExpansion

composer braceParse

 

templates collateSequence

@: [''];

$... -> #

$@!

def part: $;

@: [$@... -> '$;$part;'];

 

'{}} some }{,{\\{ edge, edge} \,}{ cases, {here} \\\\\}' -> '"$;" expands to $ -> braceExpansion ... -> '$#10;$;';$#10;$#10;' -> !OUT::write

{{out}}

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

</pre>

 

=={{header|Wren}}==

{{trans|Python}}

 

var getItem = Fn.new { |s, depth|

for (s in getItem.call(input, 0)[0]) System.print(" " + s)

System.print()

 

{{out}}

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