Latar Belakang

Teka-teki ini adalah variasi dari empat merangkak puzzle (itu sendiri topik pertanyaan masa lalu ). Seperti puzzle itu, tujuannya adalah untuk menemukan ekspresi matematika untuk bilangan bulat yang berbeda, hanya menggunakan empat digit dan operator matematika tertentu. Namun dalam kasus ini, angka yang diizinkan hanya 2, 0, 1 dan 5 . Masing-masing harus muncul tepat sekali dalam solusi dan dalam urutan yang benar. Secara mengejutkan banyak bilangan bulat dapat direpresentasikan dengan cara ini. Pemecah masalah disarankan untuk mencoba menyelesaikannya dengan tangan terlebih dahulu, karena ini anehnya menyenangkan.

Aturan

Konstanta dapat dibangun dari satu atau beberapa digit:

• Integer: mis. 2, 0, 15, dll.
• Desimal: misalnya .2, .01, 1.5, dll.
• Pengulangan desimal : mis. .2 ~ (= 0.222 ...), .15 ~ (= 0.1555 ...), 20.15 ~~ (= 20.1515 ...)

Operasi unary berikut diizinkan:

• Negasi unary: -x
• Root kuadrat: sqrt (x)
• Faktor integer: x!

Operasi biner berikut diizinkan:

• Operator aritmatika standar: x + y, xy, x * y dan x / y
• Eksponensial sewenang-wenang: x ^ y
• Akar sewenang-wenang: rt [x] (y) (= akar ke-x y)

Tugas

Program Anda harus mencetak ekspresi sebanyak mungkin dari bilangan bulat antara 0 dan 100, dan kemudian menampilkan jumlah ekspresi yang telah dihasilkan.

• Solusi harus dicetak dalam format n = [expr].
• Ekspresi harus menggunakan semua digit 2, 0, 1, 5, sekali masing-masing dalam urutan itu.
• Ekspresi harus dicetak menggunakan notasi yang dijelaskan di atas. Tanda kurung yang tidak perlu diizinkan tetapi tidak diperlukan, seperti halnya spasi putih. Urutan operator yang didahulukan adalah negasi unary, faktorial, eksponensial, perkalian / pembagian dan penambahan / pengurangan.
• Program tidak perlu mengembalikan solusi untuk semua angka. Program yang hanya menghasilkan 0 karena itu valid; namun, lihat bagian penilaian di bawah ini.
• Program harus berjalan dalam waktu kurang dari 15 menit di komputer modern.

Anda dapat menulis suatu program atau fungsi. Ekspresi harus dicetak ke STDOUT (atau alternatif terdekat). Jumlah ekspresi dapat dicetak ke STDOUT atau dikembalikan sebagai integer. Berlaku pembatasan standar kode golf.

Contoh output

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

Mencetak gol

Pembaruan : @orlp telah mencatat kesalahan dalam sistem penilaian. Lihat http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge untuk diskusi tentang bagaimana atau apakah ini harus diperbaiki.

Solusi diberi skor pertama dengan jumlah ekspresi yang mereka hasilkan dan kemudian oleh panjang kode mereka dalam byte. Oleh karena itu, program 1000 byte yang menghasilkan 80 hasil akan mengalahkan program 100 byte yang hanya menghasilkan 79 (meskipun yang terakhir dapat dengan mudah diperluas untuk memasukkan hasil yang hilang).

Bagi mereka yang ingin target yang memotivasi, di bawah ini adalah batas bawah pada jumlah ekspresi yang dapat diwakili. Saya tidak berencana untuk mengirimkan entri, jadi mungkin menang dengan lebih sedikit!

Setidaknya 85 (dari 101), meskipun mungkin lebih tinggi.

Papan angka

Sebagai insentif tambahan, berikut adalah ringkasan perkembangan skor. Setiap kali Anda mengalahkan skor tertinggi, jangan ragu untuk menambahkan diri Anda ke atas meja (atau meminta orang lain melakukannya).

• 0 ekspresi, 1 byte (Pyth): implementasi yang hanya menghasilkan 0

85, ~ 2400 byte

Saya agak sedih ini adalah tantangan kode golf, karena saya merasa bahwa semua upaya saya sebelumnya sudah tidak berguna sekarang karena saya akan memposting ini:

  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

Dari sini, itu hanya tantangan kompresi. Mungkin saya akan bersaing nanti, mungkin saya tidak akan. Bagi saya sebagian besar kesenangan adalah tantangan untuk menemukan formula terbanyak.

Petunjuk bagi mereka yang kesulitan menulis solver - runtime seharusnya tidak menjadi masalah. Jika Anda memiliki terlalu banyak rumus untuk diperiksa, Anda perlu heuristik yang lebih baik untuk membuang solusi dan duplikat yang tidak ada harapan. Kode yang saya tulis untuk menghasilkan menjalankan di atas dalam ~ 5 detik pada Python.