Harap dicatat: Sesuai sifatnya, spesifikasi untuk tantangan ini sulit dipahami. Mungkin memerlukan setidaknya kursus baru dalam teori komputasi, atau membaca latar belakang yang setara. Selain itu, tantangannya sendiri agak sulit. Menjawabnya akan membutuhkan penulisan seluruh juru bahasa untuk beberapa bagian dari bahasa pilihan Anda, dan tidak hanya itu tetapi penerjemah harus dalam bentuk sesuatu seperti quine. Jika jawaban Anda tidak melakukan semua ini, hampir pasti tidak akan memenuhi spesifikasi.

Anda tidak perlu menyelesaikan masalah penghentian (bahkan sebagian) untuk menyelesaikan tantangan ini. Namun, Anda hampir pasti lakukan perlu menulis penerjemah (dari bahasa yang Anda gunakan, ditulis dalam bahasa yang sama menafsirkan), meskipun tidak perlu fitur yang lengkap. Inilah yang membuat ini tantangan yang menarik.

Saya berjanji akan memberikan hadiah 500 poin untuk jawaban pertama yang memenuhi spesifikasi, dan ini akan diberikan kepada jawaban BF King BF .

Tantangan

Versi kasar, versi sederhana dari bukti Alan Turing tentang tidak terselesaikannya masalah terhenti adalah seperti ini:

Misalkan saya telah menulis sebuah program Fyang dimaksudkan untuk menyelesaikan program penghentian. Yaitu, Fmengambil kode sumber dari program lain sebagai input, dan F(G)seharusnya kembali 1jika Gberhenti, dan 0sebaliknya.

Tetapi jika saya memberi Anda program saya Fmaka Anda dapat membangun program lain H,, yang menjalankan program saya dengan Hmasukannya. Jika F(H)kembali 0maka Hkembali 0, tetapi sebaliknya dengan sengaja masuk ke loop tak terbatas. Ini mengarah ke sebuah paradoks, dan kita harus menyimpulkan bahwa bagaimanapun Fjuga tidak dapat menyelesaikan masalah penghentian.

Tugas Anda adalah menulis program H, tetapi dengan twist: Saya tidak akan memberi Anda program saya. Sebaliknya, program Anda akan menerima kode sumber program saya sebagai input. Itu adalah:

• Program Anda akan menerima program saya sebagai input, dalam bentuk kode sumber. (Misalnya sebagai file atau sebagai input baris perintah, detailnya terserah Anda.)

• Program saya akan ditulis dalam bahasa yang sama dengan program Anda, dan juga mengambil input dalam bentuk string kode sumber.

• Jika program saya kembali 0ketika diberikan program Anda sebagai input, program Anda harus berhenti (dan kembali 0) ketika diberi program saya sebagai input. (Arti tepat dari "returing 0" terserah Anda.)

• jika program saya tidak berhenti, atau jika ia mengembalikan apa pun selain 0ketika diberikan program Anda sebagai input, program Anda harus tetap berjalan tanpa batas.

Kelebihannya adalah, hanya untuk membuatnya sangat jauh lebih sulit, Anda harus mematuhi aturan berikut:

1. Anda tidak dapat menggunakan fungsi bawaan execatau evaljenis apa pun.

2. Anda tidak dapat menggunakan metode "curang" apa pun untuk mendapatkan kode sumber program Anda sendiri. (Misalnya Anda tidak bisa mengatakan "simpan ini di file yang disebut 'program'" dan kemudian miliki open(program)di program Anda.)

Ini berarti bahwa program Anda harus menjadi semacam super-quine gila yang tidak hanya dapat mereproduksi kode sumbernya sendiri dalam bentuk string, tetapi juga mampu mengurai dan menafsirkan bahasa yang ditulis dengan benar.

Untuk membuatnya sedikit lebih sulit, Anda diperbolehkan menggunakan hanya sebagian (bahasa Turing) dari bahasa pilihan Anda. Jadi jika program Anda ditulis dalam Python dan hanya akan berfungsi jika program saya hanya berisi operasi ifs dan whileloop dan string dasar, maka itu boleh saja selama program Anda hanya menggunakan hal-hal itu juga. (Ini berarti Anda tidak perlu khawatir menerapkan seluruh perpustakaan standar bahasa yang Anda pilih!) Namun, program Anda harus benar-benar berjalan - Anda tidak bisa hanya membuat bahasa Anda sendiri.

Ini adalah kontes popularitas , jadi jawaban dengan suara terbanyak menang. Namun, seperti yang disebutkan di atas, itu adalah tantangan serius hanya untuk memenuhi spesifikasi sama sekali, jadi saya akan memberikan hadiah 500 poin untuk jawaban pertama yang menurut penilaian saya.

harap dicatat: tidak diragukan lagi ada banyak cara Anda dapat "menipu" pada tantangan ini, mengingat kata-kata persis yang saya gunakan. Namun, saya benar-benar berharap jawaban yang masuk ke dalam semangat pertanyaan. Tantangan sebagaimana dimaksud sangat sulit tetapi mungkin, dan saya benar-benar berharap untuk melihat solusi yang tulus untuk itu. Saya tidak akan menghadiahkan hadiah itu untuk jawaban yang terasa curang dalam penilaian saya.

