Data una stringa di caratteri diversi e un numero n, genera tutte le combinazioni ordinate con ripetizione, di lunghezza da 1 a n, usando quei caratteri.

Un altro modo per definirlo è vedere i caratteri dati come cifre "personalizzate" nella base (radix) del numero di caratteri, quindi il programma dovrebbe generare tutti i "numeri" con cifre da 1 a n in quella base, tuttavia, portando sono inclusi anche "zeri".

Le combinazioni devono essere ordinate in base alla loro lunghezza (1 carattere prima, poi 2, ecc.), Ma a parte questo possono essere in qualsiasi ordine. Puoi scegliere i modi più convenienti per gestire input e output. Il codice più corto vince.

Esempi:

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) , 13 byte ^SBCS

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

Provalo online!

non perdere mai l'opportunità di usare una scansione :)

richiede una stringa di "cifre" e quindi per n

grazie @Adám per avermi detto come abilitare ]boxsu TIO

Python 2, 56 byte

nè la lunghezza massima e sdovrebbe essere un elenco di caratteri. Non mi è chiaro se n = 0 o un elenco di caratteri vuoto siano input validi, ma questa funzione li gestisce anche correttamente.

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

J, 41 caratteri

   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: l'argomento sinistro è la stringa e l'argomento destro è il numero, in questo modo:

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

L'output è ordinato per lunghezza, ma all'interno dei gruppi di lunghezza sono spostati di uno a sinistra, questo è stato più semplice.

Spiegazione:

• ,/⍺∘{... }¨⍳⍵: per 1..⍵, applica la funzione a ⍺ e unisci i risultati.
• (⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺: per ogni numero compreso tra 1 e (⍵ = (lunghezza corrente)) ^ (⍴⍺ = (quantità di caratteri)), converti in base ⍴⍺ usando ⍵ cifre.
• 1+: aggiungine uno perché gli array sono 1 indicizzati.
• ⍺[... ]: usa questi come indici nella stringa
• ↓⍉: ruota la matrice, in modo che i "numeri" siano nelle righe anziché nelle colonne, quindi dividi la matrice per righe.

Haskell, 34 personaggi

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

Uso semplice della monade lista. L'unico vero golf è l'uso mapMinvece del più idiomatico (e più breve) replicateMche richiederebbe l'importazione 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]non può essere abbreviato t+=[s]perché L e t indicherebbero lo stesso elenco.

Ingresso: 'ab', 3

Produzione:

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

x:"1G@Z^

Provalo su MATL Online!

(MATL è stato creato dopo che questa sfida è stata pubblicata, ma credo che al giorno d'oggi vada bene per meta consenso.)

(-1 byte grazie a @Luis Mendo.)

x - cancella l'input di stringa dallo stack (lo copia automaticamente negli appunti G)

:" - input implicito del numero n, loop da 1 a n

1G - incolla indietro la stringa di input dagli Appunti G nello stack

@ - spingere l'indice di iterazione del loop corrente

Z^- potere cartesiano: prodotto cartesiano di input con se stesso @numero di volte

I risultati della potenza cartesiana ( @-digit "numeri" nella base data) vengono accumulati nello stack e implicitamente visualizzati alla fine.

Python - 106

La soluzione semplice e non creativa. Se trovi miglioramenti significativi, pubblica come risposta separata.

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

Ingresso: "ab",3
Uscita:

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

Python, 100

Derivato dalla soluzione di @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

Ingresso: 'ab', 3

Produzione:

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

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

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

Provalo online!

-1 byte grazie a @Xcali !

Pyth, 6 byte

s^LQSE

Prevede l'insieme di caratteri come primo input, il numero di cifre come secondo. Un byte potrebbe essere salvato se esistesse un metodo a byte singolo per accedere ripetutamente al secondo ingresso, ma purtroppo ...

Provalo online qui .

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 byte

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

Provalo online!

Blocco di codice anonimo che accetta una stringa e un numero e restituisce un elenco di stringhe.

PHP 180

Non ne ho idea ... Mi sento pigro.

<?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 versione combinatrice Y (per 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)

Versione del modulo:

-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)].

Caratteri conteggiati senza contabilità obbligatoria (modulo ed esportazione).

Rubino , 73 byte

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

Provalo online!

Japt , 9 byte

Spiegazioni da seguire.

õ!àUçV)mâ

Provalo

õ_çV àZ â

Provalo

Gelatina , 6 byte

WẋŒpƤẎ

Provalo online!

Invio di funzioni, prendendo l'elenco di cifre come primo argomento e il numero di cifre come secondo. Le cifre stesse possono essere uno qualsiasi dei tipi di dati di Jelly, ma ho usato numeri interi nel link TIO sopra perché produce l'output più bello nel wrapper automatico "funzione → programma completo" di Jelly.

Spiegazione

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

Il prodotto cartesiano ci fornisce effettivamente tutti i numeri con un determinato numero di cifre (in base al prefisso con cui stiamo lavorando). Quindi finiamo con un elenco di elenchi di combinazioni (raggruppati per lunghezza) e possiamo appiattire quel livello per ottenere un elenco che non è raggruppato (ma che è ancora ordinato per lunghezza, come richiesto dalla domanda, come Ẏnon cambia l'ordine relativo degli elementi e Ƥprova prima i prefissi più brevi).

05AB1E , 6 byte

「˜Ùé

Provalo online o verifica tutti i casi di test .

Spiegazione:

ã         # 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 a 6 byte:

NOTA: output flessibile: genera un nuovo elenco per ogni lunghezza, tutti sulla stessa linea di stampa.
La conversione in un unico elenco sarebbe più lunga di 2 byte: Lv²yã`})( Provalo online ).

Lv²yã?

Provalo online o verifica tutti i casi di test .

Spiegazione:

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 byte

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

Provalo online!