Contexte

Ce puzzle est une variation du puzzle à quatre pattes (lui-même le sujet d'une question passée ). Comme ce puzzle, le but est de trouver des expressions mathématiques pour différents nombres entiers, en utilisant seulement quatre chiffres et certains opérateurs mathématiques. Dans ce cas, cependant, les chiffres autorisés ne sont que 2, 0, 1 et 5 . Chacun doit apparaître précisément une fois dans la solution et dans le bon ordre. Étonnamment, de nombreux nombres entiers peuvent être représentés de cette façon. Les solveurs sont encouragés à essayer de le résoudre d'abord à la main, car c'est étrangement agréable.

Règles

Les constantes peuvent être construites à partir d'un ou de plusieurs chiffres:

• Entiers: par exemple 2, 0, 15, etc.
• Décimales: par exemple .2, .01, 1.5, etc.
• Répétition décimales : par exemple 0,2 ~ (= 0,222 ...), .15 ~ (= 0,1555 ...), 20,15 ~~ (= 20,1515 ...)

Les opérations unaires suivantes sont autorisées:

• Négation unaire: -x
• Racine carrée: sqrt (x)
• Factoriel entier: x!

Les opérations binaires suivantes sont autorisées:

• Opérateurs arithmétiques standard: x + y, xy, x * y et x / y
• Exponentiation arbitraire: x ^ y
• Racines arbitraires: rt [x] (y) (= xième racine de y)

Tâche

Votre programme doit imprimer des expressions pour autant d'entiers compris entre 0 et 100 qu'il peut, puis afficher le nombre d'expressions qu'il a produites.

• Les solutions doivent être imprimées dans l'ordre au format n = [expr].
• Les expressions doivent utiliser tous les chiffres 2, 0, 1, 5, une fois chacun dans cet ordre.
• Les expressions doivent être imprimées en utilisant la notation décrite ci-dessus. Les parenthèses inutiles sont autorisées mais pas obligatoires, tout comme les espaces. L'ordre de priorité des opérateurs est la négation unaire, la factorielle, l'exponentiation, la multiplication / division et l'addition / soustraction.
• Le programme n'a pas besoin de renvoyer des solutions pour tous les nombres. Un programme qui sort simplement 0 est donc valide; cependant, voir la section de notation ci-dessous.
• Le programme devrait s'exécuter en moins de 15 minutes sur un ordinateur moderne.

Vous pouvez écrire un programme ou une fonction. Les expressions doivent être imprimées dans STDOUT (ou l'alternative la plus proche). Le nombre d'expressions peut être imprimé dans STDOUT ou renvoyé sous forme d'entier. Des restrictions de golf de code standard s'appliquent.

Exemple de sortie

0=2*0*1*5
10=20*1*.5
42=((2+0!)!+1)!/5!
100=20*1*5
4

Notation

Mise à jour : @orlp a noté une faille dans le système de notation. Voir http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge pour une discussion sur comment ou si cela devrait être corrigé.

Les solutions sont notées d' abord par le nombre d'expressions qu'elles produisent, puis par leur longueur de code en octets. Par conséquent, un programme de 1000 octets qui produit 80 résultats battra un programme de 100 octets qui n'en produit que 79 (bien que ce dernier puisse facilement être étendu pour inclure les résultats manquants).

Pour ceux qui souhaitent une cible motivante, voici une limite inférieure du nombre d'expressions qui peuvent être représentées. Je ne prévois pas de soumettre de candidature, il est donc possible de gagner avec moins!

Au moins 85 (sur 101), mais il pourrait bien être plus élevé.

Tableau d'affichage

Comme incitation supplémentaire, voici un résumé de la progression du score. Chaque fois que vous battez le score le plus élevé, n'hésitez pas à vous ajouter en haut du tableau (ou à demander à quelqu'un d'autre).

• 0 expressions, 1 octet (Pyth): implémentation qui ne génère que 0

85, ~ 2400 octets

Je suis un peu triste, c'est un défi de golf de code, car je pense que tous mes efforts précédents ont été plutôt inutiles maintenant que je posterai ceci:

  0 = ((2*0)^15)
  1 = ((2^0)^15)
  2 = (2-(0^15))
  3 = (20*.15)
  4 = (20*(1/5))
  5 = (20-15)
  6 = ((.20+1)*5)
  7 = ((20*.1)+5)
  8 = (2*((0-1)+5))
  9 = ((.20/.1~)*5)
 10 = (20/(1/.5))
 11 = ((((2-0)+1))!+5)
 12 = (20*(.1+.5))
 13 = ((-(2)-0)+15)
 14 = (20-(1+5))
 15 = ((2*0)+15)
 16 = ((2^0)+15)
 17 = ((2-0)+15)
 18 = (20-(1/.5))
 19 = (20-(1^5))
 20 = (20^(1^5))
 21 = (20+(1^5))
 22 = (20+(1/.5))
 23 = (((2-0)/.1~)+5)
 24 = ((20-1)+5)
 25 = ((20^1)+5)
 26 = ((20+1)+5)
 27 = (rt[.2](((0)!+1))-5)
 28 = (2*(-((0)!)+15))
 29 = ((((2+(0)!)+1))!+5)
 30 = ((2-0)*15)
 31 = (20+sqrt((1+(5)!)))
 32 = ((20*.1)^5)
 33 = ((.2^-((0)!))/.15~~)
 34 = (2+(((0)!+1)^5))
 35 = (20+15)
 36 = (20*(1/.5~))
 37 = (rt[.2](((0)!+1))+5)
 38 = ((20-1)/.5)
 39 = (-((2^0))+(sqrt(.1~)*(5)!))
 40 = (20*(1/.5))
 41 = (((.2~^-((0)!))/.1~)+.5)
 42 = ((20+1)/.5)
 43 = (-(2)+(((0)!/.1~)*5))
 44 = (20+((-(1)+5))!)
 45 = (20/(1-.5~))
 46 = ((.2+((0)!/.1~))*5)
 47 = (2+(((0)!/.1~)*5))
 48 = (2*(((0-1)+5))!)
 49 = ((((2+(0)!))!/.1~)-5)
 50 = (((2^0)/.1)*5)
 51 = ((.2+((0)!/.1))*5)
 52 = (2+(((0)!/.1)*5))
 54 = (((2+(0)!)/.1)/.5~)
 55 = ((2+((0)!/.1~))*5)
 56 = (((.2-(0)!)+sqrt(.1~))*-((5)!))
 58 = (-(2)+sqrt((((((0)!/sqrt(.1~)))!)!*5)))
 59 = ((((2+(0)!))!/.1~)+5)
 60 = (20/(.1~^.5))
 62 = (2*(-((0)!)+sqrt(rt[-(.1)](.5))))
 64 = ((2-0)^(1+5))
 65 = ((20/sqrt(.1~))+5)
 66 = ((-(((2+(0)!))!)/.1~)+(5)!)
 67 = (((((2+(0)!))!)!*.1)-5)
 69 = ((2^(((0)!/sqrt(.1~)))!)+5)
 70 = (((.2^-((0)!))/-(.1))+(5)!)
 72 = ((2+(0)!)*((-(1)+5))!)
 75 = ((.2^-((0)!))*15)
 76 = (rt[(-(2)^-((0)!))](.1~)-5)
 77 = (((((2+(0)!))!)!*.1)+5)
 78 = (2*(-((0)!)+(sqrt(.1~)*(5)!)))
 80 = (-(20)*(1-5))
 81 = (201-(5)!)
 82 = (2*((0)!+(sqrt(.1~)*(5)!)))
 84 = (((.2-(0)!)+.1)*-((5)!))
 85 = (((((2+(0)!))!)!*.1~)+5)
 86 = (rt[(-(2)^-((0)!))](.1~)+5)
 88 = (rt[.2]((-((0)!)-1))+(5)!)
 90 = ((20/.1~)*.5)
 93 = (((2+(0)!)/-(.1~))+(5)!)
 95 = ((20-1)*5)
 96 = ((.20-1)*-((5)!))
 98 = (-(20)*(.1-5))
 99 = ((-(20)-1)+(5)!)
100 = (20/(1/5))
85

À partir de là, ce n'est plus qu'un défi de compression. Peut-être que je participerai plus tard, peut-être pas. Pour moi, la plupart du plaisir était dans le défi de trouver le plus de formules.

Un conseil pour ceux qui ont du mal à écrire un solveur - l'exécution ne devrait pas être un problème. Si vous avez trop de formules à vérifier, vous avez besoin de meilleures heuristiques pour éliminer les solutions et les doublons désespérés. Le code que j'ai écrit pour générer les exécutions ci-dessus s'exécute en ~ 5 secondes sur Python.