Nota: per sua natura, le specifiche per questa sfida sono difficili da capire. Probabilmente richiede almeno un corso di matricola in teoria della computabilità o una lettura di base equivalente. Inoltre, la sfida stessa è piuttosto difficile. Per rispondere, dovrai scrivere un intero interprete per un sottoinsieme della tua lingua preferita, e non solo, ma l'interprete dovrà avere la forma di qualcosa come un quine. Se la tua risposta non sta facendo tutto questo, è quasi certo di non soddisfare le specifiche.

Non è necessario risolvere il problema di arresto (anche parzialmente) per risolvere questa sfida. Tuttavia, quasi certamente devi scrivere un interprete (della lingua che stai utilizzando, scritta nella stessa lingua che interpreta), anche se non è necessario che sia completo. È questo che lo rende una sfida interessante.

Ho promesso di assegnare un premio di 500 punti alla prima risposta che soddisfa le specifiche, e questo sarà assegnato alla risposta BF di Jo King .

La sfida

Una versione approssimativa e semplificata della prova di Alan Turing dell'insolvibilità del problema di arresto va in questo modo:

Supponiamo di aver scritto un programma Fche ha lo scopo di risolvere il programma di arresto. Cioè, Fprende il codice sorgente di un altro programma come input e F(G)dovrebbe restituire 1se si Gferma, e 0altrimenti.

Ma se ti do il mio programma, Fallora puoi costruire un altro programma H, che esegue il mio programma Hcome input. Se F(H)restituisce, 0allora Hritorna 0, ma altrimenti va deliberatamente in un ciclo infinito. Ciò porta a un paradosso, e dobbiamo concludere che, Fdopo tutto, non è possibile risolvere il problema dell'arresto.

Il tuo compito è scrivere il programma H, ma con una svolta: non ho intenzione di darti il ​​mio programma. Invece, il tuo programma riceverà il codice sorgente del mio programma come input. Questo è:

• Il tuo programma riceverà il mio programma come input, in forma di codice sorgente. (Ad esempio come file o come input da riga di comando, i dettagli dipendono da te.)

• Il mio programma verrà scritto nella stessa lingua del programma e accetta anche input sotto forma di stringa di codice sorgente.

• Se il mio programma ritorna 0quando viene fornito il programma come input, il programma dovrebbe arrestarsi (e tornare 0) quando viene fornito il mio programma come input. (Il significato esatto di "returing 0" dipende da te.)

• se il mio programma non si interrompe, o se restituisce qualcosa di diverso rispetto a 0quando viene fornito il programma come input, il programma dovrebbe continuare a funzionare indefinitamente.

Il colpo di scena è che, solo per renderlo molto più difficile, devi obbedire alle seguenti regole:

1. Non è possibile utilizzare alcun tipo di funzione integrata execo di evaltipo.

2. Non è possibile utilizzare alcun metodo "imbroglione" per ottenere il codice sorgente del proprio programma. (Ad esempio non puoi dire "salvalo in un file chiamato 'programma'" e poi inseriscilo open(program)nel tuo programma.)

Ciò significa che il tuo programma deve essere una sorta di super-quine pazzo che non solo può riprodurre il proprio codice sorgente sotto forma di stringa, ma è anche in grado di analizzare e interpretare correttamente la lingua in cui è scritto.

