Étant donné une chaîne de caractères différents et un nombre n, générez toutes les combinaisons ordonnées avec répétition, de longueur 1 à n, en utilisant ces caractères.

Une autre façon de le définir est de voir les caractères donnés comme des chiffres "personnalisés" dans la base (radix) du nombre de caractères, puis le programme devrait générer tous les "nombres" avec 1 à n chiffres dans cette base, cependant, menant "zéros" sont également inclus.

Les combinaisons doivent être classées selon leur longueur (1 caractère en premier, puis 2, etc.), mais à part cela, elles peuvent être dans n'importe quel ordre. Vous pouvez choisir les moyens les plus pratiques de gérer les entrées et les sorties. Le code le plus court gagne.

Exemples:

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 octets ^SBCS

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

Essayez-le en ligne!

ne manquez jamais une occasion d'utiliser un scan :)

vous invite à saisir une chaîne de "chiffres", puis à n

merci @ Adám de m'avoir expliqué comment activer ]boxsur TIO

Python 2, 56 octets

nest la longueur maximale et sdevrait être une liste de caractères. Il n'est pas clair pour moi si n = 0 ou une liste de caractères vide sont des entrées valides, mais cette fonction les gère également correctement.

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

J, 41 car

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

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

APL (31)

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

Utilisation: l'argument de gauche est la chaîne et l'argument de droite est le nombre, comme ceci:

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

La sortie est ordonnée par longueur, mais dans les groupes de longueurs, ils sont décalés d'un vers la gauche, c'était plus simple.

Explication:

• ,/⍺∘{... }¨⍳⍵: pour 1..⍵, appliquez la fonction à ⍺ et joignez les résultats ensemble.
• (⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺: pour chaque nombre de 1 à (⍵ = (longueur actuelle)) ^ (⍴⍺ = (quantité de caractères)), convertissez en base ⍴⍺ en utilisant ⍵ chiffres.
• 1+: ajoutez-en un car les tableaux sont indexés sur 1.
• ⍺[... ]: utilisez-les comme index dans la chaîne
• ↓⍉: faites pivoter la matrice, de sorte que les «nombres» se trouvent sur les lignes plutôt que dans les colonnes, puis divisez la matrice en lignes.

Haskell, 34 caractères

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

Utilisation simple de la monade de liste. Le seul vrai golf est l'utilisation mapMau lieu du plus idiomatique (et plus court) replicateMqui nécessiterait l'importation Control.Monad.

Usage

> "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]ne peut pas être raccourci t+=[s]car L et t pointeraient vers la même liste.

Contribution: 'ab', 3

Production:

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

Mathematica 29 19 28

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

Usage

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 octets

x:"1G@Z^

Essayez-le sur MATL Online!

(MATL a été créé après la publication de ce défi, mais je pense que c'est correct par le méta-consensus de nos jours.)

(-1 octets grâce à @Luis Mendo.)

x - supprimer l'entrée de chaîne de la pile (la copie automatiquement dans le presse-papiers G)

:" - entrée implicite du nombre n, boucle de 1 à n

1G - collez la chaîne d'entrée du presse-papiers G sur la pile

@ - pousser l'index d'itération de la boucle actuelle

Z^- pouvoir cartésien: produit d'entrée cartésien avec lui-même @nombre de fois

Les résultats de puissance cartésienne ( @-digit "nombres" dans la base donnée) sont accumulés sur la pile et affichés implicitement à la fin.

Python - 106

La solution simple et non créative. Si vous trouvez des améliorations significatives, veuillez poster une réponse séparée.

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

Entrée: "ab",3
Sortie:

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

Python, 100

Dérivé de la solution 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

Contribution: 'ab', 3

Production:

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

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

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

Essayez-le en ligne!

-1 octet grâce à @Xcali !

Pyth, 6 octets

s^LQSE

Attend le jeu de caractères comme 1ère entrée, le nombre de chiffres comme 2ème. Un octet pourrait être enregistré s'il existait une méthode à un octet pour accéder à plusieurs reprises à la 2e entrée, mais hélas ...

Essayez-le en ligne ici .

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 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend une chaîne et un nombre et renvoie une liste de chaînes.

PHP 180

Je n'en ai aucune idée ... je me sens paresseux.

<?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 version combinateur Y (pour 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)

Version du module:

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

Caractères comptés sans comptabilité obligatoire (module et exportation).

Rubis , 73 octets

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

Essayez-le en ligne!

Japt , 9 octets

Explications à suivre.

õ!àUçV)mâ

Essayez-le

õ_çV àZ â

Essayez-le

Gelée , 6 octets

WẋŒpƤẎ

Essayez-le en ligne!

Soumission de la fonction, en prenant la liste des chiffres comme premier argument et le nombre de chiffres comme deuxième. Les chiffres eux-mêmes peuvent être l'un des types de données de Jelly, mais j'ai utilisé des entiers dans le lien TIO ci-dessus car il produit la meilleure sortie dans le wrapper automatique «fonction → programme complet» de Jelly.

Explication

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

Le produit cartésien nous donne effectivement tous les nombres avec un nombre donné de chiffres (selon le préfixe avec lequel nous travaillons). Nous nous retrouvons donc avec une liste de listes de combinaisons (regroupées par longueur), et pouvons aplatir ce niveau afin d'obtenir une liste qui n'est pas groupée (mais qui est toujours triée par longueur, comme la question l'exige, comme Ẏne le fait pas 'change pas l'ordre relatif des éléments et Ƥessaie d'abord des préfixes plus courts).

05AB1E , 6 octets

「˜Ùé

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Alternative à 6 octets:

REMARQUE: sortie flexible: génère une nouvelle liste pour chaque longueur, le tout sur la même ligne d'impression.
Le convertir en une seule liste serait plus long de 2 octets: Lv²yã`})( Essayez-le en ligne ).

Lv²yã?

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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 octets

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

Essayez-le en ligne!