Xin lưu ý: Theo bản chất của nó, thông số kỹ thuật cho thử thách này là khó hiểu. Nó có thể yêu cầu ít nhất một khóa học sinh viên năm nhất về lý thuyết tính toán, hoặc đọc nền tương đương. Ngoài ra, bản thân thử thách khá khó khăn. Trả lời nó sẽ yêu cầu viết toàn bộ trình thông dịch cho một số tập hợp con ngôn ngữ bạn chọn, và không chỉ vậy mà phiên dịch viên sẽ phải ở dạng một thứ gì đó giống như một câu hỏi. Nếu câu trả lời của bạn không làm tất cả những điều này, gần như chắc chắn sẽ không đáp ứng được thông số kỹ thuật.

Bạn không cần phải giải quyết vấn đề tạm dừng (thậm chí một phần) để giải quyết thách thức này. Tuy nhiên, bạn gần như chắc chắn làm cần phải viết một thông dịch viên (của ngôn ngữ mà bạn đang sử dụng, viết bằng ngôn ngữ tương tự nó diễn giải), mặc dù nó không cần phải được tính năng hoàn chỉnh. Chính điều này làm cho đây là một thử thách thú vị.

Tôi đã hứa sẽ thưởng một khoản tiền thưởng 500 điểm cho câu trả lời đầu tiên đáp ứng thông số kỹ thuật và điều này sẽ được trao cho câu trả lời của BF của Jo .

Các thách thức

Một phiên bản thô sơ, đơn giản của bằng chứng của Alan Turing về tính không thể giải quyết của vấn đề tạm dừng diễn ra như sau:

Giả sử tôi đã viết một chương trình Fnhằm giải quyết chương trình tạm dừng. Nghĩa là, Flấy mã nguồn của một chương trình khác làm đầu vào và F(G)được cho là trả về 1nếu Gdừng lại, và 0nếu không.

Nhưng nếu tôi cung cấp cho bạn chương trình của tôi Fthì bạn có thể xây dựng một chương trình khác, chương trình Hđó chạy chương trình của tôi với Htư cách là đầu vào của nó. Nếu F(H)trả về 0thì Htrả về 0, nhưng nếu không thì nó cố tình đi vào một vòng lặp vô hạn. Điều này dẫn đến một nghịch lý, và chúng ta phải kết luận rằng Frốt cuộc không thể giải quyết vấn đề tạm dừng.

Nhiệm vụ của bạn là viết chương trình H, nhưng với một bước ngoặt: Tôi sẽ không cung cấp cho bạn chương trình của tôi. Thay vào đó, chương trình của bạn sẽ nhận được mã nguồn của chương trình của tôi làm đầu vào. Đó là:

• Chương trình của bạn sẽ nhận được chương trình của tôi dưới dạng đầu vào, ở dạng mã nguồn. (Ví dụ như một tệp hoặc là đầu vào dòng lệnh, các chi tiết tùy thuộc vào bạn.)

• Chương trình của tôi sẽ được viết bằng cùng ngôn ngữ với chương trình của bạn và cũng nhận đầu vào dưới dạng chuỗi mã nguồn.

• Nếu chương trình của tôi trở lại 0khi được cung cấp chương trình của bạn làm đầu vào, chương trình của bạn sẽ tạm dừng (và trả lại 0) khi đưa chương trình của tôi làm đầu vào. (Ý nghĩa chính xác của "giữ lại 0" là tùy thuộc vào bạn.)

• nếu chương trình của tôi không dừng lại hoặc nếu nó trả về bất cứ thứ gì khác ngoài 0khi được đưa vào chương trình của bạn làm đầu vào, chương trình của bạn sẽ tiếp tục chạy vô thời hạn.

Vấn đề khó khăn là, để làm cho nó thực sự khó hơn rất nhiều, bạn phải tuân thủ các quy tắc sau:

1. Bạn không thể sử dụng bất kỳ loại chức năng tích hợp exechoặc eval-type nào.

2. Bạn không thể sử dụng bất kỳ phương pháp "gian lận" nào để lấy mã nguồn của chương trình của riêng bạn. (Ví dụ: bạn không thể nói "lưu tệp này trong tệp có tên 'chương trình'" và sau đó có open(program)trong chương trình của bạn.)

