Desafio

Imprima os seguintes caracteres:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

O problema é que você não pode usar nenhum deles em seu código.

Você pode imprimi-los em ordem arbitrária, com ou sem uma nova linha inicial ou posterior, mas não pode imprimir outros caracteres.

Regras

• Você não pode usar nenhum caractere do conjunto mencionado acima
• Você pode usar outros caracteres
• Sem trapaça
• Falhas padrão proibidas
• Este é o código-golfe , a resposta mais curta vence.

Esclarecimentos

• Se o seu idioma usar um conjunto de caracteres diferente, você não poderá usar pontos de código nesse conjunto de caracteres que correspondam a caracteres alfanuméricos.
• Retornar uma string de uma função é considerado uma forma válida de saída.
• Você pode retornar uma matriz de caracteres.

V , 8 7 bytes

1 byte salvo graças a @DJMcMayhem, colocando tudo em uma instrução regex

¬/{Ó×ü_

Experimente online!

Saídas:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Nota: não× é ou é xX0xd7

Hexdump:

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

Explicação

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

Agora a saída se parece com:

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

Temos que remover todos os caracteres não alfanuméricos e o _(já que não está incluído \W), então vamos fazer isso usando regex

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

Oitava , 52 46 40 bytes

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

Isso avalia como

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Explicação

Aqui, estamos usando o fato de que os caracteres são implicitamente convertidos em números inteiros quando operações aritméticas como +-ou a função range :são aplicadas. Quando concatenados com uma sequência vazia ( [...,'']), os números novamente são convertidos em caracteres.

Experimente online!

brainfuck , 77 76 75 72 bytes

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

Experimente online!

Como funciona

O intérprete começa com uma fita de 0 células.

++++++++

Isso define a primeira célula como 8 , deixando a fita no seguinte estado.

   8
   ^

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

Isso incrementa a segunda célula uma vez, a terceira célula 6 vezes, a quarta célula 4 vezes, diminui a quinta célula uma vez, depois volta para o início da fita e diminui a primeira célula. Após 8 iterações, a fita se parece com a seguinte.

  0   8  48  32  -8
  ^

>++

Avançamos para a segunda célula e a incrementamos duas vezes, preparando-se para imprimir os dígitos.

  0  10  48  32  -8
      ^

[>.+<-]

Isso imprime a terceira célula, a incrementa e depois volta para a segunda célula e a diminui. Após 10 iterações, imprimimos 0123456789e a fita se parece com a seguinte.

  0   0  58  32  -8
      ^

>>

Hora de preparar a fita para as cartas! Começamos avançando duas células.

  0   0  58  32  -8   0   0
              ^

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

Isso incrementa a quinta célula uma vez, a sexta célula duas vezes, a sétima célula três vezes, depois volta para a quarta célula e a diminui. Após 32 iterações, a fita se parece com a seguinte.

  0   0  58   0  24  64  96
              ^

>++

Como último passo antes de imprimir as letras, avançamos para a quinta célula e a incrementamos duas vezes.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Finalmente, avançamos para a sexta célula para incrementá-la e imprimi-la, fazemos o mesmo para a sétima célula, depois voltamos para a quinta célula e a diminuímos. Após 26 iterações, imprimimos Aa...Zz.

Ruby, 42 bytes

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

Uma função que retorna uma matriz de caracteres. Um programa que gera apenas os caracteres tem 49 bytes:

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

Isso simplesmente usa os caracteres ascii em ambos os lados dos intervalos relevantes para definir um intervalo. Por exemplo, ?/...?:significa os caracteres entre uma barra e dois pontos, excluindo o final. Para se livrar do começo, subtraímos uma matriz contendo os três caracteres iniciais.

6502 linguagem de máquina, 74 70 68 bytes

Hex dump (programas 6502 geralmente não são realocáveis; o código aqui é armazenado a partir do local $ 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

Você pode ver que isso usa nenhum dos bytes proibidos: US $ 41 a US $ 5a, US $ 61 a US $ 7a ou US $ 30 a US $ 39.

Esta é uma função sem argumentos que, quando chamada, retorna um ponteiro para a matriz de caracteres "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" na parte superior da pilha, de acordo com as convenções de chamada padrão 6502.

A título de explicação, aqui está uma desmontagem:

Desmontagem do endereço Hexdump
-------------------------------
Esse anunciante possui o telefone validado pela equipe da OLX.
$ 0605 0a ASL A
Preço: R $ 0606 8d 20 06 STA $ 0620
Preço: r $ 0609 8d 21 06 STA $ 0621
Preço: r $ 060c 8d 23 06 STA $ 0623
Preço: r $ 060f 8d 25 06 STA $ 0625
$ 0612 09 20 ORA # $ 20
Preço: r $ 0614 8d 1a 06 STA $ 061a
$ 0617 8d 1c 06 STA $ 061c
$ 061a e o NOP 
$ 061b aa IMPOSTO 
$ 061c e a NOP 
A8 TAY TAY 
$ 061e a9 00 LDA # $ 00
$ 0620 e o NOP 
$ 0621 e o NOP 
$ 0622 98 TYA 
$ 0623 e o NOP 
$ 0624 8a TXA 
$ 0625 e o NOP 
$ 0626 a2 ff LDX # $ ff
$ 0628 a9 7b LDA # $ 7b
Preço a vista: R $ 60,00
Preço: r $ 062c 20 3a 06 JSR $ 063a
$ 062f a9 5b LDA # $ 5b
Preço: r $ 0631 a0 40
$ 0633 20 3a 06 JSR $ 063a
Esse anunciante possui o telefone validado pela equipe da OLX.
$ 0638 a0 2f LDY # $ 2f
Preço: r $ 660
Preço: r $ 063 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

O código do idioma da máquina é auto-modificável. Para manipulação de pilha, eu precisava usar PHA e PLA para empurrar e acionar o acumulador, mas essas instruções têm códigos de operação $ 48 e $ 68, que são proibidos (são os códigos ASCII para as letras 'H' e 'h'). Portanto, para o PHA, pego o número $ 24, faço um deslocamento aritmético para a esquerda (ASL) e armazeno os $ 48 resultantes nos quatro pontos do código em que ele precisa ser executado. Em seguida, para o PLA, eu uso um OR bit a bit nos US $ 48 no acumulador para calcular US $ 68 e armazená-lo nos dois pontos no código onde é necessário.

Havia várias instruções além de PHA e PLA que eu também não poderia usar porque seus códigos de operação são os mesmos que letras ou dígitos ASCII, mas achei soluções alternativas diretas para esses outros.

A matriz de caracteres desejada é calculada e armazenada começando no local 0 (realmente não importa onde está armazenada, pois precisamos ter certeza de que um ponteiro para ela retorne ao topo da pilha).

Você pode tentar fazer isso no emulador e montador 6502 do Nick Morgan . Aqui está uma captura de tela; a caixa do monitor na parte inferior mostra a sequência de saída (nos locais $ 00 a $ 3D) após a execução do programa.

Haskell , 75 72 63 58 56 bytes

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

Experimente online! Ligue com __. Resultado:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Obrigado ao xnor que sugeriu __e _'como nomes de variáveis ​​de dois bytes em vez de (!)ou semelhantes, economizando 9 bytes. Eu gosto especialmente de como _'quebra o destaque da sintaxe. E obrigado novamente ao xnor por generalizar os intervalos, economizando outros 4 bytes.
Edit: eu descobri que caracteres Unicode são permitidos como identificadores em Haskell, por isso, por exemplo ä, ö... pode também ser usado como dois identificadores bytes. Como restava um identificador de três bytes no programa, substituí-o ä, economizando outros 2 bytes.

Explicação:

__e _'são nomes de variáveis ​​válidos. Na especificação de idioma :

Um identificador consiste em uma letra seguida por zero ou mais letras, dígitos, sublinhados e aspas simples. [...] Sublinhado,, _é tratado como uma letra minúscula e pode ocorrer sempre que uma letra minúscula. No entanto, _por si só é um identificador reservado, usado como curinga nos padrões.

Portanto, o código é equivalente a

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

Na lista, a compreensão afica vinculada a '/'e ba ':'( "/:"é equivalente a ['/',':'], portanto a correspondência de padrões é bem-sucedida). Em seguida, o intervalo [a..]cria a sequência de todos os caracteres maior que igual '/':

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

Para cada caractere xnessa sequência, é verificado se '/'<xe x<':', resultando nos caracteres 0123456789. Então ae bsão obrigados a @ e [, produzindo os caracteres ABCDEFGHIJKLMNOPQRSTUVWXYZe assim por diante.

Perl (5.10 ou 5.12), 30 29 bytes

Este programa consiste principalmente de caracteres não imprimíveis, então aqui está um 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 é muito simples: estamos regexing ( =~) um sublinhado ( _; obrigado @Dennis por apontar que isso funciona) contra um regex. O regex é especificado como uma expressão, em vez de literalmente; especificamente, estamos usando o complemento bit a bit ( ~) de uma string. Revertendo o complemento bit a bit para obter a cadeia subjacente, obtemos o seguinte regex que está sendo executado:

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

Nas versões 5.10 e 5.12 do Perl, a (?{…})sintaxe era uma sintaxe experimental para permitir que as expressões regulares executassem código arbitrário no tempo de execução. Nesse caso, usamos-o para executar um programa Perl simples para imprimir a saída desejada. (Versões anteriores à 5.10 não podem ser usadas porque não possuem say.)

As versões modernas do Perl foram desativadas (?{…})por padrão por razões de segurança, mas se você tiver uma versão do Perl, poderá desativar a verificação (e, portanto, executar este programa) via -Mre=evalcomo um argumento de linha de comando (junto com o padrão -M5.010que especifica a versão da linguagem a ser implementada e que não conta contra o bytecount).

Na verdade 8 5 4 bytes

'>┘▀

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

A impressão está implícita no final do programa.

Editar 1: Substituído, colocando o alfabeto em maiúsculas / minúsculas e, em seguida, o intervalo numérico (10), obtendo apenas os caracteres imprimíveis da base 62.

Editar 2: alterado ">" para '> graças ao Mego :) economizou 1 byte.

Experimente online!

PHP, 69 bytes

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

O código é estilizado usando o Windows-1252 aqui. Abaixo está um hexdump reversível xxd .

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

Experimente online!

Java (OpenJDK 9) , 277 bytes

Sim, Java, você leu bem!

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

Experimente online!

Isso imprime os intervalos, mas invertidos, pois o pedido não tem importância.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Eu joguei na ausência da regra "sem entrada" para definir implicitamente uma charque é necessária para fazer a coisa toda funcionar. Se isso é trapaça, diga-o.

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 bytes

Como o brainfuck ignora caracteres alfanuméricos de qualquer maneira, este é apenas um desafio de saída constante ... (Edit: See Dennis 'Solution para uma versão 10 bytes mais curta)

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

Experimente online!

Este código é um bom exemplo de loops contados básicos no 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)

Observe que isso usa atalhos de quebra automática para gerar números, o que significa que o intérprete precisa ter células de quebra automática de 8 bits (como a que eu vinculei).

JavaScript (ES6), 983 bytes

Acontece que no ES6 existem muitos caracteres que você pode usar nos nomes de variáveis ​​JavaScript ! Funciona muito bem após você esgotar os seis nomes de variáveis ​​de 1-2 bytes com $e _.

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

JavaScript, 1223 bytes

Esta foi a minha resposta antes de aprender o que foi dito acima.

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

Corri console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')pelo jjencode e joguei o resultado manualmente. Definitivamente, existem mais otimizações que podem ser feitas.

Befunge, 73 72 59 57 55 53 bytes

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

Experimente online!

Este é um loop único com contagem decrescente de {(ou seja, um caractere depois z). Na primeira iteração, a "{"<sequência envia duas cópias {para a pilha - uma sendo o contador de loop inicial e a outra sendo usada para decrementar esse contador usando a sequência !!-(dois NOTs produzem 1, que são subtraídos). Nas iterações subseqüentes, o contador de loop já está na pilha, portanto, apenas um {é necessário para configurar a sequência de decréscimo.

O restante do código é apenas uma expressão booleana longa que calcula se o caractere está dentro do intervalo. Se for, o ramo na segunda linha se divide para a esquerda para escrever o valor. Caso contrário, o ramo direito será usado para testar se chegamos a zero e devemos terminar. Os dois ramos se fundem no meio para subir e repetir o loop. Observe que todos os comandos de direção vertical sobem, pois não podemos usar a v, mas isso é bom porque o ponteiro de instruções é automaticamente agrupado na parte superior do campo de jogo.

Agradecemos a Mistah Figgins por ter apresentado inicialmente uma técnica melhor para o incremento do loop.

Mas um agradecimento especial a Jo King por uma abordagem ainda melhor na contagem regressiva, em vez de acima, além de um layout de filial mais compacto.

Geléia , 17 16 bytes

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

Experimente online!

Como 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-modificável , 32 bytes

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

Experimente online!

xxd -rhexdump reversível (contém não imprimíveis):

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

C, 128 bytes

Sim, C. E é ainda mais curto que alguns dos esotéricos.

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

Chame _um char *buffer suficientemente grande e vazio .

_{Pode ser um pequenino dependente do compilador. Testado usando o GCC; O arquivo foi salvo na página de código 1252.}

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

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

Editar: usando a codificação ISO8859-1, esta solução tem 416 bytes em vez de 520 bytes. O programa completo tem 432 bytes, levando em consideração os 16 bytes extras para

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

Este é um envio de função, em oposição a um programa completo. Passei muito tempo jogando golfe no JJEncode (gorjeta para darrylyeo por isso), mas em vez de jogar golfe

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Eu jogava golfe

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

onde Øé inicializado ""na sobrecarga.

Reescritos com operadores de vírgula convertidos em novas linhas:

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

Explicação

Esse script começa inicializando alguns tipos internos e coagindo-os em strings. As strings que podemos obter sem usar caracteres alfanuméricos são:

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

A partir dessas strings e dos dígitos necessários para fazer referência a caracteres individuais, podemos obter as strings returne constructor, que podem ser usadas como:

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

O construtor do objeto é Object(), e seu construtor é Function(), que podemos usar essencialmente como eval().

Nesse caso, o script codificado a ser executado são os forloops aninhados que concatenam todos os caracteres alfanuméricos em uma string usando seus pontos de código e retornando-os.

Para caracteres alfabéticos no script codificado que não podem ser acessados ​​usando os built-ins, o JJEncode usa escapes octais para representá-los e decodifica a cadeia inteira, retornando-a de uma função interna. A função externa pode ser chamada para executar a fonte.

Demo

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

Flacidez Cerebral , 171 bytes

Inclui +3 para -A

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

Experimente 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

Provavelmente existe uma maneira de fazer isso sem precisar repetir a função "add 1".

Julia 0.4 , 46 bytes

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

Essa é uma função genérica que retorna uma matriz de caracteres.

Experimente online!

Versão alternativa, 47 bytes, somente ASCII

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

Experimente online!

J, 171 bytes

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

Ow ... meu cérebro dói ... Experimente online!

Aqui está para que você possa ver tudo em uma linha (no entanto, não será executado com quebras de linha).

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

Garantido apenas para trabalhar com a versão J j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, nessa ordem. (Apenas os 12 primeiros caracteres são importantes.)

Explicação

A maior parte do programa é dedicada à geração constante. Com essas constantes substituídas por seus valores, o programa fica assim:

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

Com alguns parênteses removidos e alguns números mais agradáveis:

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

Este é composto por um monte de ,e ,~s, o que acrescentar e argumentos preceder. Aqui estão os valores separados:

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

1é 26como uma string.

9!:14'' gera a seguinte string no TIO:

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

com 2, obtemos o 10caractere th ( ide linux) e adicionamos .a ao final dele, produzindo i..

3e 5são auto-explicativos.

4é a lista de números 65 97 48como uma sequência.

6é semelhante a 2, exceto que é o 12caractere th ( ude linux) e adiciona :a ao final, produzindo u:.

Tudo isso, em conjunto, produz u:,65 97 48+/i.26. ".avalia isso, dando-nos:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Nota: +/é uma adição tabulada.)

Então, com 62{., pegamos os primeiros 62caracteres disso, dando-nos ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 bytes

-4 graças a Adnan, porque se o tamanho da entrada for 1, 05AB1E usará 0 para b no primeiro comando.

•£•Ýç©á®þ«˜

Experimente 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. 

Eu tentei tantas abordagens diferentes, mas os principais pontos aqui que dificultaram:

- 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

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

Resultado:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Experimente online!

Inicializa a fita para 3,2 · ⁿ e funciona a partir daí.

+++[[<+>->++<]>]    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 - não-concorrentes

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

Um lambda que retorna uma lista de caracteres.
Explicação:

   '`'                                       # 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 uma correção de bug do interpretador Rakudo Perl 6, que só foi comprometida com o repositório git hoje e ainda não faz parte de um lançamento oficial do Rakudo. De fato, encontrei o bug ao responder a esse desafio e consegui ser corrigido com a ajuda de um dos desenvolvedores principais do Perl 6. As regras deste site, como eu as entendo, não permitem respostas para competir em tal situação, então eu o marquei como não competidor.

PHP 7.0 ou superior, 110 bytes

Deus abençoe cordas bit a bit!

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

Substitua \npor uma nova linha real no estilo * NIX.
Está presente no código para evitar problemas com novas linhas, mas não é contado na pontuação.

Isso gera vários avisos, mas esses podem ser suprimidos anexando-se um @na frente de todos os perdidos _.

Sem aviso , 113 bytes

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

Idioma da 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

Imprime abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Deve começar às $8000.

Desmontagem

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

isso armazena uma matriz de caracteres na variável global __

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

ele precisa ser executado em uma máquina Linux recém-inicializada com /proc, ou algo como um namespace pid

explicação:

# {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 experimentá-lo, podemos adicionar declare -p __no final para exibir o 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 solução funciona essencialmente da mesma forma que as outras duas respostas sobre esta discussão aqui e aqui , onde ele usa cartas dos true, false, undefined, e [object Object]cordas para construir as funções que necessita para gerar as outras letras.

Como um bom número de letras já foi colocado no objeto, tentei adicionar todas as letras minúsculas restantes e os números ao objeto e, em seguida, apliquei toUpperCasea todos os valores no objeto para gerar as letras maiúsculas ausentes.

Atualizar:

Consegui melhorar a maneira como os valores octais estavam sendo definidos, mas eles ainda ocupam 13 x 30 bytes (ou serão 30 bytes depois que eu mudei os números para chaves diferentes), agora cada um segue essa regra geral. padrão: $.ž=\'\\'+$.一+$.七+$.二+'\';.

49 bytes adicionais podem ser facilmente removidos alternando as teclas dos números para caracteres de 2 bytes.

Envio atual:

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

C (clang) , 164 bytes

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

Experimente online!

Essa é uma função recursiva que obtém os caracteres começando com um valor de 1 (subtraindo de si e incrementando) e cria todos os outros números a partir disso.

Ungolfed / Explicação:

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

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

Experimente online!

Explicação

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

ᶐ+ᶛ+⩥Ⅹă⬯

Experimente aqui!

ᶐé o alfabeto maiúsculo, ᶛé o alfabeto minúsculo e ⩥Ⅹă⬯está no intervalo ( ⩥) de 0até 10( Ⅹ, o número romano unicode) menos 1, unido por ( ă) nada ( ⬯).