Crea un codice che accetta un elenco e un numero come input e genera tutte le possibili combinazioni con la lunghezza del numero. Ad esempio, con l'elenco {0,1} e il numero 2 :

00
01
10
11

Il tuo programma non deve aspettarsi caratteri due o più volte nell'elenco, come {0,0,0,0,0,1,1,5,5}

Assicurati di stampare le combinazioni ordinate, nell'ordine dell'elenco:

Con l'elenco {0,1} e il numero 5 (generato da alcuni dei miei codici, che è un modo troppo lungo per vincere):

00000
00001
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
11101
11110
11111

Ma con l'elenco {1,0} e il numero 2 :

11
10
01
00

Come puoi vedere, l'elenco invertito significa ordine invertito.

Dai un'occhiata alla struttura, è come un albero.

Questo è code-golf, quindi vince il codice più corto in byte!

Gelatina , 1 byte

ṗ

TryItOnline

Atomo incorporato di potenza cartesiana, come collegamento diadico con argomento sinistro gli elementi e argomento destro il conteggio, o come programma completo con primo argomento gli elementi e secondo argomento il conteggio.

Haskell, 20 byte

(mapM id.).replicate

Uso exaple:

*Main> ( (mapM id.).replicate )  2 "01" 
["00","01","10","11"]
*Main> ( (mapM id.).replicate )  2 "10" 
["11","10","01","00"]

replicatecrea ncopie del secondo parametro e mapM idcrea le combinazioni. A proposito, mapM idè lo stesso di sequence, ma 1 byte in meno.

MATL , 2 byte

Z^

Potere cartesiano incorporato ...

Provalo online!

Pyth, 2 byte

^F

Un programma che accetta input nel modulo list,numbere stampa un elenco di elenchi.

Suite di test

Come funziona

^F   Program. Input: Q
^FQ  Implicit input fill
 F   Fold
^    repeated Cartesian power
  Q  over Q
     Implicitly print

Perl 6 , 15 byte

{[X] @^a xx$^b}

Spiegazione:

{[X] @^a xx$^b}

{             } # bare block lambda

     @^a        # declare first parameter as Positional
           $^b  # declare second parameter
         xx     # list repeat ｢@a｣, ｢$b｣ times

# at this point given ｢ (0,1), 5 ｣
# ((0 1) (0 1) (0 1) (0 1) (0 1))

 [ ]            # list reduce
  X             #    using cross meta-operator

# results in a list of lists
# ((0 0 0 0 0)
#  (0 0 0 0 1)
#  (0 0 0 1 0)
#  (0 0 0 1 1)
#  (0 0 1 0 0)
#  (0 0 1 0 1)
#  ...
#  (1 1 1 1 1))

say {[X] $^a xx$^b}( (0,1), 2 ); # ((0 0) (0 1) (1 0) (1 1))
say {[X] $^a xx$^b}( (1,0), 2 ); # ((1 1) (1 0) (0 1) (0 0))
say {[X] $^a xx$^b}( (0,1,2), 2 );
# ((0 0) (0 1) (0 2) (1 0) (1 1) (1 2) (2 0) (2 1) (2 2))

put {[X] $^a xx$^b}( (0,1), 5 )».join;
# 00000 00001 00010 00011 00100 00101 00110 00111 01000 01001 01010 01011 01100 01101 01110 01111 10000 10001 10010 10011 10100 10101 10110 10111 11000 11001 11010 11011 11100 11101 11110 11111

JavaScript (Firefox 30+), 55 byte

f=(a,n)=>n?[for(b of a)for(c of f(a,n-1))[b,...c]]:[[]]

Sono sicuro che il 99% di ricorsione è il modo migliore per farlo in JavaScript.

Perl, 30 byte

28 byte di codice + -nlflag.

$"=",";say for glob"{@F}"x<>

Per eseguirlo:

perl -alE '$"=",";say for glob"{@F}"x<>' <<< "1 0
2"

Penso che prendere l'input come un elenco di numeri sia logico per Perl. Tuttavia, se consentiamo un po 'di fantasia e prendiamo l'input con le parentesi e la virgola (come mostrato nella domanda), possiamo scendere a 20 byte :

perl -nlE 'say for glob$_ x<>' <<< "{1,0}
2"

