Dyalog APL oficial do ano de 2016


26

Se você acha que isso pode ser divertido, mas dá muito trabalho, considere participar desse desafio muito menor.


Um pouco de diversão (e possivelmente frustração!) Para 2016 ... o "quebra-cabeça do ano" de Dyalog . Apreciar!

O objetivo

Encontre expressões Dyalog APL ( download ) (outros idiomas são permitidos, consulte Elegibilidade abaixo) envolvendo exatamente os dígitos 2 0 1 6 nessa ordem para igualar os números de 0 a 100. Por exemplo:

20=16
×2016
2⌊016
2+0+1*6
...

O objetivo é usar o mínimo de caracteres possível em cada expressão (o número mínimo de caracteres para uma expressão é 5 - os quatro dígitos 2 0 1 6 e uma única função / operador primitivo).

As regras

  • Cada expressão deve conter os dígitos 2 0 1 6 (nessa ordem) e nenhum outro dígito. Constantes e variáveis ​​predefinidas também não são permitidas.
  • Além dos quatro dígitos 2 0 1 6, apenas símbolos e nomes embutidos, parênteses / chaves, espaços, sinais de menos altos e pontos decimais podem ser usados. As expressões resultantes devem ser determinísticas (ou seja, fornecer o mesmo resultado em avaliações repetidas). Para não APLs, funções / operadores com um nome também são permitidos; mesmas regras que aqui .
  • Suponha todas as configurações padrão para o seu idioma. Para o Dyalog APL, isso significa ⎕MLe ⎕IOsão ambos 1 e ⎕PPé 10.
  • Cada entrada que compreende expressões corretas para todos os números de 0 a 100 inclusive será classificada de acordo com o número de caracteres usados ​​por essas expressões, excluindo espaços redundantes (mínimo 505 para todas as 101 expressões).

Elegibilidade

Qualquer um pode entrar. Você pode responder em qualquer idioma, mas apenas as respostas da APL serão consideradas para aceitação. Se você usar outro idioma que não o APL, poderá usar trechos, programas, funções etc. como alternativas às expressões e poderá imprimir, deixar o número em um local de memória acessível ou retornar o resultado, desde que seu código seja diretamente avalia o número desejado como qualquer tipo de dado numérico padrão para o seu idioma.

Data de encerramento

30 de novembro de 2016.

Prémios

  • Aceite sua resposta
  • Seja imortalizado no Hall of Fame de Dyalog 2016!

Como enviar sua inscrição

Após 30 de novembro de 2016, aceitarei a resposta mais curta e enviá -la-ei em seu nome ao Hall da Fama de Dyalog 2016.

