Défi

Imprimez les caractères suivants:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Le problème, c'est que vous ne pouvez en utiliser aucun dans votre code.

Vous pouvez les imprimer dans un ordre arbitraire, avec ou sans nouvelle ligne, mais vous ne pouvez imprimer aucun autre caractère.

Règles

• Vous ne pouvez utiliser aucun caractère de l'ensemble mentionné ci-dessus
• Vous pouvez utiliser d'autres caractères
• Pas de tricherie
• Lacunes standard interdites
• C'est le code-golf , la réponse la plus courte gagne.

Des clarifications

• Si votre langue utilise un jeu de caractères différent, vous ne pouvez pas utiliser de points de code correspondant à des caractères alphanumériques.
• Le renvoi d'une chaîne d'une fonction est considéré comme une forme de sortie valide.
• Vous pouvez retourner un tableau de caractères.

V , 8 7 octets

1 octet enregistré grâce à @DJMcMayhem en le mettant dans une déclaration regex

¬/{Ó×ü_

Essayez-le en ligne!

Les sorties:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Note: ×n'est pas x ou X, c'est0xd7

Hexdump:

00000000: ac2f 7bd3 d7fc 5f                        ./{..._

Explication

¬/{            " inserts every character in the range / to {

Maintenant, la sortie ressemble à:

/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{

Nous devons supprimer tous les caractères non alphanumériques et le _(puisqu'il n'est pas inclus dans \W), alors faisons-le en utilisant regex

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g

Octave , 52 46 40 octets

['['-('"':'+'),'{'-(_='!':':'),_+'@','']

Ceci est évalué à

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Explication

Nous utilisons ici le fait que les caractères sont implicitement convertis en entiers lorsque des opérations arithmétiques telles que +-ou la fonction range :sont appliquées. Lorsqu'ils sont concaténés avec une chaîne vide ( [...,'']), les nombres sont à nouveau convertis en caractères.

Essayez-le en ligne!

brainfuck , 77 76 75 72 octets

++++++++[>+>++++++>++++>-<<<<-]>++[>.+<-]>>[>+>++>+++<<<-]>++[>+.>+.<<-]

Essayez-le en ligne!

Comment ça fonctionne

L'interprète commence par une bande de 0 cellules.

++++++++

Cela définit la première cellule sur 8 , laissant la bande dans l'état suivant.

   8
   ^

[>+>++++++>++++>-<<<<-]

Cela incrémente la deuxième cellule une fois, la troisième cellule 6 fois, la quatrième cellule 4 fois, décrémente la cinquième cellule une fois, puis revient au début de la bande et décrémente la première cellule. Après 8 itérations, la bande ressemble à ce qui suit.

  0   8  48  32  -8
  ^

>++

Nous passons à la deuxième cellule et l'incrémentons deux fois pour nous préparer à imprimer les chiffres.

  0  10  48  32  -8
      ^

[>.+<-]

Cela imprime la troisième cellule, l’incrémente, puis revient à la deuxième cellule et la décrémente. Après 10 itérations, nous avons imprimé 0123456789et la bande ressemble à ce qui suit.

  0   0  58  32  -8
      ^

>>

Il est temps de préparer la bande pour les lettres! Nous commençons par avancer de deux cellules.

  0   0  58  32  -8   0   0
              ^

[>+>++>+++<<<-]

Cela incrémente la cinquième cellule une fois, la sixième cellule deux fois, la septième cellule trois fois, puis revient à la quatrième cellule et la décrémente. Après 32 itérations, la bande ressemble à ce qui suit.

  0   0  58   0  24  64  96
              ^

>++

Comme dernière étape avant d’imprimer les lettres, nous passons à la cinquième cellule et l’incrémentons deux fois.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Enfin, nous passons à la sixième cellule pour l'incrémenter et l'imprimer, faisons de même pour la septième cellule, puis revenons à la cinquième cellule et la décrémentons. Après 26 itérations, nous avons imprimé Aa...Zz.

Ruby, 42 octets

->{[*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`]}

Une fonction qui retourne un tableau de caractères. Un programme qui affiche uniquement les caractères est de 49 octets:

$><<([*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`])*''

Ceci utilise simplement les caractères ascii de chaque côté des plages pertinentes pour définir une plage. Par exemple, ?/...?:signifie les caractères entre une barre oblique et un deux-points, sans compter la fin. Pour se débarrasser des débuts, on soustrait un tableau contenant les trois caractères de départ.

6502 langage machine, 74 70 68 octets

Hex dump (les programmes 6502 ne sont généralement pas déplaçables; le code est stocké à partir de l'emplacement 0603 $):

0600:          a9 24 0a 8d 20 06 8d 21 06 8d 23 06 8d 
0610: 25 06 09 20 8d 1a 06 8d 1c 06 ea aa ea a8 a9 00 
0620: ea ea 98 ea 8a ea a2 ff a9 7b a0 60 20 3a 06 a9 
0630: 5b a0 40 20 3a 06 a9 3a a0 2f 85 80 c8 e8 98 95 
0640: 00 c8 c4 80 d0 f7 60

Vous pouvez voir que cela n'utilise aucun des octets interdits: 41 $ à 5a $, 61 $ à 7a $ ou 30 $ à 39 $.

Il s'agit d'une fonction sans argument qui, lorsqu'elle est appelée, renvoie un pointeur sur le tableau de caractères "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" situé en haut de la pile, conformément aux conventions d'appel 6502.

En guise d’explication, voici un démontage:

Adresse Hexdump Disassembly
-------------------------------
0603 $ a9 24 LDA # 24 $
0605 $ 0a ASL A
0606 $ 8j 20 06 STA 0620 $
0609 $ 8j 21 06 STA 0621 $
060c $ 8d 23 06 STA 0623 $
$ 060f 8d 25 06 STA $ 0625
0612 $ 09 20 ORA # 20 $
0614 $ 8d 1a 06 STA 061a
0617 $ 8d 1c 06 STA $ 061c
$ 061a NOP 
$ 061b aa taxe 
061c $ par personne NOP 
061d $ a8 TAY 
061e $ a9 00 LDA # 00 $
0620 $ ch. NOP 
0621 $ ch. NOP 
$ 0622 98 TYA 
0623 $ ch. NOP 
$ 0624 8a TXA 
0625 $ ch. NOP 
$ 0626 a2 ff LDX # $ ff
0628 $ a9 7b LDA # 7b $
$ 062a a0 60 LDY # 60 $
062c $ 20 3a 06 JSR 063a $
062f $ a9 5b ADL # 5b $
0631 $ a0 40 LDY # 40 $
0633 $ 20 3a 06 JSR 063a $
0636 $ a9 3a LDA # 3a $
$ 0638 a0 2f LDY # $ 2f
$ 063a 85 80 STA $ 80
063c $ c8 INY 
063d $ e8 INX 
$ 063e 98 TYA 
$ 063f 95 00 STA $ 00, X
0641 $ c8 INY 
0642 $ c4 80 CPY 80 $
0644 $ d0 f7 BNE 063d $
$ 0646 60 RTS

Le code en langage machine se modifie automatiquement. Pour manipuler les piles, je devais utiliser PHA et PLA pour insérer et extraire l'accumulateur, mais ces instructions portent les codes d'opération $ 48 et $ 68, qui sont interdits (ce sont les codes ASCII des lettres "H" et "h"). Ainsi, pour PHA, je prends le nombre de 24 USD, fais un décalage arithmétique à gauche (ASL) et stocke les 48 USD obtenus dans les quatre emplacements du code où ils doivent être exécutés. Ensuite, pour PLA, j’utilise un OU au niveau des bits sur les 48 $ de l’accumulateur pour calculer 68 $ et les stocke dans les deux emplacements du code où cela est nécessaire.

Il y avait plusieurs instructions autres que PHA et PLA que je ne pouvais pas non plus utiliser car leurs opcodes étaient identiques à des lettres ou des chiffres ASCII, mais j'ai trouvé des solutions de contournement directes pour ces autres.

Le tableau de caractères souhaité est calculé et stocké à partir de l'emplacement 0 (peu importe l'endroit où il est stocké car nous devons simplement nous assurer qu'un pointeur sur ce point est renvoyé en haut de la pile).

Vous pouvez essayer ceci chez l'assembleur et l'émulateur de Nick Morgan 6502 . Voici une capture d'écran; le moniteur en bas affiche la chaîne de sortie (aux emplacements compris entre 00 $ et $ 3D) après l'exécution du programme.

Haskell , 75 72 63 58 56 octets

__=[__|[_',ä]<-["/:","@[","`{"],__<-[_'..],_'<__,__<ä]

Essayez-le en ligne! Appeler avec __. Sortie:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Merci à xnor qui a suggéré __et en _'tant que noms de variables à deux octets au lieu de (!)ou similaires, en économisant 9 octets. J'aime particulièrement comment _'brise la coloration syntaxique. Et merci encore à xnor d’avoir généralisé les plages, sauvant encore 4 octets.
Edit: Je trouve que les caractères Unicode sont autorisés comme identifiants dans Haskell, donc par exemple ä, ö... peut également être utilisé comme deux identifiants d'octets. Puisqu'il restait un identifiant de trois octets dans le programme, je l'ai remplacé par ä, en enregistrant 2 autres octets.

Explication:

__et _'sont des noms de variables valides. A partir de la spécification de langue :

Un identifiant consiste en une lettre suivie de zéro ou plusieurs lettres, chiffres, traits de soulignement et guillemets simples. [...] Le trait de soulignement, _est traité comme une lettre minuscule et peut se produire partout où une lettre minuscule le peut. Cependant, _tout seul est un identificateur réservé, utilisé comme caractère générique dans les modèles.

Donc, le code est équivalent à

s = [x|[a,b]<-["/:", "@[", "`{"], x<-[a..], a<x, x<b]

Dans la compréhension liste ase lie à '/'et bà ':'( "/:"est équivalent à ['/',':'], de sorte que le pattern matching réussit). Ensuite, la plage [a..]construit la chaîne de tous les caractères supérieurs '/':

"/0123456789:;<=>?@ABCDE ... \1114110\1114111"

Pour chaque caractère xde cette chaîne, il est ensuite vérifié si '/'<xet x<':', ce qui donne les caractères 0123456789. Alors aet bsont liés à, @ et [cédant les caractères ABCDEFGHIJKLMNOPQRSTUVWXYZet ainsi de suite.

Perl (5.10 ou 5.12), 30 29 octets

Ce programme est principalement composé de caractères non imprimables, alors voici un hexdump:

00000000: 5f 3d 7e 7e 22 d7 c0 84 8c 9e 86 df 9e d1 d1 85 _=~~"...........
00000010: d3 be d1 d1 a5 d3 cf d1 d1 c6 82 d6 22          ............"

Ce programme est très simple: nous regexons ( =~) un trait de soulignement ( _; merci @ Dennis pour nous avoir signalé que cela fonctionne) contre une expression rationnelle. La regex est spécifiée en tant qu'expression plutôt que littéralement; Plus précisément, nous prenons le complément bitwise ( ~) d'une chaîne. En inversant le complément au niveau du bit pour obtenir la chaîne sous-jacente, nous obtenons la regex suivante en cours d'exécution:

(?{say a..z,A..Z,0..9})

Dans les versions 5.10 et 5.12 de Perl, la (?{…})syntaxe était une syntaxe expérimentale permettant aux expressions rationnelles d'exécuter du code arbitraire au moment de l'exécution. Dans ce cas, nous l'utilisons pour exécuter un programme Perl simple afin d'imprimer le résultat souhaité. (Les versions antérieures à 5.10 ne peuvent pas être utilisées car elles ne le sont pas say.)

Les versions modernes de Perl ont été désactivées (?{…})par défaut pour des raisons de sécurité, mais si vous avez une telle version de Perl, vous pouvez désactiver le contrôle (et donc exécuter ce programme) via -Mre=evalun argument de ligne de commande (avec le standard -M5.010qui spécifie la version). du langage à implémenter, et qui ne compte pas dans le décompte).

Actuellement 8 5 4 octets

'>┘▀

Comment ça fonctionne:

 '>    Pushes > onto the stack as a string
           STACK: [>]
    ┘  Converts the top item of the stack to it's ordinal
           STACK: [62]
     ▀ Push all digits from base n(top item of the stack)
           STACK: [012...xyz]

L'impression est implicite à la fin du programme.

Édition 1: Remplacement de l’alphabet en minuscule / majuscule, puis dans la plage de chiffres (10) avec uniquement les caractères imprimables de la base 62.

Edit 2: changé ">" en '> grâce à Mego :) enregistré 1 octet.

Essayez-le en ligne!

PHP, 69 octets

<?=~"ÏÎÍÌËÊÉÈÇƾ½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…";

Le code est stylisé sous Windows-1252 ici. Ci-dessous se trouve un xxd hexdump réversible .

00000000: 3c 3f 3d 7e 22 cf ce cd cc cb ca c9 c8 c7 c6 be  <?=~"...........
00000010: bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae  ................
00000020: ad ac ab aa a9 a8 a7 a6 a5 9e 9d 9c 9b 9a 99 98  ................
00000030: 97 96 95 94 93 92 91 90 8f 8e 8d 8c 8b 8a 89 88  ................
00000040: 87 86 85 22 3b                                   ...";

Essayez-le en ligne!

Java (OpenJDK 9) , 277 octets

Oui, Java, vous avez bien lu!

$->""+($='='+'=')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='-'+'-')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='_'-'&')+--$+--$+--$+--$+--$+--$+--$+--$+--$

Essayez-le en ligne!

Ceci affiche les plages, mais inversé, car l'ordre n'a aucune importance.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

J'ai joué sur l'absence de règle "pas d'entrée" pour définir implicitement ce charqui est nécessaire pour que tout fonctionne. Si c'est de la triche, dites-le s'il vous plaît.

Ungolfed & testing

public class PCG105781 {
  interface X { String apply(char x); }

  public static void main(String[] args) {
    X x = $
        -> "" // Force the result as a String.
        // The line below appends "zyxwvutsrqponmlkjihgfedcba"
        // '=' + '=' is 122 as int. $=122 casts 122 as a char, 'z'
        + ($ = '=' + '=') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "ZYXWVUTSRQPONMLKJIHGFEDCBA"
        // '-' + '-' is 90 as int. $=90 casts 90 as a char, 'Z'
        + ($ = '-' + '-') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "9876543210"
        // '_' - '&' is 57 as int. $=57 casts 57 as a char, '9'
        + ($ = '_' - '&') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
      ;

    System.out.println(x.apply('_'));
  }
}

Brainfuck, 89 85 octets

Parce que brainfuck ignore de toute façon les caractères alphanumériques, il s’agit là d’un défi à sortie constante ... (Edit: voir la solution de Dennis pour une version plus courte de 10 octets)

+[-[--<]>>--]++++++++++[<+.>-]<++++++++>+[-[---<]>>-]<-<<+++++[>+++++<-]>+[>.+<<<.+>>-]

Essayez-le en ligne!

Ce code est un bon exemple de boucles comptées de base dans le brainfuck:

+[-[--<]>>--]   Create value 47: char just before '0'
++++++++++      Set adjacent cell to 10: to be used as a counter

[               While the counter is not 0:
 <+.              Increment and print the char
    >-            Decrement the counter
       ]        (End loop: Exits when all digits have been printed)


<++++++++>           The char is now at '9' so add 8 to make it 'A'
+[-[---<]>>-]<-      In another cell create lowercase 'a'
<<+++++[>+++++<-]>+  Create 26: the number of times to loop

[                While the counter is not 0:
 >.+               Print and increment the lowercase char
    <<<.+          Print and increment the uppercase char
         >>-       Decrement the counter
            ]    (End loop: Exits when all letters have been printed)

Notez que cela utilise des raccourcis d'habillage pour générer des nombres, ce qui signifie que l'interpréteur doit avoir des cellules d'habillage de 8 bits (telles que celle à laquelle je suis lié).

JavaScript (ES6), 983 octets

Il se trouve que dans ES6, vous pouvez utiliser beaucoup de caractères dans les noms de variables JavaScript ! Fonctionne très bien après avoir épuisé les six noms de variable de 1 à 2 octets avec $et _.

_=~[]
$={}
Á=++_
À=![]+""
Â=À[_]
Ã=++_
Ä=À[_]
Å=++_
Æ=($+"")[_]
Ç=(_[_]+"")[_]
È=++_
É=(!""+"")[_]
Ë=++_
Ì=++_
Ê=($+"")[_]
Í=++_
µ=++_
Î=++_
Ï=++_
_="\\"
Ð=$.$
È_=(!""+"")[Ã]
Å_=$+""
Ñ=Å_[Ã]
Ò=(Ð+"")[Ã]
__=Å_[Í]
Ó=(!""+"")[Å]
$_=Å_[Ì]+Ñ+Ò+(!$+"")[È]+__+È_+Ó+Å_[Ì]+__+Ñ+È_
$$=È_+(!""+"")[È]+__+Ó+È_+Ò
$=Á[$_][$_]
$($($$+"\""+Ê+Ñ+_+Ã+Ì+Í+_+Ã+Í+È+Ñ+À[Å]+É+"."+À[Å]+Ñ+_+Ã+Ë+µ+"('"+Ä+Æ+Ê+Ç+É+Â+_+Ã+Ë+µ+_+Ã+Ì+Á+_+Ã+Ì+Ã+_+Ã+Ì+Å+_+Ã+Ì+È+À[Å]+_+Ã+Ì+Ì+_+Ã+Ì+Í+Ñ+_+Ã+Í+Á+_+Ã+Í+Ã+_+Ã+Í+Å+_+Ã+Í+È+__+Ó+_+Ã+Í+Í+_+Ã+Í+µ+_+Ã+µ+Á+_+Ã+µ+Ã+_+Ã+µ+Å+_+Ã+Á+Ã+_+Ã+Á+Å+_+Ã+Á+È+_+Ã+Á+Ë+_+Ã+Á+Ì+_+Ã+Á+Í+_+Ã+Á+µ+_+Ã+Ã+Á+_+Ã+Ã+Ã+_+Ã+Ã+Å+_+Ã+Ã+È+_+Ã+Ã+Ë+_+Ã+Ã+Ì+_+Ã+Ã+Í+_+Ã+Ã+µ+_+Ã+Å+Á+_+Ã+Å+Ã+_+Ã+Å+Å+_+Ã+Å+È+_+Ã+Å+Ë+_+Ã+Å+Ì+_+Ã+Å+Í+_+Ã+Å+µ+_+Ã+È+Á+_+Ã+È+Ã+_+Ã+È+Å+Ã+Å+È+Ë+Ì+Í+µ+Î+Ï+Á+"')\"")())()

JavaScript, 1223 octets

C'était ma réponse avant que j'apprenne ce qui précède.

_=~[]
$={}
___=++_
____=![]+""
$$$$=____[_]
__$=++_
$_$_=____[_]
_$_=++_
$_$$=($+"")[_]
$$_$=(_[_]+"")[_]
_$$=++_
$$$_=(!""+"")[_]
$__=++_
$_$=++_
$$__=($+"")[_]
$$_=++_
$$$=++_
$___=++_
$__$=++_
_="\\"
_$_$=$.$
_$$_=(!""+"")[__$]
_$__=$+""
_$=_$__[__$]
__$_=(_$_$+"")[__$]
__=_$__[$$_]
___$=(!""+"")[_$_]
$_=_$__[$_$]+_$+__$_+(!$+"")[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
$$=_$$_+(!""+"")[_$$]+__+___$+_$$_+__$_
$=___[$_][$_]
$($($$+"\""+$$__+_$+_+__$+$_$+$$_+_+__$+$$_+_$$+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"('"+$_$_+$_$$+$$__+$$_$+$$$_+$$$$+_+__$+$__+$$$+_+__$+$_$+___+_+__$+$_$+__$+_+__$+$_$+_$_+_+__$+$_$+_$$+____[_$_]+_+__$+$_$+$_$+_+__$+$_$+$$_+_$+_+__$+$$_+___+_+__$+$$_+__$+_+__$+$$_+_$_+_+__$+$$_+_$$+__+___$+_+__$+$$_+$$_+_+__$+$$_+$$$+_+__$+$$$+___+_+__$+$$$+__$+_+__$+$$$+_$_+_+__$+___+__$+_+__$+___+_$_+_+__$+___+_$$+_+__$+___+$__+_+__$+___+$_$+_+__$+___+$$_+_+__$+___+$$$+_+__$+__$+___+_+__$+__$+__$+_+__$+__$+_$_+_+__$+__$+_$$+_+__$+__$+$__+_+__$+__$+$_$+_+__$+__$+$$_+_+__$+__$+$$$+_+__$+_$_+___+_+__$+_$_+__$+_+__$+_$_+_$_+_+__$+_$_+_$$+_+__$+_$_+$__+_+__$+_$_+$_$+_+__$+_$_+$$_+_+__$+_$_+$$$+_+__$+_$$+___+_+__$+_$$+__$+_+__$+_$$+_$_+__$+_$_+_$$+$__+$_$+$$_+$$$+$___+$__$+___+"')\"")())()

Je courus console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')par jjencode et le résultat manuellement joué au golf. Il y a certainement plus d'optimisations possibles.

Befunge, 73 72 59 57 55 53 octets

"{"< ^+`"`"\+*`\":"\`"/":\*`\"["\`"@":::::-!!
#@_^,_!

Essayez-le en ligne!

Il s’agit d’une boucle unique comptant à partir de {(c’est-à-dire un caractère après z). Lors de la première itération, la "{"<séquence place deux copies de {sur la pile, l’un étant le compteur de boucle initial et l’autre servant à décrémenter ce compteur à l’aide de la séquence !!-(deux NOTs 1, qui sont ensuite soustraits). Lors des itérations suivantes, le compteur de boucle est déjà sur la pile, il ne vous en faut donc qu'un {pour configurer la séquence de décrémentation.

Le reste du code est juste une longue expression booléenne calculant si le caractère est dans la plage. Si c'est le cas, la branche de la deuxième ligne se divise à gauche pour écrire la valeur. Sinon, la branche droite vérifie si nous avons atteint zéro et devrions nous arrêter. Les deux branches se confondent au milieu pour remonter et répéter la boucle. Notez que toutes les commandes de direction verticale vont vers le haut, car nous ne pouvons pas utiliser de v, mais c'est bien parce que le pointeur d'instruction se positionne automatiquement en haut du champ de lecture.

Merci à Mistah Figgins d’ avoir initialement trouvé une meilleure technique pour l’incrément de boucle.

Mais un merci tout spécial à Jo King pour une approche encore meilleure du décompte plutôt que de la hausse, ainsi que pour une configuration de branche plus compacte.

Gelée , 17 à 16 octets

“:[{“/@`‘Ḷḟ"/ỌḊ€

Essayez-le en ligne!

Comment ça fonctionne

“:[{“/@`‘Ḷḟ"/ỌḊ€  Main link. No arguments.

“:[{“/@`‘         Yield [[58, 91, 123], [47, 64, 96]].
         Ḷ        Unlength; map each n to [0, ..., n-1].
          ḟ"/     Reduce by vectorizing filter-false.
                  This yields [[47, ..., 57], [64, ..., 90], [96, ..., 122]].
             Ọ    Unordinal; replace each n with the corr. Unicode character.
              Ḋ€  Deqeue each; remove the first character of each of the three
                  generated strings ('/', '@', and '`').

Brainfuck à modification automatique , 32 octets

<[-<+.>]<<[-<+.>]<<[-<+.>]`@/

Essayez-le en ligne!

xxd -rhexdump irréversible (contient des éléments non imprimables):

00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.

C, 128 octets

Oui, C. Et même plus court que quelques ésotériques.

__($$,_,$,_$,$_){$>_$?_$=_$?!$:$,$=*(""-_+$_++)&*"{":_;_$?*(""-_+$$++)=$++:_;$&&__($$,_,$,_$,$_);}_(_){__(_,"",_,!!_,"½´ÞÅþå");}

Appelez _un char *tampon suffisamment grand et vide .

_{Peut-être dépendant du compilateur. Testé avec GCC; Le fichier a été enregistré dans la page de codes 1252.}

JavaScript (ES6), 812 745 657 650 536 520 416 octets

(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))

Edit: En utilisant le codage ISO8859-1, cette solution contient 416 octets au lieu de 520 octets. Le programme complet compte 432 octets, en tenant compte des 16 octets supplémentaires pour

f=\r\n
416 byte submission here\r\n
alert(f())

Ceci est une soumission de fonction, par opposition à un programme complet. JJEncode (pointe du chapeau à darrylyeo pour ça), j’ai passé beaucoup de temps à jouer au golf , mais au lieu de jouer au golf

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

J'ai joué au golf

for($ of[[48,58],[65,91],[97,123]])for(_=$[0];_<$[1];)Ø+=String.fromCharCode(_++);return Ø

où Øest initialisé à ""dans la surcharge.

Réécrit avec les opérateurs de virgule convertis en nouvelles lignes:

À=(Á=!($={})+(Ø=""))[Â=_=+[]]
Ã=(Ä=!_+Ø)[Å=++_]
Æ=(Ç=$+Ø)[_]
È=(É=$.$+Ø)[_]
Ê=Ä[Ë=++_]
Ì=Ä[Í=++_]
Î=++_
Ï=Ç[Ð=++_]
Ñ=Ç[Ò=++_]
Ó=++_
$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô]
// function that returns string
$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)())

Explication

Ce script commence par initialiser quelques types intégrés et les contraindre dans des chaînes. Les chaînes que nous pouvons obtenir sans utiliser de caractères alphanumériques sont:

{}+""     -> "[object Object]"
!{}+""    -> "false"
!+[]+""   -> "true"
{}[{}]+"" -> "undefined"

À partir de ces chaînes et des chiffres nécessaires pour référencer des caractères individuels, nous pouvons obtenir les chaînes returnet constructor, qui peuvent être utilisées comme:

$={}[Ô="constructor"][Ô]
$(("return"+`"encoded script"`)())

Le constructeur de l'objet est Object(), et son constructeur est Function(), que nous pouvons utiliser essentiellement comme eval().

Dans ce cas, le script codé à exécuter est la forboucle imbriquée concaténant tous les caractères alphanumériques dans une chaîne en utilisant leurs points de code et en les renvoyant.

Pour les caractères alphabétiques du script codé auxquels il est impossible d'accéder à l'aide des fonctions intégrées, JJEncode utilise des échappements octaux pour les représenter, puis décode la chaîne entière en la renvoyant à partir d'une fonction interne. La fonction externe peut ensuite être appelée pour exécuter le source.

Démo

f=
(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))
console.log(f())

Brain-Flak , 171 octets

Comprend +3 pour -A

(((((()()()){}){}){}){})(((()()())){}{}){({}[()]<(({})())>)}{}(({})(()()()()){})(((((()()()){}){}){}())<{({}[()]<(({})())>)}{}(({})(()()()){}())>){({}[()]<(({})())>)}{}

Essayez-le en ligne!

(((((()()()){}){}){}){}) # push 48
(((()()())){}{})         # push 9
{({}[()]<                # for 9..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()()){})       # pop a, push a, push a + 8
(((((()()()){}){}){}())< # push 26 and save a 26 for later
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()){}())       # pop a, push a, push a + 7
>)                       # push that 26 that we held
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for

Il existe probablement un moyen de le faire sans avoir à répéter la fonction "add 1".

Julia 0.4 , 46 bytes

_()=['¥':'®';'¶':'Ï';'Ö':'ï'].-['~'-'	']

C'est une fonction générique qui retourne un tableau de caractères.

Essayez-le en ligne!

Version alternative, 47 octets, uniquement ASCII

_(_=_==_)=['/'+_:':'-_;'@'+_:'['-_;'`'+_:'{'-_]

Essayez-le en ligne!

J, 171 octets

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Ow ... mon cerveau me fait mal ... Essayez-le en ligne!

Pour que vous puissiez voir l’ensemble d’une ligne (elle ne fonctionnera pas, mais avec des sauts de ligne).

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*
_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Garanti uniquement de fonctionner avec la version J j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, dans cet ordre. (Seuls les 12 premiers caractères sont importants.)

Explication

La majeure partie du programme est consacrée à la génération constante. Avec ces constantes remplacées par leurs valeurs, le programme ressemble à ceci:

(62){.".(':',~(12){(9)!:(14)''),',',(":(65),(97),48),'+/',('.',~(10){(9)!:(14)''),":26

Avec quelques parenthèses supprimées et quelques chiffres plus agréables:

62{.".(':',~12{9!:14''),',',(":65 97 48),'+/',('.',~10{9!:14''),":26

Ceci est composé d'un tas de ,et ,~s, qui ajoutent et ajoutent des arguments. Voici les valeurs séparées:

1. ":26
2. ('.',~10{9!:14'')
3. '+/'
4. (":65 97 48)
5. ','
6. (':',~12{9!:14'')

1est 26comme une chaîne.

9!:14'' génère la chaîne suivante sur TIO:

j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52

avec 2, nous obtenons le 10caractère th ( ide linux), et ajoutons un .à la fin de celui-ci, cédant i..

3et 5sont explicites.

4est la liste des nombres 65 97 48sous forme de chaîne.

6est similaire à 2, sauf que c'est le 12caractère th ( ude linux) et ajoute un :à la fin, cédant u:.

Tout cela cède u:,65 97 48+/i.26. ".évalue cela en nous donnant:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Note: +/addition tabulée.)

Ensuite, avec 62{., nous prenons les premiers 62personnages de ceci, nous donnant ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 octets

-4 grâce à Adnan, car si la taille en entrée est 1, 05AB1E utilisera 0 pour b sur la première commande.

•£•Ýç©á®þ«˜

Essayez-le en ligne!

•£•Ÿ            # Push [0..122] using implicit 0 and the base-214 of `£`.
    ç           # Convert to ASCII chars.
     ©          # Store full array in register.
      á         # Push the same array with ONLY letters.
       ®        # Push contents of register (char)[0..122].
        þ       # Push only the digits.
         «˜     # Concat to list, flatten it. 

J'ai essayé tellement d'approches différentes, mais les points clés qui ont rendu la tâche difficile:

- Basic commands will not work, only extended and a select few of the basics.
- Extended commands are pretty complex.
- Eval (.V) will not work.
- To push numbers you can do a base 214 compression.
- ALL sequence pushes (E.G. žK) won't work.
- ALL number pushes won't work, except for compression and the -1 an empty register pushes.

Brainfuck, 55 octets

+++[[<+>->++<]>]<<[-<->]<<<<++[->>+.>+.<<<]<--[->>.+<<]

Sortie:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Essayez-le en ligne!

Initialise la bande à 3,2 ⁿ et fonctionne à partir de là.

+++[[<+>->++<]>]    initialize the tape
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 | 192 | 128 |   0 |   0 |
                                                                                    ^
<<[-<->]            subract 128 from 192
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                                        ^
<<<<++              increment 24 twice
                    |   0 |   3 |   6 |  12 |  26 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                ^
[->>+.>+.<<<]       output aAbBcC ~ zZ
                    |   0 |   3 |   6 |  12 |   0 |  48 | 122 |  90 |   0 |   0 |   0 |
                                                ^
<--[->>.+<<]        decrement 12 twice; output 0 ~ 9
                    |   0 |   3 |   6 |   0 |   0 |  58 | 122 |  90 |   0 |   0 |   0 |
                                          ^

Perl 6 , 43 octets - sans compétition

{|('`'^..^'{'),|('@'^..^'['),|('/'^..^':')}

Un lambda qui renvoie une liste de caractères.
Explication:

   '`'                                       # The character before "a" (in Unicode order)
          '{'                                # The character after "z"
      ^..^                                   # Endpoint-exclusive range between them
 |(          )                               # Slip the range into the outer list
               |('@'^..^'[')                 # Same thing for "A" to "Z"
                             |('/'^..^':')}  # Same thing for "0" to "9"

Dépend d'une correction de bug de l'interprète Rakudo Perl 6 qui était uniquement réservée au dépôt Git aujourd'hui, et ne fait pas encore partie d'une version officielle de Rakudo. En fait, j'ai rencontré le bogue en répondant à ce défi et j'ai réussi à le réparer avec l'aide de l'un des développeurs principaux de Perl 6. Les règles de ce site, telles que je les comprends, ne permettent pas aux réponses d'entrer en concurrence dans une telle situation, aussi je l'ai marqué comme non compétitif.

PHP 7.0+, 110 octets

Que Dieu bénisse les chaînes de bits!

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^_,'%'^_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^_));

Remplacez-la \npar une vraie nouvelle ligne de style NIX.
Il est présent dans le code pour éviter les problèmes de nouvelles lignes, mais n'est pas compté dans la partition.

Cela lance une série d’avertissements, mais ceux-ci pourraient être supprimés en ajoutant un @en face de chaque errant _.

Avertissement gratuit , 113 octets

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));

65c02 langage machine + Apple] [ROM, 25 octets

A9 E0 20 0F 80 A9 C0 20 0F 80 A2 0A A9 AF 2C A2 1A 1A 20 ED FD CA D0 F9 60

Impressions abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Devrait commencer à $8000 .

Démontage

8000-   A9 E1       LDA   #$E0
8002-   20 0F 80    JSR   $800F
8005-   A9 C1       LDA   #$C0
8007-   20 0F 80    JSR   $800F
800A-   A2 0A       LDX   #$0A
800C-   A9 B0       LDA   #$AF
800E-   2C          HEX   2C     ; SKIPS NEXT 2 BYTES
800F-   A2 1A       LDX   #$1A
8011    1A          INC   
8012-   20 ED FD    JSR   $FDED
8015-   CA          DEX   
8016-   D0 F9       BNE   $8011
8018-   60          RTS   

bash (sur linux), 507 493 490 485 octets

cela stocke un tableau de caractères dans la variable globale __

: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
__=(/????/????/??/??)
___=${__%??}
__=(${__[@]#$___?})
____=${___#/*/?}
____=${____%?/*/}
_____=${____%?}
____=${____#?}
___=${___%??/}
______=($___*_??)
______=${______#$___???????}
______=${______%??_*}
_______=($___$_____???*)
_______=${_______#$___??}
_______=${_______%????}
___=$#
___=$((++___))$((___+++++___+___--))$___
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
__=(${__[@]} ${___[@]} ${___[@]^})

il doit être exécuté sur une machine Linux fraîchement démarrée avec /proc, ou quelque chose comme un espace de noms pid

explication:

# {var}>file opens a file descriptor >= 10 to that file
: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
# at startup no pid is > 999 so there's no other /proc/pid/fd/??
__=(/????/????/??/??)                                 # /proc/self/fd/1[0-9]
___=${__%??}                                          # /proc/self/fd/
__=(${__[@]#$___?})                                   # {0..9}
____=${___#/*/?}                                      # elf/fd/
____=${____%?/*/}                                     # el
_____=${____%?}                                       # e
____=${____#?}                                        # l
___=${___%??/}                                        # /proc/self/
______=($___*_??)                                     # /proc/self/timerslack_ns
______=${______#$___???????}                          # ack_ns
______=${______%??_*}                                 # a
_______=($___$_____???*)                              # /proc/self/environ
_______=${_______#$___??}                             # viron
_______=${_______%????}                               # v

___=$#                                                # 0
___=$((++___))$((___+++++___+___--))$___              # 172 (z in octal)

# eval eval                   ___="\({a..$'\172'}\)"
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
#   {0..9}   {a..z}    {A..Z}
__=(${__[@]} ${___[@]} ${___[@]^})

pour l'essayer, nous pouvons ajouter declare -p __à la fin pour afficher le résultat

$ sudo unshare --fork --pid --mount-proc bash golf
declare -a __=([0]="0" [1]="1" [2]="2" [3]="3" [4]="4" [5]="5" [6]="6" [7]="7" [8]="8" [9]="9" [10]="a" [11]="b" [12]="c" [13]="d" [14]="e" [15]="f" [16]="g" [17]="h" [18]="i" [19]="j" [20]="k" [21]="l" [22]="m" [23]="n" [24]="o" [25]="p" [26]="q" [27]="r" [28]="s" [29]="t" [30]="u" [31]="v" [32]="w" [33]="x" [34]="y" [35]="z" [36]="A" [37]="B" [38]="C" [39]="D" [40]="E" [41]="F" [42]="G" [43]="H" [44]="I" [45]="J" [46]="K" [47]="L" [48]="M" [49]="N" [50]="O" [51]="P" [52]="Q" [53]="R" [54]="S" [55]="T" [56]="U" [57]="V" [58]="W" [59]="X" [60]="Y" [61]="Z")

Javascript, 1273 1351 1610 octets

Cette solution fonctionne essentiellement de la même façon que les deux autres réponses sur ce sujet ici et ici , où il utilise des lettres des true, false, undefinedet les [object Object]chaînes pour construire les fonctions dont il a besoin pour générer les autres lettres.

Puisqu'un bon nombre de lettres sont déjà insérées dans l'objet, j'ai essayé d'ajouter toutes les lettres minuscules restantes et les chiffres à l'objet, puis de les appliquer toUpperCaseà toutes les valeurs de l'objet pour générer les lettres majuscules manquantes.

Mise à jour:

J'ai pu améliorer la manière dont les valeurs octales étaient définies, mais elles prennent toujours 13 x 30 octets (ou elles seront de 30 octets chacune après que je change les nombres en différentes clés), chacune suit maintenant ce général motif: $.ž=\'\\'+$.一+$.七+$.二+'\';.

49 octets supplémentaires peuvent être facilement supprimés en commutant les touches pour les nombres en caractères de 2 octets.

Soumission actuelle:

$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()

C (clang) , 164 octets

é,ú,í,ó;_(*$){ú-=ú;ú++;í=ú+ú;ó=í<<í*í<<ú;!é?é++,é<<=í*í+ú,é+=í<<í+ú:é;*$++=é++;é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú;é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú;é<í*ó-(í*í)-ú?_($):ú;}

Essayez-le en ligne!

C'est une fonction récursive qui obtient les caractères en commençant par une valeur de 1 (soustrayant de soi et en augmentant), et crée tous les autres nombres à partir de cela.

Ungolfed / Explaination:

é,ú,í,ó;
_(*$){ //function "_" taking a pointer "$"
	ú-=ú;ú++; //constant ú=1
	í=ú+ú; //constant í=2
	ó=í<<í*í<<ú; //constant ó=64
	!é?é++,é<<=í*í+ú,é+=í<<í+ú:é; //if é isn't initialized, seek to character '0'
	*$++=é++; //write to string and increase string index
	é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú; //skip to 'A'
	é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú; //skip to 'a'
	é<í*ó-(í*í)-ú?_($):ú; //keep recursing until end of alphabet
}

CJam , 15 octets

"{`[@:/"_:,:^\-

Essayez-le en ligne!

Explication

"{`[@:/" e# Push this string. Note that these are the characters just above and
         e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
         e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
         e# appear in an odd number of the strings. Those are the letters, the digits
         e# as well as `, @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.

, 8 caractères / 19 octets

ᶐ+ᶛ+⩥Ⅹă⬯

Essayez-le ici!

ᶐest l'alphabet majuscule, ᶛl'alphabet minuscule et la ⩥Ⅹă⬯plage ( ⩥) de 0à 10( Ⅹ, le chiffre romain unicode) moins 1, joint par ( ă) rien ( ⬯).