Spiegazioni: glob lo scopo iniziale in Perl è la lista e iterare attraverso i nomi dei file, ma quando il suo argomento contiene parentesi graffe, genera combinazioni formate da un elemento di ciascun gruppo di parentesi.
-aSposta automaticamente su spazi l'input e inserisce il risultato all'interno @Fdell'array.
$"è il separatore di elenco: è il separatore inserito tra gli elementi di un elenco all'interno di una stringa. Lo impostiamo su ,, quindi "{@F"}produce {.,.}(se @Fcontiene 0 e 1).
Quindi xè l'operatore di ripetizione stringa (e <>ottiene una riga di input).
E infine, say forscorre l'elenco generato globe stampa gli elementi.

Mathematica, 6 byte

Tuples

Ancora peggio di Jelly :(

uso

Tuples[{0, 1}, 5]

{{0, 0, 0, 0, 0}, {0, 0, 0, 0, 1}, {0, 0, 0, 1, 0}, {0, 0, 0, 1, 1}, {0, 0, 1, 0, 0}, {0, 0, 1, 0, 1}, {0, 0, 1, 1, 0}, {0, 0, 1, 1, 1}, {0, 1, 0, 0, 0}, {0, 1, 0, 0, 1}, {0, 1, 0, 1, 0}, {0, 1, 0, 1, 1}, {0, 1, 1, 0, 0}, {0, 1, 1, 0, 1}, {0, 1, 1, 1, 0}, {0, 1, 1, 1, 1}, {1, 0, 0, 0, 0}, {1, 0, 0, 0, 1}, {1, 0, 0, 1, 0}, {1, 0, 0, 1, 1}, {1, 0, 1, 0, 0}, {1, 0, 1, 0, 1}, {1, 0, 1, 1, 0}, {1, 0, 1, 1, 1}, {1, 1, 0, 0, 0}, {1, 1, 0, 0, 1}, {1, 1, 0, 1, 0}, {1, 1, 0, 1, 1}, {1, 1, 1, 0, 0}, {1, 1, 1, 0, 1}, {1, 1, 1, 1, 0}, {1, 1, 1, 1, 1}}

Python, 57 byte

from itertools import*
lambda o,n:list(product(*([o]*n)))

repl.it

Funzione senza nome che prende un elenco di oggetti oe un conteggio ne restituisce un elenco delle combinazioni.

Pure Bash, 36

printf -vv %$2s
eval echo ${v// /$1}

Inserito da parametri della riga di comando - L'elenco è un elenco separato da virgole tra parentesi graffe, ad esempio:

./elemcombo.sh "{0,1}" 2

Si noti che l'elenco di input deve essere citato in modo che la shell chiamante non lo espanda troppo presto.

Ideone .

R , 53 45 byte

function(x,n)rev(expand.grid(rep(list(x),n)))

Provalo online!

rev è lì per conformarsi al preciso ordinamento richiesto (che non sembra davvero essenziale al problema) e aggiunge 5 byte.

Racchetta 123 byte

(let p((s "")(l(map number->string(sort l <))))
(if(= n(string-length s))(displayln s)(for((i l))(p(string-append s i)l))))

Ungolfed:

(define(f l n)
  (let loop ((s "")
             (l (map number->string (sort l <))))
    (if (= n (string-length s))
        (displayln s)
        (for ((i l))
          (loop (string-append s i) l)))))

test:

(f '(0 1) 2)
(f '(0 1) 3)
(f '(0 1) 5)

Produzione:

00
01
10
11

000
001
010
011
100
101
110
111

00000
00001
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
11101
11110
11111

PHP, 109 byte

for($o=$a=array_slice($argv,2);--$argv[1];$o=$c,$c=[])foreach($a as$n)foreach($o as$s)$c[]=$n.$s;print_r($o);

Prende la lunghezza come primo argomento e l'elenco come ulteriori argomenti.
Usa come:

php -r "for($o=$a=array_slice($argv,2);--$argv[1];$o=$c,$c=[])foreach($a as$n)foreach($o as$s)$c[]=$n.$s;print_r($o);" 5 0 1

Si verificherà un errore irreversibile "memoria insufficiente" se viene richiesta la lunghezza 0.

05AB1E , 2 1 byte s

ã

-1 byte grazie a @Enigma .

Provalo online.

Input as number\nlist, output as list of lists.

Spiegazione:

     # Implicit input `a`, `b`
ã    # Take the Cartesian product of list `b` repeated `a` times