Hintergrund

Dieses Puzzle ist eine Variation des Vierer-Puzzles (selbst das Thema einer früheren Frage ). Ziel ist es, mathematische Ausdrücke für verschiedene ganze Zahlen zu finden, wobei nur vier Ziffern und bestimmte mathematische Operatoren verwendet werden. In diesem Fall sind die zulässigen Ziffern jedoch nur 2, 0, 1 und 5 . Jeder muss genau einmal in der Lösung und in der richtigen Reihenfolge erscheinen. Überraschenderweise können so viele ganze Zahlen dargestellt werden. Löser werden ermutigt, es zuerst mit der Hand zu lösen, da es seltsamerweise Spaß macht.

Regeln

Konstanten können ein- oder mehrstellig aufgebaut sein:

• Ganzzahlen: zB 2, 0, 15 usw.
• Dezimalstellen: zB .2, .01, 1.5 usw.
• Wiederholte Dezimalstellen : zB .2 ~ (= 0.222 ...), .15 ~ (= 0.1555 ...), 20.15 ~~ (= 20.1515 ...)

Folgende unäre Operationen sind erlaubt:

• Unäre Verneinung: -x
• Quadratwurzel: sqrt (x)
• Ganzzahlige Fakultät: x!

Die folgenden binären Operationen sind zulässig:

• Standardrechenoperatoren: x + y, xy, x * y und x / y
• Willkürliche Potenzierung: x ^ y
• Beliebige Wurzeln: rt [x] (y) (= x'te Wurzel von y)

Aufgabe

Ihr Programm sollte Ausdrücke für so viele der Ganzzahlen zwischen 0 und 100 wie möglich ausgeben und dann die Anzahl der von ihm erzeugten Ausdrücke ausgeben.

• Die Lösungen müssen der Reihe nach im Format n = [Ausdruck] gedruckt werden.
• Die Ausdrücke müssen alle Ziffern 2, 0, 1, 5 einmal in dieser Reihenfolge verwenden.
• Die Ausdrücke müssen unter Verwendung der oben beschriebenen Notation gedruckt werden. Unnötige Klammern sind zulässig, aber ebenso wie Leerzeichen nicht erforderlich. Die Rangfolge der Operatoren ist unäre Negation, Fakultät, Potenzierung, Multiplikation / Division und Addition / Subtraktion.
• Das Programm muss nicht für alle Zahlen Lösungen zurückgeben. Ein Programm, das einfach 0 ausgibt, ist daher gültig; Weitere Informationen finden Sie im Abschnitt "Wertung".
• Das Programm sollte auf einem modernen Computer in weniger als 15 Minuten ausgeführt werden.

Sie können ein Programm oder eine Funktion schreiben. Die Ausdrücke sollten nach STDOUT (oder der nächstgelegenen Alternative) gedruckt werden. Die Anzahl der Ausdrücke kann an STDOUT ausgegeben oder als Ganzzahl zurückgegeben werden. Es gelten die Standardcode-Golfbeschränkungen.

Beispielausgabe

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

Wertung

Update : @orlp hat einen Fehler im Punktesystem festgestellt. Unter http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge erfahren Sie, wie oder ob dies behoben werden sollte.

Lösungen werden zuerst nach der Anzahl der von ihnen erzeugten Ausdrücke und dann nach ihrer Codelänge in Bytes bewertet. Daher schlägt ein 1000-Byte-Programm, das 80 Ergebnisse liefert, ein 100-Byte-Programm, das nur 79 Ergebnisse liefert (obwohl das letztere leicht erweitert werden könnte, um die fehlenden Ergebnisse einzuschließen).

Für diejenigen, die ein motivierendes Ziel haben möchten, ist unten eine Untergrenze für die Anzahl der Ausdrücke angegeben, die dargestellt werden können. Ich habe nicht vor, einen Beitrag einzureichen, daher kann es durchaus möglich sein, mit weniger zu gewinnen!

Mindestens 85 (von 101), obwohl es durchaus höher sein kann.

Anzeigetafel

Als zusätzlichen Anreiz finden Sie hier eine Zusammenfassung des Ergebnisverlaufs. Wenn Sie die höchste Punktzahl erreichen, können Sie sich selbst ganz oben auf den Tisch setzen (oder jemanden bitten, dies zu tun).

• 0 Ausdrücke, 1 Byte (Pyth): Implementierung, die nur 0 ausgibt

85, ~ 2400 Bytes

Ich bin ein bisschen traurig, dass dies eine Code-Golf-Herausforderung ist, da ich das Gefühl habe, dass alle meine bisherigen Bemühungen ziemlich nutzlos waren, jetzt wo ich dies posten werde:

  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

Ab hier ist es nur noch eine Herausforderung für die Komprimierung. Vielleicht werde ich später antreten, vielleicht werde ich nicht. Für mich lag der größte Spaß in der Herausforderung, die meisten Formeln zu finden.

Ein Hinweis für diejenigen, die Schwierigkeiten haben, einen Löser zu schreiben - Laufzeit sollte kein Problem sein. Wenn Sie zu viele Formeln zur Überprüfung haben, benötigen Sie bessere Heuristiken, um hoffnungslose Lösungen und Duplikate zu beseitigen. Der Code, den ich geschrieben habe, um das obige zu generieren, läuft in ~ 5 Sekunden auf Python.