Haga un código que tome una lista y un número como entrada, y genere todas las combinaciones posibles con la longitud del número. Por ejemplo, con la lista {0,1} y el número 2 :

00
01
10
11

Su programa no tiene que esperar caracteres dos veces o más a menudo en la lista, como {0,0,0,0,0,1,1,5,5}

Asegúrese de imprimir las combinaciones ordenadas, en el orden de la lista:

Con la lista {0,1} y el número 5 (generado por parte de mi código, que es demasiado largo para ganar):

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

Pero con la lista {1,0} y el número 2 :

11
10
01
00

Como puede ver, la lista inversa significa el orden inverso.

Echa un vistazo a la estructura, es como un árbol.

Este es el código de golf, por lo que gana el código más corto en bytes

Jalea , 1 byte

ṗ

TryItOnline

Átomo incorporado de potencia cartesiana, como un enlace diádico con argumento izquierdo los elementos y argumento derecho el recuento, o como un programa completo con primer argumento los elementos y segundo argumento el recuento.

Haskell, 20 bytes

(mapM id.).replicate

Ejemplo de uso:

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

replicaterealiza ncopias del segundo parámetro y mapM idconstruye las combinaciones. Por cierto, mapM ides lo mismo que sequence, pero 1 byte menos.

MATL , 2 bytes

Z^

El poder cartesiano ...

Pruébalo en línea!

Pyth, 2 bytes

^F

Un programa que toma datos en el formulario list,numbere imprime una lista de listas.

Banco de pruebas

Cómo funciona

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

Explicación:

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

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

Estoy 99% seguro de que la recursión es la mejor manera de hacerlo en JavaScript.

Perl, 30 bytes

28 bytes de código + -nlbandera.

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

Para ejecutarlo:

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

Creo que tomar la entrada como una lista de números es lógico para Perl. Sin embargo, si permitimos algo de fantasía y tomamos la entrada con los corchetes y la coma (como se muestra en la pregunta), podemos bajar a 20 bytes :

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

Explicaciones: glob el propósito inicial en Perl es enumerar e iterar a través de los nombres de archivo, pero cuando su argumento contiene llaves, genera combinaciones formadas por un elemento de cada grupo de llaves.
-aautosplit en espacios la entrada, y poner el resultado dentro de la @Fmatriz.
$"es el separador de lista: es el separador insertado entre los elementos de una lista dentro de una cadena. Lo configuramos en ,, entonces "{@F"}produce {.,.}(si @Fcontiene 0 y 1).
Entonces xes el operador de repetición de cadena (y <>obtiene una línea de entrada).
Y finalmente, say forrecorre la lista generada por globe imprime los elementos.

Mathematica, 6 bytes

Tuples

Aún peor que 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 bytes

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

repl.it

Función sin nombre que toma una lista de objetos oy un recuento, ny devuelve una lista de las combinaciones.

Pure Bash, 36

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

Entrada por parámetros de línea de comandos: la lista es una lista separada por comas entre llaves, por ejemplo:

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

Tenga en cuenta que la lista de entrada debe citarse para que el shell de llamada no la expanda demasiado pronto.

Ideone .

R , 53 45 bytes

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

Pruébalo en línea!

rev está ahí para cumplir con el orden de clasificación preciso solicitado (que realmente no parece esencial para el problema) y agrega 5 bytes.

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

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

Pruebas:

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

Salida:

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

Toma la longitud como primer argumento y la lista como cualquier otro argumento.
Usar como:

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

Se ejecutará un error fatal "sin memoria" si se le solicita la longitud 0.

05AB1E , 2 1 byte s

ã

-1 byte gracias a @Enigma .

Pruébalo en línea.

Entrada como number\nlist, salida como lista de listas.

Explicación:

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