Puzzle dua nol satu

13

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
Uri Granta
sumber
Apakah 0,20 konstanta yang diizinkan?
Luke
1
@ Lukas: ya, meskipun juga dapat direpresentasikan sebagai (.2 + 0) sehingga tidak meningkatkan ekspresifitas
Uri Granta
1
@ orlp Perhatikan bahwa angka nol di depan dan pecahan lebih besar dari nol tidak menambahkan ekspresifitas apa pun: misalnya 015 = 0 + 15 dan 1,5 = 1 + .5.
Uri Granta
1
@ mbomb007 Itu terlalu rumit. Berikut penjelasan singkat yang saya tulis: gist.github.com/orlp/e92b3b7d26ad9b11378e
orlp
2
@UriZarfaty Kemudian ada 99 set konstanta berguna yang berbeda: gist.github.com/orlp/eb997e49e41878c76d0a
orlp

Jawaban:

9

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.

orlp
sumber
rt [.1] (-. 5) adalah akar 0,1 dari -0,5, bukan akar -0,5 dari 0,1.
Uri Granta
Juga, saya mulai curiga bahwa pemenangnya mungkin adalah keluaran teks terkompresi. Seharusnya memikirkan cara yang lebih baik untuk menghindari itu :-(
Uri Granta
@ UriZarfaty Oh, saya akan memperbaikinya dalam kode saya dan menjalankan kembali, beri saya satu detik.
orlp
Saya secara signifikan melebih-lebihkan seberapa besar output akan dibandingkan dengan ukuran program. Mengingat rentang karakter yang kecil dan tanda kurung yang berlebihan, saya kira solusinya akan benar-benar mengompresi dengan terlalu baik.
Uri Granta
1
@ mbomb007 Saya tidak melakukan upaya apapun untuk membersihkannya, dan saya pikir kode dalam keadaan saat ini rusak - coba batalkan komentar beberapa hal: gist.github.com/orlp/878da16b5b7c650ebd09 .
orlp