Observe: por sua natureza, as especificações para este desafio são difíceis de entender. Provavelmente requer pelo menos um curso de calouro em teoria da computabilidade ou leitura equivalente em segundo plano. Além disso, o desafio em si é bastante difícil. Para respondê-lo, será necessário escrever um intérprete inteiro para algum subconjunto do seu idioma de escolha, e não apenas isso, mas o intérprete terá que estar na forma de algo como um quine. Se sua resposta não estiver fazendo tudo isso, é quase certo que não atenda às especificações.

Você não precisa resolver o problema da parada (mesmo que parcialmente) para resolver esse desafio. No entanto, você quase certamente fazer necessidade de escrever um intérprete (do idioma que você está usando, escrito na mesma língua que interpreta), embora ele não precisa ser completo de recursos. É isso que faz deste um desafio interessante.

Prometi conceder uma recompensa de 500 pontos à primeira resposta que atenda às especificações, e isso será concedido à resposta BF de Jo King .

O desafio

Uma versão aproximada e simplificada da prova de Alan Turing da insolubilidade do problema da parada é mais ou menos assim:

Suponha que eu escrevi um programa Fque visa solucionar o programa de interrupção. Ou seja, Fusa o código fonte de outro programa como entrada e F(G)deve retornar 1se for Ginterrompido ou 0não.

Mas se eu lhe der meu programa F, você poderá construir outro programa H, que executa o meu programa Hcomo entrada. Se F(H)retorna, 0então Hretorna 0, mas, caso contrário, deliberadamente entra em um loop infinito. Isso leva a um paradoxo, e temos que concluir que, Fafinal, não podemos resolver o problema da parada.

Sua tarefa é escrever o programa H, mas com uma reviravolta: não vou lhe dar meu programa. Em vez disso, seu programa receberá o código-fonte do meu programa como uma entrada. Isso é:

• Seu programa receberá meu programa como uma entrada, no formato de código-fonte. (Por exemplo, como um arquivo ou como entrada da linha de comando, os detalhes são com você.)

• Meu programa será escrito no mesmo idioma do seu programa e também recebe entradas na forma de uma sequência de código-fonte.

• Se meu programa retorna 0quando dado o seu programa como entrada, seu programa deve parar (e regresso 0) quando dado o meu programa como entrada. (O significado exato de "returing 0" é com você.)

• Se meu programa não parar, ou se ele retorna outra coisa senão 0quando dado o seu programa como entrada, seu programa deve continuar funcionando indefinidamente.

A desvantagem é que, só para tornar as coisas muito mais difíceis, você deve obedecer às seguintes regras:

1. Você não pode usar nenhum tipo de função interna execou de evaltipo.

2. Você não pode usar nenhum método de "trapaça" para obter o código-fonte do seu próprio programa. (Por exemplo, você não pode dizer "salve isso em um arquivo chamado 'programa'" e, em seguida, coloque-o open(program)em seu programa.)

Isso significa que seu programa deve ser algum tipo de superquino louco que não apenas pode reproduzir seu próprio código-fonte na forma de uma string, mas também é capaz de analisar e interpretar corretamente o idioma em que está escrito.

Para torná-lo um pouco menos insanamente difícil, você pode usar apenas um subconjunto (completo de Turing) do idioma escolhido. Portanto, se o seu programa for escrito em Python e só funcionará se o meu programa contiver apenas ifs e whileloops e operações básicas de string, tudo bem se o seu programa também usar essas coisas também. (Isso significa que você não precisa se preocupar em implementar toda a biblioteca padrão do idioma escolhido!) No entanto, seu programa precisa ser executado de verdade - você não pode simplesmente criar seu próprio idioma.

Este é um concurso de popularidade , então a resposta com mais votos vence. No entanto, como mencionado acima, é um sério desafio apenas atender às especificações, portanto atribuirei uma recompensa de 500 pontos à primeira resposta que fizer isso de acordo com meu julgamento.

observe: sem dúvida, existem muitas maneiras de "enganar" esse desafio, dada a redação exata que eu usei. No entanto, estou realmente esperando por respostas que entrem no espírito da pergunta. O desafio pretendido é muito difícil, mas possível, e espero realmente encontrar soluções genuínas. Não concederei a recompensa a uma resposta que pareça barata no meu julgamento.