Per renderlo leggermente meno follemente difficile, ti è permesso usare solo un sottoinsieme (completo di Turing) della lingua scelta. Così, se il programma è scritto in Python e funziona solo se il mio programma contiene solo ifs e whileloop e operazioni di stringa di base, allora questo è OK fino a quando il programma utilizza solo le cose troppo. (Ciò significa che non devi preoccuparti di implementare l'intera libreria standard della tua lingua scelta!) Tuttavia, il tuo programma deve effettivamente funzionare - non puoi semplicemente inventare la tua lingua.

Questo è un concorso di popolarità , quindi vince la risposta con il maggior numero di voti. Tuttavia, come accennato in precedenza, è una vera sfida solo per soddisfare le specifiche, quindi assegnerò un premio di 500 punti alla prima risposta che lo fa secondo il mio giudizio.

per favore nota: senza dubbio ci sono molti modi in cui puoi "imbrogliare" in questa sfida, date le parole esatte che ho usato. Tuttavia, sto davvero sperando in risposte che entrino nello spirito della domanda. La sfida, come previsto, è molto difficile ma possibile, e spero davvero di vedere soluzioni autentiche. Non assegnerò la generosità a una risposta che mi sembra pesante nel mio giudizio.

_{Nota: questa sfida è stata originariamente pubblicata come concorso di popolarità , ma è stata chiusa nel 2016 perché non aveva un "criterio vincente obiettivo" e l'ho cambiata in code-golf per riaprirla. Tuttavia, ho scoperto che, a partire da gennaio 2018, i contest di popolarità non sono in realtà vietati su PPCG ( essendo questa la meta-discussione più recente), quindi chiuderlo in primo luogo era contro la politica del sito. Capisco che i popcon non sono popolari in questi giorni, ma questa è una vecchia sfida, e la sua natura lo rende davvero inadatto per il code-golfsistema di punteggio. Se qualcuno sente ancora fermamente che non dovrebbe essere permesso, allora facciamo una meta discussione prima che i voti ravvicinati inizino a essere lanciati. Infine, nel caso in cui qualcuno abbia trascorso l'ultimo anno a tentare di giocare a golf la propria soluzione, sii certo che sarà altrettanto competitivo in questa sfida e altrettanto degno della generosità, come sarebbe stato nel code-golf versione.}

brainfuck , 6013 4877 4376 byte

Modifica: -1136 byte. Passato a un modo migliore di generare i dati per il quine

Modifica2: -501 byte. Ho rivisitato il mio interprete personale e l'ho ridotto di un paio di centinaia di byte

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

Provalo online! L'input qui è un semplice programma cat (,[.,]) che stamperà il programma stesso.

"Return 0" viene definito terminando il programma su una cella con valore 0.

Una scellerata combinazione di due programmi che ho scritto in passato, un quine e un interprete di sé. La prima sezione è la parte quine, che prende i dati e popola il nastro con la generazione dei dati seguita dal codice sorgente. Il prossimo è l'auto-interprete, che prende il tuo programma e lo esegue. Questa è praticamente una copia invariata di un normale interprete automatico, tranne per il fatto che invece di prendere direttamente l'input, ottiene l'input dall'inizio della sezione dati, impostando la cella su 0 se non c'è più input. Infine, termina sulla cella corrente del programma ed esegui []. Se il valore restituito era 0, il mio programma terminerà su zero. Se è qualcos'altro, eseguirà un ciclo infinito. Se il tuo programma funziona per sempre,il mio programma funzionerà per sempre.

Come funziona:

Parte 1: generazione di dati

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

Questa parte costituisce la sezione dati del quine ed è di gran lunga la maggior parte del codice a 3270 byte. L'inizio -è un marcatore per l'inizio dei dati. Ciascuno >+++rappresenta un carattere del codice dopo questa sezione.

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

Parte 2: genera la sezione dati utilizzando i dati

+[<+]>

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

Questo utilizza i dati della prima parte per aggiungere i caratteri utilizzati per generare i dati nella sezione del codice. Aggiunge un >alla fine della sezione di codice e il valore di quella cella molti vantaggi.

Parte 3: genera il resto del codice utilizzando i dati

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

Distrugge la sezione dati e aggiunge il resto del codice sorgente alla sezione codice

Parte 4: Ottieni il programma inserito

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

Ottiene il programma inserito. Rimuove i caratteri non bloccati e rappresenta ogni personaggio con un numero:

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

Rappresenta la fine del programma con 255.

Parte 5: interpretazione dell'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
    [+<<->>]>
]

Interpreta il programma. L'unica differenza rispetto a una normale è che l'input è preso dall'inizio della sezione di codice anziché l'input.

Parte 6: interrompere se il ritorno non è 0

>>[]

Passa alla cella finale del programma ed esegui un ciclo infinito se il ritorno non è 0. Se è 0, esci dal ciclo e termina sullo stesso 0.

Ingressi di prova:

Restituisce sempre 0 (si arresta e restituisce 0)

(empty program)

Restituisce sempre 1 (funziona per sempre)

+

Restituisce tutti gli input aggiunti insieme, mod 256 (restituisce 211, quindi funziona per sempre)

,[[->+<],]>

Restituisce 0 se gli ultimi due caratteri di un codice sono un ciclo infinito ( []) (il tuo programma restituisce 0 quando viene dato il mio programma , quindi il mio programma si ferma)

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

Fatto divertente per coloro che stanno ancora leggendo

Se l'input per questo programma è il codice sorgente di questo programma, allora ricomincerà a ripetersi, creando ripetutamente auto-interpreti che eseguono questo programma e poi gli restituiranno lo stesso programma. Questo mi dà alcune idee interessanti sulla creazione di programmi ricorsivi reali in brainfuck. Invece di verificare il valore restituito e avviare un ciclo infinito come in questa domanda, è possibile salvare e agire sul valore restituito. Un semplice esempio sarebbe un programma fattoriale che va

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

Naturalmente, questo è un modo completamente folle di codificare Brainfuck, dato che l'esecuzione di auto-interpreti ricorrenti aumenterà il tempo di esecuzione in modo esponenziale.