La tâche consiste à générer toutes les chaînes de 'a' à '999', y compris les caractères majuscules comme ceci:

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

et ainsi de suite (combler les lacunes), en commençant éventuellement par la chaîne vide.

Contribution:

• Le nombre de caractères consécutifs que le programme doit imprimer.

Production:

• Un tableau contenant chaque chaîne OU une chaîne par ligne

Précisions:

• L'ordre n'a pas d'importance, vous pouvez d'abord imprimer des lettres majuscules ou minuscules si vous le souhaitez.

• La sortie peut renvoyer n'importe quel type d'énumération, ne doit pas être spécifiquement un tableau, bien que je doute que l'impression de toutes les combinaisons ne soit pas la manière la plus simple de procéder.

• Une entrée de 3afficherait toute la chaîne de 'a'(ou '') à '999'‚une entrée de 5jusqu'à '99999'et ainsi de suite.

Gelée , 7 octets

ØWṖṗR;/

Il s'agit d'un lien monadique qui accepte un entier en entrée et renvoie un tableau de chaînes.

Essayez-le en ligne!

Comment ça fonctionne

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

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

Exemple d'utilisation: k 3-> ["a","b","c",....,"997","998","999"].

Comment ça fonctionne

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 octets

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

Génère une liste de chaînes non vides. Ajoute récursivement chaque caractère alphanumérique à chaque sortie n-1et chaîne vide.

JavaScript (Firefox 30-57), 108 octets

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

Enregistré 3 octets en utilisant toUpperCase. Le calcul des 62 caractères me prend 10 octets supplémentaires.

Gomme de cannelle, 15 octets

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

Pas assez court, bien que ce soit le genre de défi que Cinnamon Gum a été fait pour :(

Compressé en convertissant la base bijective 96 en base 256. Essayez-le en ligne. Les entrées supérieures à 2 entraîneront des problèmes sur TIO.

Explication

Cela décompresse le regex [a-zA-Z0-9]{1,%s}. Le hmode remplace ensuite l'entrée dans %set produit toutes les chaînes correspondant à l'expression régulière.

Rubis, 82 octets

Construit des produits cartésiens du jeu de caractères à la longueur donnée. Le jeu de caractères est généré en saisissant tous les caractères entre 0et zet en filtrant les caractères non verbaux et également _.

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

05AB1E , 9 8 octets

Code:

ƒžj¨Nã€,

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Python 2.7, 136 134 octets

Merci à Maltysen et NonlinearFruit pour avoir économisé 2 octets

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

Prend ascii_letterset digitsdu module de chaîne et utilise le produit cartésien à productpartir d'itertools pour calculer toutes les combinaisons.

Production

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 octets

1 octets enregistrés grâce à @Jakube.

sm^s+rBG1UTh

Essayez-le en ligne ici .

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 octets

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

Essayez-le sur Ideone .

MATL , 12 octets

:"3Y24Y2h@Z^

Cela prend un nombre en entrée.

Essayez-le en ligne!

Explication

:       % 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 caractères / 27 octets

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

Try it here (Firefox only).

Nan. Nan. Nan.

Explication

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

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

Utilisez "perl -E" sur ce qui précède, avec un argument qui est un nombre. Je pourrais sans doute décemment ne pas avoir compté le dernier "map say" dans le nombre de caractères.

J, 50 octets

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

La moitié des octets, 25 pour être exact, sont dépensés pour générer les lettres et les chiffres nécessaires.

APL, 38 37 octets

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

Utilitaires Bash + GNU, 90

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

Entrée en tant que paramètre de ligne de commande. La sortie est une liste séparée par des espaces.

Fonctionne pour les entrées jusqu'à et y compris 3. Manque de mémoire avec 4 - le eval printfprend un ensemble complet de 63 ⁿ éléments de l'expansion bash.

Utilitaires Bash + GNU, 66

Approche différente (et je pense légèrement nouvelle) de mon autre réponse :

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

• dccompte à rebours de 2 ⁴⁸ -1 à 2 ⁴⁸ -64 ⁿ et Pimprime chaque nombre résultant sous la forme d'un flux secondaire (c'est-à-dire la base 256). Si l'entrée est comprise entre 1 et 4 inclus, cela est garanti d'être exactement 6 octets par numéro.
• base64 convertit cela en sortie base64 et donc 8 octets par chiffre base64, un par ligne.
• seddénude menant /(base64 chiffre 63), puis supprime toutes les lignes contenant +ou /(base64 chiffres 62 et 63). Cela laisse la séquence requise.

R , 73 octets

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

ycommence comme une chaîne vide, xcomme le cas de base 'a','b','c',...,'8','9'. outerprend chacun de ses arguments d'entrée et applique la fonction paste0à chaque combinaison d'éléments dans yet xqui concatène les chaînes. yenregistre le résultat, l' catimprime et l'itère à travers le nombre STDIN de fois.

Essayez-le en ligne!

Jq 1,5 , 97 octets

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

Étendu

  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

Essayez-le en ligne!