Tenga en cuenta: por su naturaleza, las especificaciones para este desafío son difíciles de entender. Probablemente requiere al menos un curso de primer año en teoría de la computabilidad, o una lectura de fondo equivalente. Además, el desafío en sí es bastante difícil. Para contestarla, deberá escribir un intérprete completo para un subconjunto de su idioma de elección, y no solo eso, sino que el intérprete tendrá que tener la forma de una especie de quine. Si su respuesta no está haciendo todo esto, es casi seguro que no cumpla con las especificaciones.

No necesita resolver el problema de detención (incluso parcialmente) para resolver este desafío. Sin embargo, es casi seguro que necesite escribir un intérprete (del idioma que está usando, escrito en el mismo idioma que interpreta), aunque no es necesario que esté completo. Es esto lo que hace de este un desafío interesante.

Prometí otorgar una recompensa de 500 puntos a la primera respuesta que cumpla con las especificaciones, y esto se otorgará a la respuesta BF de Jo King .

El reto

Una versión aproximada y simplificada de la prueba de Alan Turing de la insolubilidad del problema de detención es algo así:

Supongamos que he escrito un programa Fdestinado a resolver el programa de detención. Es decir, Ftoma el código fuente de otro programa como entrada, y F(G)se supone que devuelve 1si se Gdetiene, y de lo 0contrario.

Pero si le doy mi programa, Fentonces puede construir otro programa Hque ejecute mi programa Hcomo entrada. Si F(H)regresa, 0entonces Hregresa 0, pero de lo contrario entra deliberadamente en un bucle infinito. Esto lleva a una paradoja, y tenemos que concluir que Fno puede resolver el problema de detención después de todo.

Su tarea es escribir el programa H, pero con un giro: no voy a darle mi programa. En cambio, su programa recibirá el código fuente de mi programa como entrada. Es decir:

• Su programa recibirá mi programa como entrada, en forma de código fuente. (Por ejemplo, como un archivo o como entrada de línea de comando, los detalles dependen de usted).

• Mi programa se escribirá en el mismo idioma que su programa, y ​​también recibe información en forma de una cadena de código fuente.

• Si mi programa regresa 0cuando se le da su programa como entrada, su programa debería detenerse (y regresar 0) cuando se le da mi programa como entrada. (El significado exacto de "retroceder 0" depende de usted).

• Si mi programa no se detiene, o si devuelve algo que no sea 0cuando se le dio su programa como entrada, su programa debería seguir ejecutándose indefinidamente.

El giro es que, solo para hacerlo mucho más difícil, debes obedecer las siguientes reglas:

1. No puede utilizar ningún tipo de función incorporada execo de evaltipo.

2. No puede utilizar ningún método de "trampa" para obtener el código fuente de su propio programa. (Por ejemplo, no puede decir "guardar esto en un archivo llamado 'programa'" y luego tenerlo open(program)en su programa).

Esto significa que su programa tiene que ser algún tipo de súper quine loco que no solo puede reproducir su propio código fuente en forma de cadena, sino que también es capaz de analizar e interpretar correctamente el lenguaje en el que está escrito.

Para hacerlo un poco menos increíblemente difícil, puede usar solo un subconjunto (completo de Turing) de su idioma elegido. Entonces, si su programa está escrito en Python y solo funcionará si mi programa solo contiene ifs y whilebucles y operaciones básicas de cadena, entonces está bien siempre que su programa solo use esas cosas también. (¡Esto significa que no tiene que preocuparse por implementar la biblioteca estándar completa de su idioma elegido!) Sin embargo, su programa realmente tiene que ejecutarse: no puede inventar su propio idioma.

Este es un concurso de popularidad , por lo que gana la respuesta con más votos. Sin embargo, como se mencionó anteriormente, es un gran desafío solo cumplir con las especificaciones, por lo que otorgaré una recompensa de 500 puntos a la primera respuesta que lo haga de acuerdo a mi juicio.

tenga en cuenta: sin duda, hay muchas formas en que puede "engañar" en este desafío, dada la redacción exacta que he usado. Sin embargo, realmente espero respuestas que entren en el espíritu de la pregunta. El desafío según lo previsto es muy difícil pero posible, y realmente espero ver soluciones genuinas para él. No otorgaré la recompensa a una respuesta que me parezca engañosa a mi juicio.

