Bạn nên viết chương trình Brainfuck (BF) dài 100 byte.

Một ký tự sẽ bị xóa khỏi nó theo mọi cách có thể tạo ra 100 chương trình mới (dài 99 byte). Ví dụ như cho chương trình ++.>.5 chương trình con là +.>., +.>., ++>., ++..và ++.>.

Điểm của bạn sẽ là số lượng đầu ra duy nhất mà 100 chương trình tạo ra. Điểm cao hơn là tốt hơn.

Chi tiết

• Các chương trình của bạn sẽ bị chấm dứt sau khi xuất ký tự đầu tiên.
• Các chương trình và chương trình không hợp lệ hoặc không kết thúc tạo đầu ra trống không được tính vào điểm số.
• Các tế bào BF là 8 bit gói. (255 + 1 = 0, 0-1 = 255)
• Chương trình của bạn không có đầu vào. Nếu bạn sử dụng ,trong mã, nó sẽ đặt ô hiện tại thành 0.
• Không có ô ở bên trái của vị trí bắt đầu. Ví dụ: <.không hợp lệ nhưng .<hợp lệ vì việc thực thi bị chấm dứt tại .. Các băng không bị ràng buộc theo hướng khác.
• Các chương trình có dấu ngoặc không cân bằng ( [và ]) không hợp lệ.
• Chương trình ban đầu của bạn có thể ngắn hơn 100 byte vì thật dễ dàng để mở rộng thành 100 byte mà không thay đổi điểm số.
• Chương trình ban đầu của bạn không phải là mã BF hợp lệ.

Bạn có thể sử dụng chương trình python3 này (liên kết ideone) để xác định điểm của câu trả lời của bạn. (Đối với các chương trình chạy dài, bạn có thể cần phải sửa đổi maxstepbiến.)

Thí dụ

(Để đơn giản, chương trình này ngắn hơn 100 byte.)

Solution: ++,+[-]+><.-,-.

Score: 3

Explanation:

Subprogram     => Output

