给定一串不同的字符和一个数字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个字符

   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到（⍵=（当前长度））^（⍴⍺=（字符数））的每个数字，请使用⍵位将其转换为以base为底的数字。
• 1+：添加1，因为数组是1索引的。
• ⍺[... ]：将它们用作字符串的索引
• ↓⍉：旋转矩阵，使“数字”位于行而不是列中，然后按行将矩阵拆分。

Haskell，34个字符

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

直接使用列表monad。唯一真正的高尔夫运动是使用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']

Mathematica 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在线上尝试一下！

（MATL是在发布此挑战后创建的，但我相信这些天通过元共识是可以的。）

（由于@Luis Mendo，-1个字节。）

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

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

预期字符集为第一输入，位数为第二。如果有一个单字节方法可以重复访问第二个输入，则可以保存一个字节，但是a ...

在这里在线尝试。

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

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

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

K（ngn / k），17个字节

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

在线尝试！