_{Nota: este desafío se publicó originalmente como un concurso de popularidad , pero se cerró en 2016 debido a que no tenía un "criterio de objetivo ganador", y lo cambié a código de golf para reabrirlo. Sin embargo, descubrí que, a partir de enero de 2018, los concursos de popularidad no están prohibidos en PPCG (siendo esta la meta discusión más reciente), por lo que cerrarlo en primer lugar fue contrario a la política del sitio. Entiendo que los popcons no son populares en estos días, pero este es un viejo desafío, y su naturaleza lo hace realmente inadecuado para el código de golfsistema de puntuación. Si alguien todavía siente firmemente que no debería permitirse, entonces tengamos una meta discusión antes de que se empiecen a emitir votos cerrados. Finalmente, en el caso de que alguien haya pasado el último año intentando jugar golf su solución, tenga la seguridad de que será tan competitivo en este desafío y tan digno de la recompensa, como lo habría sido en el código golf. versión.}

brainfuck , 6013 4877 4376 bytes

Editar: -1136 bytes. Se cambió a una mejor forma de generar los datos para la quine

Edit2: -501 bytes. Volví a visitar mi autointerpretador y lo reduje a un par de cientos de bytes.

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

Pruébalo en línea! La entrada aquí es un simple programa cat (,[.,]) que imprimirá el programa en sí.

El "retorno 0" se define al finalizar el programa en una celda con valor 0.

Una combinación impía de dos programas que he escrito en el pasado, un quine y un auto-intérprete. La primera sección es la parte quine, que toma los datos y llena la cinta con la generación de datos seguida del código fuente. El siguiente es el autointerpretador, que toma su programa y lo ejecuta. Esto es más o menos una copia sin cambios de un autointerpretador normal, excepto que en lugar de recibir información directamente, obtiene información desde el comienzo de la sección de datos, configurando la celda a 0 si no hay más información. Finalmente, finalice en la celda actual de su programa y ejecútelo []. Si el valor devuelto fue 0, mi programa finalizará en cero. Si es algo más, ejecutará un bucle infinito. Si su programa se ejecuta para siempre,Mi programa se ejecutará para siempre.

Cómo funciona:

Parte 1: generación de datos

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

Esta parte constituye la sección de datos de la quine, y es, con mucho, la mayoría del código en 3270 bytes. El comienzo -es un marcador para el comienzo de los datos. Cada uno >+++representa un carácter del código después de esta sección.

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

Parte 2: generar la sección de datos utilizando los datos

+[<+]>

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

Esto utiliza los datos de la primera parte para agregar los caracteres que se utilizan para generar los datos a la sección de código. Agrega una >al final de la sección de código y el valor de esa celda tiene muchas más ventajas.

Parte 3: generar el resto del código utilizando los datos

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

Destruye la sección de datos y agrega el resto del código fuente a la sección de código.

Parte 4: Obtenga un programa ingresado

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

Obtiene el programa ingresado. Elimina los personajes que no son una mierda mental y representa cada personaje con un número:

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

Representa el final del programa con 255.

Parte 5: Interpretar la entrada

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 el programa. La única diferencia con respecto a una normal es que la entrada se toma desde el comienzo de la sección de código en lugar de la entrada.

Parte 6: Detener si el retorno no es 0

>>[]

Navegue a la celda final de su programa y ejecute un ciclo infinito si el retorno no es 0. Si es 0, salga del ciclo y termine en ese mismo 0.

Entradas de prueba:

Siempre devuelve 0 (se detiene y devuelve 0)

(empty program)

Siempre devuelve 1 (se ejecuta para siempre)

+

Devuelve todas las entradas agregadas juntas, mod 256 (devuelve 211, por lo que se ejecuta para siempre)

,[[->+<],]>

Devuelve 0 si los dos últimos caracteres de un código son un bucle infinito ( []) ( su programa devuelve 0 cuando se le da mi programa , por lo tanto, mi programa se detiene)

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

Dato curioso para aquellos que todavía están leyendo

Si la entrada para este programa es el código fuente de este programa, comenzará a recurrir, creando repetidamente autointerpretadores que ejecutan este programa y luego le dan el mismo programa nuevamente. Esto me da algunas ideas interesantes sobre la creación de programas recursivos reales en brainfuck. En lugar de verificar el valor de retorno y comenzar un ciclo infinito como en esta pregunta, el valor de retorno se puede guardar y actuar sobre él. Un ejemplo simple sería un programa factorial que 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

Por supuesto, esta es una forma completamente loca de codificar brainfuck, dado que ejecutar autointerpretadores recurrentes aumentará el tiempo de ejecución exponencialmente.