Điều này có nghĩa là chương trình của bạn phải là một loại siêu quine điên rồ không chỉ có thể sao chép mã nguồn của chính nó dưới dạng một chuỗi, mà còn có khả năng phân tích và giải thích chính xác ngôn ngữ mà nó viết.

Để làm cho nó bớt khó khăn một chút, bạn chỉ được phép sử dụng một tập hợp con (hoàn thành Turing) của ngôn ngữ bạn đã chọn. Vì vậy, nếu chương trình của bạn được viết bằng Python và sẽ chỉ hoạt động nếu chương trình của tôi chỉ chứa ifs và whilevòng lặp và các hoạt động chuỗi cơ bản, thì cũng được miễn là chương trình của bạn cũng chỉ sử dụng những thứ đó. (Điều này có nghĩa là bạn không phải lo lắng về việc triển khai toàn bộ thư viện chuẩn của ngôn ngữ bạn đã chọn!) Tuy nhiên, chương trình của bạn thực sự phải chạy - bạn không thể tạo ra ngôn ngữ của riêng mình.

Đây là cuộc thi phổ biến , vì vậy câu trả lời có nhiều phiếu nhất sẽ chiến thắng. Tuy nhiên, như đã đề cập ở trên, đó là một thách thức nghiêm trọng chỉ để đáp ứng thông số kỹ thuật, vì vậy tôi sẽ trao phần thưởng 500 điểm cho câu trả lời đầu tiên theo phán đoán của tôi.

xin lưu ý: không còn nghi ngờ gì nữa, có rất nhiều cách bạn có thể "gian lận" trong thử thách này, dựa trên từ ngữ chính xác mà tôi đã sử dụng. Tuy nhiên, tôi thực sự hy vọng câu trả lời đi vào tinh thần của câu hỏi. Thách thức như dự định là rất khó nhưng có thể, và tôi thực sự hy vọng sẽ thấy các giải pháp đích thực cho nó. Tôi sẽ không trao tiền thưởng cho một câu trả lời mà cảm thấy gian lận trong đánh giá của tôi.

_{Lưu ý: thử thách này ban đầu được đăng dưới dạng cuộc thi phổ biến , nhưng nó đã bị đóng cửa vào năm 2016 do không có "tiêu chí chiến thắng khách quan" và tôi đã đổi nó thành môn đánh gôn để mở lại. Tuy nhiên, tôi đã thấy rằng, kể từ tháng 1 năm 2018, trên thực tế , cuộc thi về sự nổi tiếng không bị cấm đối với PPCG (với điều này là cuộc thảo luận meta gần đây nhất) nên việc đóng cửa ở vị trí đầu tiên là trái với chính sách của trang web. Tôi hiểu rằng popcons không phổ biến ngày nay, nhưng đây là một thách thức cũ và bản chất của nó làm cho nó thực sự không phù hợp với môn đánh gônhệ thống tính điểm. Nếu bất cứ ai vẫn cảm thấy mạnh mẽ rằng không nên cho phép thì hãy thảo luận về meta trước khi những lá phiếu gần bắt đầu bị ném xung quanh. Cuối cùng, nếu không có cơ hội ai đó đã dành năm ngoái để chơi giải pháp của họ, hãy yên tâm rằng nó sẽ cạnh tranh trong thử thách này, và cũng xứng đáng với tiền thưởng, giống như trong môn đánh gôn phiên bản.}

brainfuck , 6013 4877 4376 byte

Chỉnh sửa: -1136 byte. Chuyển sang một cách tốt hơn để tạo dữ liệu cho quine

Chỉnh sửa2: -501 byte. Xem lại trình thông dịch tự của tôi và cắt giảm vài trăm byte

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

Hãy thử trực tuyến! Đầu vào ở đây là một chương trình mèo đơn giản (,[.,]) sẽ tự in chương trình.

"Trả về 0" được xác định bằng cách kết thúc chương trình trên một ô có giá trị 0.

