Görev, 'a' ile '999' arasındaki tüm dizeleri şu şekilde büyük harf karakterleri oluşturmaktır:

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

ve böylece (boşlukları doldurmak), isteğe bağlı olarak boş dize ile başlayarak.

Giriş:

• Programın yazdırması gereken art arda karakter sayısı.

Çıktı:

• Her dizeyi VEYA her satıra bir dizeyi içeren bir dizi

Açıklamalar:

• Sıra önemli değil, isterseniz büyük veya küçük harfleri yazdırabilirsiniz.

• Çıktı her tür numaralandırılabilir dönebilir, özellikle bir dizi olmak zorunda değildir, ancak tüm kombinasyonları yazdırmanın en kolay yolu olmayacağından şüpheliyim.

• Girişi, 3tüm dizgiyi 'a'(veya '') 'den '999'input' ye 5kadar bir girişe '99999'vb.

Jöle , 7 bayt

ØWṖṗR;/

Bu, bir tamsayıyı girdi olarak kabul eden ve bir dize dizisi döndüren monadik bir bağlantıdır.

Çevrimiçi deneyin!

Nasıl çalışı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 bayt

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

Kullanım örneği: k 3-> ["a","b","c",....,"997","998","999"].

Nasıl çalışır

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 bayt

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

Boş olmayan dizelerin bir listesini çıkarır. Her alfasayısal karakteri, her bir çıktıya n-1ve boş dizeye özyineli olarak ekler .

JavaScript (Firefox 30-57), 108 bayt

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

ToUpperCase kullanılarak 3 bayt kaydedildi. 62 karakteri hesaplamak fazladan 10 bayt alır.

Tarçın Sakızı, 15 bayt

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

Yeterince kısa değil, buna rağmen Tarçın Sakızının tam olarak ne tür bir meydan okuma için yapıldığı :(

İkili taban 96'dan taban 256'ya dönüştürülerek sıkıştırılır . Çevrimiçi deneyin. 2'den büyük girişler TIO'da sorunlara neden olur.

açıklama

Bu, normal ifadeye kadar açılır [a-zA-Z0-9]{1,%s}. hMod sonra giriş girişi yerine %sve regex eşleşen tüm dizeleri çıkarır.

Ruby, 82 bayt

Verilen uzunluğa kadar karakter setinin kartezyen ürünlerini oluşturur. Karakter kümesi, sözcükler arasındaki tüm karakterlerin yakalanması 0ve zsözcük olmayan karakterler ve ayrıca filtrelenmesi ile oluşturulur _.

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

05AB1E , 9 8 bayt

Kod:

ƒžj¨Nã€,

Açıklama:

ƒ          # 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 kodlamasını kullanır . Çevrimiçi deneyin! .

Python 2.7, 136134 bayt

2 bayt kazandığı için Maltysen ve NonlinearFruit'e teşekkürler

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

Alır ascii_lettersve digitsdize modülünden gibi Kartezyen Ürünü kullanan producttüm kombinasyonları hesaplamak için itertools dan.

Çıktı

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 bayt

@Jakube sayesinde 1 bayt kaydedildi.

sm^s+rBG1UTh

Burada çevrimiçi deneyin .

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 bayt

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 üzerinde deneyin .

MATL , 12 bayt

:"3Y24Y2h@Z^

Bu sayı olarak girdi alır.

Çevrimiçi deneyin!

açıklama

:       % 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 karakter / 27 bayt

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

Try it here (Firefox only).

Hayır! Hayır! Hayır!

açıklama

ⒶïⓜᵖɱĬ⟦ᶛ+ᶐ+⩤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 bayt + boşluk

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

Yukarıdaki "perl -E" tuşunu, sayı olan bir argümanla kullanın. Muhtemelen karakter sayısında son "harita demek" sayılmazdı.

J, 50 bayt

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

Baytların yarısı, tam olarak 25, gerekli harfleri ve rakamları oluşturmak için harcanmaktadır.

APL, 38 37 bayt

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

Bash + GNU yardımcı programları, 90

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

Komut satırı parametresi olarak girin. Çıktı boşlukla ayrılmış bir listedir.

3 dahil olmak üzere girişler için çalışır. 4 ile bellek tükenir - bash genişlemesinin eval printf63 ⁿ elemanının tamamını alır .

Bash + GNU araçları, 66

Farklı yaklaşım (ve biraz roman düşünüyorum) benim diğer cevap :

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

• dc2 ⁴⁸ -1 ila 2 ⁴⁸ -64 ⁿ arasında geri sayım yapar ve Psonuçta elde edilen her sayıyı bir bytestream (yani taban 256) olarak çizer. Giriş 1 ile 4 arasındaysa, sayı başına tam olarak 6 bayt olması garanti edilir.
• base64 bunu base64 çıkışına ve böylece her satırda bir tane olmak üzere base64 basamağı başına 8 bayta dönüştürür.
• sedkapalı şeritler gelen /sonra (Base64 rakam 63) ihtiva eden ve satırları kaldırır +ya da /(Base64 62 ve 63 basamak). Bu, gerekli diziyi bırakır.

R , 73 bayt

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

yxtemel durum olarak boş dize olarak başlar 'a','b','c',...,'8','9'. outerKonvertör, giriş bağımsız değişkenleri her birini alır ve fonksiyonu uygular paste0elemanların her bir kombinasyonu için yve xbu dizileri birleştirir. ysonucu kaydeder, catyazdırır ve bunu STDIN sayısıyla yineler.

Çevrimiçi deneyin!

Jq 1,5 , 97 bayt

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

Expanded

  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

Çevrimiçi deneyin!