Dada una cadena de caracteres diferentes y un número n, genere todas las combinaciones ordenadas con repetición, de longitud 1 a n, utilizando esos caracteres.

Otra forma de definirlo es ver los caracteres dados como dígitos "personalizados" en la base (raíz) del número de caracteres, luego el programa debe generar todos los "números" con 1 a n dígitos en esa base, sin embargo, También se incluyen "ceros".

Las combinaciones deben ordenarse por su longitud (1 carácter primero, luego 2, etc.), pero aparte de eso pueden estar en cualquier orden. Puede elegir las formas más convenientes de manejar la entrada y la salida. El código más corto gana.

Ejemplos:

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

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

Pruébalo en línea!

nunca pierdas la oportunidad de usar un escaneo :)

solicita una cadena de "dígitos" y luego n

gracias @ Adám por decirme cómo habilitar ]boxen TIO

Python 2, 56 bytes

nes la longitud máxima y sse espera que sea una lista de caracteres. No me queda claro si n = 0 o una lista de caracteres vacía son entradas válidas, pero esta función también las maneja correctamente.

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

J, 41 char

   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: el argumento izquierdo es la cadena y el argumento derecho es el número, así:

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

La salida está ordenada por longitud, pero dentro de los grupos de longitud se desplazan uno a la izquierda, esto fue más fácil.

Explicación:

• ,/⍺∘{... }¨⍳⍵: para 1..⍵, aplique la función a ⍺ y combine los resultados.
• (⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺: para cada número de 1 a (⍵ = (longitud actual)) ^ (⍴⍺ = (cantidad de caracteres)), convierta a base ⍴⍺ usando ⍵ dígitos.
• 1+: agrega uno porque las matrices están indexadas en 1.
• ⍺[... ]: utilícelos como índices en la cadena
• ↓⍉: gire la matriz, de modo que los 'números' estén en las filas en lugar de en las columnas, y luego divida la matriz en filas.

Haskell, 34 personajes

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

Uso directo de la lista mónada. El único golf real es el uso de, en mapMlugar del más idiomático (y más corto) replicateMque requeriría importación 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] no se puede acortar a t+=[s] porque L y t estarían apuntando a la misma lista.

Entrada: 'ab', 3

Salida:

['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^

Pruébalo en MATL Online!

(MATL se creó después de publicar este desafío, pero creo que está bien por meta consenso en estos días).

(-1 bytes gracias a @Luis Mendo.)

x - Eliminar la entrada de cadena de la pila (la copia automáticamente al portapapeles G)

:" - entrada implícita del número n, bucle de 1 a n

1G - pegue la cadena de entrada del portapapeles G en la pila

@ - empujar el índice de iteración de bucle actual

Z^ - poder cartesiano: producto cartesiano de entrada consigo mismo @ número de veces

Los resultados del poder cartesiano ( @"números" de dígitos en la base dada) se acumulan en la pila y se muestran implícitamente al final.

Python - 106

La solución sencilla y poco creativa. Si encuentra mejoras significativas, publique como respuesta por separado.

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
Salida:

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

Python, 100

Derivado de la solución de @ 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

Salida:

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

Pruébalo en línea!

-1 byte gracias a @Xcali !

Pyth, 6 bytes

s^LQSE

Espera el conjunto de caracteres como primera entrada, número de dígitos como segunda. Se podría guardar un byte si hubiera un método de un solo byte para acceder repetidamente a la segunda entrada, pero por desgracia ...

Pruébelo en línea aquí .

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

Pruébalo en línea!

Bloque de código anónimo que toma una cadena y un número y devuelve una lista de cadenas.

PHP 180

No tengo idea ... me siento flojo.

<?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

La versión del 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)

Versión del 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 sin contabilidad obligatoria (módulo y exportación).

Ruby , 73 bytes

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

Pruébalo en línea!

Japt , 9 bytes

Explicaciones a seguir.

õ!àUçV)mâ

Intentalo

õ_çV àZ â

Intentalo

Jalea , 6 bytes

WẋŒpƤẎ

Pruébalo en línea!

Envío de funciones, tomando la lista de dígitos como primer argumento y el número de dígitos como segundo. Los dígitos en sí pueden ser cualquiera de los tipos de datos de Jelly, pero utilicé números enteros en el enlace TIO anterior porque produce la salida más atractiva en el contenedor automático "función → programa completo" de Jelly.

Explicación

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

El producto cartesiano nos da efectivamente todos los números con un número determinado de dígitos (según el prefijo con el que estamos trabajando). Así que terminamos con una lista de listas de combinaciones (agrupados por longitud), y se puede acoplar un nivel que con el fin de obtener una lista que no está agrupado (pero que sigue siendo solucionado por la longitud, ya que la cuestión requiere, como Ẏdoesn No cambie el orden relativo de los elementos e Ƥintente prefijos más cortos primero).

05AB1E , 6 bytes

「˜Ùé

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ã         # 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: Salida flexible: genera una nueva lista para cada longitud, todo en la misma línea de impresión.
Convertirlo en una sola lista sería 2 bytes más largo: Lv²yã`})( Pruébelo en línea ).

Lv²yã?

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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}

Pruébalo en línea!