Utwórz kod, który pobiera listę i liczbę jako dane wejściowe i generuje wszystkie możliwe kombinacje o długości liczby. Na przykład z listą {0,1} i liczbą 2 :

00
01
10
11

Twój program nie musi oczekiwać znaków dwa lub więcej razy na liście, takich jak {0,0,0,0,0,1,1,5,5}

Upewnij się, że kombinacje zostały wydrukowane posortowane, w kolejności na liście:

Z listą {0,1} i liczbą 5 (wygenerowaną przez część mojego kodu, co jest zbyt długą wygraną):

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

Ale z listą {1,0} i liczbą 2 :

11
10
01
00

Jak widać, odwrócona lista oznacza odwróconą kolejność.

Spójrz na strukturę, to jest jak drzewo.

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach!

Galaretka , 1 bajt

ṗ

TryItOnline

Wbudowany atom kartezjański, jako ogniwo diademowe z lewym argumentem liczby i prawym argumentem liczby lub jako pełny program z pierwszym argumentem liczby i drugim argumentem liczby.

Haskell, 20 bajtów

(mapM id.).replicate

Przykład użycia:

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

replicatetworzy nkopie drugiego parametru i mapM idbuduje kombinacje. Btw, mapM idjest taki sam jak sequence, ale 1 bajt mniej.

MATL , 2 bajty

Z^

Moc kartezjańska wbudowana ...

Wypróbuj online!

Pyth, 2 bajty

^F

Program, który pobiera dane z formularza list,numberi drukuje listę list.

Zestaw testowy

Jak to działa

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

Perl 6 , 15 bajtów

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

Wyjaśnienie:

{[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 bajtów

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

Mam 99% pewności, że rekursja jest najlepszym sposobem na zrobienie tego w JavaScript.

Perl, 30 bajtów

28 bajtów kodu + -nlflaga.

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

Aby uruchomić:

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

Myślę, że przyjmowanie danych wejściowych jako listy liczb jest logiczne dla Perla. Jeśli jednak pozwolimy na trochę fantazji i weźmy dane w nawiasach i przecinkach (jak pokazano w pytaniu), możemy zmniejszyć do 20 bajtów :

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

Objaśnienia: glob początkowym celem w Perlu jest lista i iteracja po nazwach plików, ale gdy jej argument zawiera nawiasy klamrowe, generuje kombinacje utworzone z jednego elementu z każdej grupy nawiasów.
-aautosplit na spacje wejścia i umieść wynik w @Ftablicy.
$"to separator listy: jest to separator wstawiany między elementami listy w ciągu. Ustawiamy na ,, więc "{@F"}produkuje {.,.}(jeśli @Fzawiera 0 i 1).
Następnie xjest operator powtarzania łańcucha (i <>pobiera jeden wiersz danych wejściowych).
I na koniec, say foriteruje listę wygenerowaną przez globi drukuje elementy.

Mathematica, 6 bajtów

Tuples

Nadal gorzej niż galaretka :(

Stosowanie

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 bajtów

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

repl.it

Nienazwana funkcja pobierająca listę obiektów ooraz liczbę ni zwracająca listę kombinacji.

Pure Bash, 36

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

Wprowadzanie za pomocą parametrów wiersza polecenia - lista jest nawiasami rozdzielonymi przecinkami, np .:

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

Uwaga: lista wejściowa musi być cytowana, aby powłoka wywołująca nie rozwijała jej zbyt wcześnie.

Ideone .

R , 53 45 bajtów

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

Wypróbuj online!

rev jest zgodny z żądaną dokładną kolejnością sortowania (co nie wydaje się tak naprawdę istotne dla problemu) i dodaje 5 bajtów.

Rakieta 123 bajtów

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

Nie golfowany:

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

Testowanie:

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

Wynik:

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 bajtów

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

Traktuje długość jako pierwszy argument, a listę jako kolejne argumenty.
Użyj jak:

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

Jeśli zostaniesz zapytany o długość 0, wystąpi błąd krytyczny „brak pamięci”.

05AB1E , 2 1 bajty s

ã

-1 bajt dzięki @Enigma .

Wypróbuj online.

Wprowadź jako number\nlist, wyślij jako listę list.

Wyjaśnienie:

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