Nhiệm vụ là tạo tất cả các chuỗi từ 'a' đến '999' bao gồm các ký tự chữ hoa như sau:

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

và v.v. (điền vào các khoảng trống), tùy ý bắt đầu với chuỗi trống.

Đầu vào:

• Số lượng ký tự liên tiếp mà chương trình phải in lên tới.

Đầu ra:

• Một mảng chứa mỗi chuỗi HOẶC một chuỗi trên mỗi dòng

Làm rõ:

• Thứ tự không quan trọng, bạn có thể in chữ hoa hoặc chữ thường trước nếu muốn.

• Đầu ra có thể trả về bất kỳ loại liệt kê nào, không nhất thiết phải là một mảng, mặc dù tôi nghi ngờ việc in tất cả các kết hợp sẽ không phải là cách dễ nhất.

• Một đầu vào 3sẽ in tất cả các chuỗi từ 'a'(hoặc '') đến '999'một đầu vào 5lên đến '99999'và cứ thế.

Thạch , 7 byte

ØWṖṗR;/

Đây là một liên kết đơn âm chấp nhận một số nguyên làm đầu vào và trả về một chuỗi các chuỗi.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

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

Ví dụ sử dụng: k 3-> ["a","b","c",....,"997","998","999"].

Làm thế nào nó hoạt động

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 byte

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

Xuất ra một danh sách các chuỗi không trống. Đệ quy đệ trình từng ký tự chữ và số cho mỗi đầu ra cho n-1và chuỗi trống.

JavaScript (Firefox 30-57), 108 byte

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

Đã lưu 3 byte bằng cách sử dụng toUpperCase. Việc tính toán 62 ký tự sẽ cho tôi thêm 10 byte.

Quế Gum, 15 byte

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

Không đủ ngắn, mặc dù đây là loại thử thách chính xác mà Cinnamon Gum đã thực hiện cho :(

Được nén bằng cách chuyển đổi từ cơ sở sinh học 96 sang cơ sở 256. Hãy thử trực tuyến. Đầu vào lớn hơn 2 sẽ gây ra sự cố trên TIO.

Giải trình

Điều này giải nén đến regex [a-zA-Z0-9]{1,%s}. Các hchế độ sau đó thay thế các đầu vào trong để %svà kết quả đầu ra phù hợp với tất cả các chuỗi regex.

Ruby, 82 byte

Xây dựng các sản phẩm cartesian của nhân vật được thiết lập theo chiều dài nhất định. Bộ ký tự được tạo ra bằng cách lấy tất cả các ký tự giữa 0và zvà lọc ra những ký tự không phải chữ và cũng _.

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

05AB1E , 9 8 byte

Mã số:

ƒžj¨Nã€,

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Python 2.7, 136 134 byte

Cảm ơn Maltysen và NonlinearFnut đã lưu 2 byte

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

Lấy ascii_lettersvà digitstừ mô-đun chuỗi và sử dụng Sản phẩm Cartesian như producttừ itertools để tính toán tất cả các kết hợp.

Đầu ra

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 byte

Lưu 1 byte nhờ @Jakube.

sm^s+rBG1UTh

Hãy thử trực tuyến tại đây .

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 byte

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

Hãy thử nó trên Ideone .

MATL , 12 byte

:"3Y24Y2h@Z^

Điều này có một số là đầu vào.

Hãy thử trực tuyến!

Giải trình

:       % 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 chars / 27 byte

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

Try it here (Firefox only).

Không. Không. Không.

Giải trình

ⒶïⓜᵖɱĬ⟦ᶛ+ᶐ+⩤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 byte + khoảng trắng

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

Sử dụng "perl -E" ở trên, với một đối số là số. Tôi có lẽ đã không thể đếm được "bản đồ nói" cuối cùng trong số đếm ký tự.

J, 50 byte

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

Một nửa số byte, chính xác là 25, được dành để tạo các chữ cái và chữ số cần thiết.

APL, 38 37 byte

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

Tiện ích Bash + GNU, 90

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

Nhập dưới dạng tham số dòng lệnh. Đầu ra là một danh sách được phân tách bằng khoảng trắng.

Hoạt động để tăng đầu vào và bao gồm 3. Hết bộ nhớ với 4 - eval printfmất toàn bộ 63 ⁿ phần tử của việc mở rộng bash.

Đồ dùng Bash + GNU, 66

Cách tiếp cận khác nhau (và tôi nghĩ hơi mới lạ) đối với câu trả lời khác của tôi :

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

• dcđếm ngược từ 2 ⁴⁸ -1 đến 2 ⁴⁸ -64 ⁿ và Pgợi ý mỗi số kết quả là một bytestream (tức là cơ sở 256). Nếu đầu vào nằm trong khoảng từ 1 đến 4, điều này được đảm bảo chính xác là 6 byte cho mỗi số.
• base64 chuyển đổi nó thành đầu ra base64 và do đó 8 byte cho mỗi chữ số base64, một byte trên mỗi dòng.
• sedloại bỏ hàng đầu /(cơ sở 64 chữ số 63), và sau đó loại bỏ bất kỳ dòng nào chứa +hoặc /(cơ sở 64 chữ số 62 và 63). Điều này để lại trình tự cần thiết.

R , 73 byte

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

ybắt đầu như chuỗi rỗng, xnhư trường hợp cơ sở 'a','b','c',...,'8','9'. outernhận từng đối số đầu vào của nó và áp dụng hàm paste0cho từng tổ hợp các phần tử trong đó yvà xnối các chuỗi. ylưu kết quả, catin nó và lặp lại thông qua số lần STDIN thực hiện việc này.

Hãy thử trực tuyến!

Jq 1.5 , 97 byte

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

Mở rộng

  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

Hãy thử trực tuyến!