Perguntas frequentes

  • É permitido J(por exemplo, 37 = ⌈⍟!20J16)?
  • Não: além dos quatro dígitos 2 0 1 6, somente símbolos e nomes internos, parênteses / colchetes, espaços, sinais de menos e pontos decimais podem ser usados.

  • A saída como uma string é aceitável?
  • Não: igual aos números de 0 a 100.

  • Dígitos físicos ou dígitos de dados?
  • Dígitos de dados, conforme OP: mesmas regras que aqui , onde um dos exemplos contém LOG10(.

  • É a+16+a←20permitido atribuir variáveis ​​e usá-las como parte da expressão (por exemplo, 56 = ) permitido?
  • Sim, mas você não pode usar uma atribuição de uma expressão em outra.

Eu tenho permissão explícita por escrito para postar esse desafio aqui, do autor original desse desafio. Sinta-se livre para verificar, seguindo o link fornecido e entrando em contato com o autor. Dei ao autor original do concurso o link para esta página no minuto em que o publiquei, para que eles possam verificar se eu envio a resposta de alguém como minha.



Tantas respostas e nenhuma solução APL?
Akangka 16/09/16

1
@ChristianIrwan Certo, isso é de se esperar: quem faz isso na APL pode preferir se submeter à competição real em vez de revelar seus segredos aqui.
Adám 16/09/16

@ Adám, isso pode ser tarde, mas seria aceitável usar ⎕MLe ⎕IO(supostamente 1)?
Zacharý

@ZacharyT Você quer dizer colocar nomes quad na expressão? Parece um monte de personagens extras para ganhar pouco. Você pode me dar um exemplo?
Adám 4/16/16

Respostas:


7

Geléia, 686 bytes

20=16
20>16
2+0%16
201%6
20%16
20%16‘
201a6
20>1+6
20%16Ḥ
2016DS
20Ho16
2016BL
20:1.6
20_1_6
20×1_6
20+1_6
20&16
20:+16
2+0+16
20+1^6
20|16
20|16‘
20|16‘‘
20%16!’
20%16!
20²:16
20H+16
20+1+6
20×1_6Ḥ
20×1_6Ḥ‘
20+1_6Ḥ
2016&½’
2016&½
201:6
201:6‘
20Cạ16
20+16
20+16‘
20+1^6Ḥ
20|16Ḥ’
20|16Ḥ
20|16Ḥ‘
20|16‘Ḥ
2016½Ḟ’
2016½Ḟ
2016½Ċ
2016½Ċ‘
20Ḥ+1+6
2r0×16S
201a6‘²
20²:16Ḥ
2r016+S
201ÆC+6
20&16ÆN
20H_1×6
20ạC+16
20Ḥ+16
20_1×6H
20_1×6H‘
20_1×6H‘‘
20+1_6ḤḤ
2+0+16ÆN
20:.16H
20+1×6H
2²+0×16
201:6Ḥ’
201:6Ḥ
201Ḥ:6
201Ḥ:6‘
20Cạ16Ḥ’
20Cạ16Ḥ
20+16Ḥ’
20+16Ḥ
20+16Ḥ‘
20+16Ḥ‘‘
20+ÆN_16
20+1^6ḤḤ
20+1^6ḤḤ‘
20×16HH’’
20×16HH’
20×16HH
20×16HH‘
20|16Ḥ‘Ḥ
20|16Ḥ‘Ḥ‘
20|16‘ḤḤ
201½×6Ḟ
201½×6Ċ
20ÆN+16
2016½ḞḤ
20Æn16¡
20r16S
20r16S‘
20r16S‘‘
20Ḥ+1+6Ḥ’
20Ḥ+1+6Ḥ
20ḤḤ+16’
20ḤḤ+16
20ḤḤ+16‘
201a6‘²Ḥ
201’Ho6’
201’Ho6

Escrevi cerca de 50 delas e, em seguida, gerou automaticamente o restante anexando (× 2) e ‘’(± 1) conforme necessário. Eu os melhorarei mais tarde!


46 pode se tornar 201ÆCo6. Eu não acho que você pode usar (que foi implementado em fevereiro), mas 20|16Ḥ‘Ḥe 20|16‘ḤḤ’são igualmente curto.
Dennis

@ Dennis Ops, meu script Python na verdade preferia erroneamente o excesso de ‘’46, entre outros quatro números, deveria ter um caractere menor. Eu substituí-o pelo 2016½Ċ‘qual é contanto que o seu.
Lynn

9

Hexagonia , 888 bytes

Ok, primeiro algumas regras básicas do Hexagony, caso alguém queira superar isso:

  • Estou interpretando "snippet" como um trecho de código linear que pode ser despejado em qualquer programa suficientemente grande, desde que as bordas da memória atual e adjacente sejam zero.
  • O trecho deve ser inserido da esquerda e retirado da direita. Eu seria capaz de economizar um monte de bytes sem isso (por exemplo, 2|01622), mas parece mais com o espírito do desafio.
  • O trecho "produz" um determinado número, se houver alguma margem de memória (não necessariamente a atual) que mantém esse valor após a execução.
  • A regra que proíbe qualquer outro número no snippet afeta os outros dígitos e as letras, pois eles atuam efetivamente como literais inteiros no Hexagony. (Isso economizaria uma tonelada de bytes.)

Então aqui está a lista. Eu testei a maioria deles, mas não todos (alguns são modificações triviais de outros), então espero não ter cometido erros:

2016
20&1}6
2}016
2)}016
20{16'-
201}6(
201}6
201}6)
2}016":
2(0(}16
2(0}16
2(0)}16
)2}016
)2)}016
20}16((
20}16(
20}16
20}16)
20}16))
20(}16
20}16
20)}16
20))}16
20)))}16
20}1)6((
20}1)6(
20}1)6
20}1)6)
201{6)':
2)0(}16
2)0}16
2)0)}16
2{016'*
201{6':
2{016)'*
20}1))6(
20}1))6
20}1))6)
20}1))6))
2))0(}16
2))0}16
2))0)}16
2))0))}16
2))0)))}16
20)){1)'6*
2){016('*
2){016('*)
2){016'*(
2){016'*
2){016'*)
2)))0}16
2){016)'*
2){016)'*)
2{01)6)'*(
2{01)6)'*
2{01)6)'*)
2{01)6)'*))
2{01)6)'*)))
2))))0((}16
2))))0(}16
2))))0}16
2))))0)}16
2)0){1)'6*
2)){016'*(
2)){016'*
2)){016'*)
2)){016'*))
2)){016'*)))
2{01))6('*(
2{01))6('*
2{01))6'*((
2{01))6'*(
2{01))6'*
2{01))6'*)
2{01))6)'*
2){01)6('*
2){01)6'*((
2){01)6'*(
2){01)6'*
2){01)6'*)
20{1)))'6*
2){01)6)'*
2){01)6)'*)
2){01)6)'*))
2){01)6))'*
2){01)6))'*)
2){01)6))'*))
2){01)6)))'*
2{01)))6(('*
2{01)))6('*(
2{01)))6('*
2{01)))6'*(
2{01)))6'*
2{01)))6'*)
2{01)))6)'*
2{01)))6)'*)
2{01)))6))'*
2(01((((}16
2(01(((}16
2(01((}16
2(01(}16

Fiquei um pouco preguiçoso no final, então tenho certeza de que isso não é o ideal. Pode ser interessante (e possível) forçá-los a força bruta.


Muito agradável. Lembre-se de que você tem 10 meses (ou para sempre, realmente) para melhorar isso. Suponho que o Hexagony tenha poucos comandos suficientes para que a força bruta seja razoável. Levei uma semana de uso 100% de núcleo único para 4 caracteres APL de força bruta inseridos.
Adám 31/01

Então você fez isso? Você conseguiu uma solução ideal?
precisa saber é o seguinte

@NBZ Desde incrementar e decrementar o resultado é sempre possível, por um único byte pode ser mais fácil para Hexagony para verificar os programas para quaisquer números (em vez de um número de cada vez), e se eu encontrar algo mais curto do que o melhor curso para esse número e pode encurtar isso e potencialmente alguns números ao seu redor também. E sim, depois de remover os dígitos e as letras (e alguns outros caracteres que são inúteis aqui), deve ser bastante brutal à força.
Martin Ender

@ jimmy23013 Quase pronto. Falta a solução ideal para dois dos 101 números.
Adám 01/02/16

@NBZ Você só precisa usar a força bruta de 4 caracteres para provar que não existe. Acho que você pode escrever uma solução de 5 caracteres à mão e isso seria o ideal.
precisa saber é o seguinte

8

J, 1041 ... 838 bytes

981 961 952 860 859

Fiquei um pouco preguiçoso até o fim, mas deveria ser mais fixo que menos. Acho que nunca superarei o Hexagony, mas você nunca sabe! batendo hexagonia! Economizou 9 bytes graças ao Zgarb! e muito mais para Lynn!

20=16
*2016
2[016
2+01[6
20-16
p:2[016
201]6
2+0-1-6
-:20]16
2+01+6
-:20[16
p:20-16
+/2$01]6
<:20-1]6
20-1]6
<:20]16
20]16
p:201]6
2+016
20-1[6
20[16
20+1[6
20++~1[6
+/q:2016
20-(+:1)-6
<:20+1]6
20+1]6
20+1+6
+:20-1]6
p:2+01+6
-2-+:016
<:2*016
2*016
>.201%6
<.201%6
<:20+16
20+16
20+>:16
+~20-1[6
-20-p:16
+:20[16
p:2*01*6
>:p:2*01*6
<:<.%:2016
<.%:2016
>.%:2016
+/q:*:2016
p:20-1]6
>:p:20-1]6
*:2+0-1-6
+:20-1-6
20++:16
<.%:20^%:1+6
20+#i:i:16
*/2,01]$~-:6
<:<.o.2+016
<.o.2+016
>.o.2+016
<:p:20]16
p:20]16
>:p:20]16
2+p:016
<.o.20[16
<:2^01]6
2^01]6
>:2^01]6
<:p:2+016
p:2+016
>:p:2+016
>:>:p:2+016
<:p:20-1[6
p:20-1[6
+/+~20 16
p:20[16
>:p:20[16
>:>:p:20[16
-:+/2+i.016
<:<:p:20+1[6
<:p:20+1[6
20+p:16
20*.16
*:2+01+6
>:*:2+01+6
p:20++~1[6
<.o.20+1+6
>.o.20+1+6
>:>.o.20+1+6
<.o.+:20-1]6
>.o.+:20-1]6
p:+/q:2016
>:p:+/q:2016
<.o.p:2+01+6
>.o.p:2+01+6
(*:-:20)-1+6
>:(*:-:20)-1+6
<:(++:)2*016
(++:)2*016
p:20-(+:1)-6
2**~p:-:01]6
<:*:-:20[16
*:-:20[16

Destaques e Notas

Eu usei muito números primos nisso. De fato, eu usei p:(a enésima enésima) função 37 vezes nessa coisa.

 *:-:20[16

90 foi feito usando um garfo. Yay! É aproximado a isso:

(*+&1)2+01+6

Traduzido como

inc =: + &1
mul =: *
nin =: 2 + 1 + 6
NB. since (f g) y = y f (g y):
  (mul inc) nin   = nin mul (inc y)
                  =  9   *    9+1
                  =  90

54 usa um desfile de modelagem!

*/2,01]$~-:6

É equivalente a

*/ 2 , $~ -:6
*/ 2 , -:6 $ -:6
*/ 2 , 3 $ 3
*/ 2 , 3 , 3 , 3
   2 * 3 * 3 * 3
   54

Bem, você tem 3/4 anos para fazer melhorias.
Adám 02/03/16

24: !20-1654: <.^20-1655: >.^20-1697:p:!20-16
Lynn

Bom truque com os quatro fatoriais!
Conor O'Brien

Que 94 parece suspeito por muito tempo ... que tal +:p:-2-016(4 bytes mais curto)?
Lynn

Eu acho que 7 pode ser 2]01+6, 8 pode ser 2%~016e 12 podem ser 2*01]6.
Zgarb

7

JavaScript, 1021 bytes

Corrigido e salvo dois bytes graças a Charlie Wynn e ETHProductions .

201&6
-~!2016
2%016
201%6
20%16
2^0^1^6
2*0*1+6
2|0|1|6
2*01+6
2-~01+6
~2+016
~2+016
2^016
20-1-6
2|016
20+1-6
20&16
2-~016
2.0+16
20^1+6
20|16
-~20|16
20*1|6
20|1|6
-2*~01*6
20-1+6
20+1*6
20+1+6
2*016
-~(2*016)
2*-~016
~-(2.0*16)
2.0*16
-~(2.0*16)
2.0*-~16
~-20+16
20+16
-~20+16
-~-~20+16
-~2*~-016
20*-~1.6
~-(-~2*016)
-~2*016
~-~-(~2*~016)
~-(~2*~016)
~2*~016
20<<1|6
20*-~1-~6
~2*~-~016
-~(~2*~-~016)
~-~(~-~2*~-016)
~2*~-~-~016
-~-~2*~-016
20*-~-~1+~6
20*-~-~1-6
20*-~-~1-~-6
-~-~2*016
-~20*-~-~1-6
-~-~(-~-~2*016)
~-(20*~-~(1-6))
~-~2*~016
-~(20*~-~(1-6))
-~-~(20*~-~(1-6))
-~20*~-~(1-6)
~-~2*~-~016
20*-~-~1+~-6
20*-~-~1+6
20*-~-~1-~6
~-~2*~16
-~20*-~-~1+6
-~-~-~2*016
~-(~-~2*~-~16)
~-~2.0*~-~16
-~(~-~2*~-~16)
20*-~-~-~1-6
~-~-~2*~016
~-20*~(1-6)
-~(~-20*~(1-6))
~-~-(20*~(1-6))
~-(20*~(1-6))
20*~(1-6)
-~(20*~(1-6))
~-~-(~20*-~(1-6))
~-(~20*-~(1-6))
~20*-~(1-6)
20*-~-~-~1+~-6
20*-~-~-~1+6
20*-~-~-~1+-~6
20*-~-~-~1+-~-~6
~-(~-~-20*-(1-6))
~-~-20*-(1-6)
-~(~-~-20*-(1-6))
~-~-~-(~-20*-(1-6))
~-~-(~-20*-(1-6))
~-(~-20*-(1-6))
~-20*-(1-6)
-~(~-20*-(1-6))
~-~-~-(20*-(1-6))
~-~-(20*-(1-6))
~-(20*-(1-6))
20*-(1-6)

20 ^ 1 + 6 economiza um para 19 (que é ok se você colocar o número ao lado de cada entrada?)
Charlie Wynn

20 << 1 | 6 salva uma para 46 (devo apenas editar sua resposta?) #
Charlie Wynn

@CharlieWynn No. Use sugestões de comentários. Há um meta post nele.
mbomb007

Testando no Firefox 44, o 1 é realmente 2, e seu 10 é 11. Você pode usar o seu actual de 10, quando 11 (é três bytes mais curto), 2-~01+6como 10, e -~!2016como 1.
ETHproductions

wow alguém conseguiu bater o meu 5244 caracteres solução
clamchowder314

7

JavaScript (ES7), 836 bytes

Tudo deve funcionar em qualquer navegador, exceto 81, 88 e 97, que usa o novo **operador.

Principalmente tudo aqui foi feito à mão. Eu tenho trabalhado em um bruto para melhorar qualquer coisa que possa ser melhorada. Atualmente, ele salvou 103 bytes em vários itens.

  0: 201&6
  1: 2-01%6
  2: 2%016
  3: 201%6
  4: 20%16
  5: 201%~6
  6: 2%01+6
  7: 2-01+6
  8: 2*01+6
  9: 2+01+6
 10: 2-~01+6
 11: ~2+016
 12: 2^016
 13: 20-1-6
 14: 2|016
 15: 20+1-6
 16: 2+016
 17: 2-~016
 18: 2+0+16
 19: 20-1%6
 20: 20|16
 21: 20+1%6
 22: 20*1|6
 23: 20+1|6
 24: 20+~1+6
 25: 20-1+6
 26: 20*1+6
 27: 20+1+6
 28: 2*016
 29: 20-~1-~6
 30: -2*~016
 31: 20|~-16
 32: 20*1.6
 33: 20*~1^~6
 34: -20*~1-6
 35: 20+~-16
 36: 20+16
 37: 20-~16
 38: 20-~-~16
 39: -~2*~-016
 40: 20<<1%6
 41: -20*~1-~!6
 42: ~2*-016
 43: ~20^-1<<6
 44: ~20*~1^6
 45: ~2*~016
 46: 20<<1|6
 47: -20*~1-~6
 48: ~20*~1+6
 49: ~20*~1-~6
 50: ~2/.01/-6
 51: ~2.0*~16
 52: 20|1<<~-6
 53: -20*~-~1+~6
 54: ~2.0*~-~16
 55: -20*~-~1-~-6
 56: ~-~2*-016
 57: ~20*~-~1-6
 58: -20*~-~1^6
 59: ~(20/~1*6)
 60: -20/~1*6
 61: ~2^0-1<<6
 62: -2^0-1<<6
 63: ~20/~1*6
 64: 2-01<<6
 65: 2+~0|1<<6
 66: 2|01<<6
 67: 2-~0|1<<6
 68: 2*~!0*~16
 69: ~20*~-~1+6
 70: 20/~1*~6
 71: -~(20/~1*~6)
 72: 2+~0/.1*~6
 73: -20<<-~1^~6
 74: -20<<-~1^-6
 75: ~-~-~2*~016
 76: ~-20*(~1+6)
 77: ~-~20/~1*-~6
 78: ~-20<<-~1|6
 79: -20<<-~1^~!6
 80: 20*(~1+6)
 81: ~2*~0**(~1+6)
 82: ~-~-20|1<<6
 83: ~-20|1<<6
 84: 20|1<<6
 85: -~20|1<<6
 86: 20<<-~1|6
 87: 20<<-~1|-~6
 88: .2**~!0|1<<6
 89: ~20*~-~-~1+~-6
 90: ~2*~!0*~-16
 91: ~20*~-~-~1-~6
 92: ~-2/.01+~-~6
 93: ~-2/.01+~6
 94: ~-2/.01-6
 95: ~-20*1*~-6
 96: 2+01<<~-6
 97: ~2+.01**~.6
 98: ~-2/.01^6
 99: ~-2/.01+~.6
100: 20*1*~-6

Forçador bruto

Não é o código mais bonito, mas isso não parece importar nessas partes.

AVISO: Não execute a menos que esteja preparado para o seu navegador / mecanismo congelar por alguns minutos. Ninguém gosta de calcular 7 loops aninhados.

var a=new Array().fill("000000000000000000000000000"), // An array of non-solutions to start
    time=new Date(),                                   // For timing how long this takes
    o=["","+","-","*","/","%","&","|","^",".","<<"],   // Operators for between numbers
    p=["",".","~.","-","~","~-","-~","~-~","~-~-","~!"];        // Prefixes for each number
for(i=0;i<o.length;i++)
for(j=0;j<o.length;j++)
for(k=0;k<o.length;k++)
for(I=0;I<p.length;I++)
for(J=0;J<p.length;J++)
for(K=0;K<p.length;K++)
for(L=0;L<p.length;L++) {      // 7 nested loops = O(len(o)^3 * len(p)^4)
    z=      p[I]+2
      +o[i]+p[J]+0
      +o[j]+p[K]+1
      +o[k]+p[L]+6;            // Put all the current chars in one string. 
    try { v=eval(z) }          // Try setting v to the evaluated value of z.
    catch(e) { v=-1 }          // If an error occurs, set v to -1.
    if( (v === (v|0)) &&       // If v is an integer, and
        v>=0 && v<=100 &&      // v is between 0 and 100, inclusive, and
        z.length<a[v].length ) // z is shorter than the current entry,
        a[v]=z;                // overwrite the current entry.
}

console.log("time: " + ((new Date()-time)/1e3) + "seconds\n"
           + "length: " + (a.join("").length) + "\n"
           + a.map((x,y) => y + ": " + x).join("\n"))

3
Sim, beleza não importa aqui. Nós não somos CR. : P
Rɪᴋᴇʀ

wow alguém conseguiu bater o meu 5244 caracteres solução
clamchowder314

4

PowerShell v3 +, 1575 1499 bytes

2*0*16
2*0+1%6
2%016
201%6
20%16
2*0+-1+6
2*0+1*6
2*0+1+6
2+0*1+6
2+01+6
2*(0-1+6)                #10
2*($a=01)*6-$a           ################################## First variable
2*01*6
20-1-6
20*1-6
20+1-6
2*0+16
!!20+16                  ################################## First Boolean not
2+016
2+!0+16
20+!16                   #20
20+1+!6
!2+0x16                  ################################## First use of 0x16
(20+1)-bor6              ################################## First binary or
2+0x16
20-1+6
20*1+6
20+1+6
20+($a=1)+6+$a
20+($a=1)+6+$a+$a
2*-bnot-016              #30 ############################## First binary not
-bnot(-2*016)
2*016
-(-bnot(2*016))
-2*-bnot016
-bnot(-20)+16
20+16
20-(-bnot16)
-(-bnot20)-(-bnot16)
(20-shl1)-!!6            ################################## First binary shl
(20-shl1)+!6             #40
(20-shl1)+!!6
($a=2)*0x16-$a
($a=2)*0x16-$a/$a
2*0x16
-(-bnot2)*(-bnot-016)
(20-shl1)+6
$a=20;$b=1;$a+$a+$b+6
-(-bnot2*016)
2*0+($a=1+6)*$a
(20-shr($a=1))*(6-$a)    #50
(-bnot2)*(-bnot016)
20+($a=16)+$a
($b=20*($a=1)+6)+$b+$a
($a=20+1+6)+$a
($a=20+($b=1)+6)+$a+$b
($a=20)+16+$a
(($a=(2+!0))+16)*$a
(20-shr($a=1))*6-$a-$a
(20-shr($a=1))*6-$a
(20-shr1)*6              #60
(20-shr($a=1))*6+$a
(($a=2)*0+1-shl6)-$a
-bnot-(2*0+1-shl6)
2*0+1-shl6
(2*0+($a=1)-shl6)+$a
(-bnot2)*-0x16
($a=201)/($a%6)
20+($a=16)+$a+$a
20+($a=16)+$a+$a+$a/$a
-($a=2)*-bnot016*$a+$a   #70
2*01*($a=6)*$a-$a/$a
2*01*($a=6)*$a
($a=2+01+6)*$a-$a+$a/$a
($a=2)*01*($b=6)*$b+$a
($a=20)+16+$a+$a-$a/$a
($a=20)+16+$a+$a
($a=20)+16+$a+$a+$a/$a
2*01*($a=6)*$a+$a
($a=20)%16*$a-$a/$a
($a=20)%16*$a            #80
($a=2+01+6)*$a
($a=2)*0x16*$a-$a*$a-$a
20+(($a=1)-shl6)-$a
20+(1-shl6)
20+(($a=1)-shl6)+$a
($a=2)*0x16*$a-$a
($a=2)*0x16*$a-$a/$a
($a=2)*0x16*$a
($a=2)*0x16*$a+$a/$a
($a=2)*0x16*$a+$a        #90
($a=2)*0x16*$a+$a+$a/$a
($a=2)*0x16*$a+$a+$a
20*(-1+($a=6))-$a-$a/$a
20*(-1+($a=6))-$a
20*($a=-1+6)-$a
2*(!0+1+($a=6))*$a
20*(($a=-1)+6)+$a+$a+$a
($a=2)*($b=01+6)*$b
20*(($a=-1)+6)+$a
20*(-1+6)                #100

Golfe 100% manual - não há programas de força bruta ou outros auxílios alistados.
Eu sinto que 1500 talvez esteja ao alcance do
Sub-1500 alcançado! Vamos ver o quão bem eu posso fazer para diminuir isso. (NB - Isso foi testado apenas na v4, mas deve funcionar na v3 e v5 sem modificação. Não funcionará na v2 ou v1, pois essas versões não tinham operadores de deslocamento bit a bit.)

Os pontos principais estão marcados com ##.hashes.##no código acima.

# 11 é a primeira atribuição à variável $a. Ao contrário de outros idiomas, as variáveis ​​não precisam ser pré-inicializadas para análise, e somente durante a execução as variáveis ​​são resolvidas. Como o ($a=01)é cercado por parênteses, ele é avaliado primeiro e, portanto, o segundo -$aé equivalente a -1. Isso é usado extensivamente daqui em diante e é uma das maiores coisas que mantém o número de bytes baixo.

# 17 mostra o primeiro uso de !para booleano não. No PowerShell, os tipos são muito pouco expressos; portanto, se a conversão puder ser implícita, funcionará. Aqui, estamos usando o fato de que !!20iguais !$false, o que é $true, que podem ser expressos implicitamente como [int]1, o que resulta em 17. Isso é usado várias vezes para obter outro 1ou fazer com que uma parte vá para 0.

# 22 mostra o 0xoperador hexadecimal elenco, aqui transformando 0x16em 22. No entanto, como 0x16é o único número que podemos obter, sua utilidade é limitada.

O número 23 tem o -boroperador, para "binário ou". No entanto, como ambos -bore -bxortêm precedência menor que os operadores aritméticos simples, seu uso geralmente requer parênteses, o que limita severamente a utilidade. Este é o único que encontrei, onde é mais curto usar o binário ou o operador (eliminei o operador de 22).-bxor

# 30 é a primeira vez que o -bnotoperador é apresentado. Este é o operador "binário não" e funciona de maneira semelhante ao ~(por exemplo) JavaScript. No entanto, geralmente precisa de parênteses, pois a negação será exibida --bnote resultará em um erro de análise / sintaxe, e, como são cinco caracteres em comparação a um ~, é usado com moderação.

# 39 é o primeiro uso de nossos operadores de turno binário, -shle -shr. Eles são semelhantes <<ou >>em outros idiomas, mas são explicitamente diádicos, o que significa que precisamos de um número de ambos os lados para que eles funcionem, o que limita sua utilidade nesse desafio. Além disso, sua precedência não é explicitamente citada na documentação, mas o teste mostra que eles são inferiores à aritmética simples, o que significa que os parênteses precisam ser usados ​​livremente, para que não pareçam tanto quanto em outras respostas de idiomas.


Ótima resposta. Obrigado por explicar suas técnicas tão minuciosamente.
Adám 9/03/16

4

CJam, 792 791 bytes

Eu fiquei meio preguiçoso perto do fim, muitos deles acabaram sendo incrementos e decrementos (101 é muito!), Embora eu não tenha certeza se existe outra maneira de alguns números. Ainda há muito tempo para jogar golfe, se eu precisar.

Em torno de # 40 há alguns rostos piscantes;)

2016!          e# 0
2016g
2016g)
201 6%
20 16-
20)16-
20 1>6*
20 1>6+
201mQ6-
201mQ6-)
2 01 6*(*      e# 10
2 01*6*(
2 01*6*
2~016+
-2 016+
2)016(|
20;16
2(016+
2 016+
2)016+
20 16|         e# 20
20)16|
20 1*6|
20 1|6|
20 16mQ+
20_*16/
20 1 6*+
20 1+6+
20 1)6++
20)1)6++
2 016(*        e# 30
2 016*(
2 016*
201 6/
2 016)*
20(16+
20 16+
20)16+
20)16)+
20_+16;(
20_+16;        e# 40
20_+16;)
20)_+16;
20)_+16;)
20(1m<6+
2)016(*
20 1m<6+
2)016*(
2)016*
2)016*)
2)016)*(       e# 50
2)016)*
20 16_++
20)1 6(m<+
20(_16++
20_16++(
20_16++
20_16++)
20)_16++
20)_16++)
20 16mQ(*      e# 60
20 16mQ(*)
2 01*6#((
2 01*6#(
2 01*6#
2 01*6#)
201_+6/(
201_+6/
201_+6/)
201mQ6(*(
201mQ6(*       e# 70
20_16_+++(
20_16_+++
20_16_+++)
20)_16_+++
20(16mQ*(
20(16mQ*
20(16mQ*)
20_16^*((
20_16^*(
20_16^*        e# 80
2)016mQ#
201mQ6*((
201mQ6*(
201mQ6*
201mQ6*)
201mQ6*))
201mQ6*)))
[20_16__]:+
[20_16__]:+)   
[20)_16__]:+   e# 90
[20_16)__]:+
[20__16_]:+
20(1*6(*((
20(1*6(*(
20(1*6(*
20(1*6(*)
201mQ6)*(
201mQ6)*
20 1*6(*(
20 1*6(*       e# 100

Queria votar de forma positiva pelos rostos piscantes, mas notei que você tinha exatamente 1.000 representantes, então não quero estragar tudo. ;) Voto a favor mais tarde. : P
Kevin Cruijssen

e agora a sua 1089: P (outro número mágico para matemática: P)
masterX244

3

Mathematica, 2912 2502 2282 2180 bytes

Definitivamente poderia ser jogado ainda mais. Principalmente resolve apenas algumas equações separadas de Frobenius, que produzem soluções de comprimento O ( n ). O resto foi gerado pelo meu brute-forcer.

2 0 16
2-01^6
2 01^6
2+01^6
20-16
2 0-1+6
201;6
2-01+6
2 01+6
2+01+6
a=2;01 6+a+a
2#-01&@6
2 01 6
20-1-6
20 1-6
20+1-6
20;16
2^0+16
2+016
20-1^6
20 1^6
20+1^6
a=2;b=016;a+a+a+b
a=2;b=01;c=6;a+a+b+c+c+c
201;a=6;a+a+a+a
20-1+6
20 1+6
20+1+6
a=2;b=016;a+a+a+a+a+a+b
a=2;b=01;c=6;a+a+b+c+c+c+c
201;a=6;a+a+a+a+a
2;a=01;b=6;a+b+b+b+b+b
2 016
a=2;b=01;c=6;a+b+c+c+c+c+c
a=2;b=016;a+b+b
a=2;b=01;c=6;a+a+b+c+c+c+c+c
20+16
2;a=01;b=6;a+b+b+b+b+b+b
a=2;b=016;a+a+a+b+b
a=2;b=01;c=6;a+b+c+c+c+c+c+c
a=20;16;a+a
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c
201;a=6;a+a+a+a+a+a+a
2;a=01;b=6;a+b+b+b+b+b+b+b
a=2;b=016;a+a+a+a+a+a+b+b
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c
a=2;b=016;a+a+a+a+a+a+a+b+b
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c+c
201;6!!
2;a=01;b=6;a+b+b+b+b+b+b+b+b
2 01+6!!
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c+c
a=20;b=16;a+b+b
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c+c+c
201;a=6;a+a+a+a+a+a+a+a+a
2;a=01;b=6;a+b+b+b+b+b+b+b+b+b
a=20;16+a+a
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c+c+c
a=2;b=016;a+a+a+a+a+b+b+b
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c+c+c+c
a=20;16;a+a+a
2;a=01;b=6;a+b+b+b+b+b+b+b+b+b+b
a=2;b=016;a+a+a+a+a+a+a+b+b+b
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c+c+c+c
2&@01^6
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c+c+c+c+c
201;a=6;a+a+a+a+a+a+a+a+a+a+a
2;a=01;b=6;a+b+b+b+b+b+b+b+b+b+b+b
20 1+6!!
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c+c+c+c+c
a=2;b=016;a+a+a+b+b+b+b
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c+c+c+c+c+c
2#01#&@6
2;a=01;b=6;a+b+b+b+b+b+b+b+b+b+b+b+b
a=2;b=016;a+a+a+a+a+b+b+b+b
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c+c+c+c+c+c
a=20;16+a+a+a
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c+c+c+c+c+c+c
201;a=6;a+a+a+a+a+a+a+a+a+a+a+a+a
2;a=01;b=6;a+b+b+b+b+b+b+b+b+b+b+b+b+b
a=20;16;a+a+a+a
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c+c+c+c+c+c+c
a=2;b=016;a+b+b+b+b+b
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c+c+c+c+c+c+c+c
a=20;b=16;a+b+b+b+b
2;a=01;b=6;a+b+b+b+b+b+b+b+b+b+b+b+b+b+b
a=2;b=016;a+a+a+b+b+b+b+b
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c+c+c+c+c+c+c+c
a=20;b=16;a+a+b+b+b
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c+c+c+c+c+c+c+c+c
201;a=6;a+a+a+a+a+a+a+a+a+a+a+a+a+a+a
2;a=01;b=6;a+b+b+b+b+b+b+b+b+b+b+b+b+b+b+b
a=20;b=16;a+a+a+b+b
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c+c+c+c+c+c+c+c+c
a=2;b=016;a+a+a+a+a+a+a+b+b+b+b+b
a=2;b=01;c=6;a+a+b+c+c+c+c+c+c+c+c+c+c+c+c+c+c+c
2 01 6!!
2;a=01;b=6;a+b+b+b+b+b+b+b+b+b+b+b+b+b+b+b+b
a=2;b=016;a+b+b+b+b+b+b
a=2;b=01;c=6;a+b+c+c+c+c+c+c+c+c+c+c+c+c+c+c+c+c
a=20;16;a+a+a+a+a

Hrm, a menos que eu não entendi a pergunta, você não deveria ser capaz de guardar um monte de bytes através da atribuição cde 16quando o número é ainda e grande? Como para 96, etc. Não sabe ao certo como o solucionador de equações funciona, mas o uso a=20também deve ser útil para vários deles?
FryAmTheEggman

Sim, então eu não sei quanto tempo levaria para rodá-lo com 16 e 20 também, mas espero que isso apare um pouco para números maiores.
FryAmTheEggman

3

Dyalog APL (Esta é uma piada, não envie), 25.957 bytes.

2016⊢≢⍬
2016⊢(⊢+≢)≢⍬
2016⊢(⊢+≢)(⊢+≢)≢⍬
...

Sim, é uma entrada de brincadeira, precisamos de uma solução de APL, mesmo que seja completamente horrível. Funciona incrementando ≢⍬( 0) os ntempos. Não quero revelar segredos da minha apresentação real.

Obviamente, poderia ser jogado muito mais.


RI MUITO. Eu recebi duas votações.
Zacharý 16/02

Sério, por que as pessoas estão votando nisso?
Zachary

2

JavaScript, 5244 caracteres

Provavelmente poderia ser jogado muito mais longe. Teste no console do Chrome. Eu meio que desisti às 10.

201&6
!!2016
2%016
20+~16
20-16
-2+0+1+6
2*0*1+6
2*0+1+6
2*01+6
2+01+6
-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~-~-~20-16
20*1-6
!!2+016
2+016
!!20+16
2.0+16
2+!0+16
20+!16
20+!!16
-~20+!!16
-~-~20+!!16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
2*016
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
(2+0)*16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20-16
20+16
-~20+16
-~-~20+16
-~-~-~20+16
-~-~-~-~20+16
-~-~-~-~-~20+16
-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~20+16
20*-(1-6)

Se 101 expressões foi um pouco demais, você pode querer ter uma ir a este . Já existe uma resposta JavaScript, mas talvez você possa fazer melhor - ou de forma diferente ...
Adám

1

Java 7, 1.083 bytes

Para a contagem de bytes, contei apenas as expressões entre parênteses. Então eu excluídos os System.out.printlns e class. Incluindo esses, seriam 3.049 bytes .
PS: Não tenho certeza se a conversão para int 72é válida. Embora adicione 5 bytes de qualquer maneira ..

201&6
2-01%6
2%016
201%6
20-16
201%~6
2%01+6
2-01+6
2*01+6
2+01+6
~2+016
~2+016
2^016
20-1-6
2|016
20+1-6
2+016
2-~016
2+0+16
20-1%6
20|16
20+1%6
20*1|6
20|1|6
20+~1+6
20-1+6
20*1+6
20+1+6
2*016
20-~1-~6
-2*~016
20|~-16
(2+0)*16
20*~1^~6
-20*~1-6
20+~-16
20+16
20-~16
20-~-~16
-~2*~-016
20<<1%6
~-(-~2*016)
~2*-016
~20^-1<<6
~20*~1^6
~2*~016
20<<1|6
-20*~1-~6
~20*~1+6
~20*~1-~6
-20/~1*~-6
~2*~-~-~016
20|1<<~-6
-20*~-~1+~6
20*-~-~1-6
-20*~-~1-~-6
~-~2*-016
~20*~-~1-6
-20*~-~1^6
~(20/~1*6)
-20/~1*6
~2^(0-1)<<6
-2^(0-1)<<6
~20/~1*6
(2-01)<<6
(2+~0)|1<<6
2|01<<6
2-~0|1<<6
~-~2*~16
~20*~-~1+6
20/~1*~6
-~(20/~1*~6)
~-~(int)2.0*~-~16
-20<<-~1^~6
-20<<-~1^-6
~-~-~2*~016
~-20*(~1+6)
~-~20/~1*-~6
~-20<<-~1|6
~-(20*~(1-6))
20*(~1+6)
-~(20*~(1-6))
~-~-20|1<<6
~-20|1<<6
20|1<<6
-~20|1<<6
20<<-~1|6
20<<-~1|-~6
-~-~20*(~1+6)
~20*~-~-~1+~-6
~-~-20*-(1-6)
~20*~-~-~1-~6
~20*~-~-~1-~-~6
~2^~-~01<<~-6
-2^~-~01<<~-6
~-20*1*~-6
(2+01)<<~-6
-~(~2*~-~0*16)
~-~-(20*-(1-6))
~-(20*1*~-6)
20*-(1-6)

Ungolfed & código de teste:

Experimente aqui.

class M{
  public static void main(String[]a){
    System.out.println(201&6);
    System.out.println(2-01%6);
    System.out.println(2%016);
    System.out.println(201%6);
    System.out.println(20-16);
    System.out.println(201%~6);
    System.out.println(2%01+6);
    System.out.println(2-01+6);
    System.out.println(2*01+6);
    System.out.println(2+01+6);
    System.out.println(~2+016);
    System.out.println(~2+016);
    System.out.println(2^016);
    System.out.println(20-1-6);
    System.out.println(2|016);
    System.out.println(20+1-6);
    System.out.println(2+016);
    System.out.println(2-~016);
    System.out.println(2+0+16);
    System.out.println(20-1%6);
    System.out.println(20|16);
    System.out.println(20+1%6);
    System.out.println(20*1|6);
    System.out.println(20|1|6);
    System.out.println(20+~1+6);
    System.out.println(20-1+6);
    System.out.println(20*1+6);
    System.out.println(20+1+6);
    System.out.println(2*016);
    System.out.println(20-~1-~6);
    System.out.println(-2*~016);
    System.out.println(20|~-16);
    System.out.println((2+0)*16);
    System.out.println(20*~1^~6);
    System.out.println(-20*~1-6);
    System.out.println(20+~-16);
    System.out.println(20+16);
    System.out.println(20-~16);
    System.out.println(20-~-~16);
    System.out.println(-~2*~-016);
    System.out.println(20<<1%6);
    System.out.println(~-(-~2*016));
    System.out.println(~2*-016);
    System.out.println(~20^-1<<6);
    System.out.println(~20*~1^6);
    System.out.println(~2*~016);
    System.out.println(20<<1|6);
    System.out.println(-20*~1-~6);
    System.out.println(~20*~1+6);
    System.out.println(~20*~1-~6);
    System.out.println(-20/~1*~-6);
    System.out.println(~2*~-~-~016);
    System.out.println(20|1<<~-6);
    System.out.println(-20*~-~1+~6);
    System.out.println(20*-~-~1-6);
    System.out.println(-20*~-~1-~-6);
    System.out.println(~-~2*-016);
    System.out.println(~20*~-~1-6);
    System.out.println(-20*~-~1^6);
    System.out.println(~(20/~1*6));
    System.out.println(-20/~1*6);
    System.out.println(~2^(0-1)<<6);
    System.out.println(-2^(0-1)<<6);
    System.out.println(~20/~1*6);
    System.out.println((2-01)<<6);
    System.out.println((2+~0)|1<<6);
    System.out.println(2|01<<6);
    System.out.println(2-~0|1<<6);
    System.out.println(~-~2*~16);
    System.out.println(~20*~-~1+6);
    System.out.println(20/~1*~6);
    System.out.println(-~(20/~1*~6));
    System.out.println(~-~(int)2.0*~-~16);
    System.out.println(-20<<-~1^~6);
    System.out.println(-20<<-~1^-6);
    System.out.println(~-~-~2*~016);
    System.out.println(~-20*(~1+6));
    System.out.println(~-~20/~1*-~6);
    System.out.println(~-20<<-~1|6);
    System.out.println(~-(20*~(1-6)));
    System.out.println(20*(~1+6));
    System.out.println(-~(20*~(1-6)));
    System.out.println(~-~-20|1<<6);
    System.out.println(~-20|1<<6);
    System.out.println(20|1<<6);
    System.out.println(-~20|1<<6);
    System.out.println(20<<-~1|6);
    System.out.println(20<<-~1|-~6);
    System.out.println(-~-~20*(~1+6));
    System.out.println(~20*~-~-~1+~-6);
    System.out.println(~-~-20*-(1-6));
    System.out.println(~20*~-~-~1-~6);
    System.out.println(~20*~-~-~1-~-~6);
    System.out.println(~2^~-~01<<~-6);
    System.out.println(-2^~-~01<<~-6);
    System.out.println(~-20*1*~-6);
    System.out.println((2+01)<<~-6);
    System.out.println(-~(~2*~-~0*16));
    System.out.println(~-~-(20*-(1-6)));
    System.out.println(~-(20*1*~-6));
    System.out.println(20*-(1-6));
  }
}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.