Dada uma sequência de caracteres diferentes e um número n, gere todas as combinações ordenadas com repetição, de 1 a n, usando esses caracteres.

Outra maneira de defini-lo é ver os caracteres dados como dígitos "personalizados" na base (raiz) do número de caracteres; o programa deve gerar todos os "números" com 1 a n dígitos nessa base, levando, no entanto, "zeros" também estão incluídos.

As combinações devem ser ordenadas de acordo com seu tamanho (1 caractere primeiro, depois 2 etc.), mas, além disso, elas podem estar em qualquer ordem. Você pode escolher as formas mais convenientes de lidar com entrada e saída. O menor código vence.

Exemplos:

ab, 3-> a,b,aa,ab,ba,bb,aaa,aab,aba,baa,abb,bab,bba,bbb
0123456789, 2->0,1,2,3,4,5,6,7,8,9,00,01,...,09,10,11,...,99

APL (Dyalog Unicode) , ^{SBCS de} 13 bytes

⊃,/,¨∘.,\⎕⍴⊂⍞

Experimente online!

nunca perca a oportunidade de usar uma digitalização :)

solicita uma sequência de "dígitos" e, em seguida, n

obrigado @ Adám por me dizer como ativar ]boxno TIO

Python 2, 56 bytes

né o tamanho máximo e sespera-se que seja uma lista de caracteres. Não está claro para mim se n = 0 ou uma lista de caracteres vazia são entradas válidas, mas essa função também as manipula corretamente.

f=lambda s,n:n*s and s+[x+c for x in f(s,n-1)for c in s]