Một sự kết hợp không lành mạnh của hai chương trình tôi đã viết trong quá khứ, một câu hỏi và một người phiên dịch. Phần đầu tiên là phần quine, lấy dữ liệu và điền vào băng với việc tạo dữ liệu theo sau là mã nguồn. Tiếp theo là trình thông dịch tự, lấy chương trình của bạn và chạy nó. Đây gần như là một bản sao không thay đổi của trình thông dịch tự thông thường, ngoại trừ việc thay vì lấy đầu vào trực tiếp, nó nhận đầu vào từ đầu phần dữ liệu, đặt ô thành 0 nếu không có thêm đầu vào. Cuối cùng, kết thúc trên ô hiện tại của chương trình của bạn và chạy []. Nếu giá trị trả về là 0, chương trình của tôi sẽ kết thúc bằng 0. Nếu nó là bất cứ điều gì khác, nó sẽ chạy một vòng lặp vô hạn. Nếu chương trình của bạn chạy mãi mãi,chương trình của tôi sẽ chạy mãi mãi.

Làm thế nào nó hoạt động:

Phần 1: Tạo dữ liệu

->++>++++> ....... >+++++>>>+++>>+++>>>++++>+++

Phần này tạo nên phần dữ liệu của quine và cho đến nay phần lớn mã ở mức 3270 byte. Sự khởi đầu -là một điểm đánh dấu cho sự bắt đầu của dữ liệu. Mỗi >+++đại diện cho một ký tự của mã sau phần này.