_{Catatan: tantangan ini awalnya diposting sebagai kontes popularitas , tetapi ditutup pada tahun 2016 karena tidak memiliki "kriteria kemenangan yang objektif", dan saya mengubahnya menjadi golf kode untuk membuatnya dibuka kembali. Namun, saya telah menemukan bahwa, pada Januari 2018, popularitas-kontes sebenarnya tidak dilarang di PPCG (dengan ini menjadi diskusi meta terbaru) sehingga menutupnya di tempat pertama adalah bertentangan dengan kebijakan situs. Saya mengerti bahwa popcons tidak populer akhir-akhir ini, tetapi ini adalah tantangan lama, dan sifatnya membuatnya sangat tidak cocok untuk kode-golfsistem penilaian. Jika ada orang yang masih merasa bahwa itu tidak boleh diizinkan, mari kita bahas meta diskusi sebelum orang-orang dekat mulai dilemparkan. Akhirnya, jika seseorang menghabiskan tahun terakhir mencoba golf solusi mereka, yakinlah bahwa itu akan sama kompetitif dalam tantangan ini, dan sama layaknya dengan karunia, seperti yang akan ada dalam kode-golf versi.}

brainfuck , 6013 4877 4376 byte

Edit: -1136 byte. Beralih ke cara yang lebih baik untuk menghasilkan data untuk quine

Sunting2: -501 byte. Tinjau kembali penerjemah mandiri saya dan kurangi beberapa ratus byte

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

Cobalah online! Input di sini adalah program kucing sederhana (,[.,]) yang akan mencetak program itu sendiri.

"Return 0" didefinisikan dengan mengakhiri program pada sel dengan nilai 0.

Kombinasi yang tidak suci dari dua program yang telah saya tulis sebelumnya, quine dan interpreter mandiri. Bagian pertama adalah bagian quine, yang mengambil data dan mengisi rekaman dengan generasi data yang diikuti oleh kode sumber. Berikutnya adalah self-interpreter, yang mengambil program Anda dan menjalankannya. Ini adalah salinan yang tidak berubah dari self interpreter normal, kecuali bahwa alih-alih mengambil input secara langsung, itu mendapat input dari awal bagian data, mengatur sel ke 0 jika tidak ada lagi input. Akhirnya, akhiri di sel saat ini dari program Anda dan jalankan []. Jika nilai yang dikembalikan adalah 0, program saya akan berakhir pada nol. Jika ada hal lain, itu akan menjalankan loop tak terbatas. Jika program Anda berjalan selamanya,program saya akan berjalan selamanya.

Bagaimana itu bekerja:

Bagian 1: Pembuatan Data

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

Bagian ini merupakan bagian data quine, dan sejauh ini merupakan mayoritas kode pada 3270 byte. Awal -adalah penanda untuk awal data. Masing-masing >+++mewakili karakter kode setelah bagian ini.

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

Bagian 2: Hasilkan bagian data menggunakan data

+[<+]>

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

Ini menggunakan data dari bagian satu untuk menambahkan karakter yang digunakan untuk menghasilkan data ke bagian kode. Ini menambahkan >bagian akhir kode dan nilai banyak nilai sel itu.

Bagian 3: Hasilkan sisa kode menggunakan data

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
>>[>]>>[>]<[[-]<]

Hancurkan bagian data dan tambahkan sisa kode sumber ke bagian kode

Bagian 4: Dapatkan program yang dimasukkan

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

Mendapat program yang dimasukkan. Menghapus karakter non-brainfuck dan mewakili setiap karakter dengan angka:

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

Merupakan akhir dari program dengan 255.

Bagian 5: Menafsirkan input

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
    [+<<->>]>
]

Menafsirkan program. Satu-satunya perbedaan dari yang normal adalah bahwa input diambil dari awal bagian kode daripada input.

Bagian 6: Hentikan jika pengembalian bukan 0

>>[]

Arahkan ke sel akhir dari program Anda dan jalankan infinite loop jika pengembaliannya tidak 0. Jika 0, keluar dari loop dan akhiri pada 0 yang sama.

Input Tes:

Selalu mengembalikan 0 (berhenti dan kembali 0)

(empty program)

Selalu mengembalikan 1 (berjalan selamanya)

+

Mengembalikan semua input yang ditambahkan bersama-sama, mod 256 (mengembalikan 211, sehingga berjalan selamanya)

,[[->+<],]>

Mengembalikan 0 jika dua karakter terakhir dari sebuah kode adalah infinite loop ( []) ( program Anda mengembalikan 0 ketika diberi program saya , karena itu program saya berhenti)

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

Fakta Menarik bagi mereka yang masih membaca

Jika input untuk program ini adalah kode sumber program ini, maka program itu akan mulai berulang, berulang kali membuat self-interpreter yang menjalankan program ini dan kemudian memberikannya program yang sama lagi. Ini memberi saya beberapa ide menarik untuk membuat program rekursif aktual di brainfuck. Alih-alih memeriksa nilai kembali dan memulai infinite loop seperti dalam pertanyaan ini, nilai kembali dapat disimpan dan ditindaklanjuti. Contoh sederhana akan menjadi program faktorial yang berjalan

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

Tentu saja, ini adalah cara pengodean brainfuck yang benar-benar gila, mengingat bahwa menjalankan self-interpreter yang berulang akan meningkatkan runtime secara eksponensial.