J, 41 caracteres

   f=.}:@;@({@(,&(<',')@(]#<@[))"1 0>:@i.@])

   'ab' f 3
a,b,aa,ab,ba,bb,aaa,aab,aba,abb,baa,bab,bba,bbb

APL (31)

{,/⍺∘{↓⍉⍺[1+(⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺]}¨⍳⍵}

Uso: o argumento da esquerda é a string e o argumento da direita é o número, assim:

    'ab'{,/⍺∘{↓⍉⍺[1+(⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺]}¨⍳⍵}3
b  a  ab  ba  bb  aa  aab  aba  abb  baa  bab  bba  bbb  aaa  

A saída é ordenada por comprimento, mas dentro dos grupos de comprimento eles são deslocados um para a esquerda, isso foi mais fácil.

Explicação:

• ,/⍺∘{... }¨⍳⍵: para 1..⍵, aplique a função a ⍺ e junte os resultados.
• (⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺: para cada número de 1 a (⍵ = (comprimento atual)) ^ (⍴⍺ = (quantidade de caracteres)), converta na base ⍴⍺ usando ⍵ dígitos.
• 1+: adicione um porque as matrizes são indexadas 1.
• ⍺[... ]: use-os como índices na string
• ↓⍉: gire a matriz, para que os 'números' estejam nas linhas, e não nas colunas, e depois divida a matriz por linhas.

Haskell, 34 caracteres

x%n=do k<-[1..n];mapM(\_->x)[1..k]

Uso direto da mônada da lista. O único golfe de verdade é o uso, em mapMvez do mais idiomático (e mais curto), replicateMque exigiria importação Control.Monad.

Uso

> "ab" % 3
["a","b","aa","ab","ba","bb","aaa","aab","aba","abb","baa","bab","bba","bbb"]

Python, 97 94

from itertools import*
s,n=input()
L=t=[]
exec"t=t+[s];L+=map(''.join,product(*t));"*n
print L

t=t+[s]não pode ser reduzido, t+=[s]porque L e t apontariam para a mesma lista.

Entrada: 'ab', 3

Resultado:

['a', 'b', 'aa', 'ab', 'ba', 'bb', 'aaa', 'aab', 'aba', 'abb', 'baa', 'bab', 'bb
a', 'bbb']

Mathematica 29 19 28

Join@@(i~Tuples~#&/@Range@n)

Uso

i={a, 4, 3.2};n=3;

Join@@(i~Tuples~#&/@Range@n)

{{a}, {4}, {3.2}, {a, a}, {a, 4}, {a, 3.2}, {4, a}, {4, 4}, {4, 3.2}, { 3.2, a}, {3.2, 4}, {3.2, 3.2}, {a, a, a}, {a, a, 4}, {a, a, 3.2}, {a, 4, a}, { a, 4, 4}, {a, 4, 3,2}, {a, 3,2, a}, {a, 3,2, 4}, {a, 3,2, 3,2}, {4, a, a}, {4, a, 4}, {4, a, 3,2}, {4, 4, a}, {4, 4, 4}, {4, 4, 3,2}, {4, 3,2, a}, {4, 3,2, 4}, {4, 3,2, 3,2}, {3,2, a, a}, {3,2, a, 4}, {3,2, a, 3,2}, {3,2, 4, a}, {3,2, 4, 4} , {3,2, 4, 3,2}, {3,2, 3,2, a}, {3,2, 3,2, 4}, {3,2, 3,2, 3,2}}

MATL, 9 8 bytes

x:"1G@Z^

Experimente no MATL Online!

(O MATL foi criado depois que esse desafio foi publicado, mas acredito que tudo bem por meta consenso nos dias de hoje.)

(-1 bytes graças a @Luis Mendo.)

x - excluir entrada de string da pilha (copia automaticamente para a área de transferência G)

:" - entrada implícita do número n, loop de 1 a n

1G - cole a sequência de entrada da área de transferência G na pilha

@ - pressione o índice de iteração do loop atual

Z^- poder cartesiano: produto cartesiano de entrada com ele próprio @número de vezes

Os resultados do poder cartesiano ( @"números" de dígitos na base fornecida) são acumulados na pilha e exibidos implicitamente no final.

Python - 106

A solução direta e não criativa. Se você encontrar melhorias significativas, poste como resposta separada.

s,n=input()
l=len(s)
for i in range(1,n+1):
 for j in range(l**i):t='';x=j;exec't+=s[x%l];x/=l;'*i;print t

Entrada: "ab",3
Saída:

a
b
aa
ba
ab
bb
aaa
baa
aba
bba
aab
bab
abb
bbb

Python, 100

Derivado da solução do @ aditsu .

s,n=input()
L=len(s)
i=0
while i<n:i+=1;j=0;exec"x=j=j+1;t='';exec't+=s[x%L];x/=L;'*i;print t;"*L**i

Entrada: 'ab', 3

Resultado:

b
a
ba
ab
bb
aa
baa
aba
bba
aab
bab
abb
bbb
aaa

Perl 5 + -nlF -M5.010 -MList::Util+(uniq), 41 bytes

$,=$"=",";say grep/./,uniq glob"{,@F}"x<>

Experimente online!

-1 byte graças a @Xcali !

Pitão, 6 bytes

s^LQSE

Espera o conjunto de caracteres como 1ª entrada, número de dígitos como 2ª. Um byte poderia ser salvo se houvesse um método de byte único para acessar repetidamente a segunda entrada, mas ...

Experimente online aqui .

s^LQSE   Implicit: Q=input 1, E=evaluate next input
    SE   Range [1,2,...,E]
 ^LQ     Perform repeated cartesian product of Q for each element of the above
s        Flatten

Perl 6 , 33 bytes

{flat [\X~] '',|[$^a.comb xx$^b]}

Experimente online!

Bloco de código anônimo que pega uma sequência e um número e retorna uma lista de sequências.

PHP 180

Não faço ideia ... estou com preguiça.

<?php $f=fgetcsv(STDIN);$l=strlen($f[1]);$s=str_split($f[1]);for($i=1;$i<=$f[0];$i++)for($j=0;$j<pow($l,$i);$j++){$o="";$x=$j;for($q=0;$q<$i;$q++){$o.=$s[$x%$l];$x/=$l;}echo"$o ";}

Erlang 110

A versão do combinador Y (para shell):

fun(X, N)->F=fun(_,_,0)->[[]];(G, X, Y)->[[A|B]||A<-X,B<-G(G,X,Y-1)]end,[V||Y<-lists:seq(1,N),V<-F(F,X,Y)]end.

Erlang 89 (118)

Versão do módulo:

-module(g).
-export([g/2]).
h(_,0)->[[]];h(X,N)->[[A|B]||A<-X,B<-h(X,N-1)].
g(X,N)->[V||Y<-lists:seq(1,N),V<-h(X,Y)].

Caracteres contados sem escrituração obrigatória (módulo e exportação).

Ruby , 73 bytes

->s,n{(1..n).flat_map{|i|[*s.chars.repeated_permutation(i)]}.map(&:join)}

Experimente online!

Japonês , 9 bytes

Explicações a seguir.

õ!àUçV)mâ

Tente

õ_çV àZ â

Tente

Gelatina , 6 bytes

WẋŒpƤẎ

Experimente online!

Função envio, tomando a lista de dígitos como o primeiro argumento e o número de dígitos como o segundo. Os dígitos em si podem ser qualquer um dos tipos de dados de Jelly, mas eu usei números inteiros no link TIO acima porque ele produz a melhor aparência do wrapper automático de "função → programa completo" do Jelly.

Explicação

WẋŒpƤẎ                      (called with arguments, e.g. [1,2,5], 3)
Wẋ       Make {argument 2} copies of {argument 1}  (e.g. [[1,2,5],[1,2,5],[1,2,5])
    Ƥ    For each prefix:                          (e.g. 1-3 copies of [1,2,5])
  Œp       take Cartesian product of its elements
     Ẏ   Flatten one level

O produto cartesiano efetivamente nos fornece todos os números com um determinado número de dígitos (de acordo com o prefixo com o qual estamos trabalhando). Portanto, terminamos com uma lista de listas de combinações (agrupadas por comprimento) e podemos nivelar esse nível para obter uma lista que não é agrupada (mas que ainda é classificada por comprimento, conforme a pergunta exige, como Ẏnão altere a ordem relativa dos elementos e Ƥtente prefixos mais curtos primeiro).

05AB1E , 6 bytes

「˜Ùé

Experimente online ou verifique todos os casos de teste .

Explicação:

ã         # Cartesian product of the second input repeated the first input amount of times
          #  i.e. 3 and 'ab' → ['aaa','aab','aba','abb','baa','bab','bba','bbb']
 €Œ       # Take all the substrings for each of those results
          #  i.e. 'aba' → ['a','ab','aba','b','ba','a']
   ˜      # Flatten the list of lists
    Ù     # Remove all duplicated values
     é    # Sort the list by length

Alternativa de 6 bytes:

NOTA: Saída flexível: gera uma nova lista para todos os comprimentos, todos na mesma linha de impressão.
Convertê-lo em uma única lista levaria 2 bytes a mais: Lv²yã`})( Experimente online ).

Lv²yã?

Experimente online ou verifique todos os casos de teste .

Explicação:

Lv        # Loop `y` in the range [1, integer_input]
  ²yã     #  Take the second input and create an `y` times repeated cartesian product of it
          #   i.e. y=2 and 'ab' → ['aa','ab','ba','bb']
     ?    #  Print this list (without new-line)

K (ngn / k) , 17 bytes

{,/(,/,'/:)\x#,y}

Experimente online!