Generieren Sie mit einer Zeichenfolge aus verschiedenen Zeichen und einer Zahl n alle geordneten Kombinationen mit Wiederholung der Länge 1 bis n unter Verwendung dieser Zeichen.

Eine andere Möglichkeit, dies zu definieren, besteht darin, die angegebenen Zeichen als "benutzerdefinierte" Ziffern in der Basis (Radix) der Anzahl der Zeichen zu sehen. Das Programm sollte dann alle "Zahlen" mit 1 bis n Ziffern in dieser Basis generieren, jedoch führend "Nullen" sind ebenfalls enthalten.

Die Kombinationen sollten nach ihrer Länge geordnet sein (zuerst 1 Zeichen, dann 2 usw.), aber ansonsten können sie in beliebiger Reihenfolge sein. Sie können die bequemsten Methoden für die Verarbeitung von Ein- und Ausgaben auswählen. Der kürzeste Code gewinnt.

Beispiele:

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

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

Probieren Sie es online aus!

Verpassen Sie nie die Gelegenheit, einen Scan zu verwenden :)

fordert zur Eingabe einer Zeichenfolge mit "Ziffern" und dann für auf n

danke @ Adám, dass du mir gesagt hast, wie man ]boxTIO aktiviert

Python 2, 56 Bytes

nist die maximale Länge und swird voraussichtlich eine Liste von Zeichen sein. Mir ist nicht klar, ob n = 0 oder eine leere Zeichenliste gültige Eingaben sind, aber diese Funktion behandelt sie auch korrekt.

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+(⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺]}¨⍳⍵}

Verwendung: Das linke Argument ist die Zeichenfolge und das rechte Argument ist die Zahl wie folgt:

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

Die Ausgabe ist nach Länge geordnet, aber innerhalb der Längengruppen sind sie um eins nach links verschoben. Dies war am einfachsten.

Erläuterung:

• ,/⍺∘{... }¨⍳⍵: Wenden Sie für 1..⍵ die Funktion auf ⍺ an und verbinden Sie die Ergebnisse.
• (⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺: Konvertieren Sie für jede Zahl von 1 bis (⍵ = (aktuelle Länge)) ^ (⍴⍺ = (Anzahl der Zeichen)) mit ⍵ Ziffern in die Basis ⍴⍺.
• 1+: füge eins hinzu, da Arrays 1-indiziert sind.
• ⍺[... ]: Verwenden Sie diese als Indizes für die Zeichenfolge
• ↓⍉: Drehen Sie die Matrix so, dass sich die 'Zahlen' in den Zeilen anstatt in den Spalten befinden, und teilen Sie die Matrix dann nach Zeilen auf.

Haskell, 34 Zeichen

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

Unkomplizierte Verwendung der Listenmonade. Das einzig wahre Golfen ist die Verwendung von mapManstelle der idiomatischeren (und kürzeren) replicateM, die importiert werden müssten Control.Monad.

Verwendungszweck

> "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]kann nicht verkürzt werden, t+=[s]da L und t auf dieselbe Liste zeigen würden.

Eingang: 'ab', 3

Ausgabe:

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

Mathematica 29 19 28

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

Verwendungszweck

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^

Probieren Sie es auf MATL Online aus!

(MATL wurde erstellt, nachdem diese Herausforderung veröffentlicht wurde, aber ich glaube, dass dies heutzutage durch Meta-Konsens in Ordnung ist.)

(-1 Bytes dank @Luis Mendo.)

x - Zeichenfolgeneingabe vom Stapel löschen (automatisch in die Zwischenablage G kopieren)

:" - implizite Eingabe der Nummer n, Schleife von 1 nach n

1G - Fügen Sie die Eingabezeichenfolge aus der Zwischenablage G in den Stapel ein

@ - Drücken Sie den aktuellen Schleifeniterationsindex

Z^- kartesische Macht: kartesisches Produkt der Eingabe mit sich selbst @mehrmals

Die kartesischen @Potenzergebnisse ( -stellige "Zahlen" in der angegebenen Basis) werden auf dem Stapel akkumuliert und am Ende implizit angezeigt.

Python - 106

Die unkomplizierte, unkreative Lösung. Wenn Sie signifikante Verbesserungen feststellen, geben Sie diese bitte als separate Antwort an.

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

Eingabe: "ab",3
Ausgabe:

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

Python, 100

Abgeleitet von der Lösung von @ 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

Eingang: 'ab', 3

Ausgabe:

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

Probieren Sie es online aus!

-1 Byte dank @Xcali !

Pyth, 6 Bytes

s^LQSE

Erwartet den Zeichensatz als 1. Eingabe, die Anzahl der Ziffern als 2 .. Ein Byte könnte gespeichert werden, wenn es eine Einzelbyte-Methode gäbe, um wiederholt auf die zweite Eingabe zuzugreifen, aber leider ...

Probieren Sie es hier online aus .

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

Probieren Sie es online aus!

Anonymer Codeblock, der eine Zeichenfolge und eine Zahl verwendet und eine Liste von Zeichenfolgen zurückgibt.

PHP 180

Ich habe keine Ahnung ... Ich fühle mich faul.

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

Die Y-Kombinator-Version (für 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)

Modulversion:

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

Gebühren ohne obligatorische Buchhaltung (Modul und Export) gezählt.

Ruby , 73 Bytes

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

Probieren Sie es online aus!

Japt , 9 Bytes

Erklärungen folgen.

õ!àUçV)mâ

Versuch es

õ_çV àZ â

Versuch es

Gelee , 6 Bytes

WẋŒpƤẎ

Probieren Sie es online aus!

Funktionsübermittlung, wobei die Liste der Ziffern als erstes Argument und die Anzahl der Ziffern als zweites Argument verwendet werden. Die Ziffern selbst können beliebige Datentypen von Jelly sein, aber ich habe im obigen TIO-Link Ganzzahlen verwendet, da dies die bestaussehende Ausgabe in Jellys automatischem Wrapper "Funktion → Vollprogramm" erzeugt.

Erläuterung

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

Das kartesische Produkt gibt uns effektiv alle Zahlen mit einer bestimmten Anzahl von Ziffern (je nachdem, mit welchem ​​Präfix wir arbeiten). Wir erhalten also eine Liste von Kombinationslisten (nach Länge gruppiert) und können diese eine Ebene reduzieren , um eine Liste zu erhalten, die nicht gruppiert ist (die jedoch nach Länge sortiert ist , wie es die Frage erfordert, wie dies nicht der ẎFall ist) 'ändere nicht die relative Reihenfolge der Elemente und Ƥversuche zuerst kürzere Präfixe).

05AB1E , 6 Bytes

「˜Ùé

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

6-Byte-Alternative:

HINWEIS: Flexible Ausgabe: Gibt für jede Länge eine neue Liste in derselben Druckzeile aus.
Das Konvertieren in eine einzelne Liste würde 2 Bytes länger dauern: Lv²yã`})( Online ausprobieren ).

Lv²yã?

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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}

Probieren Sie es online aus!