+,+[-]+><.-,-. => 1
+,+[-]+><.-,-. => 1
+++[-]+><.-,-. => 1
++,[-]+><.-,-. => 1
++,+-]+><.-,-. => None
++,+[]+><.-,-. => None
++,+[-+><.-,-. => None
++,+[-]><.-,-. => 0
++,+[-]+<.-,-. => None
++,+[-]+>.-,-. => 0
++,+[-]+><-,-. => 255
++,+[-]+><.,-. => 1
++,+[-]+><.--. => 1
++,+[-]+><.-,. => 1
++,+[-]+><.-,- => 1

Unique outputs are [0, 1, 255]    
Score is 3 for ++,+[-]+><.-,-. (length = 15)

Trong trường hợp hòa, người chiến thắng là người có mã ngắn hơn. (Chương trình của bạn có thể ngắn hơn 100 byte như được nêu trong phần Chi tiết.) Nếu các mã có độ dài bằng nhau, người chiến thắng là người đăng trước đó.

Phần thưởng câu đố: không có giới hạn in đậm, bạn có thể tìm thấy một chương trình có điểm 100 không?

Điểm: 35 41 69 78 79 83

(Xóa dòng mới.)

-->+>->+>->+>->+>->+>->+>->+>->+>->+>->+>->+>->+>-
>+>->+>->+>->+>->+>->+>->+>->+>++[>[-<+++>]<<++]>.

Hãy thử trực tuyến!

Tôi không chắc chính xác tại sao nó hoạt động ...

Điểm: 79

X->>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>
+>+>+>+>+>+>+>+>+>+>+>+[>[-<+>>+<]+>[-<+>]<<<+]>>.

Hãy thử trực tuyến!

Nó được cho là tổng 2 * mem [i] * i và thêm số lượng ô (+ const) trong đó các địa chỉ được tính từ phải sang trái. Số nhân 2 và số lượng ô có thể giúp loại bỏ + và> có tính chẵn lẻ khác nhau.

Nó thực sự hoạt động như thế trong phiên bản 69 điểm. Nhưng phiên bản mới nhất đã phá vỡ điều đó và có một cái gì đó khác bởi sự trùng hợp. Nó tính tổng (mem [i] * i + i + 1) và loại bỏ + và> gần như giống nhau, ngoại trừ tổng (i) có sự khác biệt về số lượng ô, cũng là số lượng đầu ra khác nhau để loại bỏ + và>.

Đối với phần thưởng:

+. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +.

Điểm: 37 43

+>-,->,+-><->-[>---+-+<[--->>+><,+>>>++<><<<+<[>--]]><><+-+>+<<+<><+++<[[<[---->-<-]>++>],>,]<,]<+-.

EDIT: Bây giờ chương trình của tôi cho phép một số dấu ngoặc vuông. Sẽ không giành được bất kỳ giải thưởng nào với nó, nhưng đó là những gì tôi nhận được khi tạo ra một số RNG có trọng số làm công việc bận rộn cho tôi.

Điều này được tạo ra bởi một chương trình tôi đã viết trong C.

Đối với mỗi Nký tự thứ bị xóa, đây là các đầu ra:

N = 0 => 158
N = 1 => 158
N = 2 => 158
N = 3 => 187
N = 4 => 129
N = 5 => 100
N = 6 => 158
N = 7 => 13
N = 8 => 1
N = 9 => 211
N = 10 => 129
N = 11 => 1
N = 12 => 57
N = 13 => 255
N = 14 => Mismatched Braces
N = 15 => 59
N = 16 => 11
N = 17 => 11
N = 18 => 11
N = 19 => 117
N = 20 => 11
N = 21 => 117
N = 22 => 166
N = 23 => Mismatched Braces
N = 24 => 206
N = 25 => 206
N = 26 => 206
N = 27 => 147
N = 28 => 147
N = 29 => 158
N = 30 => 148
N = 31 => 188
N = 32 => 51
N = 33 => 17
N = 34 => 84
N = 35 => 84
N = 36 => 84
N = 37 => 158
N = 38 => 158
N = 39 => 94
N = 40 => 46
N = 41 => 94
N = 42 => 94
N = 43 => 94
N = 44 => 17
N = 45 => 196
N = 46 => Mismatched Braces
N = 47 => 149
N = 48 => No Termination
N = 49 => No Termination
N = 50 => Mismatched Braces
N = 51 => Mismatched Braces
N = 52 => 45
N = 53 => 77
N = 54 => 45
N = 55 => 77
N = 56 => 50
N = 57 => 209
N = 58 => 50
N = 59 => 251
N = 60 => 249
N = 61 => 99
N = 62 => 99
N = 63 => 117
N = 64 => 89
N = 65 => 207
N = 66 => 89
N = 67 => 115
N = 68 => 115
N = 69 => 115
N = 70 => 95
N = 71 => Mismatched Braces
N = 72 => Mismatched Braces
N = 73 => 104
N = 74 => Mismatched Braces
N = 75 => No Termination
N = 76 => No Termination
N = 77 => No Termination
N = 78 => No Termination
N = 79 => Left Overflow
N = 80 => 3
N = 81 => 2
N = 82 => No Termination
N = 83 => Mismatched Braces
N = 84 => No Termination
N = 85 => 133
N = 86 => 133
N = 87 => 0
N = 88 => Mismatched Braces
N = 89 => 158
N = 90 => 0
N = 91 => 4
N = 92 => Mismatched Braces
N = 93 => 0
N = 94 => 158
N = 95 => Mismatched Braces
N = 96 => 0
N = 97 => 157
N = 98 => 159
N = 99 => None

Có tổng cộng 37 đầu ra duy nhất, theo thứ tự số:

0, 1, 2, 3, 4, 11, 13, 17, 45, 46, 50, 51, 57, 59, 77, 84, 89, 94, 95, 99,
100, 104, 115, 117, 129, 133, 147, 148, 149, 157, 158, 159, 166, 187, 188, 
196, 206, 207, 209, 211, 249, 251, 255

Tôi chắc chắn 90% 100% giải pháp này không tối ưu , nhưng việc chứng minh rằng điều đó có thể cực kỳ khó khăn . Có một vài điều rõ ràng. Không có .biểu tượng cho đến khi ký tự cuối cùng có vẻ là hướng đi và dấu ngoặc vuông ( []) dường như khá vô dụng . Tôi đã suy nghĩ một chút ở đây, điều mà tôi muốn phác thảo:

Đặt Lđộ dài của mã theo byte (trong thử thách 100) và nlà số lượng đầu ra duy nhất của các chương trình phụ.

Đối với L=3, có một số giải pháp tối ưu của biểu mẫu +-., trong đó n=2(trong trường hợp này, các đầu ra lần lượt là 1 và 255 +.và -.). Điều này đặt tỷ lệ tốt nhất cho L = 3tại n/L = 66.67%. Lưu ý rằng tỷ lệ này không thể bị đánh bại ít nhất L<10.

Đối với L=10, các giải pháp là đủ đơn giản để bruteforce nó. Dưới đây là tất cả các giải pháp tốt nhất, tại n = 6:

++>-->+<+. => 6
++>-->+<+. => 6
+++>->+<+. => 6
--->->+<+. => 6
++>---><+. => 6
+++>--><+. => 6
-->++>-<-. => 6
+++>+>-<-. => 6
--->+>-<-. => 6
-->+++><-. => 6
--->++><-. => 6

Mà mang lại một tỷ lệ điểm của n/L = 60%.

Như L->infinity, rõ ràng là tỷ lệ phải đạt tới 0, vì chỉ có 255 đầu ra có thể cho một khả năng vô hạn L.

Tỷ lệ KHÔNG, tuy nhiên, giảm đồng đều. Không thể xây dựng một giải pháp cho n=6, L=9, vì vậy tỷ lệ tốt nhất có thể L=9là 5/9 = 55.56% < 60%.

Điều này đặt ra câu hỏi, làm thế nào nhanh chóng , và trong vấn đề gì, tỷ lệ giảm xuống? Vì L = 100, và tại 10^9 checks/second, nó sẽ mất nhiều đơn đặt hàng lớn hơn thời gian tồn tại của vũ trụ để đưa ra giải pháp tối ưu. Có một cách thanh lịch để đi về điều này? Tôi rất nghi ngờ rằng đó là xuống 37%cho L = 100.

Tỷ lệ thực sự tăng, lên đến L=100. Xem câu trả lời khác để xác nhận.

Tôi muốn nghe đánh giá của bạn về những điều trên. Rốt cuộc, tôi có thể đã sai lầm.