tło

Ta łamigłówka jest odmianą układanki z czterema czwórkami (sama w sobie jest tematem poprzedniego pytania ). Podobnie jak ta łamigłówka, celem jest znalezienie wyrażeń matematycznych dla różnych liczb całkowitych, przy użyciu tylko czterech cyfr i niektórych operatorów matematycznych. Jednak w tym przypadku dozwolonymi cyframi są tylko 2, 0, 1 i 5 . Każdy musi pojawić się dokładnie raz w roztworze i we właściwej kolejności. W ten sposób można zaskoczyć wiele liczb całkowitych. Solvery są zachęcane, aby najpierw spróbować rozwiązać to ręcznie, ponieważ jest to dziwnie przyjemne.

Zasady

Stałe mogą być zbudowane z jednej lub wielu cyfr:

• Liczby całkowite: np. 2, 0, 15 itd.
• Ułamki dziesiętne: np. 2, 0,01, 1,5 itd.
• Powtarzanie ułamków dziesiętnych : np. 2 ~ (= 0,222 ...), 0,15 ~ (= 0,1555 ...), 20,15 ~~ (= 20,1515 ...)

Dozwolone są następujące operacje jednostkowe:

• Unary negation: -x
• Pierwiastek kwadratowy: sqrt (x)
• Silnia całkowita silnia: x!

Dozwolone są następujące operacje binarne:

• Standardowe operatory arytmetyczne: x + y, xy, x * y i x / y
• Dowolne potęgowanie: x ^ y
• Dowolne pierwiastki: rt [x] (y) (= x-ty pierwiastek y)

Zadanie

Twój program powinien wydrukować wyrażenia dla jak największej liczby liczb całkowitych od 0 do 100, a następnie wypisać liczbę wyprodukowanych wyrażeń.

• Rozwiązania należy wydrukować w kolejności w formacie n = [expr].
• Wyrażenia muszą używać wszystkich cyfr 2, 0, 1, 5, po jednym w tej kolejności.
• Wyrażenia muszą być wydrukowane przy użyciu zapisu opisanego powyżej. Niepotrzebne nawiasy są dozwolone, ale nie są wymagane, podobnie jak białe znaki. Kolejność pierwszeństwa operatorów to jednoargumentacja, silnia, potęgowanie, mnożenie / dzielenie i dodawanie / odejmowanie.
• Program nie musi zwracać rozwiązań dla wszystkich liczb. Dlatego program, który po prostu wyprowadza 0, jest poprawny; patrz jednak sekcja punktacji poniżej.
• Program powinien działać w niecałe 15 minut na nowoczesnym komputerze.

Możesz napisać program lub funkcję. Wyrażenia powinny być wydrukowane do STDOUT (lub najbliższej alternatywy). Liczbę wyrażeń można wydrukować do STDOUT lub zwrócić jako liczbę całkowitą. Obowiązują standardowe ograniczenia gry w golfa.

Przykładowe dane wyjściowe

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

Punktacja

Aktualizacja : @orlp zauważył wadę w systemie punktacji. Zobacz http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge w celu omówienia, w jaki sposób lub czy należy to naprawić.

Rozwiązania są oceniane najpierw według liczby wyrażeń, które produkują, a następnie według długości kodu w bajtach. Dlatego program 1000-bajtowy, który daje 80 wyników, pokona program 100-bajtowy, który daje tylko 79 (choć ten ostatni można łatwo rozszerzyć o brakujące wyniki).

Dla tych, którzy chcieliby motywować cel, poniżej znajduje się dolna granica liczby wyrażeń, które mogą być reprezentowane. Nie planuję przesłać zgłoszenia, więc może być możliwe, aby wygrać mniej!

Co najmniej 85 (na 101), choć może być również wyższy.

Tablica wyników

Jako dodatkową zachętę, oto podsumowanie progresji wyniku. Za każdym razem, gdy osiągniesz najwyższy wynik, możesz dodać siebie na szczyt tabeli (lub poprosić kogoś innego).

• 0 wyrażeń, 1 bajt (Pyth): implementacja, która po prostu zwraca 0

85, ~ 2400 bajtów

Trochę mi smutno, że to wyzwanie dla golfistów, ponieważ wszystkie moje wcześniejsze wysiłki były raczej bezużyteczne, kiedy to opublikuję:

  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

Odtąd jest to tylko wyzwanie kompresji. Może wezmę udział później, a może nie. Dla mnie największą frajdą było znalezienie jak największej liczby receptur.

Wskazówka dla tych, którzy próbują napisać solver - środowisko uruchomieniowe nie powinno stanowić problemu. Jeśli masz zbyt wiele formuł do sprawdzenia, potrzebujesz lepszej heurystyki, aby wyrzucić beznadziejne rozwiązania i duplikaty. Kod, który napisałem, aby wygenerować powyższe, działa w Pythonie w ~ 5 sekund.