Erstellen Sie einen Code, der eine Liste und eine Nummer als Eingabe verwendet und alle möglichen Kombinationen mit der Länge der Nummer generiert. Zum Beispiel mit der Liste {0,1} und der Nummer 2 :

00
01
10
11

Ihr Programm muss nicht zweimal oder öfter Zeichen in der Liste erwarten, z. B. {0,0,0,0,0,1,1,5,5}.

Stellen Sie sicher, dass Sie die Kombinationen sortiert in der Reihenfolge der Liste ausdrucken:

Mit der Liste {0,1} und der Nummer 5 (generiert durch einen Teil meines Codes, der viel zu lang ist, um zu gewinnen):

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

Aber mit der Liste {1,0} und der Nummer 2 :

11
10
01
00

Wie Sie sehen, bedeutet umgekehrte Liste umgekehrte Reihenfolge.

Schauen Sie sich die Struktur an, sie ist wie ein Baum.

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes!

Gelee , 1 Byte

ṗ

TryItOnline

In die kartesische Kraft eingebautes Atom, als dyadische Verknüpfung mit dem linken Argument die Elemente und dem rechten Argument die Anzahl oder als vollständiges Programm mit dem ersten Argument die Elemente und dem zweiten Argument die Anzahl.

Haskell, 20 Bytes

(mapM id.).replicate

Anwendungsbeispiel:

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

replicateErstellt nKopien des 2. Parameters und erstellt mapM iddie Kombinationen. Übrigens mapM idist das gleiche wie sequence, aber 1 Byte weniger.

MATL , 2 Bytes

Z^

Kartesische Kraft ...

Probieren Sie es online!

Pyth, 2 Bytes

^F

Ein Programm, das Eingaben in das Formular übernimmt list,numberund eine Liste von Listen druckt.

Testsuite

Wie es funktioniert

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

Perl 6 , 15 Bytes

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

Erläuterung:

{[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]]:[[]]

Ich bin mir zu 99% sicher, dass Rekursion der beste Weg ist, dies in JavaScript zu tun.

Perl, 30 Bytes

28 Byte Code + -nlFlag.

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

Um es auszuführen:

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

Ich denke, dass die Eingabe als Liste von Zahlen für Perl logisch ist. Wenn wir jedoch etwas Phantasie zulassen und die Eingabe mit Klammern und Komma übernehmen (wie in der Frage gezeigt), können wir auf 20 Bytes zurückgehen :

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

Erklärungen: glob In Perl wird der ursprüngliche Zweck darin gesehen, Dateinamen aufzulisten und zu durchlaufen. Wenn das Argument jedoch geschweifte Klammern enthält, werden Kombinationen generiert, die aus einem Element jeder Klammergruppe bestehen.
-aAutomatische Teilung der Eingabe durch Leerzeichen und Platzierung des Ergebnisses innerhalb des @FArrays.
$"ist das Listentrennzeichen: Es ist das Trennzeichen, das zwischen den Elementen einer Liste in einer Zeichenfolge eingefügt wird. Wir setzen es auf ,, also "{@F"}produziert {.,.}(falls @F0 und 1 enthalten).
Ist xdann der Operator für die Zeichenfolgenwiederholung (und <>erhält eine Eingabezeile).
Zum Schluss wird say fordie von globden Elementen erzeugte Liste durchlaufen und gedruckt.

Mathematica, 6 Bytes

Tuples

Noch schlimmer als Jelly :(

Verwendung

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 Bytes

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

repl.it

Unbenannte Funktion, die eine Liste von Objekten ound eine Anzahl aufnimmt nund eine Liste der Kombinationen zurückgibt.

Pure Bash, 36

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

Eingabe über Befehlszeilenparameter - Die Liste ist eine durch Kommas getrennte Liste in geschweiften Klammern, z.

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

Beachten Sie, dass die Eingabeliste in Anführungszeichen gesetzt werden muss, damit die aufrufende Shell sie nicht zu früh erweitert.

Ideone .

R , 53 45 Bytes

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

Probieren Sie es online!

rev ist da, um die genaue Sortierreihenfolge einzuhalten (was für das Problem nicht wirklich wesentlich zu sein scheint) und fügt 5 Bytes hinzu.

Schläger 123 Bytes

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

Testen:

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

Ausgabe:

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 Bytes

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

Nimmt die Länge als erstes Argument und die Liste als weiteres Argument.
Verwenden Sie wie:

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

Wird auf einen "out of memory" -Fehler stoßen, wenn nach Länge 0 gefragt wird.

05AB1E , 2 1 Byte s

ã

-1 Byte danke an @Enigma .

Probieren Sie es online aus.

Eingabe als number\nlist , Ausgabe als Listenliste.

Erläuterung:

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