sfondo

Questo puzzle è una variante del puzzle a quattro zampe (esso stesso l'argomento di una domanda passata ). Come quel puzzle, l'obiettivo è quello di trovare espressioni matematiche per diversi numeri interi, usando solo quattro cifre e alcuni operatori matematici. In questo caso, tuttavia, le cifre consentite sono solo 2, 0, 1 e 5 . Ognuno deve apparire esattamente una volta nella soluzione e nell'ordine corretto. Sorprendentemente molti numeri interi possono essere rappresentati in questo modo. I risolutori sono incoraggiati a provare a risolverlo prima a mano, poiché è stranamente divertente.

Regole

Le costanti possono essere costruite da cifre singole o multiple:

• Numeri interi: ad es. 2, 0, 15, ecc.
• Decimali: ad es. 2, .01, 1.5, ecc.
• Ripetizione di decimali : ad es. 0,2 ~ (= 0,222 ...), 0,15 ~ (= 0,1555 ...), 20,15 ~~ (= 20,1515 ...)

Sono consentite le seguenti operazioni unarie:

• Negazione unaria: -x
• Radice quadrata: sqrt (x)
• Fattoriale intero: x!

Sono consentite le seguenti operazioni binarie:

• Operatori aritmetici standard: x + y, xy, x * ye x / y
• Esponenziazione arbitraria: x ^ y
• Radici arbitrarie: rt [x] (y) (= x'th root of y)

Compito

Il programma dovrebbe stampare espressioni per il maggior numero possibile di numeri interi compresi tra 0 e 100, quindi produrre il numero di espressioni che ha prodotto.

• Le soluzioni devono essere stampate nell'ordine nel formato n = [expr].
• Le espressioni devono usare tutte le cifre 2, 0, 1, 5, una volta ciascuna in quell'ordine.
• Le espressioni devono essere stampate usando la notazione sopra descritta. Le parentesi non necessarie sono consentite ma non richieste, così come gli spazi bianchi. L'ordine di precedenza degli operatori è negazione unaria, fattoriale, esponenziale, moltiplicazione / divisione e addizione / sottrazione.
• Non è necessario che il programma restituisca soluzioni per tutti i numeri. Un programma che semplicemente genera 0 è quindi valido; tuttavia, vedere la sezione dei punteggi di seguito.
• Il programma dovrebbe funzionare in meno di 15 minuti su un computer moderno.

È possibile scrivere un programma o una funzione. Le espressioni devono essere stampate su STDOUT (o alternativa più vicina). Il numero di espressioni può essere stampato su STDOUT o restituito come numero intero. Si applicano le restrizioni standard per il golf.

Esempio di output

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

punteggio

Aggiornamento : @orlp ha riscontrato un difetto nel sistema di punteggio. Vedi http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge per una discussione su come o se questo dovrebbe essere risolto.

Le soluzioni vengono valutate prima in base al numero di espressioni che producono e quindi in base alla lunghezza del loro codice in byte. Quindi, un programma da 1000 byte che produce 80 risultati batterà un programma da 100 byte che produce solo 79 (sebbene quest'ultimo possa essere facilmente esteso per includere i risultati mancanti).

Per coloro che desiderano un obiettivo motivante, di seguito è riportato un limite inferiore al numero di espressioni che possono essere rappresentate. Non ho intenzione di presentare una domanda, quindi potrebbe essere possibile vincere con meno!

Almeno 85 (su 101), anche se potrebbe essere più alto.

tabellone segnapunti

Come ulteriore incentivo, ecco un riepilogo della progressione del punteggio. Ogni volta che ottieni il punteggio più alto, sentiti libero di aggiungerti in cima al tavolo (o chiedi a qualcun altro di farlo).

• 0 espressioni, 1 byte (Pyth): implementazione che genera solo 0

85, ~ 2400 byte

Sono un po 'triste che questa sia una sfida al codice golf, poiché ritengo che tutti i miei precedenti sforzi siano stati piuttosto inutili ora che pubblicherò questo:

  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

Da qui in poi è solo una sfida di compressione. Forse gareggerò più tardi, forse no. Per me la maggior parte del divertimento è stata la sfida di trovare il maggior numero di formule.

Un suggerimento per coloro che lottano per scrivere un risolutore: il runtime non dovrebbe essere un problema. Se hai troppe formule da controllare, hai bisogno di una migliore euristica per eliminare soluzioni e duplicati senza speranza. Il codice che ho scritto per generare le esecuzioni precedenti in ~ 5 secondi su Python.