Sfida

Stampa i seguenti caratteri:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Il trucco è che non puoi usare nessuno di essi nel tuo codice.

Puoi stamparli in ordine arbitrario, con o senza una nuova riga iniziale o finale, ma non puoi stampare nessun altro personaggio.

Regole

• Non è possibile utilizzare alcun personaggio del set sopra menzionato
• Puoi usare qualsiasi altro personaggio
• Senza imbrogliare
• Scappatoie standard vietate
• Questo è code-golf , vince la risposta più breve.

chiarimenti

• Se la tua lingua utilizza un set di caratteri diverso, non è possibile utilizzare punti di codice in quel set di caratteri che corrispondono a caratteri alfanumerici.
• Restituire una stringa da una funzione è considerata una forma valida di output.
• È possibile restituire un array di caratteri.

V , 8 7 byte

1 byte salvato grazie a @DJMcMayhem inserendo tutto in un'istruzione regex

¬/{Ó×ü_

Provalo online!

Uscite:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Nota: ×è non è x o X, è0xd7

hexdump:

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

Spiegazione

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

Ora l'output è simile a:

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

Dobbiamo rimuovere tutti i caratteri non alfanumerici e il _(poiché non è incluso in \W), quindi facciamolo usando regex

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

Ottava , 52 46 40 byte

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

Questo valuta

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Spiegazione

Qui stiamo usando il fatto che i caratteri vengono convertiti implicitamente in numeri interi quando vengono applicate operazioni aritmetiche come +-o la funzione di intervallo :. Se concatenati con una stringa vuota ( [...,'']), i numeri vengono nuovamente convertiti in caratteri.

Provalo online!

brainfuck , 77 76 75 72 byte

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

Provalo online!

Come funziona

L'interprete inizia con un nastro di 0 celle.

++++++++

Ciò imposta la prima cella su 8 , lasciando il nastro nel seguente stato.

   8
   ^

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

Questo incrementa la seconda cella una volta, la terza cella 6 volte, la quarta cella 4 volte, diminuisce la quinta cella una volta, quindi torna all'inizio del nastro e diminuisce la prima cella. Dopo 8 iterazioni, il nastro appare come segue.

  0   8  48  32  -8
  ^

>++

Passiamo alla seconda cella e la incrementiamo due volte, preparandoci a stampare le cifre.

  0  10  48  32  -8
      ^

[>.+<-]

Ciò stampa la terza cella, la incrementa, quindi torna alla seconda cella e la diminuisce. Dopo 10 iterazioni, abbiamo stampato 0123456789e il nastro appare come segue.

  0   0  58  32  -8
      ^

>>

È ora di preparare il nastro per le lettere! Iniziamo facendo avanzare due celle.

  0   0  58  32  -8   0   0
              ^

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

Questo aumenta la quinta cella una volta, la sesta cella due volte, la settima cella tre volte, quindi torna alla quarta cella e la diminuisce. Dopo 32 iterazioni, il nastro appare come segue.

  0   0  58   0  24  64  96
              ^

>++

Come ultimo passo prima di stampare le lettere, avanziamo alla quinta cella e la incrementiamo due volte.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Infine, avanziamo alla sesta cella per incrementarla e stamparla, fare lo stesso per la settima cella, quindi tornare alla quinta cella e diminuirla. Dopo 26 iterazioni, abbiamo stampato Aa...Zz.

Rubino, 42 byte

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

Una funzione che restituisce un array di caratteri. Un programma che emette solo i caratteri è di 49 byte:

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

Questo semplicemente utilizza i caratteri ASCII su entrambi i lati degli intervalli rilevanti per definire un intervallo. Ad esempio, ?/...?:indica i caratteri tra una barra e due punti, esclusa la fine. Per eliminare gli inizi, sottraggiamo un array contenente i tre caratteri iniziali.

6502 linguaggio macchina, 74 70 68 byte

Dump esadecimale (in genere i programmi 6502 non sono trasferibili; il codice qui viene archiviato a partire dalla posizione $ 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

Puoi vedere che questo non utilizza nessuno dei byte proibiti: da $ 41 a $ 5a, da $ 61 a $ 7a o da $ 30 a $ 39.

Questa è una funzione senza argomenti che, quando viene chiamata, restituisce un puntatore alla matrice di caratteri "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" nella parte superiore dello stack, in conformità con le convenzioni di chiamata standard 6502.

A titolo di spiegazione, ecco uno smontaggio:

Indirizzo Hexdump Disassembly
-------------------------------
$ 0603 a9 24 LDA # $ 24
$ 0605 0a ASL A
$ 0606 8 g 20 06 STA $ 0620
$ 0609 8 g 21 06 STA $ 0621
$ 060c 8d 23 06 STA $ 0623
$ 060f 8d 25 06 STA $ 0625
$ 0612 09 20 ORA # $ 20
$ 0614 8 g 1a 06 STA $ 061a
$ 0617 8g 1c 06 STA $ 061c
$ 061a ea NOP 
$ 061 miliardi di tasse 
$ 061c ea NOP 
$ 061d a8 TAY 
$ 061e a9 00 LDA # $ 00
$ 0620 ea NO 
$ 0621 ea NO 
$ 0622 98 TYA 
$ 0623 ea NO 
$ 0624 8a TXA 
$ 0625 ea NO 
$ 0626 a2 ff LDX # $ ff
$ 0628 a9 7b LDA # $ 7b
$ 062a a0 60 LDY # $ 60
$ 062c 20 3a 06 JSR $ 063a
$ 062f a9 5b LDA # $ 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 $ 063 d
$ 0646 60 RTS

Il codice del linguaggio macchina si modifica automaticamente. Per manipolare lo stack, avevo bisogno di usare PHA e PLA per spingere e pop l'accumulatore, ma queste istruzioni hanno codici operativi $ 48 e $ 68, che sono proibiti (sono i codici ASCII per le lettere 'H' e 'h'). Quindi, per PHA, prendo il numero $ 24, eseguo uno spostamento aritmetico a sinistra (ASL) e memorizzo i 48 $ risultanti nei quattro punti del codice in cui deve essere eseguito. Quindi, per PLA, uso un OR bit per bit sui $ 48 nell'accumulatore per calcolare $ 68 e lo memorizzo nei due punti nel codice dove è necessario.

C'erano diverse istruzioni diverse da PHA e PLA che non potevo nemmeno usare perché i loro codici operativi sono gli stessi delle lettere o delle cifre ASCII, ma ho trovato soluzioni alternative dirette per gli altri.

L'array di caratteri desiderato viene calcolato e memorizzato a partire dalla posizione 0 (non importa dove sia archiviato poiché dobbiamo solo essere sicuri che un puntatore ad esso venga restituito in cima allo stack).

Puoi provarlo nell'assemblatore e nell'emulatore 6502 di Nick Morgan . Ecco uno screenshot; la casella di monitoraggio in basso mostra la stringa di output (in posizioni da $ 00 a $ 3D) dopo l'esecuzione del programma.

Haskell , 75 72 63 58 56 byte

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

Provalo online! Chiama con __. Produzione:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Grazie a xnor che ha suggerito __e _'come nomi di variabili a due byte invece (!)o simili, risparmiando 9 byte. Mi piace soprattutto come _'interrompe l'evidenziazione della sintassi. E grazie ancora a xnor per la generalizzazione degli intervalli, salvando altri 4 byte.
Edit: ho scoperto che i caratteri Unicode sono consentiti come identificatori a Haskell, così per esempio ä, ö... può essere utilizzato anche come due identificatori byte. Poiché nel programma era rimasto un identificatore a tre byte, l'ho sostituito ä, salvando altri 2 byte.

Spiegazione:

__e _'sono nomi di variabili validi. Dalle specifiche della lingua :

Un identificatore è costituito da una lettera seguita da zero o più lettere, cifre, caratteri di sottolineatura e virgolette singole. [...] Il carattere di sottolineatura, _viene trattato come una lettera minuscola e può verificarsi ovunque una lettera minuscola. Tuttavia, _tutto da solo è un identificatore riservato, utilizzato come carattere jolly nei modelli.

Quindi il codice è equivalente a

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

Nella lista di comprensione aviene legato a '/'ed ba ':'( "/:"è equivalente a ['/',':'], in modo che il pattern matching ha successo). Quindi l'intervallo [a..]crea la stringa di tutti i caratteri maggiore uguale '/':

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

Per ogni carattere xdi questa stringa viene quindi verificato se '/'<xe x<':', risultando nei caratteri 0123456789. Quindi ae bsono legati a @ e [, cedendo i caratteri ABCDEFGHIJKLMNOPQRSTUVWXYZe così via.

Perl (5.10 o 5.12), 30 29 byte

Questo programma è composto principalmente da caratteri non stampabili, quindi ecco 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          ............"

Questo programma è molto semplice: stiamo regexing ( =~) un carattere di sottolineatura ( _; grazie @Dennis per aver sottolineato che funziona) contro un regex. La regex è specificata come espressione, piuttosto che letteralmente; in particolare, stiamo prendendo il complemento bit per bit ( ~) di una stringa. Invertendo il complemento bit per bit per ottenere la stringa sottostante, otteniamo la seguente regex che viene eseguita:

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

Nelle versioni Perl 5.10 e 5.12, la (?{…})sintassi era una sintassi sperimentale per consentire alle regex di eseguire codice arbitrario in fase di esecuzione. In questo caso, lo usiamo per eseguire un semplice programma Perl per stampare l'output desiderato. (Le versioni precedenti alla 5.10 non possono essere utilizzate perché non disponibili say.)

Le versioni moderne di Perl sono disabilitate (?{…})per impostazione predefinita per motivi di sicurezza, ma se si dispone di tale versione di Perl, è possibile disabilitare il controllo (e quindi eseguire questo programma) tramite -Mre=evalun argomento da riga di comando (insieme allo standard -M5.010che specifica la versione del linguaggio da implementare e che non conta per il bytecount).

In realtà 8 5 4 byte

'>┘▀

Come funziona:

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

La stampa è implicita alla fine del programma.

Modifica 1: sostituito mettendo l'alfabeto in minuscolo / maiuscolo e poi l'intervallo di numeri (10) ottenendo solo i caratteri stampabili della base 62.

Modifica 2: modificato ">" in "> grazie a Mego :) salvato 1 byte.

Provalo online!

PHP, 69 byte

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

Il codice è stilizzato usando Windows-1252 qui. Segue una reversibile xxd hexdump.

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                                   ...";

Provalo online!

Java (OpenJDK 9) , 277 byte

Sì, Java, hai letto bene!

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

Provalo online!

Questo stampa le gamme, ma invertito, poiché l'ordine non ha importanza.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Ho giocato sull'assenza della regola "nessun input" per definire implicitamente una charrichiesta per far funzionare tutto. Se questo è barare, per favore, dillo.

Ungolfed e test

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 byte

Poiché brainfuck ignora comunque i caratteri alfanumerici, questa è solo una sfida a output costante ... (Modifica: vedi la soluzione di Dennis per una versione che è più corta di 10 byte)

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

Provalo online!

Questo codice è un buon esempio di loop contati di base in 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)

Si noti che questo utilizza scorciatoie da avvolgere per generare numeri, il che significa che l'interprete deve avere celle di avvolgimento a 8 bit (come quella a cui mi sono collegato).

JavaScript (ES6), 983 byte

Risulta che in ES6 ci sono molti caratteri che puoi usare nei nomi delle variabili JavaScript ! Funziona alla grande dopo aver esaurito i sei nomi di variabili da 1-2 byte con $e _.

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

JavaScript, 1223 byte

Questa era la mia risposta prima di sapere quanto sopra.

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

Ho eseguito console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')attraverso jjencode e golfed il risultato manualmente. Ci sono sicuramente più ottimizzazioni che possono essere fatte.

Befunge, 73 72 59 57 55 53 byte

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

Provalo online!

Questo è un singolo conto alla rovescia da {(ovvero un carattere dopo z). Alla prima iterazione, la "{"<sequenza inserisce due copie dello {stack - una è il contatore del loop iniziale e l'altra viene utilizzata per diminuire quel contatore usando la sequenza !!-(due NOT fanno 1, che viene poi sottratto). Nelle iterazioni successive, il contatore di loop è già in pila, quindi {è necessario solo uno per impostare la sequenza di decremento.

Il resto del codice è solo una lunga espressione booleana che calcola se il carattere è nell'intervallo. In tal caso, il ramo sulla seconda riga si divide a sinistra per scrivere il valore. In caso contrario, il ramo giusto si avvolge per verificare se abbiamo raggiunto lo zero e dovremmo terminare. I due rami si uniscono nel mezzo per salire e ripetere il ciclo. Nota che tutti i comandi di direzione verticale vanno verso l'alto, poiché non possiamo usare a v, ma va bene perché il puntatore alle istruzioni si sposta automaticamente nella parte superiore del campo di gioco.

Grazie a Mistah Figgins per aver inizialmente messo a punto una tecnica migliore per l'incremento del loop.

Ma un ringraziamento speciale a Jo King per un approccio ancora migliore al conto alla rovescia piuttosto che verso l'alto, così come un layout del ramo più compatto.

Gelatina , 17 16 byte

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

Provalo online!

Come funziona

“:[{“/@`‘Ḷḟ"/ỌḊ€  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 automodificante , 32 byte

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

Provalo online!

xxd -r-deversivo reversibile (contiene non stampabili):

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

C, 128 byte

Sì, C. Ed è anche più breve di alcuni di quelli esoterici.

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

Richiamare _un char *buffer sufficientemente grande e vuoto .

_{Può essere un compilatore teensy dipendente dal compilatore. Testato utilizzando GCC; il file è stato salvato nella tabella codici 1252.}

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

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

Modifica: utilizzando la codifica ISO8859-1, questa soluzione è di 416 byte anziché 520 byte. Il programma completo è di 432 byte, tenendo conto dei 16 byte extra per

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

Questa è una presentazione della funzione, al contrario di un programma completo. Ho passato molto tempo a giocare a golf con JJEncode (da cappello a darrylyeo per quello), ma invece di giocare a golf

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Ho giocato a golf

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

dove Øè inizializzato ""in overhead.

Riscritto con operatori virgola convertiti in newline:

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

Spiegazione

Questo script inizia inizializzando alcuni tipi predefiniti e costringendoli a stringhe. Le stringhe che possiamo ottenere senza usare caratteri alfanumerici sono:

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

Da queste stringhe e dalle cifre necessarie per fare riferimento a singoli caratteri, possiamo ottenere le stringhe returne constructor, che possono essere utilizzate come:

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

Il costruttore dell'oggetto è Object(), e il suo costruttore è Function(), che possiamo usare essenzialmente come eval().

In questo caso, lo script codificato da eseguire sono i forloop nidificati che concatenano tutti i caratteri alfanumerici in una stringa usando i loro punti di codice e lo restituiscono.

Per i caratteri alfabetici nello script codificato a cui non è possibile accedere utilizzando gli incorporati, JJEncode utilizza escape ottali per rappresentarli, quindi decodifica l'intera stringa restituendola da una funzione interna. La funzione esterna può quindi essere chiamata per eseguire la sorgente.

dimostrazione

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

Brain-Flak , 171 byte

Include +3 per -A

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

Provalo online!

(((((()()()){}){}){}){}) # 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

C'è probabilmente un modo per farlo senza dover ripetere la funzione "aggiungi" 1.

Julia 0.4 , 46 byte

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

Questa è una funzione generica che restituisce una matrice di caratteri.

Provalo online!

Versione alternativa, 47 byte, solo ASCII

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

Provalo online!

J, 171 byte

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

Ow ... mi fa male il cervello ... Provalo online!

Ecco perché puoi vederlo tutto su una riga (non funzionerà, tuttavia, con interruzioni di riga.)

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

Garantito solo per funzionare con la versione J j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, in questo ordine. (Sono importanti solo i primi 12 caratteri.)

Spiegazione

Gran parte del programma è dedicato alla generazione costante. Con quelle costanti sostituite con i loro valori, il programma si presenta così:

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

Con alcune parentesi rimosse e alcuni numeri resi più belli:

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

Questo è composto da un gruppo di ,e ,~, che accoda e antepone argomenti. Ecco i valori separati:

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

1è 26come una stringa.

9!:14'' genera la seguente stringa su TIO:

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

con 2, otteniamo il 10carattere th ( ida linux) e aggiungiamo .a alla fine di esso, cedendo i..

3e 5sono autoesplicativi.

4è l'elenco di numeri 65 97 48come stringa.

6è simile a 2, tranne che è il 12th carattere ( uda linux) e aggiunge un :alla fine, cedendo u:.

Questo, tutti insieme, produce u:,65 97 48+/i.26. ".valuta questo dandoci:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Nota: +/è aggiunta tabulata.)

Quindi, con 62{., prendiamo i primi 62personaggi da questo, dandoci ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 byte

-4 grazie ad Adnan, perché se la dimensione di input è 1, 05AB1E utilizzerà 0 per b al primo comando.

•£•Ýç©á®þ«˜

Provalo online!

•£•Ÿ            # 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. 

Ho provato tanti approcci diversi, ma i punti chiave qui che lo hanno reso 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 byte

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

Produzione:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Provalo online!

Inizializza il nastro a 3 · 2 ⁿ e funziona da 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 byte - non competitivo

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

Una lambda che restituisce un elenco di caratteri.
Spiegazione:

   '`'                                       # 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"

Dipende da un bugfix per l'interprete Rakudo Perl 6 che è stato impegnato solo nel repository git oggi e non fa ancora parte di una versione ufficiale di Rakudo. In effetti, ho riscontrato il bug mentre rispondevo a questa sfida e sono riuscito a risolverlo con l'aiuto di uno degli sviluppatori core di Perl 6. Le regole di questo sito, come le capisco, non consentono alle risposte di competere in una situazione del genere, quindi l'ho contrassegnato come non competitivo.

PHP 7.0+, 110 byte

Dio benedica le stringhe bit a bit!

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

Sostituisci \ncon una nuova riga in stile * NIX.
È presente nel codice per evitare problemi con le nuove righe, ma non viene conteggiato nel punteggio.

Questo genera un sacco di avvertimenti, ma quelli potrebbero essere soppressi aggiungendo un @davanti a ogni randagio _.

Avviso libero , 113 byte

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

65c02 linguaggio macchina + Apple] [ROM, 25 byte

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

Stampe abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Dovrebbe iniziare alle $8000.

Smontaggio

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 (su Linux), 507 493 490 485 byte

questo memorizza una matrice di caratteri nella variabile globale __

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

deve essere eseguito su una macchina linux appena avviata /proco con qualcosa come uno spazio dei nomi pid

spiegazione:

# {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}
__=(${__[@]} ${___[@]} ${___[@]^})

per provarlo possiamo aggiungere declare -p __alla fine per visualizzare il risultato

$ 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 byte

Questa soluzione funziona essenzialmente nello stesso modo come gli altri due risposte su questo filo qui e qui , dove utilizza le lettere dai true, false, undefined, e [object Object]stringhe per costruire le funzioni di cui ha bisogno per generare le altre lettere.

Dato che un buon numero di lettere è già inserito nell'oggetto, ho provato ad aggiungere tutte le lettere minuscole rimanenti e i numeri all'oggetto, quindi ho applicato toUpperCasetutti i valori nell'oggetto per generare le lettere maiuscole mancanti.

Aggiornare:

Sono stato in grado di migliorare il modo in cui venivano impostati i valori ottali, ma stanno ancora occupando 13 x 30 byte (o saranno 30 byte ciascuno dopo aver cambiato i numeri in chiavi diverse), ognuno ora segue questo generale modello: $.ž=\'\\'+$.一+$.七+$.二+'\';.

Ulteriori 49 byte possono essere facilmente eliminati commutando le chiavi dei numeri in caratteri a 2 byte.

Presentazione attuale:

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

C (clang) , 164 byte

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

Provalo online!

Questa è una funzione ricorsiva che ottiene i caratteri iniziando con un valore di 1 (sottraendo da sé e incrementando), e crea tutti gli altri numeri da quello.

Ungolfed / analitico:

é,ú,í,ó;
_(*$){ //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 byte

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

Provalo online!

Spiegazione

"{`[@:/" 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 caratteri / 19 byte

ᶐ+ᶛ+⩥Ⅹă⬯

Provalo qui!

ᶐè l'alfabeto maiuscolo, ᶛè l'alfabeto minuscolo ed ⩥Ⅹă⬯è range ( ⩥) da 0a 10( Ⅹ, il numero romano unicode) meno 1, unito da ( ă) nothing ( ⬯).