Jeu officiel de l'année Dyalog APL 2016

26

Si vous pensez que cela pourrait être amusant, mais trop de travail, pensez à participer à ce défi beaucoup plus petit.


Un peu de plaisir (et peut-être de frustration!) Pour 2016 ... "Le puzzle de l'année" de Dyalog . Prendre plaisir!

L'objectif

Rechercher des expressions Dyalog APL ( téléchargement ) (d'autres langues sont autorisées, voir Éligibilité ci-dessous) impliquant exactement les chiffres 2 0 1 6 dans cet ordre pour égaler les nombres 0 à 100. Par exemple:

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

L'objectif est d'utiliser le moins de caractères possible dans chaque expression (le nombre minimum de caractères pour une expression est de 5 - les quatre chiffres 2 0 1 6 et une seule fonction / opérateur primitif).

Les règles

  • Chaque expression doit contenir les chiffres 2 0 1 6 (dans cet ordre) et aucun autre chiffre. Les constantes et variables prédéfinies ne sont pas non plus autorisées.
  • En plus des quatre chiffres 2 0 1 6, seuls les symboles et noms intégrés, les parenthèses / accolades, les espaces, les signes moins élevés et les décimales peuvent être utilisés. Les expressions résultantes doivent être déterministes (c'est-à-dire donner le même résultat sur des évaluations répétées). Pour les non-APL, les fonctions / opérateurs avec un nom sont également autorisés; mêmes règles qu'ici .
  • Supposez tous les paramètres par défaut pour votre langue. Pour Dyalog APL, cela signifie ⎕MLet ⎕IOsont tous les deux 1 et ⎕PP10.
  • Chaque entrée comprenant des expressions correctes pour tous les nombres de 0 à 100 inclus sera évaluée selon le nombre de caractères utilisés par ces expressions à l'exclusion des espaces redondants (minimum 505 pour les 101 expressions).

Admissibilité

Tout le monde peut entrer. Vous pouvez répondre dans n'importe quelle langue, mais seules les réponses APL seront prises en compte pour l'acceptation. Si vous utilisez une autre langue que APL, vous pouvez utiliser des extraits, des programmes, des fonctions, etc. comme alternatives aux expressions, et vous pouvez imprimer, laisser le numéro dans un emplacement de mémoire accessible, ou renvoyer le résultat, tant que votre code est directement évalue le nombre souhaité comme n'importe quel type de données numériques standard pour votre langue.

Date de clôture

30 novembre 2016.

Prix

  • Faites accepter votre réponse
  • Soyez immortalisé dans le Hall of Fame de Dyalog 2016!

Soumettre votre inscription

Après le 30 novembre 2016, j'accepterai la réponse la plus courte et soumettrai votre réponse, en votre nom, au Temple de la renommée 2016 de Dyalog.

FAQ

  • Est J(par exemple , 37 = ⌈⍟!20J16) permis?
  • Non: en plus des quatre chiffres 2 0 1 6, seuls les symboles et noms intégrés, les parenthèses / accolades, les espaces, les signes moins élevés et les décimales peuvent être utilisés.

  • La sortie sous forme de chaîne est-elle acceptable?
  • Non: égal les nombres 0 à 100.

  • Chiffres physiques ou chiffres de données?
  • Chiffres de données, selon OP: mêmes règles qu'ici , où l'un des exemples contient LOG10(.

  • Est-il a+16+a←20permis d' affecter des variables puis de les utiliser dans le cadre de l'expression (par exemple 56 = )?
  • Oui, mais vous ne pouvez pas utiliser une affectation d'une expression dans une autre.

J'ai la permission écrite explicite de publier ce défi ici de l'auteur original de ce défi. N'hésitez pas à vérifier en suivant le lien fourni et en contactant l'auteur. J'ai donné à l'auteur du concours d'origine le lien vers cette page dans la minute où je l'ai publiée, afin qu'il puisse vérifier si je soumets la réponse de quelqu'un comme étant la mienne.

Adam
la source
Tant de réponses et aucune solution APL?
Akangka
1
@ChristianIrwan Oui, c'est normal: quiconque le fait dans APL peut préférer se soumettre à la vraie compétition au lieu de révéler ses secrets ici.
Adám
@ Adám, cela pourrait être en retard, mais l'utilisation ⎕MLet ⎕IO(supposée être 1) serait-elle acceptable?
Zacharý
@ZacharyT Vous voulez dire mettre des noms de quad dans l'expression? Cela ressemble à beaucoup de personnages supplémentaires pour une petite victoire. Peux-tu me donner un exemple?
Adám

Réponses:

7

Gelée, 686 octets

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

J'ai écrit environ 50 d'entre eux, puis généré automatiquement le reste en ajoutant (× 2) et ‘’(± 1) selon les besoins. Je les améliorerai plus tard!

Lynn
la source
46 peut devenir 201ÆCo6. Je ne pense pas que vous puissiez utiliser (qui a été mis en œuvre en février), mais 20|16Ḥ‘Ḥet 20|16‘ḤḤ’sont également courts.
Dennis
@Dennis Oops, mon script Python a en fait préféré à tort plus de ‘’- 46, parmi quatre autres nombres, aurait dû être un caractère plus court. Je l'ai remplacé par 2016½Ċ‘ce qui est aussi long que le vôtre.
Lynn
9

Hexagonie , 888 octets

D'accord, d'abord quelques règles de base pour l'Hexagonie, au cas où quelqu'un voudrait battre ceci:

  • J'interprète "l'extrait" comme un morceau de code linéaire qui peut être vidé dans n'importe quel programme suffisamment grand, à condition que les bords de mémoire actuels et adjacents soient nuls.
  • L'extrait doit être entré par la gauche et sorti par la droite. Je serais en mesure d'économiser un tas d'octets sans cela (par exemple 2|016pour 22), mais cela semble le plus dans l'esprit du défi.
  • L'extrait "produit" un nombre donné, si un bord de mémoire (pas nécessairement celui en cours) contient cette valeur après l'exécution.
  • La règle interdisant tout autre nombre dans l'extrait de code affecte à la fois les autres chiffres et les lettres, car ils agissent effectivement comme des littéraux entiers dans Hexagony. (Cela permettrait d'économiser une tonne d'octets.)

Voici donc la liste. J'ai testé la plupart d'entre eux mais pas tous (certains sont des modifications triviales d'autres), donc j'espère que je n'ai fait aucune erreur:

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

Je suis devenu un peu paresseux vers la fin, donc je suis sûr que ce n'est pas optimal. Cela pourrait être intéressant (et possible) de les forcer brutalement.

Martin Ender
la source
Très agréable. N'oubliez pas que vous avez 10 mois (ou pour toujours, vraiment) pour améliorer cela. Je suppose que Hexagony a assez peu de commandes pour que le forçage brutal soit raisonnable. Il m'a fallu une semaine d'utilisation 100% monocœur pour utiliser les caractères APL insérés par force brute 4.
Adám
Alors tu l'as fait? Avez-vous obtenu une solution optimale?
jimmy23013
@NBZ Étant donné que l'incrémentation et la décrémentation du résultat sont toujours possibles, pour un seul octet, il peut être plus facile pour Hexagony de vérifier les programmes pour tout nombres (au lieu d'un nombre à la fois), et si je trouve quelque chose de plus court que le meilleur actuellement pour cela nombre et peut raccourcir cela et potentiellement quelques chiffres autour d'elle aussi. Et oui, une fois que vous supprimez les chiffres et les lettres (et certains autres caractères inutiles ici), cela devrait être assez brutal.
Martin Ender
@ jimmy23013 Presque terminé. Il manque la solution optimale pour deux des 101 numéros.
Adám
@NBZ Il suffit de forcer les solutions à 4 caractères pour prouver qu'il n'y en a pas. Je pense qu'il est probable que vous puissiez écrire une solution à 5 caractères à la main et ce serait optimal.
jimmy23013
8

J, 1041 ... 838 octets

981 961 952 860 859

Je suis devenu un peu paresseux à la fin, mais ça devrait être plus fixe que moins. Je ne pense pas que je dépasserai jamais Hexagony, mais on ne sait jamais! battre l'hexagonie! 9 octets enregistrés grâce à Zgarb! et bien plus encore à 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

Faits saillants et notes

J'ai beaucoup utilisé des nombres premiers dans ce domaine. En fait, j'ai utilisé la fonction p:(le Nième nombre) 37 fois dans cette chose.

 *:-:20[16

90 a été fabriqué à l'aide d'une fourchette. Yay! C'est approximatif:

(*+&1)2+01+6

Traduit comme

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 utilise un ravel de mise en forme!

*/2,01]$~-:6

Est équivalent à

*/ 2 , $~ -:6
*/ 2 , -:6 $ -:6
*/ 2 , 3 $ 3
*/ 2 , 3 , 3 , 3
   2 * 3 * 3 * 3
   54
Conor O'Brien
la source
Eh bien, vous avez 3/4 ans pour apporter des améliorations.
Adám
24: !20-1654: <.^20-1655: >.^20-1697:p:!20-16
Lynn
Belle astuce avec les quatre factoriels!
Conor O'Brien
Ce 94 semble étrangement long ... que diriez-vous +:p:-2-016(4 octets plus court)?
Lynn
Je pense que 7 peuvent être 2]01+6, 8 peuvent être 2%~016et 12 peuvent être 2*01]6.
Zgarb
7

JavaScript, 1021 octets

Correction et enregistrement de deux octets grâce à Charlie Wynn et 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)
ASCII uniquement
la source
20 ^ 1 + 6 enregistre un pour 19 (est-ce correct si vous mettez le numéro à côté de chaque entrée?)
Charlie Wynn
20 << 1 | 6 enregistre un pour 46 (devrais-je simplement modifier votre réponse?)
Charlie Wynn
@CharlieWynn No. Utilisez des suggestions de commentaires. Il y a un meta post dessus.
mbomb007
Test sur Firefox 44, votre 1 est en fait 2 et votre 10 est 11. Vous pouvez utiliser votre 10 actuel comme 11 (c'est trois octets plus court), 2-~01+6comme 10 et -~!2016comme 1.
ETHproductions
wow quelqu'un a réussi à battre ma solution à 5244 caractères
clamchowder314
7

JavaScript (ES7), 836 octets

Tout devrait fonctionner dans n'importe quel navigateur, sauf 81, 88 et 97, qui utilisent le nouvel **opérateur.

Presque tout ici a été fait à la main. J'ai travaillé sur un brute-forcer pour améliorer tout ce qui peut être amélioré. Actuellement, il a économisé 103 octets sur divers éléments.

  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

Brute-forcer

Ce n'est pas le plus joli code, mais cela ne semble pas avoir d'importance autour de ces parties.

AVERTISSEMENT: ne vous exécutez que si vous êtes prêt à geler votre navigateur / moteur pendant quelques minutes. Personne n'aime calculer 7 boucles imbriquées.

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"))
ETHproductions
la source
3
Ouais, la beauté n'a pas d'importance ici. Nous ne sommes pas CR. : P
Rɪᴋᴇʀ
wow quelqu'un a réussi à battre ma solution à 5244 caractères
clamchowder314
4

PowerShell v3 +, 1575 1499 octets

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

100% joué au golf manuellement - aucun programme de force brute ou autre aide enrôlé.
Je pense que 1500 est peut - être à portée de main
Sub-1500 atteint! Voyons voir comment je peux faire pour réduire cela. (NB - Cela n'a été testé qu'en v4, mais devrait fonctionner en v3 et v5 sans modification. Ne fonctionnera pas en v2 ou v1 car ces versions n'avaient pas d'opérateurs de décalage au niveau du bit.)

Les points clés sont signalés par ##.hashes.##dans le code ci-dessus.

# 11 est la première affectation à la variable $a. Contrairement à d'autres langages, les variables n'ont pas besoin d'être pré-initialisées pour l'analyse, et ce n'est que pendant l'exécution que les variables sont résolues. Puisque le ($a=01)est entouré de parens, il est évalué en premier et donc le second -$aest équivalent à -1. Ceci est utilisé assez largement à partir de maintenant, et c'est l'une des plus grandes choses en réduisant le nombre de bytes.

# 17 montre la première utilisation de !Boolean non. Dans PowerShell, les types sont castés de manière assez lâche, donc si le cast peut être implicite, cela fonctionnera. Ici, nous utilisons le fait que !!20equals !$false, qui est $true, qui peut être implicitement converti en [int]1, ce qui se traduit par 17. Ceci est utilisé plusieurs fois pour en obtenir un autre 1ou pour en faire passer une partie 0.

# 22 Présente l' 0xopérateur de conversion hexadécimal, se transformant ici 0x16en 22. Cependant, comme 0x16c'est le seul nombre que nous pouvons obtenir, son utilité est limitée.

# 23 a l' -boropérateur, pour "binaire ou." Cependant, étant donné que les deux -boret -bxoront une priorité plus faible que les simples opérateurs arithmétiques, leur utilisation nécessite généralement des parenthèses, ce qui limite considérablement l'utilité. C'est le seul que j'ai trouvé où il est plus court d'utiliser le binaire ou l'opérateur (j'ai éliminé l' -bxoropérateur de 22).

# 30 est la première fois que l' -bnotopérateur est présenté. Il s'agit de l'opérateur "non binaire", et fonctionne de manière similaire à ~(par exemple) JavaScript. Cependant, il a généralement besoin de parens, car la négation s'affichera --bnotet entraînera une erreur d'analyse / syntaxe, et comme il s'agit de cinq caractères par rapport à un pour ~, il est utilisé avec parcimonie.

# 39 est la première utilisation de nos opérateurs de décalage binaire, -shlet -shr. Ceux-ci sont similaires à <<ou >>dans d'autres langues, mais sont explicitement dyadiques, ce qui signifie que nous avons besoin d'un nombre des deux côtés pour qu'ils fonctionnent, ce qui limite leur utilité dans ce défi. De plus, leur priorité n'est pas explicitement indiquée dans la documentation, mais les tests montrent qu'ils sont inférieurs à la simple arithmétique, ce qui signifie que les parens doivent être utilisés généreusement, de sorte qu'ils ne font pas autant d'apparence que dans les autres réponses linguistiques.

AdmBorkBork
la source
Très bonne réponse. Merci d'avoir bien expliqué vos techniques.
Adám
4

CJam, 792 791 octets

Je suis devenu paresseux à la fin, beaucoup d'entre eux ont fini par être des incréments et des décrémentations (101, c'est beaucoup!), Bien que je ne sois pas sûr qu'il existe un autre moyen pour quelques-uns des nombres. Il reste encore beaucoup de temps pour jouer au golf si j'en ai besoin.

