Desafío

Imprima los siguientes caracteres:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

El problema es que no puede usar ninguno de ellos en su código.

Puede imprimirlos en orden arbitrario, con o sin una nueva línea inicial o posterior, pero no puede imprimir ningún otro carácter.

Reglas

• No puede usar ningún personaje del conjunto mencionado anteriormente
• Puedes usar cualquier otro personaje
• Sin trampa
• Lagunas estándar prohibidas
• Este es el código de golf , gana la respuesta más corta.

Aclaraciones

• Si su idioma usa un juego de caracteres diferente, no puede usar puntos de código en ese juego de caracteres que correspondan a caracteres alfanuméricos.
• Devolver una cadena de una función se considera una forma válida de salida.
• Puede devolver una matriz de caracteres.

V , 8 7 bytes

1 byte guardado gracias a @DJMcMayhem al ponerlo todo en una declaración regex

¬/{Ó×ü_

Pruébalo en línea!

Salidas:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Nota: no× es o es xX0xd7

Hexdump:

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

Explicación

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

Ahora la salida se ve así:

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

Tenemos que eliminar todos los caracteres no alfanuméricos y el _(ya que no está incluido en \W), así que hagámoslo usando expresiones regulares

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

Octava , 52 46 40 bytes

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

Esto evalúa a

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Explicación

Aquí estamos usando el hecho de que los caracteres se convierten implícitamente en enteros cuando se aplican operaciones aritméticas como +-o la función de rango :. Cuando se concatenan con una cadena vacía ( [...,'']), los números nuevamente se convierten en caracteres.

Pruébalo en línea!

brainfuck , 77 76 75 72 bytes

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

Pruébalo en línea!

Cómo funciona

El intérprete comienza con una cinta de 0 celdas.

++++++++

Esto establece la primera celda en 8 , dejando la cinta en el siguiente estado.

   8
   ^

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

Esto incrementa la segunda celda una vez, la tercera celda 6 veces, la cuarta celda 4 veces, disminuye la quinta celda una vez, luego regresa al comienzo de la cinta y disminuye la primera celda. Después de 8 iteraciones, la cinta se ve como sigue.

  0   8  48  32  -8
  ^

>++

Avanzamos a la segunda celda y la incrementamos dos veces, preparándonos para imprimir los dígitos.

  0  10  48  32  -8
      ^

[>.+<-]

Esto imprime la tercera celda, la incrementa, luego regresa a la segunda celda y la disminuye. Después de 10 iteraciones, hemos impreso 0123456789y la cinta se ve de la siguiente manera.

  0   0  58  32  -8
      ^

>>

¡Es hora de preparar la cinta para las letras! Comenzamos avanzando dos celdas.

  0   0  58  32  -8   0   0
              ^

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

Esto incrementa la quinta celda una vez, la sexta celda dos veces, la séptima celda tres veces, luego regresa a la cuarta celda y la disminuye. Después de 32 iteraciones, la cinta se ve como sigue.

  0   0  58   0  24  64  96
              ^

>++

Como último paso antes de imprimir las letras, avanzamos a la quinta celda y la incrementamos dos veces.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Finalmente, avanzamos a la sexta celda para incrementarlo e imprimirlo, hacer lo mismo para la séptima celda, luego volver a la quinta celda y disminuirlo. Después de 26 iteraciones, hemos impreso Aa...Zz.

Ruby, 42 bytes

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

Una función que devuelve una matriz de caracteres. Un programa que genera solo los caracteres tiene 49 bytes:

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

Esto simplemente usa los caracteres ascii a cada lado de los rangos relevantes para definir un rango. Por ejemplo, ?/...?:significa los caracteres entre una barra diagonal y dos puntos, excluyendo el final. Para deshacernos de los comienzos, restamos una matriz que contiene los tres caracteres iniciales.

6502 lenguaje máquina, 74 70 68 bytes

Volcado hexadecimal (los programas 6502 generalmente no son reubicables; el código aquí se almacena a partir de la ubicación $ 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

Puede ver que esto no usa ninguno de los bytes prohibidos: $ 41 a $ 5a, $ 61 a $ 7a o $ 30 a $ 39.

Esta es una función sin argumentos que, cuando se llama, devuelve un puntero a la matriz de caracteres "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" en la parte superior de la pila, de acuerdo con las convenciones de llamadas estándar 6502.

A modo de explicación, aquí hay un desmontaje:

Dirección Desmontaje Hexdump
-------------------------------
$ 0603 a9 24 LDA # $ 24
$ 0605 0a ASL A
$ 0606 8d 20 06 STA $ 0620
$ 0609 8d 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 ea NOP 
$ 061b aa IMPUESTO 
$ 061c ea NOP 
$ 061d a8 TAY 
$ 061e a9 00 LDA # $ 00
$ 0620 ea NOP 
$ 0621 ea NOP 
$ 0622 98 TYA 
$ 0623 ea NOP 
$ 0624 8a TXA 
$ 0625 ea 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 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 $ 063d
$ 0646 60 RTS

El código del lenguaje de máquina se auto modifica. Para la manipulación de la pila, necesitaba usar PHA y PLA para empujar y hacer estallar el acumulador, pero estas instrucciones tienen códigos de operación $ 48 y $ 68, que están prohibidos (son los códigos ASCII para las letras 'H' y 'h'). Entonces, para PHA, tomo el número $ 24, hago un cambio aritmético a la izquierda (ASL) y almaceno los $ 48 resultantes en los cuatro puntos en el código donde debe ejecutarse. Luego, para PLA, uso un OR bit a bit en los $ 48 en el acumulador para calcular $ 68, y lo guardo en los dos puntos del código donde es necesario.

Hubo varias instrucciones además de PHA y PLA que tampoco pude usar porque sus códigos de operación son los mismos que las letras o dígitos ASCII, pero encontré soluciones directas para esos otros.

La matriz de caracteres deseada se calcula y almacena a partir de la ubicación 0 (realmente no importa dónde esté almacenada, ya que solo debemos asegurarnos de que un puntero a ella se devuelva en la parte superior de la pila).

Puede probar esto en el ensamblador y emulador 6502 de Nick Morgan . Aquí hay una captura de pantalla; el cuadro del monitor en la parte inferior muestra la cadena de salida (en ubicaciones de $ 00 a $ 3D) después de ejecutar el programa.

Haskell , 75 72 63 58 56 bytes

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

Pruébalo en línea! Llamada con __. Salida:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Gracias a xnor que sugirió __y _'como nombres de variables de dos bytes en lugar de (!)o similares, ahorrando 9 bytes. Me gusta especialmente cómo se _'rompe el resaltado de sintaxis. Y gracias nuevamente a xnor por generalizar los rangos, ahorrando otros 4 bytes.
Editar: descubrí que caracteres Unicode se permiten como identificadores en Haskell, así por ejemplo ä, ö, ... También puede ser utilizado como dos identificadores de bytes. Como quedaba un identificador de tres bytes en el programa, lo reemplacé ä, guardando otros 2 bytes.

Explicación:

__y _'son nombres de variables válidos. De la especificación del lenguaje :

Un identificador consiste en una letra seguida de cero o más letras, dígitos, guiones bajos y comillas simples. [...] El subrayado, _se trata como una letra minúscula y puede aparecer donde sea que pueda hacerlo una letra minúscula. Sin embargo, _por sí solo es un identificador reservado, utilizado como comodín en los patrones.

Entonces el código es equivalente a

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

En la lista, la comprensión ase une a '/'y bpara ':'( "/:"es equivalente a ['/',':'], por lo que la coincidencia de patrones tiene éxito). Luego, el rango [a..]construye la cadena de todos los caracteres mayor igual '/':

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

Para cada carácter xen esta cadena, se verifica si '/'<xy x<':', lo que da como resultado los caracteres 0123456789. Entonces ay bestán obligados a @ y [, produciendo los caracteres ABCDEFGHIJKLMNOPQRSTUVWXYZy así sucesivamente.

Perl (5.10 o 5.12), 30 29 bytes

Este programa consiste principalmente en caracteres no imprimibles, así que aquí hay 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          ............"

Este programa es muy simple: estamos regexing ( =~) un guión bajo ( _; gracias @Dennis por señalar que esto funciona) contra una regex. La expresión regular se especifica como una expresión, en lugar de literalmente; específicamente, estamos tomando el complemento bit a bit ( ~) de una cadena. Al invertir el complemento a nivel de bits para llegar a la cadena subyacente, obtenemos la siguiente expresión regular que se está ejecutando:

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

En las versiones 5.10 y 5.12 de Perl, la (?{…})sintaxis era una sintaxis experimental para permitir que las expresiones regulares ejecutaran código arbitrario en tiempo de ejecución. En este caso, lo usamos para ejecutar un programa sencillo de Perl para imprimir la salida deseada. (Las versiones anteriores a 5.10 no se pueden usar porque no tienen say).

Las versiones modernas de Perl se han deshabilitado (?{…})de forma predeterminada por razones de seguridad, pero si tiene una versión de Perl de este tipo, puede deshabilitar la verificación (y, por lo tanto, ejecutar este programa) mediante -Mre=evalun argumento de línea de comandos (junto con el estándar -M5.010que especifica la versión del lenguaje a implementar, y que no cuenta contra el bytecount).

En realidad 8 5 4 bytes

'>┘▀

Cómo funciona:

 '>    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 impresión está implícita al final del programa.

Edición 1: se reemplazó poniendo el alfabeto en minúsculas / mayúsculas y luego el rango de números (10) con solo obtener los caracteres imprimibles de la base 62.

Edición 2: cambió ">" a '> gracias a Mego :) guardado 1 byte.

Pruébalo en línea!

PHP, 69 bytes

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

El código está estilizado usando Windows-1252 aquí. A continuación se muestra un xdux hexdump reversible .

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

Pruébalo en línea!

Java (OpenJDK 9) , 277 bytes

Sí, Java, ¡lo leíste bien!

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

Pruébalo en línea!

Esto imprime los rangos, pero se invierte, ya que el orden no tiene importancia.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Jugué con la ausencia de la regla "sin entrada" para definir implícitamente una charque se requiere para que todo funcione. Si eso es trampa, por favor dilo.

Sin golf y pruebas

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 bytes

Debido a que Brainfuck ignora los caracteres alfanuméricos de todos modos, esto es solo un desafío de salida constante ... (Editar: vea la solución de Dennis para una versión que es 10 bytes más corta)

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

Pruébalo en línea!

Este código es un buen ejemplo de bucles contados básicos en 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)

Tenga en cuenta que esto utiliza accesos directos de ajuste para generar números, lo que significa que el intérprete necesita tener celdas de ajuste de 8 bits (como la que he vinculado).

JavaScript (ES6), 983 bytes

Resulta que en ES6 hay muchos caracteres que puedes usar en los nombres de variables de JavaScript . Funciona muy bien después de agotar los seis nombres de variables de 1-2 bytes con $y _.

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

JavaScript, 1223 bytes

Esta fue mi respuesta antes de conocer lo anterior.

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

Corrí a console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')través de jjencode y jugué el resultado manualmente. Definitivamente hay más optimizaciones que se pueden hacer.

Befunge, 73 72 59 57 55 53 bytes

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

Pruébalo en línea!

Este es un solo ciclo de cuenta atrás desde {(es decir, un carácter después z) En la primera iteración, la "{"<secuencia empuja dos copias de {la pila: una es el contador de bucle inicial y la otra se usa para disminuir ese contador usando la secuencia !!-(dos NOTs 1que luego se restan). En iteraciones posteriores, el contador de bucle ya está en la pila, por lo que solo {se necesita uno para configurar la secuencia de disminución.

El resto del código es solo una expresión booleana larga que calcula si el carácter está dentro del rango. Si es así, la rama en la segunda línea se divide a la izquierda para escribir el valor. Si no, la rama derecha se ajusta para probar si hemos llegado a cero y debería terminar. Las dos ramas se fusionan en el medio para subir y repetir el ciclo. Tenga en cuenta que todos los comandos de dirección vertical van hacia arriba, ya que no podemos usar a v, pero eso está bien porque el puntero de instrucción se ajusta automáticamente en la parte superior del campo de juego.

Gracias a Mistah Figgins por haber ideado inicialmente una mejor técnica para el incremento de bucle.

Pero gracias especiales a Jo King por un enfoque aún mejor para la cuenta atrás en lugar de hacia arriba, así como un diseño de rama más compacto.

Jalea , 17 16 bytes

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

Pruébalo en línea!

Cómo funciona

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

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

Pruébalo en línea!

xxd -rhexdump reversible (contiene no imprimibles):

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

C, 128 bytes

Sí, C. E incluso es más corto que algunos de los esotéricos.

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

Llame _a un char *búfer vacío suficientemente grande .

_{Puede ser un pequeño compilador dependiente. Probado con GCC; El archivo se guardó en la página de códigos 1252.}

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

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

Editar: con la codificación ISO8859-1, esta solución tiene 416 bytes en lugar de 520 bytes. El programa completo tiene 432 bytes, teniendo en cuenta los 16 bytes adicionales para

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

Esta es una presentación de función, a diferencia de un programa completo. Pasé mucho tiempo jugando al golf JJEncode (de punta a punta para darrylyeo por eso), pero en lugar de jugar al golf

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Yo golf

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

donde Øse inicializa ""en la sobrecarga.

Reescrito con operadores de coma convertidos a nuevas líneas:

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

Explicación

Este script comienza inicializando algunos tipos incorporados y obligándolos a formar cadenas. Las cadenas que podemos obtener sin usar caracteres alfanuméricos son:

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

A partir de estas cadenas y los dígitos necesarios para hacer referencia a caracteres individuales, podemos obtener las cadenas returny constructor, que se pueden usar como:

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

Constructor del objeto es Object(), y su constructor es Function(), que podemos utilizar como esencialmente eval().

En este caso, el script codificado que se ejecutará son los forbucles anidados que concatenan todos los caracteres alfanuméricos a una cadena usando sus puntos de código y devolviéndolos.

Para los caracteres alfabéticos en la secuencia de comandos codificada a los que no se puede acceder utilizando los elementos integrados, JJEncode usa escapes octales para representarlos, luego decodifica la cadena completa devolviéndola desde una función interna. Entonces se puede llamar a la función externa para ejecutar la fuente.

Manifestación

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

Brain-Flak , 171 bytes

Incluye +3 para -A

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

Pruébalo en línea!

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

Probablemente haya una manera de hacerlo sin tener que repetir la función "agregar 1".

Julia 0.4 , 46 bytes

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

Esta es una función genérica que devuelve una matriz de caracteres.

Pruébalo en línea!

Versión alternativa, 47 bytes, solo ASCII

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

Pruébalo en línea!

J, 171 bytes

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

Ow ... me duele el cerebro ... ¡ Pruébalo en línea!

Aquí está para que pueda verlo todo en una línea (sin embargo, no se ejecutará con saltos de línea).

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

Solo se garantiza que funcione con la versión J j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, en ese orden. (Solo importan los primeros 12 caracteres).

Explicación

La mayor parte del programa está dedicado a la generación constante. Con esas constantes reemplazadas por sus valores, el programa se ve así:

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

Con algunos paréntesis eliminados y algunos números mejorados:

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

Este se compone de un grupo de ,y ,~s, que de agregación y de argumentos Prefijo. Aquí están los valores separados:

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

1es 26como una cuerda

9!:14'' genera la siguiente cadena en TIO:

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

con 2, obtenemos el 10carácter th ( ide linux), y agregamos .a al final del mismo, rindiendo i..

3y 5se explican por sí mismos.

4es la lista de números 65 97 48como una cadena.

6es similar a 2, excepto que es el 12carácter th ( ufrom linux) y agrega un :al final, cediendo u:.

Esto, todo junto, rinde u:,65 97 48+/i.26. ".evalúa esto, dándonos:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Nota: +/es una adición tabulada).

Luego, con 62{., tomamos los primeros 62personajes de esto, dándonos ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 bytes

-4 gracias a Adnan, porque si el tamaño de entrada es 1, 05AB1E usará 0 para b en el primer comando.

•£•Ýç©á®þ«˜

Pruébalo en línea!

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

Intenté muchos enfoques diferentes, pero los puntos clave aquí lo hicieron difícil:

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

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

Salida:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Pruébalo en línea!

Inicializa la cinta a 3 · 2 ⁿ , y trabaja desde allí.

+++[[<+>->++<]>]    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 bytes - sin competencia

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

Una lambda que devuelve una lista de caracteres.
Explicación:

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

Depende de una corrección de errores para el intérprete Rakudo Perl 6 que solo se comprometió con el repositorio de git hoy, y aún no forma parte de un lanzamiento oficial de Rakudo. De hecho, me encontré con el error al responder a este desafío y logré solucionarlo con la ayuda de uno de los desarrolladores principales de Perl 6. Las reglas de este sitio, tal como las entiendo, no permiten que las respuestas compitan en tal situación, por lo que lo marqué como no competitivo.

PHP 7.0+, 110 bytes

¡Dios bendiga las cuerdas bit a bit!

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

Reemplace el \ncon una nueva línea de estilo * NIX real.
Está presente en el código para evitar problemas con las nuevas líneas, pero no se cuenta en el puntaje.

Esto arroja un montón de advertencias, pero esas podrían suprimirse agregando un @frente a cada parásito _.

Advertencia libre , 113 bytes

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

Lenguaje de máquina 65c02 + Apple] [ROM, 25 bytes

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

Impresiones abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Debería comenzar a las $8000.

Desmontaje

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 (en linux), 507 493 490 485 bytes

esto almacena una matriz de caracteres en la variable global __

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

debe ejecutarse en una máquina Linux recién iniciada con /proc, o algo así como un espacio de nombres pid

explicación:

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

para probarlo podemos agregar declare -p __al final para mostrar el resultado

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

Esta solución funciona esencialmente de la misma manera que las otras dos respuestas en este hilo aquí y aquí , donde utiliza cartas de los true, false, undefined, y [object Object]cuerdas para construir las funciones que necesita para generar las otras letras.

Dado que un buen número de las letras ya están colocadas en el objeto, intenté agregar todas las letras minúsculas y los números restantes al objeto, y luego apliqué toUpperCasea todos los valores en el objeto para generar las letras mayúsculas faltantes.

Actualizar:

Pude mejorar la forma en que se establecían los valores octales, pero todavía ocupan 13 x 30 bytes (o serán 30 bytes cada uno después de cambiar los números a diferentes claves), cada uno ahora sigue este general patrón: $.ž=\'\\'+$.一+$.七+$.二+'\';.

Se pueden extraer fácilmente 49 bytes adicionales cambiando las teclas de los números a caracteres de 2 bytes.

Presentación actual:

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

C (clang) , 164 bytes

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

Pruébalo en línea!

Esta es una función recursiva que obtiene los caracteres comenzando con un valor de 1 (restando de sí mismo e incrementando), y crea todos los demás números a partir de eso.

Sin golf / Explicación:

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

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

Pruébalo en línea!

Explicación

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

ᶐ+ᶛ+⩥Ⅹă⬯

Pruébalo aquí!

ᶐes el alfabeto en mayúsculas, ᶛes el alfabeto en minúsculas y ⩥Ⅹă⬯es range ( ⩥) de 0a 10( Ⅹ, el número romano unicode) menos 1, unido por ( ă) nada ( ⬯).