任务是生成从“ a”到“ 999”的所有字符串，包括大写字符，如下所示：

'a', 'b', 'c' ... 'y', 'z', 'A', 'B', 'C' ... 'Y', 'Z', '0', '1', 2' ... 
'8', '9', 'aa', 'ab', 'ac' ... 'az', 'aA', 'aB' ... 'aZ', 'a0' ... 'a9', 'ba'

等等（填补空白），可以选择从空字符串开始。

输入：

• 程序必须打印到的连续字符数。

输出：

• 包含每个字符串或每行一个字符串的数组

说明：

• 顺序无关紧要，可以根据需要先打印大写或小写字母。

• 输出可以返回任何可枚举的类型，不必专门是数组，尽管我怀疑打印所有组合不是最简单的方法。

• 的输入3将打印所有从字符串'a'（或''）至'999'的输入5最多'99999'等。

果冻，7 个字节

ØWṖṗR;/

这是一个单子链接，接受整数作为输入并返回字符串数组。

在线尝试！

怎么运行的

ØWṖṗR;/  Main link. Argument: n

ØW       Yield 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_'.
  Ṗ      Remove the last element (underscore).
    R    Range; yield [1, ..., n].
   ṗ     Cartesian product. For each k in the range, this yields the arrays of all
         strings of alphanumeric characters.
     ;/  Concatenate the arrays of strings of each length.

Haskell，65个字节

a#b=[a..b]
k n=mapM id.('a'#'z'++'A'#'Z'++'0'#'9'<$)=<<(1#)<$>1#n

用法示例：k 3-> ["a","b","c",....,"997","998","999"]。

怎么运行的

a#b = [a..b]        -- helper function that builds a list from a to b


        (1#n)<$>    -- map the function (1#), i.e. "build the list from 1 up to" 
                1#n -- on the list from 1 to n

                    -- now we have [[1],[1,2],[1,2,3]]

              =<<   -- map over this list (and combine results in a single list)
  (        <$)      -- a function that makes length of input copies of
 'a'#'z'++ ... '9'  -- all characters we need

                    -- now we have [["a..9"],["a..9","a..9"],["a..9","a..9","a..9"]]

mapM id.            -- and make the cartesian product of each sublist 

Python，86个字节

f=lambda n:n*[1]and[x+chr(y)for x in['']+f(n-1)for y in range(128)if chr(y).isalnum()]

输出非空字符串列表。将每个字母数字字符递归地添加到n-1和空字符串的每个输出中。

JavaScript（Firefox 30-57），108字节

f=n=>n?[for(s of['',...f(n-1)])for(c of(t='abcdefghijklmnopqrstuvwxyz')+t.toUpperCase()+'0123456789')s+c]:[]

使用toUpperCase保存了3个字节。计算62个字符需要我多花10个字节。

肉桂胶，15个字节

0000000: 689b b718 05be a345 9c4b c283 d077 de    h......E.K...w.

尽管这正是Cinnamon Gum挑战的确切类型，但还不够短：(

通过从双射基数96转换为基数256进行压缩。在线尝试。输入大于2会在TIO上引起问题。

说明

这将解压缩为正则表达式[a-zA-Z0-9]{1,%s}。h然后，该模式将输入替换为，%s并输出所有与正则表达式匹配的字符串。

Ruby，82个字节

构造具有给定长度的字符集的笛卡尔积。字符集是通过在0和之间抓住所有字符z并过滤掉非单词字符and来生成的_。

->n{a=(?0..?z).grep(/\w/)-[?_];r=[]
n.times{|i|r+=a.product(*[a]*i).map &:join};r}

05AB1E，9 8字节

码：

ƒžj¨Nã€,

说明：

ƒ          # For N in range(0, input + 1), do:
 žj        #   Push predefined literal [a-zA-Z0-9_]
   ¨       #   Remove the last character (the underscore)
    N      #   Push N
     ã     #   Take the Cartesian product, with N repetitions.
      €,   #   For each element in the array, print with a newline

使用CP-1252编码。在线尝试！。

Python 2.7版，136个 134字节

感谢Maltysen和NonlinearFruit节省2个字节

from itertools import*;from string import*;f=lambda n:[''.join(a) for i in range(1,n+1) for a in product(ascii_letters+digits,repeat=i)]

从string模块获取ascii_lettersand digits并使用productitertools中的笛卡尔乘积来计算所有组合。

输出量

out = f(3)

print out[:10]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

print out[100:110]
['aM', 'aN', 'aO', 'aP', 'aQ', 'aR', 'aS', 'aT', 'aU', 'aV']

print out[-10:]
['990', '991', '992', '993', '994', '995', '996', '997', '998', '999']

Pyth- 13 12字节

@Jakube节省了1个字节。

sm^s+rBG1UTh

在这里在线尝试。

s                    Add up the lists of different lengths  
 m          (Q)      Map implicitly over input
  ^     h(d)         Cartesian product of string to implicit lambda var + 1
   s                 Add up list
    ++               Concat up three things
     G               Alphabet
     rG1             Uppercase alphabet
     UT              All digits

Python 2，106 97字节

from string import*
f=lambda n,r=['']:n and r+f(n-1,[x+y for x in r for y in letters+digits])or r

在Ideone上尝试一下。

MATL，12字节

:"3Y24Y2h@Z^

这需要一个数字作为输入。

在线尝试！

说明

:       % Implicitly take input, say N. Generate range [1 2... N]
"       % For each number in that range
  3Y2   %   Predefined literal: string with all letters, uppercase and lowercase
  4Y2   %   Predefined literal: string with all digits
  h     %   Concatenate horizontally
  @     %   Push number of characters corresponding to current iteration
  Z^    %   Cartesian power. Each result is a row 
        % End for each. Implicitly display

𝔼𝕊𝕄𝕚𝕟，21个字符/ 27个字节

ⒶïⓜᵖɱĬ⟦ᶛ+ᶐ+⩤9⨝],⧺_)ė)

