Faça um código que use uma lista e um número como entrada e gere todas as combinações possíveis com o comprimento do número. Por exemplo, com a lista {0,1} e o número 2 :

00
01
10
11

Seu programa não precisa esperar caracteres duas ou mais vezes na lista, como {0,0,0,0,0,1,1,5,5}

Certifique-se de imprimir as combinações ordenadas, na ordem da lista:

Com a lista {0,1} e o número 5 (gerado por parte do meu código, que é muito longo para ganhar):

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

Mas com a lista {1,0} e o número 2 :

11
10
01
00

Como você pode ver, lista invertida significa ordem invertida.

Dê uma olhada na estrutura, é como uma árvore.

Isso é código-golfe, então o código mais curto em bytes vence!

Geléia , 1 byte

ṗ

TryItOnline

Átomo embutido no poder cartesiano, como um elo diádico com o argumento esquerdo dos itens e o argumento direito da contagem, ou como um programa completo com o primeiro argumento dos itens e o segundo argumento a contagem.

Haskell, 20 bytes

(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"]

replicatefaz ncópias do segundo parâmetro e mapM idcria as combinações. Btw, mapM idé o mesmo que sequence, mas 1 byte a menos.

MATL , 2 bytes

Z^

Poder cartesiano construído ...

Experimente online!

Pitão, 2 bytes

^F

Um programa que recebe entrada no formulário list,number e imprime uma lista de listas.

Suíte de teste

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

Explicação:

{[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 ou superior), 55 bytes

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

Tenho 99% de certeza de que a recursão é a melhor maneira de fazer isso em JavaScript.

Perl, 30 bytes

28 bytes de código + -nlsinalizador.

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

Para executá-lo:

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

Eu acho que tomar a entrada como uma lista de números é lógico para Perl. No entanto, se permitirmos alguma fantasia e pegar a entrada com colchetes e vírgula (como mostrado na pergunta), podemos reduzir para 20 bytes :

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

Explicações: glob o objetivo inicial no Perl é listar e iterar por meio de nomes de arquivos, mas quando seu argumento contém colchetes, ele gera combinações formadas por um elemento de cada grupo de colchetes.
-adivisão automática em espaços da entrada e coloque o resultado dentro da @Fmatriz.
$"é o separador de lista: é o separador inserido entre os elementos de uma lista dentro de uma string. Nós configuramos para ,, então "{@F"}produz {.,.}(se @Fcontém 0 e 1).
Então xé o operador de repetição de string (e <>obtém uma linha de entrada).
E, finalmente, say forpercorre a lista gerada globe imprime os elementos.

Mathematica, 6 bytes

Tuples

Ainda pior do 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

Função sem nome, obtendo uma lista de objetos oe uma contagem ne retornando uma lista das combinações.

Pure Bash, 36

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

Entrada por parâmetros de linha de comando - A lista é uma lista separada por vírgula entre chaves, por exemplo:

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

Observe que a lista de entrada precisa ser citada para que o shell de chamada não a expanda cedo demais.

Ideone .

R , 53 45 bytes

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

Experimente online!

rev está em conformidade com a ordem de classificação precisa solicitada (o que realmente não parece essencial para o problema) e adiciona 5 bytes.

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

Teste:

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

Resultado:

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

Leva o comprimento como o primeiro argumento e a lista como qualquer outro argumento.
Use 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

Será executado um erro fatal "falta de memória" se for solicitado o comprimento 0.

05AB1E , 2 1 byte s

ã

-1 byte graças ao @Enigma .

Experimente online.

Entrada como number\nlist, saída como lista de listas.

Explicação:

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