Die Aufgabe besteht darin, alle Zeichenfolgen von 'a' bis '999' einschließlich Großbuchstaben wie folgt zu generieren:

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

und so weiter (Ausfüllen der Lücken), optional beginnend mit der leeren Zeichenkette.

Eingang:

• Die Anzahl aufeinanderfolgender Zeichen, bis zu der das Programm drucken muss.

Ausgabe:

• Ein Array, das jede Zeichenfolge ODER eine Zeichenfolge pro Zeile enthält

Klarstellungen:

• Die Reihenfolge spielt keine Rolle, Sie können zuerst Groß- oder Kleinbuchstaben drucken, wenn Sie möchten.

• Die Ausgabe kann jede Art von Aufzählung zurückgeben, muss nicht unbedingt ein Array sein, obwohl ich bezweifle, dass das Drucken aller Kombinationen nicht der einfachste Weg ist.

• Eine Eingabe von 3würde den gesamten String von 'a'(oder '') bis '999'‚eine Eingabe von 5bis zu '99999'und so weiter ausgeben.

Gelee , 7 Bytes

ØWṖṗR;/

Dies ist eine monadische Verknüpfung, die eine Ganzzahl als Eingabe akzeptiert und ein Array von Zeichenfolgen zurückgibt.

Probieren Sie es online!

Wie es funktioniert

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

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

Anwendungsbeispiel: k 3-> ["a","b","c",....,"997","998","999"].

Wie es funktioniert

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 Bytes

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

Gibt eine Liste nicht leerer Zeichenfolgen aus. Stellt jedem Ausgang für eine n-1leere Zeichenfolge rekursiv ein alphanumerisches Zeichen voran .

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]:[]

3 Bytes mit toUpperCase gespeichert. Für die Berechnung der 62 Zeichen benötige ich zusätzliche 10 Byte.

Zimtgummi, 15 Bytes

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

Nicht kurz genug, obwohl dies genau die Herausforderung ist, für die Cinnamon Gum gemacht wurde :(

Komprimiert durch Konvertieren von der bijektiven Basis 96 zur Basis 256. Probieren Sie es online aus. Eingänge größer als 2 verursachen Probleme beim TIO.

Erläuterung

Dies dekomprimiert zum regulären Ausdruck [a-zA-Z0-9]{1,%s}. Der hModus ersetzt dann die Eingabe in %sund gibt alle Zeichenfolgen aus, die dem regulären Ausdruck entsprechen.

Ruby, 82 Bytes

Konstruiert kartesische Produkte des Zeichensatzes bis zur angegebenen Länge. Der Zeichensatz wird durch Erfassen aller Zeichen zwischen 0und zund Herausfiltern von Nicht-Wort-Zeichen sowie erstellt _.

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

05AB1E , 9 8 Bytes

Code:

ƒžj¨Nã€,

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

Python 2.7, 136 134 Bytes

Vielen Dank an Maltysen und NonlinearFruit für die Einsparung von 2 Bytes

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

Nimmt ascii_lettersund digitsaus dem String-Modul und verwendet das kartesische Produkt als productaus itertools, um alle Kombinationen zu berechnen.

Ausgabe

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 Bytes

Dank @Jakube 1 Byte gespart.

sm^s+rBG1UTh

Probieren Sie es hier online aus .

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 Bytes

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

Probieren Sie es auf Ideone .

MATL , 12 Bytes

:"3Y24Y2h@Z^

Dies nimmt eine Zahl als Eingabe.

Probieren Sie es online!

Erläuterung

:       % 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 Zeichen / 27 Bytes

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

Try it here (Firefox only).

Nee. Nee. Nee.

Erläuterung

ⒶïⓜᵖɱĬ⟦ᶛ+ᶐ+⩤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 Bytes + Leerzeichen

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

Verwenden Sie oben "perl -E" mit einem Argument, das eine Zahl ist. Ich hätte die letzte "Karte sagen" in der Anzahl der Zeichen wohl anständig nicht zählen können.

J, 50 Bytes

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

Die Hälfte der Bytes, genauer gesagt 25, wird für die Generierung der benötigten Buchstaben und Ziffern aufgewendet.

APL, 38 37 Bytes

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

Bash + GNU-Dienstprogramme, 90

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

Eingabe als Befehlszeilenparameter. Die Ausgabe ist eine durch Leerzeichen getrennte Liste.

Funktioniert für Eingaben bis einschließlich 3. Bei 4 ist der Speicher voll - es werden eval printfdie gesamten 63 ⁿ Elemente der Bash-Erweiterung benötigt.

Bash + GNU-Utils, 66

Anderer (und meiner Meinung nach etwas neuer) Ansatz für meine andere Antwort :

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

• dczählt von 2 ⁴⁸ -1 auf 2 ⁴⁸ -64 ⁿP herunter und druckt jede resultierende Zahl als Nebenstrom (dh Basis 256). Wenn die Eingabe zwischen 1 und einschließlich 4 liegt, sind dies garantiert genau 6 Bytes pro Zahl.
• base64 konvertiert dies in eine Base64-Ausgabe und somit 8 Bytes pro Base64-Ziffer, eine pro Zeile.
• sedEntfernt das führende /Zeichen (base64 Ziffer 63) und alle Zeilen, die +oder enthalten /(base64 Ziffern 62 und 63). Damit bleibt die gewünschte Reihenfolge erhalten.

R , 73 Bytes

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

yBeginnt als leere Zeichenfolge xals Basisfall 'a','b','c',...,'8','9'. outerNimmt jedes seiner Eingabeargumente und wendet die Funktion paste0auf jede Kombination von Elementen in yund an, xdie die Zeichenfolgen verketten. ySpeichert das Ergebnis, catdruckt es aus und durchläuft dabei die STDIN-Anzahl.

Probieren Sie es online!

Jq 1,5 , 97 Bytes

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

Erweitert

  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

Probieren Sie es online!