Number of Pluses
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
> | < | + | ] | [ | - | , | . |

Phần 2: Tạo phần dữ liệu bằng dữ liệu

+[<+]>

[
    Add a right arrow
    >[>]>[>]>(10++++++++++)[-<(6++++++)>]<++[<]<[<]
    <+>>-
    Add the right amount of pluses
    [
        [>]>[>]>(7+++++++)[-<(6++++++)>]<+[<]<[<]<+>>-
    ]
    >
]
Add the beginning minus
<--[>+<++++++]>++

Điều này sử dụng dữ liệu từ phần một để thêm các ký tự được sử dụng để tạo dữ liệu vào phần mã. Nó thêm >phần cuối của phần mã và giá trị của ô đó nhiều điểm cộng.

Phần 3: Tạo phần còn lại của mã bằng dữ liệu

Initialises the 8 characters of brainfuck
>[>]+++++[->+++<]>[>+++>+++>+++>++++++>++++++>+++>++++>++++[<]>-]
>+>->>+>+++>-->>++[<]<<[<]<<[<]>

Tape looks like:
data 0 0 code 0 0 characters

Runs through the data destructively and adds the represented symbol to the code section
[
    [
        For each plus in this cell
            Shift the gap in the characters over one
        [>]>>[>]>>[>]<[->>+<<]
        <[<]<<[<]<<[<]>-
    ]
    Navigate to character
    >[>]>>[>]>>[>]>>
    Copy the character to the end of the code section
    [-<<+[<]<+>>[>]>]

    Shift the symbol section over one
    <<[[->+<]<]
    >>[>]>[[-<+>]>]

    Navigate to next byte of data
    <<[<]<<[<]<<[<]>
]

Remove characters
>>[>]>>[>]<[[-]<]

Phá hủy phần dữ liệu và thêm phần còn lại của mã nguồn vào phần mã

Phần 4: Nhận chương trình nhập

>>>,
[
    >(7+++++++)[<(6------)>-]+<-
    [>]>
    [plus <+<+>>>>]<<<
    -[>]>
    [comma <+<+>>>>]<<<
    -[>]>
    [minus <+<+>>>>]<<<
    -[>]>
    [dot <-<+++>>>>]<<<
    (14--------------)[>]>
    [left <++<+>>>>]<<<
    --[>]>
    [right <-<+++++++>>>>]<<
    (29++++[-<------>]+<+)
    [>]>
    [start loop <++<+>>>>]<<<
    --[>]>
    [end loop <-<+>>>>]<<
    -<[+]<[>]>,
]

Được chương trình nhập vào. Xóa các ký tự không phải là brainfuck và đại diện cho mỗi ký tự bằng một số:

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
] | [ | . | - | , | + | > | < |

Đại diện cho sự kết thúc của chương trình với 255.

Phần 5: Giải thích đầu vào

Initialise simulated tape
>>>+<<<<-

[<]>
[
    -[<<]>
    [end loop
        co 0 0 0 e:  _1 0 0 0 1 ?
        Check if current cell is one
        <+[>]>>[<]<<
        co 0 0 1 e _1: 0 0 !0 1
        or
        co 0 0 1 e _1 0: 0 0 1
        [ If current cell is one navigate to corresponding start loop
            Create counter
            >>+
            [
                co 0 0 de _1 0 c: !0 1
                checks if next instruction is an end loop
                <<[<]<<-
                [>>]<
                c !0 0: 0 de _1 0 c !0 1
                or
                c: 0 0  0 de _1 0 c !0 1
                [>>>>[>]>+<<[<]<] Add one to counter if it is
                checks if start loop
                <-[>>]<
                c !0 0: 0 de _1 0 c !0 1
                or
                c: 0 0  0 de _1 0 c !0 1
                [>>>>[>]>-<<[<]<] Subtract one from counter if it is
                c ? 0: 0 de _1 0 c !0 1
                Adds two to counteract checks and move to the next instruction
                <++[->>+<<]
                >>[>]>
                c 0 0 ode _1 0 c: !0 1
                End on the counter
                    If the counter is 0 then we have reached the corresponding bracket
            ]
            c 0 0 2 de _1 0 0: !0 1 0
            <
        ]
        c 0 0 1?2 de _1 0: 0 0 1 0
        Subtract one from current instruction
            This executes the start loop code next but that does nothing
        <[<]>-<
    ]
    >-[<<]>
    [start loop
        c 0 0 0 de:  _1 0 0 ? 1
        <++[>]>>[<<]>
        c 0 0 2 de _1 0 0 0 1:
        or
        c 0 0 2 de _1 0 0: !0 1
        [ If current cell is 0 navigate to corresponding end loop
            Initialise counter
            <<+
            c 0 0 ode _1 0 c: 0 1
            [ While counter is not 0
                Transfer current instruction over (first instruction is guaranteed to be start loop)
                <<[<]>[-<<+>>]>
                co 0 0 de _1 0 c: 0 1
                Check if start loop
                --[<<]>
                co 0 0: !0 e _1 0 c 0 1
                or
                co 0 0 0 e _1 0 c 0 1
                [[>]>+<<[<]<] Add one to counter if so
                checks if end loop
                >+[<<]>
                co 0 0: !0 e _1 0 c 0 1
                or
                co 0 0 0 e:  _1 0 c 0 1
                [[>]>-<<[<]<] Subtract one from counter if so
                Add one to counteract checks and navigate to counter
                >+[>]>
                co 0 0 de _1 0 c: 0 1
                End on counter
                    If counter is 0 then we have reached the corresponding end loop
            ]
            co 0 1 e _1 0 0: 0 1
        ]
        co 0 0 2?1 e _1 0 0: ? 1
        Subtract two from the current instruction to bring it back up to the right value
        <<[<]>--<
    ]
    3 of these are pretty self explanatory
    Navigate to the current cell and execute the instruction on it
    >-[<<]>
    [output
        [>]>>.<<<[<]<
    ]
    >-[<<]>
    [minus
        [>]>>-<<<[<]<
    ]
    >-[<<]>
    [input
        Reset current cell
        [>]>>, (no more input so this is set to 0)
        co 0 0 0 e:  _1 0 0 0: 1 b 1 a 0 d 1 e 1 f
        Navigate to start of code section
        <<<[<]<<<[<]<[<]>
        d: ata 0 co 0 0 0 e _1 0 0 0 1 b
        or
        0: co 0 0 0 e _1
        Transfer next instruction to current cell
        [[>]>[>]>>>[>]>>+<<<[<]<<<[<]<[<]>-]
        0: ata 0 co 0 0 0 e _1 0 0 d 1 b
        or
        0: co 0 0 0 e _1
        Navigate back to the normal spot
        >[>]>[>]>>[<]<
    ]
    >-[<<]>
    [plus
        [>]>>+<<<[<]<
    ]
    >-[<<]>
    [right
        Simulated tape looks like:
            a b c: d e f
        co 0 0 0 e:  _1 0 0 c 1 b 1 a 0 d 1 e 1 f
        Navigate to value of cell to the right
        [>]>>>[>>]>
        co 0 0 0 e _1 0 0 c 1 b 1 a 0 d: 1 e 1 f
        Transfer it to temporary cell
        [<<<[<<]<+>>>[>>]>-]
        co 0 0 0 e _1 d 0 c 1 b 1 a 0 0: 1 e 1 f
        Pop extra marker if it exists from the right cells and add one to the left
        >[-]<<+
        co 0 0 0 e _1 d 0 c 1 b 1 a 1: 0 0 e 1 f
        Transfer all left cells over 2 cells
        [<[->>+<<]<]<[->>+<<]
        co 0 0 0 e _1 0: 0 d 1 c 1 b 1: a 0 e 1 f
        Navigate back to normal spot
        <[<]<
    ]
    >-[<<]>
    [left
        Simulated tape looks like:
            a b c: d e f
        co 0 0 0: e _1 0 0 c 1 b 1 a 0 d 1 e 1 f
        Add temporary marker
        [>]>++
        co 0 0 0 e _1 0 2: c 1 b 1 a 0 d 1 e 1 f
        Remove temporary marker and transfer all left cells over two
        [-->[-<<+>>]>]
        co 0 0 0 e _1 c 0 b _1 a _1 0 0: d 1 e 1 f
        Add marker to right cells remove marker from left cells and reset left cell's markers
        +<<-[++<<]<
        co 0 0 0 e _1 c: 0 b 1 a 0 0 1 d 1 e 1 f
        Transfer current cell to to right cells
        [->>>[>>]>+<<<[<<]<]
        co 0 0 0 e _1 0: 0 b 1 a 0 c 1 d 1 e 1 f
        Navigate back to normal spot
        <[<]<
    ]
    Add 8 to reverse checks
    <(8++++++++)>>

    Execute next instruction
    [+<<->>]>
]

Giải thích chương trình. Sự khác biệt duy nhất so với bình thường là đầu vào được lấy từ đầu phần mã thay vì đầu vào.

Phần 6: Dừng lại nếu trả về không bằng 0

>>[]

Điều hướng đến ô kết thúc của chương trình của bạn và chạy một vòng lặp vô hạn nếu trả về không bằng 0. Nếu là 0, hãy thoát khỏi vòng lặp và kết thúc trên cùng 0 đó.

Đầu vào kiểm tra:

Luôn trả về 0 (dừng và trả về 0)

(empty program)

Luôn trả về 1 (chạy mãi mãi)

+

Trả về tất cả các đầu vào được thêm vào cùng nhau, mod 256 (trả về 211, vì vậy nó chạy mãi mãi)

,[[->+<],]>

Trả về 0 nếu hai ký tự cuối của mã là một vòng lặp vô hạn ( []) ( chương trình của bạn trả về 0 khi được cung cấp chương trình của tôi , do đó chương trình của tôi tạm dừng)

,[>,]>(9+++++++++)[-<(10++++++++++)>]<[-<-<->>]+<---[[-]>[-]<]<-[[-]>>[-]<<]>+>[-<->]<    

Sự thật thú vị cho những ai vẫn đang đọc

Nếu đầu vào cho chương trình này là mã nguồn của chương trình này, thì nó sẽ bắt đầu đệ quy, liên tục tạo các trình thông dịch tự chạy chương trình này và sau đó cung cấp lại cho cùng một chương trình. Điều này cho tôi một số ý tưởng thú vị về việc tạo các chương trình đệ quy thực tế trong brainfuck. Thay vì kiểm tra giá trị trả về và bắt đầu một vòng lặp vô hạn như trong câu hỏi này, giá trị trả về có thể được lưu và hành động theo. Một ví dụ đơn giản sẽ là một chương trình giai thừa

If cell1 == 0:
    Get input into cell1
If cell1 == 1 or cell1 == 0:
    Return 1
Else:
    Initialise self-interpreter-quine function
    Pass cell1-1 into cell1 of the function
    Run function
    Multiply cell1 by the return value
    Return cell1

Tất nhiên, đây là một cách mã hóa hoàn toàn điên rồ, do việc chạy các trình thông dịch tự đệ quy sẽ tăng thời gian chạy theo cấp số nhân.