_{Nota: este desafio foi originalmente publicado como concurso de popularidade , mas foi encerrado em 2016 por não ter um "critério de vitória objetivo", e eu o mudei para code-golf para reabrir. No entanto, descobri que, a partir de janeiro de 2018, os concursos de popularidade não são de fato proibidos no PPCG (com essa é a meta-discussão mais recente), portanto, fechá-lo em primeiro lugar foi contra a política do site. Entendo que os popcons não são populares atualmente, mas esse é um desafio antigo e sua natureza o torna realmente inadequado para o código-golfeSistema de pontuação. Se alguém ainda acha que isso não deveria ser permitido, vamos ter uma meta-discussão antes de começar a votação. Finalmente, com a chance de alguém passar o último ano tentando jogar com sua solução, tenha certeza de que será tão competitivo nesse desafio e tão merecedor da recompensa, como teria sido no código-golfe versão.}

brainfuck , 6013 4877 4376 bytes

Editar: -1136 bytes. Mudou para uma maneira melhor de gerar os dados para o quine

Edit2: -501 bytes. Revisitei meu auto-intérprete e reduzi-o algumas centenas de bytes

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

Experimente online! A entrada aqui é um programa simples (,[.,]) que imprime o programa em si.

"Retorno 0" é definido finalizando o programa em uma célula com o valor 0.

Uma combinação profana de dois programas que escrevi no passado, um quine e um auto-intérprete. A primeira seção é a parte quine, que pega os dados e preenche a fita com a geração de dados seguida pelo código fonte. A seguir, é o auto-intérprete, que pega seu programa e o executa. Essa é praticamente uma cópia inalterada de um auto-intérprete normal, exceto que, em vez de receber diretamente a entrada, ela recebe entrada desde o início da seção de dados, configurando a célula para 0 se não houver mais entrada. Finalmente, termine na célula atual do seu programa e execute []. Se o valor retornado for 0, meu programa terminará em zero. Se houver qualquer outra coisa, ele executará um loop infinito. Se seu programa for executado para sempre,meu programa será executado para sempre.

Como funciona:

Parte 1: Geração de Dados

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

Esta parte compõe a seção de dados do quine e é de longe a maioria do código em 3270 bytes. O início -é um marcador para o início dos dados. Cada >+++um representa um caractere do código após esta seção.

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

Parte 2: Gere a seção de dados usando os dados

+[<+]>

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

Isso usa os dados da parte um para adicionar os caracteres usados ​​para gerar os dados na seção de código. Ele adiciona um >ao final da seção de código e o valor dessa célula muitas vantagens.

Parte 3: Gere o restante do código usando os dados

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

Destrói a seção de dados e adiciona o restante do código-fonte à seção de código

Parte 4: Obter programa inserido

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

Obtém o programa inserido. Remove caracteres que não fazem cérebro e representam cada caractere com um número:

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

Representa o final do programa com 255.

Parte 5: Interpretando a 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 o programa. A única diferença de uma normal é que a entrada é obtida desde o início da seção de código em vez da entrada.

Parte 6: Pare se o retorno não for 0

>>[]

Navegue até a célula final do seu programa e execute um loop infinito se o retorno não for 0. Se for 0, saia do loop e termine no mesmo 0.

Entradas de teste:

Sempre retorna 0 (pára e retorna 0)

(empty program)

Sempre retorna 1 (executa para sempre)

+

Retorna todas as entradas adicionadas juntas, mod 256 (retorna 211, para que funcione para sempre)

,[[->+<],]>

Retorna 0 se os dois últimos caracteres de um código forem um loop infinito ( []) ( seu programa retornará 0 quando receber meu programa , portanto, meu programa será interrompido)

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

Curiosidade para quem ainda está lendo

Se a entrada para este programa for o código fonte desse programa, ele começará a se repetir, criando repetidamente auto-intérpretes que executam esse programa e, em seguida, oferecem o mesmo programa novamente. Isso me dá algumas idéias interessantes sobre a criação de programas recursivos reais no cérebro. Em vez de verificar o valor de retorno e iniciar um loop infinito como nesta pergunta, o valor de retorno pode ser salvo e acionado. Um exemplo simples seria um programa fatorial que vai

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

Obviamente, essa é uma maneira completamente insana de codificar o cérebro, já que executar auto-intérpretes recorrentes aumentará exponencialmente o tempo de execução.