Créez un code qui prend une liste et un nombre en entrée et génère toutes les combinaisons possibles avec la longueur du numéro. Par exemple, avec la liste {0,1} et le nombre 2 :

00
01
10
11

Votre programme ne doit pas s'attendre à des caractères deux fois ou plus souvent dans la liste, tels que {0,0,0,0,0,1,1,5,5}

Assurez-vous d'imprimer les combinaisons triées, dans l'ordre de la liste:

Avec la liste {0,1} et le chiffre 5 (généré par une partie de mon code, ce qui est beaucoup trop long pour gagner):

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

Mais avec la liste {1,0} et le numéro 2 :

11
10
01
00

Comme vous pouvez le voir, la liste inversée signifie l'ordre inversé.

Jetez un oeil à la structure, c'est comme un arbre.

C'est le code-golf, donc le code le plus court en octets gagne!

Gelée , 1 octet

ṗ

TryItOnline

Atome intégré de puissance cartésienne, en tant que lien dyadique avec l'argument gauche les éléments et l'argument droit le décompte, ou en tant que programme complet avec le premier argument les éléments et le deuxième argument le décompte.

Haskell, 20 octets

(mapM id.).replicate

Exemple d'utilisation:

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

replicatefait des ncopies du 2e paramètre et mapM idconstruit les combinaisons. Btw, mapM idest le même que sequence, mais 1 octet de moins.

MATL , 2 octets

Z^

Puissance cartésienne intégrée ...

Essayez-le en ligne!

Pyth, 2 octets

^F

Un programme qui prend la saisie dans le formulaire list,numberet imprime une liste de listes.

Suite de tests

Comment ça fonctionne

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

Perl 6 , 15 octets

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

Explication:

{[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 octets

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

Je suis certain à 99% que la récursivité est la meilleure façon de procéder à ce sujet en JavaScript.

Perl, 30 octets

28 octets de code + -nlindicateur.

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

Pour l'exécuter:

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

Je pense que prendre l'entrée comme une liste de nombres est logique pour Perl. Cependant, si nous permettons un peu de fantaisie, et prenons l'entrée avec les crochets et la virgule (comme indiqué dans la question), nous pouvons descendre à 20 octets :

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

Explications: glob le but initial en Perl est lister et parcourir les noms de fichiers, mais lorsque son argument contient des crochets, il génère des combinaisons formées d'un élément de chaque groupe de crochets.
-aautosplit sur les espaces de l'entrée et placez le résultat dans le @Ftableau.
$"est le séparateur de liste: c'est le séparateur inséré entre les éléments d'une liste à l'intérieur d'une chaîne. Nous le définissons sur ,, donc "{@F"}produit {.,.}(si @Fcontient 0 et 1).
Ensuite , xest l'opérateur de répétition de chaîne (et <>obtient une ligne d'entrée).
Et enfin, say forparcourt la liste générée par globet imprime les éléments.

Mathematica, 6 octets

Tuples

Encore pire que Jelly :(

Usage

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 octets

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

repl.it

Fonction sans nom prenant une liste d'objets oet un nombre net renvoyant une liste des combinaisons.

Pure Bash, 36

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

Entrée par les paramètres de ligne de commande - La liste est une liste séparée par des virgules entre accolades, par exemple:

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

Notez que la liste d'entrée doit être citée afin que le shell appelant ne la développe pas trop tôt.

Ideone .

R , 53 45 octets

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

Essayez-le en ligne!

rev est là pour se conformer à l'ordre de tri précis demandé (ce qui ne semble pas vraiment essentiel au problème) et ajoute 5 octets.

Raquette 123 octets

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

Non golfé:

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

Essai:

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

Production:

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 octets

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

Prend la longueur comme premier argument et la liste comme tout autre argument.
Utilisez comme:

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

S'exécutera dans une erreur fatale "mémoire insuffisante" si la longueur 0 est demandée.

05AB1E , 2 1 octet s

ã

-1 octet grâce à @Enigma .

Essayez-le en ligne.

Entrée en tant que number\nlist , sortir en tant que liste de listes.

Explication:

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