작업은 대문자를 포함하여 '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.

하스켈, 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 

파이썬, 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빈 문자열의 각 출력에 재귀 적으로 추가 합니다.

자바 스크립트 (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이 시도한 정확한 도전에도 불구하고 충분히 짧지는 않습니다.

bijective base 96에서 base 256으로 변환하여 압축 합니다. 온라인으로 시도하십시오. 2보다 큰 입력은 TIO에서 문제를 일으킬 것입니다.

설명

이것은 정규식으로 압축 해제됩니다 [a-zA-Z0-9]{1,%s}. h그런 다음 이 모드는 입력을 대체 %s하고 정규 표현식과 일치하는 모든 문자열을 출력합니다.

루비, 82 바이트

주어진 길이까지 설정된 문자의 데카르트 곱을 구성합니다. 문자 집합 사이의 모든 문자를 잡아에 의해 생성 0하고 z또한 비 단어 문자를 필터링하고 _.

->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 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

파이썬 2.7, 136134 바이트

2 바이트 절약을위한 Maltysen 및 NonlinearFruit 덕분에

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

소요 ascii_letters및 digits문자열 모듈에서와 같은 데카르트 제품 사용 product의 모든 조합을 계산하기 itertools에서합니다.

산출

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

파이썬 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

char , 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

펄, 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 bytes

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

Half of the bytes, 25 to be exact, are spent generating the letters and digits needed.

APL, 38 37 bytes

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

Bash + GNU utilities, 90

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

Input as a command-line parameter. Output is a whitespace-separated list.

Works for inputs upt and including 3. Run out of memory with 4 - the eval printf takes an the entire set of 63ⁿ elements of the bash expansion.

Bash + GNU utils, 66

Different (and I think slightly novel) approach to my other answer:

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

• dc counts down from 2⁴⁸-1 to 2⁴⁸-64ⁿ and Prints each resulting number as a bytestream (i.e. base 256). If the input is between 1 and 4 inclusive, this is guaranteed to be exactly 6 bytes per number.
• base64 converts this to base64 output and thus 8 bytes per base64 digit, one per line.
• sed strips off leading / (base64 digit 63), and then removes any lines containing + or / (base64 digits 62 and 63). This leaves the required sequence.

R, 73 bytes

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

y starts off as empty string, x as the base case 'a','b','c',...,'8','9'. outer takes each of its input arguments, and applies the function paste0 to each combination of elements in y and x which concatenates the strings. y saves the result, cat prints it, and it iterates through STDIN number of times of doing this.

Try it online!

Jq 1.5, 97 bytes

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

Try it online!