Давши рядок з різних символів і число n, генеруйте всі впорядковані комбінації з повторенням, довжиною від 1 до n, використовуючи ці символи.

Інший спосіб визначити це - бачити дані символи як "власні" цифри в базі (радіо) кількості символів, тоді програма повинна генерувати всі "числа" з 1 до n цифр у цій базі, однак, ведучими "нулі" також включаються.

Комбінації слід упорядкувати за їх довжиною (спочатку 1 символ, потім 2 тощо), але крім того, що вони можуть бути в будь-якому порядку. Ви можете вибрати найбільш зручні способи обробки вводу та виводу. Найкоротший код виграє.

Приклади:

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 байт ^SBCS

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

Спробуйте в Інтернеті!

ніколи не пропустіть можливість сконувати :)

запит на рядок "цифр", а потім для n

дякую @ Adám за те, що мені сказали, як увімкнути ]boxTIO

Python 2, 56 байт

n- максимальна довжина, і sочікується, що це список символів. Мені незрозуміло, чи n = 0 чи порожній список символів є дійсними входами, але ця функція також правильно їх обробляє.

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

Використання: лівий аргумент - це рядок, а правий - число, наприклад:

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

Виведення впорядковано по довжині, але в межах груп довжин вони зміщені на одну вліво, це було найпростіше.

Пояснення:

• ,/⍺∘{... }¨⍳⍵: для 1..⍵ застосуйте функцію до ⍺ та з'єднайте результати разом.
• (⍵⍴⍴⍺)⊤⍳⍵*⍨⍴⍺: для кожного числа від 1 до (⍵ = (поточна довжина)) ^ (⍴⍺ = (кількість символів)), перетворіть на базу ⍴⍺ за допомогою ⍵ цифр.
• 1+: додати його, оскільки масиви є 1-індексованими.
• ⍺[... ]: використовувати їх як індекси в рядку
• ↓⍉: поверніть матрицю, тож цифри знаходяться на рядках замість стовпців, а потім розділіть матрицю на рядки.

Хаскелл, 34 символи

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

Безпосереднє використання монади списку. Єдиний справжній гольф - це використання mapMзамість того ідіоматичного (і коротшого), replicateMякий потребує імпорту Control.Monad.

Використання

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

Пітона, 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]його не можна скоротити, t+=[s]оскільки L і t вказували б на той самий список.

Вхід: 'ab', 3

Вихід:

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

Математика 29 19 28

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

Використання

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 байт

x:"1G@Z^

Спробуйте його на MATL Online!

(MATL був створений після публікації цього виклику, але я вважаю, що це нормально мета консенсусу в наші дні.)

(-1 байт завдяки @Luis Mendo.)

x - видалити рядок із стека (автоматично копіює його в буфер G)

:" - неявне введення числа n, цикл від 1 до n

1G - вставити назад вхідний рядок із буфера обміну G на стек

@ - натисніть на індекс ітерації поточного циклу

Z^- декартові сили: декартовий добуток введення з собою @кількість разів

Результати декартової потужності ( @-значні "числа" в заданій базі) накопичуються на стеку і неявно відображаються в кінці.

Пітон - 106

Безпосереднє, нетворче рішення. Якщо ви знайдете значні покращення, будь ласка, опублікуйте їх як окрему відповідь.

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

Вхід: "ab",3
Вихід:

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

Пітона, 100

Похідне від рішення @ 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

Вхід: 'ab', 3

Вихід:

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

Perl 5 + -nlF -M5.010 -MList::Util+(uniq), 41 байт

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

Спробуйте в Інтернеті!

-1 байт завдяки @Xcali !

Pyth, 6 байт

s^LQSE

Очікує набір символів як перший вхід, кількість цифр як 2-й. Байт можна було б зберегти, якби був однобайтовий метод для повторного доступу до другого входу, але на жаль ...

Спробуйте його онлайн тут .

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 байти

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

Спробуйте в Інтернеті!

Блок анонімного коду, який приймає рядок і число і повертає список рядків.

PHP 180

Я поняття не маю ... я лінуюся.

<?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 ";}

Ерланг 110

Версія Y комбінатора (для оболонки):

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.

Ерланг 89 (118)

Версія модуля:

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

Символи рахуються без обов'язкового ведення бухгалтерського обліку (модуль та експорт).

Рубін , 73 байти

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

Спробуйте в Інтернеті!

Japt , 9 байт

Пояснення, які слід слідувати.

õ!àUçV)mâ

Спробуй це

õ_çV àZ â

Спробуй це

Желе , 6 байт

WẋŒpƤẎ

Спробуйте в Інтернеті!

Подання функції, приймаючи список цифр як перший аргумент, а кількість цифр як другий. Самі цифри можуть бути будь-якими типами даних Jelly, але я використовував цілі числа у посиланні TIO вище, оскільки він дає найкращий вигляд у автоматичній обгортці «функція → повна програма» Jelly.

Пояснення

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

Декартовий продукт ефективно дає нам усі числа із заданою кількістю цифр (відповідно до того, з яким префіксом ми працюємо). Таким чином, ми закінчуємо список списків комбінацій (згрупованих за довжиною) і можемо вирівняти цей рівень, щоб отримати список, який не групується (але який все ще відсортований за довжиною, як вимагає питання, як це Ẏне так не змінювати відносний порядок елементів і Ƥспершу спробує коротші префікси).

05AB1E , 6 байт

「˜Ùé

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

ã         # 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-байтна альтернатива:

ПРИМІТКА: Гнучкий вихід: Виводить новий список на кожну довжину, все на одній лінії друку.
Перетворити його в єдиний список було б на 2 байти довше: Lv²yã`})( Спробуйте в Інтернеті ).

Lv²yã?

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

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)

К (нг / к) , 17 байт

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

Спробуйте в Інтернеті!