Try it here (Firefox only).

不。不。不。

说明

ⒶïⓜᵖɱĬ⟦ᶛ+ᶐ+⩤9⨝],⧺_)ė) // implicit: 
Ⓐïⓜ                    // [...Array(input)].map(($,_)=>...)
    ᵖ                   // push to stack:
     ɱĬ⟦ᶛ+ᶐ+⩤9⨝],⧺_)   // list of n-digit numbers in [a-zA-Z0-9]-ary
                     ė) // formatted into a matrix (no spaces)
                        // implicit stack output, newline-separated

Perl，113个字节+空格

@r="";
for (1..shift) {
  @r = sub {
    map { $c=$_; map $c.$_, @{$_[1]} } @{$_[0]}
  }->(\@r, [0..9, "a".."z", "A".."Z"])
}
map say($_), @r

在上面使用“ perl -E”，并带有一个数字参数。我很可能还没有算上字符数中的最后一个“地图说”。

J，50个字节

62&(('0123456789',~(,toupper)u:97+i.26){~#~#:i.@^)

一半的字节（准确地说是25个字节）用于生成所需的字母和数字。

APL，38 37字节

{⊃{⍵,,⍺∘.,⍵}/⍵⍴⊂,¨⎕a,⎕d,⍨⎕ucs 96+⍳26}

Bash + GNU实用程序，90

printf -vs %$1s
eval printf '%s\\n' ${s// /{=,{a..z\},{A..Z\},{0..9\}\}}|sed s/^=*//\;/=/d

输入作为命令行参数。输出是用空格分隔的列表。

适用于upt以及3的输入。4用完内存- eval printf占用bash扩展的整个63 ^n个元素。

Bash + GNU utils，66

我的其他答案采用不同的方法（我认为有些新颖）：

dc -e"64 $1^[d2 48^r-P1-d0<m]dsmx"|base64 -w8|sed s_^/*__\;/[+/]/d

• dc从2 ⁴⁸ -1 递减到2 ⁴⁸ -64 ⁿ并P以字节流（即基数256）冲洗每个结果数。如果输入介于1和4之间（含1和4），则保证每个数字正好是6个字节。
• base64 将其转换为base64输出，因此，每个base64位为8个字节，每行一个。
• sed去除前导/（base64数字63），然后删除任何包含+或/（base64数字62和63）的行。剩下所需的顺序。

R，73字节

y='';x=c(letters,LETTERS,0:9);for(i in 1:scan())cat(y<-outer(y,x,paste0))

y以空字符串开始，x作为基本情况'a','b','c',...,'8','9'。outer接受其每个输入参数，并将函数应用于并连接字符串paste0的元素的每种组合。保存结果，打印结果，然后遍历STDIN的次数。yxycat

在线尝试！

Jq 1.5，97字节

range(.)as$n|[[range(97;123),range(65;91),range(48;58)]|implode/""|combinations($n+1)]|map(add)[]

展开式

  range(.) as $n           # for each n-digit sequence
| [
      [                    # build array of ordinals for
        range(97;123),     #   a-z
        range(65;91),      #   A-Z
        range(48;58)       #   0-9
      ]
    | implode/""           # make into array of strings
    | combinations($n+1)   # generate array of n-element combinations
  ]
| map(add)[]               # convert to sequence of strings

在线尝试！