Autour du # 40 il y a des visages clinquants;)

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
Chat d'affaires
la source
Je voulais voter pour les visages clin d'oeil, mais j'ai remarqué que vous aviez exactement 1000 représentants, donc je ne veux pas le gâcher. ;) Votera plus tard. : P
Kevin Cruijssen
et maintenant son 1089: P (un autre nombre magique pour les mathématiques: P)
masterX244
3

Mathematica, 2912 2502 2282 2180 octets

Pourrait certainement être joué plus loin. Résout principalement quelques équations de Frobenius distinctes, ce qui donne des solutions de longueur O ( n ). Le reste a été généré par mon 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
LegionMammal978
la source
Hrm, à moins que j'aie mal compris la question, ne devriez-vous pas être en mesure d'économiser beaucoup d'octets en attribuant cà 16quand le nombre est pair et grand? Comme pour 96, etc. Vous ne savez pas comment fonctionne votre solveur d'équations, mais l'utilisation a=20devrait également être utile pour plusieurs d'entre eux?
FryAmTheEggman
Ouais, alors je ne sais pas combien de temps il faudrait pour le faire fonctionner avec 16 et 20 aussi, mais je m'attends à ce que ça coupe un peu pour les plus gros nombres.
FryAmTheEggman
3

Dyalog APL (Ceci est une blague, veuillez ne pas soumettre), 25 957 octets.

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

