Lý lịch

Câu đố này là một biến thể của bốn câu đố bốn (chính nó là chủ đề của một câu hỏi trong quá khứ ). Giống như câu đố đó, mục đích là tìm các biểu thức toán học cho các số nguyên khác nhau, chỉ sử dụng bốn chữ số và các toán tử toán học nhất định. Tuy nhiên, trong trường hợp này, các chữ số được phép chỉ là 2, 0, 1 và 5 . Mỗi phải xuất hiện chính xác một lần trong giải pháp và theo đúng thứ tự. Đáng ngạc nhiên là nhiều số nguyên có thể được đại diện theo cách này. Người giải quyết được khuyến khích thử giải quyết bằng tay trước, vì điều đó thật thú vị.

Quy tắc

Các hằng số có thể được xây dựng từ một hoặc nhiều chữ số:

• Số nguyên: ví dụ 2, 0, 15, v.v.
• Số thập phân: vd .2, .01, 1.5, v.v.
• Lặp lại số thập phân : vd .2 ~ (= 0.222 ...), .15 ~ (= 0.1555 ...), 20.15 ~ ~ (= 20.1515 ...)

Các hoạt động đơn phương sau đây được cho phép:

• Phủ định đơn phương: -x
• Căn bậc hai: sqrt (x)
• Nhân tử số nguyên: x!

Các hoạt động nhị phân sau đây được cho phép:

• Toán tử số học tiêu chuẩn: x + y, xy, x * y và x / y
• Số mũ tùy ý: x ^ y
• Rễ tùy ý: rt [x] (y) (= x'th root của y)

Bài tập

Chương trình của bạn nên in ra các biểu thức cho càng nhiều số nguyên trong khoảng từ 0 đến 100 càng tốt, sau đó xuất ra số lượng biểu thức mà nó đã tạo ra.

• Các giải pháp phải được in theo thứ tự n = [expr].
• Các biểu thức phải sử dụng tất cả các chữ số 2, 0, 1, 5, mỗi lần theo thứ tự đó.
• Các biểu thức phải được in bằng cách sử dụng ký hiệu được mô tả ở trên. Dấu ngoặc không cần thiết được cho phép nhưng không bắt buộc, cũng như khoảng trắng. Thứ tự ưu tiên toán tử là phủ định đơn phương, giai thừa, lũy thừa, nhân / chia và cộng / trừ.
• Chương trình không cần trả về các giải pháp cho tất cả các số. Do đó, một chương trình chỉ xuất ra 0 là hợp lệ; tuy nhiên, hãy xem phần ghi điểm bên dưới.
• Chương trình sẽ chạy trong vòng dưới 15 phút trên một máy tính hiện đại.

Bạn có thể viết một chương trình hoặc chức năng. Các biểu thức nên được in thành STDOUT (hoặc thay thế gần nhất). Số lượng biểu thức có thể được in thành STDOUT hoặc được trả về dưới dạng số nguyên. Mã tiêu chuẩn golf áp dụng.

Ví dụ đầu ra

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

Chấm điểm

Cập nhật : @orlp đã ghi nhận một lỗ hổng trong hệ thống tính điểm. Xem http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puheads-challenge để thảo luận về cách hoặc liệu điều này có nên được khắc phục hay không.

Các giải pháp được ghi điểm đầu tiên bằng số lượng biểu thức mà chúng tạo ra và sau đó là độ dài mã của chúng theo byte. Do đó, chương trình 1000 byte tạo ra 80 kết quả sẽ đánh bại chương trình 100 byte chỉ tạo 79 (mặc dù chương trình sau có thể dễ dàng được mở rộng để bao gồm các kết quả bị thiếu).

Đối với những người muốn có một mục tiêu thúc đẩy, bên dưới là giới hạn thấp hơn về số lượng biểu thức có thể được biểu diễn. Tôi không có kế hoạch gửi một mục, vì vậy nó có thể giành chiến thắng với ít hơn!

Ít nhất 85 (trong số 101), mặc dù nó có thể cao hơn.

Bảng điểm

Như một sự khích lệ thêm, đây là một bản tóm tắt về sự tiến bộ điểm số. Bất cứ khi nào bạn đánh bại số điểm cao nhất, hãy thoải mái thêm chính mình vào đầu bảng (hoặc nhờ người khác làm).

• 0 biểu thức, 1 byte (Pyth): triển khai chỉ xuất 0

85, ~ 2400 byte

Tôi hơi buồn vì đây là một thử thách golf mã, vì tôi cảm thấy rằng tất cả những nỗ lực trước đây của tôi đã khá vô dụng khi tôi sẽ đăng bài này:

  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

Từ đây trở đi chỉ là một thử thách nén. Có lẽ tôi sẽ thi đấu sau, có lẽ tôi sẽ không. Đối với tôi, hầu hết niềm vui là trong thử thách tìm ra nhiều công thức nhất.

Một gợi ý cho những người đấu tranh để viết một bộ giải - thời gian chạy không phải là một vấn đề. Nếu bạn có quá nhiều công thức để kiểm tra, bạn cần phương pháp phỏng đoán tốt hơn để loại bỏ các giải pháp và trùng lặp vô vọng. Mã tôi đã viết để tạo các lần chạy ở trên trong ~ 5 giây trên Python.