Oui, c'est une entrée de blague, nous avons besoin d'une solution APL, même si elle est complètement horrible. Fonctionne en incrémentant ≢⍬( 0)n fois. Je ne veux dévoiler aucun secret de ma soumission.

De toute évidence, pourrait être joué beaucoup plus.

Zacharý
la source
LOL. J'ai eu deux votes positifs.
Zacharý
Sérieusement, pourquoi les gens votent-ils pour cela?
Zacharý
2

JavaScript, 5244 caractères

Pourrait probablement être joué beaucoup plus loin. Testez dans la console Chrome. J'ai un peu abandonné à 10 ans.

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)
clamchowder314
la source
Si 101 expressions était un peu plus, vous pouvez avoir un aller à ce . Il y a déjà une réponse JavaScript, mais peut-être pouvez-vous faire mieux - ou différemment ...
Adám
1

Java 7, 1 083 octets

Pour le nombre d'octets, je n'ai compté que les expressions elles-mêmes entre les parenthèses. J'ai donc exclu les System.out.printlns et class. Y compris ceux-ci, ce serait 3 049 octets .
PS: Je ne suis pas tout à fait sûr si l'int-cast pour 72est valide. Bien qu'il ajoute quand même 5 octets ..

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)

Code non testé et testé:

Essayez-le ici.

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));
  }
}
Kevin Cruijssen
la source