Componha dois programas Brainfuck

10

Dado dois trechos de código brainfuck Ae B, imprima algum código de brainfuck Cque tenha o mesmo comportamento de executar Bcom a entrada do Aresultado s. Observe que Cdeve funcionar para qualquer entrada que corresponda às seguintes suposições, como se fosse fornecida A.

Você pode assumir:

  1. Entrada finita.
  2. ambos A e B param.
  3. O EOF é consistentemente 0 ou consistentemente -1.
  4. Consistentemente permitir ou não permitir que células saiam
  5. Fita não ligada (caso contrário, o requisito pode ser impossível)
  6. Quebra consistente de 8 bits ou número inteiro ilimitado
  7. Nenhum fluxo (entrada ou saída para A ou B) contém o byte representando o EOF
  8. Os códigos A e B podem conter caracteres que possivelmente aparecem no seu C e +-[]<>,.

Por exemplo (EOF = 0)

A = ,[..,]
B = ,[...,]
C = ,[......,]

A = >,[>,]<[.<]
B = ,[...,]
C = >>>>,[[-<+<+<+>>>]>>>,]<<<<[.<]

A = >,[>,]<[.<]
B = ,[...,]
C = >,[>,]<[...<]

A = ,.
B = ,.
C = ,>,[,]<.

A = ,.
B = ,.
C = ,.

são testes válidos

O código mais curto em cada idioma vence. O vencedor em Brainfuck será aceito.

code-golf  code-generation  brainfuck 
— l4m2
fonte
7
Shortest code in each language wine Shortest Brainfuck solution will be acceptedsão dois critérios de vitória diferentes.
— Mego
2
@Mego eu quis dizer se você responder em brainfuck e você ganhar, você está aceito
— l4m2
11
Além disso. você pode elaborar 4.Consistently allow or disallow cells to left. A resposta principal requer que as células à esquerda na resposta funcionem, mas não permite que A, B e C não se movam além do primeiro byte. As linhas de resposta das minhas respostas movem-se para a esquerda nas respostas A, B e C. Se as regras para o meu programa e C puderem ser diferentes de A e B, então certamente posso reduzir muito minha resposta.
— 21418 Sylwester
11
A declaração completa do problema é sobre A, B e C, e apenas as duas últimas frases fazem qualquer referência ao idioma da resposta. Talvez o autor pretendesse que a resposta tivesse o mesmo sabor que A, B e C, mas isso não seria culpa minha. Os solventes não devem ser punidos pela falta de previsão dos autores do problema. De qualquer forma, é realmente trivial adicionar alguns >s ao início da minha resposta para torná-la compatível com um sabor mais restritivo (mas, para o golfe, também devemos considerar alternativas). Além disso, parece-me claro que A, B e C devem ter o mesmo sabor que o outro.
— 22718 Mitch
11
Talvez eu esteja entendendo completamente o desafio, mas os casos de teste 3 e 4 parecem colidir.
— James

Respostas:

8

brainfuck, 526 bytes

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

Formatado:

-<+++++<+<+++++<-[+++++++[<++++++++>-]<--->>]
<<--<--<+..<<<<
,
[
  [<+> >+<-]
  ----[>-<----]>
  [
    not question mark
    +
    [
      not greater than
      ++
      [
        not less than
        ++++++++++++++
        [
          not period
          ++
          [
            not comma
            [-]<
          ]
          <<<
          [
            comma B
            >-->>> -.>>>.<<<.>.>.<<.+>>--..>.<..<.>.>..<++.<.>..>.<..<.>--.>>.<<
            .>.<..<.>.>.<.<.>++.<<.>.>.>.<.<.>..>.<..<.>>>.<<--.++<<<
          ]
          >>>>[<]<
        ]
        >
        [
          period
          <<<<
          [
            B
            >
          ]
          >
          [
            A
            +>>> >>.>.<<<.>.<.>>>.<.[.<.>>>]<++[<<.<.>>.<<--.<<.>.>.++>>>-]<<<<.
            >.>>.<.<<<.>>..>>.<<<.>--.>.<++...<<.>>--..>>.<.<..<.>.>>.<<++...>.<
            ..<.>>>.<<--...++<<[.>]<<<--.<<.>>++.<.>>>.<<--.++<<<
          ]
        ]
        <
      ]
      >
      [
        less than
        <<<.>>
      ]
      <
    ]
    >
    [
      greater than
      >>.>.<<<.>.>>>.[<]
    ]
    <
  ]
  >
  [
    question mark
    >>.>.<..<.>>>.[<]
    <<<+>->>
  ]
  <<.[-]>,
]

Com relação a A, B e C: EOF = 0, as células restantes do início não permitiram as células de quebra de 8 bits.

Espera A ?seguido por B.

Experimente online

(Essa resposta pode ser compatível com um intérprete de cérebro que não permite sair do início com o custo de um byte, transliterando y/<>/></e acrescentando a >.)

A idéia básica é usar uma série de substituições de cadeias para simular as fitas de A e B usando nós de duas células, com atenção especial à substituição .de A e ,B para que o fluxo de dados intermediário seja mantido em um bloco de células à esquerda da fita simulada. O esquema de substituição de cadeia é:

  • Inserir >>antes de A

  • Em A e B, substitua >por >[-]+>e <por<<

  • Em A, substitua .por>[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[+<->]+</

  • Inserir >[>>]+>após A e antes de B

  • Em B, substitua ,por,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+<*

— Mitch Schwartz
fonte
,[>,]<[.<]?,[...,]12345retorno de entrada 111, mesmo com o suficiente >antes?
— L4m2
@ l4m2 Hmm, está funcionando para mim no TIO . ( ,[>,]<[.<]Não é válido, mas >,[>,]<[.<]é.)
— Mitch Schwartz
Então, qual é o seu "permite ir para a esquerda da célula inicial"?
— L4m2
11
Portanto, sua resposta precisa de um BF que comece no meio de uma fita infinita, mas a natureza de A e B é limitada ao padrão em que se inicia na primeira célula de uma fita infinita à direita?
— 21418 Sylwester
11
Para esta solução, ir para a esquerda da célula inicial não é permitido em A, B e C, mas é permitido no programa (podemos chamá-lo de D por conveniência) que pega A e B e depois produz C. acho que isso é muito notável e é uma escolha natural, dada a natureza da solução. Ir para a esquerda do início tem grandes conseqüências no contexto de A, B e C, mas é bastante trivial para D e, subjetivamente, proporciona uma experiência de golfe mais agradável, além de uma pontuação um pouco menor, e também não deve resultar testando mais tedioso, pois é fácil acrescentar >s a D, conforme necessário.
— 22718 Mitch
6

brainfuck , 1287 bytes

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

Experimente online!

Aqui está! O código do cérebro que compõe dois códigos do cérebro. Use um "!" para separar os dois trechos de código de entrada. Por exemplo fragmento A: >,[>,]<[.<], fragmento B: ,[...,]. Input para o meu programa: >,[>,]<[.<]!,[...,]. Não terminará se não houver "!" seja encontrado.

Isso faz essencialmente o mesmo que minha versão do VBA. O código gerado é o mesmo da versão do VBA (observe que os exemplos na postagem do VBA foram feitos antes da alteração mais recente nos trechos do cérebro).

Explicação

Este é o meu código fonte:

[ 
Tape: "+"(43) "-"(45) "<"(60) ">"(62) "["(91) "]"(93) readA(1) printInput(0) input else exitIf exitElse
]

++++ ++++ ++++ ++++ [->+++>+++>++++>++++>++++++>++++++<<<<<<]>----->--->---->-->----->--->+

<<<.....<<.>>....<<.>>.<<..>... print init routine
>>>>[                           while readA
  >+                              set printInput = true
  >,                              read character
  ->[-]++++[-<-------->]          decrease input by 33 to check for "!"
  +                               set else flag

  # A check for "!"
  <[                              if input not "!"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <-                              set readA = false
    <<<..>.<.....>>.<<<.....>>.<<<< print routine between A and B
    .>>..>>.<<<.>>>>.<<<...>>>.<<.<
    <<..>>>>.<<<..>>.....<<<..>>>>>
    .<<<<<.>>>>.<<<.>.....<<.>>>>>.
    <<<<.>>..>>>
    >>>>>                           go to exitElse
  ]

  # A check for "dot"
  <<<----- ----- ---              decrease input by 13 (total 46) to check for dot
  [                               if input not dot
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<..<<.>..>>.<<<.>.<<.>>>.... print list storing routine
    <<<.>>>>.<<<.>.....<<.>>>>>.<<<
    <<.>>>>.<<<..>>.....<<<..>>>>>.
    <<<<..>..<<.>>>..<<<.>>>>.<<<.>
    .....<<.>>>>>.<<<<.>.<<..>>>>.<
    <<..>>.....<<<..>>>>>.<<<<..>..
    >>>.<<<.>>.<<<.>>.<<<.>>.>>>.<<
    ....<<<.>>>>.<<<.>.....<<.>>>>>
    .<<<<<.>>>>.<<<..>>.....<<<..>>
    >>>.<<.....<<.>>>.<<<.>.....<<.
    >>>>>.<<<<.>.<<..>>>>.<<<..>>..
    ...<<<..>>>>>.<<<<.>..>>>>>
    >>>>                            go to exitElse
  ]

  # A check for "less than"
  <<<----- ----- ----             decrease input by 14 (total 60) to check for "less than"
  [                               if input not "less than"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<<...>>.<<<<.>>>>>.<<<<.>..>>>>> print A move left routine
    >>>>                            go to exitElse
  ]

  # A check for "greater than"
  <<<--                           decrease input by 2 (total 62) to check for "greater than"
  [                               if input not "greater than"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<.......>.<<<<.>>>>>.<<<<.>..>>>>> print A move right routine
    >>>>                            go to exitElse
  ]

  # print remaining character
  <<<<[                           if printInput
    +++++++[->++++++++<]>--.<     print original character
  ]

<                               go to readA
]

>>,                             read next character
[                               while input
  <+                              set printInput = true

  # B check for comma
  >>++++[-<----- ---->]+<+        decrement input by 44 to check for comma
  [                               if input not comma
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<.<<<.>>>>.<<..<<.>>.>.<..... print B list reading routine
    >>.<<<<<.>>>>.<<<.>.....<<.>>>>
    >.<<<<.>>...>.<<<.>...>>.<<....
    .>>>.<<....<<<.>>>>.<<<.>>.....
    <<<.>>>>>.<<<<.>..<<.>>>...>.<.
    ....>>.<<<<<.>>>>.<<<.>.....<<.
    >>>>>.<<<<.>>...>>.<<..<<.>>>.<
    <.....>>>.<<....<<<.>>>>.<<<.>>
    .....<<<.>>>>>.<<<..>>>>> 
    >>>>                            go to exitElse
  ]

  # B check for "less than"
  <<<----- ----- ----- -          decrease input by 16 (total 60) to check for "less than"
  [                               if input not "less than"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<<.....>>>>>                 print B move left routine
    >>>>                            go to exitElse
  ]

  # B check for "greater than"
  <<<--                           decrease input by 2 (total 62) to check for "greater than"
  [                               if input not "greater than"
    >>                              go to exitIf
  ]
  >[                              else
    <<-                             set printInput = false
    <<<<.....>>>>                   print B move right routine
    >>>>                            go to exitElse
  ]

  # print remaining character
  <<<<[                           if printInput
    +++++++[->++++++++<]>--.<     print original character
  ]

>,                              input next character
]
— Dorian
fonte
11
— L4m2 19/07/19
@ l4m2: Desculpe, cometi um pequeno erro nos dados de teste. Eu escrevi >[,>]<[.<]!,[...,], então o trecho A não produz nada. Claro que deve ser >,[>,]<[.<]!,[...,]um exemplo de trabalho.
— 197 Dorian
5

VBA, 512 489 479 bytes

Sub f(A,B):Debug.?">>>>>->>>>->--<<<"&Replace(Replace(Replace(A,"<","<<<[+]-<<"),">",">>>>>>>[+]-<<"),".",">>-<<[-<+>>>>+[-<<<<<+]+[-->>>>>++]--<<+>>+[-<<<<<+]-<++[-->>>>>++]--<<]<[->+<]>>>>+[-<<<<<+]+[-->>>>>++]>>>>>-[-<<<<<+]-<++[-->>>>>++]-<<")&">>[>>>>>]<<<<<[+<<[-]<<<]>++[-->>>>>++]+[-<<<<<+]->>"&Replace(Replace(Replace(B,"<","<<<<<"),">",">>>>>"),",","[-]>>->[>>>>>]+[-<<<<<+]->>>[-<<<[<<<<<]>>>>+[->>>>>+]-<<+>>>[>>>>>]+[-<<<<<+]->>>]>>-[<<<<<]>>>>+[->>>>>+]<<"):End Sub

Explicação

O código VBA altera o código do cérebro de uma maneira, para que a saída do trecho A seja armazenada em uma lista e a entrada do trecho B seja lida nessa lista.

Inicializa algumas variáveis 

>>>>>->>>>->--<<<

Em seguida, ele lê trecho de A e substitui todos <por <<<[+]-<<, cada >por >>>>>>>[+]-<<e cada .pela rotina de armazenamento

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

depois disso, ele exclui a memória do trecho A e faz alterações na lista armazenada, para que possa ser lido como entrada para o trecho B:

>>[>>>>>]<<<<<[+<<[-]<<<]>++[-->>>>>++]+[-<<<<<+]->>>>>-<<<

O trecho B será lido, todos <serão substituídos por <<<<<, todos >serão substituídos por >>>>>e todos ,serão substituídos pela rotina de leitura da lista:

[-]>>->[>>>>>]+[-<<<<<+]->>>[-<<<[<<<<<]>>>>+[->>>>>+]-<<+>>>[>>>>>]+[-<<<<<+]->>>]>>-[<<<<<]>>>>+[->>>>>+]<<

Código fonte do Brainfuck

Esta é a minha fonte para as partes do código do cérebro. Vou explicar isso em detalhes mais tarde.

[
Tape: tempMem data out/in dataAnchors outAnchors (all repeating)
dataAnchors of Snippet A: -1 = memory has been used, -2 = active memory cell for copying to out/in
dataAnchors of Snippet B: -1 = active memory cell for copying from out/in
outAnchors of Snippet A: -1 = start of list, -2 = next output position
outAnchors of Snippet B: -1 = character has been read (or start of input)
]

### Init
>>              two blank data cells (for non wrapping pointer)
>>>-            set start of input
>> >>-          set first "used" flag
>--             set end of input
<<<             return to first usable data cell

### A move right routine
>>>>>           move to the next data cell
>>[+]-          clear and set "used" flag
<<              return to data cell

### A move left routine
<<<[+]-         clear and set "used" flag of previous data cell
<<              go to data cell

### A print routine
>>-             set flag
<<[             while value greater 0
  -               decrement value
  <+              increment tempMem
  >>>>+[-<<<<<+]  find start of input
  +[-->>>>>++]--  find end of input
  <<+             increment input
  >>+[-<<<<<+]-   find start of input
  <++[-->>>>>++]--find flag
  <<              go to active data cell
]
<[->+<]         move stored value back to data
>>>>+[-<<<<<+]  find start of input
+[-->>>>>++]    find end of input
>>>>>-          set new end of input
[-<<<<<+]-      return to start of input
<++[-->>>>>++]- return to and delete data flag
<<              go to data cell

### After snippet A: Delete memory of A and configure out/in list
>>[>>>>>]<<<<< go to last used data
[+<<[-]<<<]    delete each data
>++[-->>>>>++] find and delete end of input flag
+[-<<<<<+]-    go to start of input
>>             go to first data cell

### B move right routine
>>>>>          go to next data cell

### B move left routine
<<<<<          go to previous data cell

### B reading routine
[-]                      set cell = 0
>>-                      set flag
>[>>>>>]+[-<<<<<+]-      find start of input
>>>[                     if value greater 0
  -                        decrement value
  <<<[<<<<<]>>>>           go to initial start of input (combined with next)
  +[->>>>>+]-              find mem cell flag
  <<+                      increment mem cell
  >>>[>>>>>]+[-<<<<<+]->>> return to input cell
]
>>-                      set new start of input
[<<<<<]>>>>              go to initial start of input (combined with next)
+[->>>>>+]               find and delete mem cell flag
<<                       go to mem cell

Saída para o caso de teste 1: f ",[..,]",",[...,]"

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

Experimente online!

Saída para o caso de teste 2: f ">,[>,]<[.<]",",[...,]"

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

Experimente online!

Saída para o caso de teste 3: f ",.",",."

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

Experimente online!

Caso de teste complexo: Trecho A: Construa um triângulo do alfabeto >+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<] Experimente on-line!

Snippet B: classifique a entrada em ordem crescente >>,[>>,]<<[[-<+<]>[>[>>]<[.[-]<[[>>+<<-]<]>>]>]<<] Experimente on-line!

Resultado:

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

Experimente online!

— Dorian
fonte
Obrigado. Eu sei que isso é praticamente não-destruído. Eu só queria fornecer o primeiro código de trabalho. Também fará alterações na parte cerebral do código.
— Dorian
5

Brainfuck , 785 bytes

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

Experimente online!

Para separar A do BI, optou por /.

Explicação:

O código real que gera esta é apenas uma leitura em malha com uma bandeira de A / B e um interruptor que reduz a entrada para procurar >, <, /, ,, e .e de outro modo apenas de saída da entrada. Na verdade, é apenas um transpilador em que o código transpilado vive dentro de uma estrutura de dados para que não interfira nos dados armazenados de A ou entre si. O /apenas move a célula ativa para a primeira célula não utilizada. Eu o limpei originalmente, mas isso aumenta o programa e a saída.

O resultado do programa possui o seguinte modelo de memória:

|0|input*|cz|d0|c0|d2|c0|...

O cé desmoronar. czé sempre 0Ele indica onde está o ponteiro nos meus dados BF emulados. O valor ativo é -1, enquanto todas as células visitadas terão 1. Em operações como aprinte breadalgumas ctêm um significado especial.

A impressão de código A pula todas as células de 1 byte para deixar espaço para mais uma entrada de byte, que é copiada com um backup nos próximos bytes que se desintegram para copiar novamente.

A leitura do código B busca a entrada da entrada. Aqui ser destrutivo é bom e quando você "lê" o último byte, obtém 0 como EOF, independentemente da implementação.

Comecei como código Extended BrainFuck , resultando em EBF. A maior parte da depuração foi realizada nos arquivos de resultado e, em seguida, é atualizada na fonte que o gerou. Então, eu apenas executo as operações de forma independente para obter a saída BF, mas notei a resposta de Dorian, que me durou muito, então continuei jogando a fonte EBF para obter uma saída BF menor. A fonte original é bastante legível e simples em comparação com outras coisas que fiz com ela:

:bck
:i
:t
:z
:r
:rc
:rz

;;; outputs a header with most of the result logic
{cinit
  |"
    ;; memory model of the result 
    ML/i/z/d/c
    PTR=1/1/2
    :iz:i:z:d:c:d2:c2

    ;; moves pointer back. Bad things will happen to 
    ;; A output if out of bounds
    {backward @d2 $c2++ $c-- $d
    }

    ;; moves pointer forward
    {forward $c++ $c2[-]- $d2 @d
    }

    ;; stores the current cell in input a the start of bf data
    {aprint
      $c2(-)+                 ; mark next cell as used even if it maybe
      $c[$c2]                 ; go to the end of used data
      $c((->+)$d(->+)@d2)     ; as long as c is something move d and c one place right
      @i$c+[->>+]@c           ; go to active cell, zero it
      $d(-                    ; copy: 
        $c2+                  ; backup in c2 
        $z[<<]@z              ; back to i
        $i+ $c[>>]@c          ; increement and back to zero carry
      )
      $c2-(- $d+)+            ; copy backup in c2 back to d
      $c-                     ; mark active cell
      $d                      ; move to d
    }

    ;; removes all the data from A. And initializes for B
    {aend
      $c[$c2]
      $c((-)<(-)<@c)@z
      $c-$d
    }

    ;; instead of read b fetched from input area
    {bread
      (-)>+@c2          ; clear d and c
      $c[$z]            ; go to z
      $i<[<] @iz        ; go to iz
      $i(-$iz+)         ; switch places between i and iz
      $iz(-             ; copy from iz to d
         $z[>]@z        ; move to z
         $c[$c2]        ; move to the current c 
         $d2+           ; increase d
         $c[$z]         ; back to z
         $i[$iz]        ; back to iz
         @i             ; but since we shave switched correct
      )
      $z[>]@z           ; go back to z
      $c[$c2]-          ; move to active cell and make it -1
      $d2 @d            ; go to d
    }

    $c-$d               ; init. Go to c t mark it active, then go to d
    "
  (-)
}

{cmain
  &cinit
  $t,(
    (-$i+$bck+) ; pour to i and bck

    ;; switch ( $i ) cases '<>,./' using $t
    $t+++++++(-$i------)+$i--; ,
    ($i--; .
      ($i-; /
        ($i-------------; <
          ($i--; >
            ((-) $t(-)  $bck.)
              $t (- |"&forward "(-) )
          ) $t (- |"&backward "(-) )
        ) $t (- |"&aend "(-) $r+ )
      ) $t (- $rc+$r[$rc-$bck.$rc]@r$rc[- |"&aprint "(-) $rz])
    ) $t (- $rc+$r[$rc-|"&bread "(-)]@r$rc[-$bck.$rz])
    $bck (-) ; clear backup
      $t,    ; read into t
  )
}

&cmain
— Sylwester
fonte
Se eu entendi corretamente, [->+]no programa C causa falha para entradas como ->->,./,., e isso pode ser corrigido usando [->>+](certificando-se de que o ponteiro inicie em uma célula com a paridade desejada). Pois [-<+], acho que você pode alterar o esquema de navegação para depender de toda a saída de A ser diferente de zero?
— 22718 Mitch
Não sei bem o que você quer dizer. Quando A é ->->,.e B é ,., seu intérprete preferido produz o mesmo C do TIO e C funciona conforme o esperado no seu intérprete? Porque falha no TIO . (Eu escrevi isso em resposta a um comentário que agora é excluído.)
— Mitch Schwartz
@MitchSchwartz Obrigado pelo seu comentário. Eu estava um pouco convencido, já que não esperava procurar -1dados do usuário, mas na verdade fiz na linha "ir para a célula ativa, zerá-la". Atualizei minha resposta e adicionei um byte: -O, mas pelo menos funciona. Entre. Se eu não estiver usando o scan para -1quando buscar entrada em B, terei que mover o byte ativo com uma cópia >[-<+]<e, portanto, adicionarei mais caracteres do que pouparei, substituindo +[-<+]-por [<]. Se você não copiar, não poderá saber se o byte que você compôs foi finalizado e copiar todos os bytes.
— 19418 Sylwester
Bem, minha menção [-<+]foi na verdade também em relação à eliminação de bugs (em vez de salvar bytes), para entradas como -./,>++++++[<++++++>-]<., que devem ser impressas em #vez de %. :) Mas vejo algumas oportunidades para salvar bytes também. Boa sorte! Tentarei otimizar minha solução de fita duplamente infinita, embora ver o que você fez me faça pensar que talvez a fita infinita à direita seja mais golfista no final.
— 22718 Mitch
Então, depois de examinar seu código mais de perto, descobri que nossas configurações são muito semelhantes e que o uso de uma fita infinita à direita é muito melhor para o golfe do que a minha fita duplamente infinita. Consulte minha recente atualização sed para uma solução que combine nossas idéias. Eu sinto que golfe C é a parte mais interessante deste problema, mas há também algum espaço para fazer o programa de substituição de cadeia mais curta fora dessa ...
— Mitch Schwartz
4

sed, 165 bytes

s > >[-]+> g
s < << g
1s \. >[-]-R+[[>+<-]<[>+<-]<]>+[->>+]<[>+>>-<L+>R+<<<-]>[<+>-]+< g
1s .* R&<R+> 
2s , ,[,]>,<L[[>]R<+L[<]>-]>[>]R+< g
s L <[<<]< g
s R >>[>>] g

Para sabores com EOF = 0, as células restantes do início não permitiram as células de quebra de 8 bits.

Espera o programa A na primeira linha e B na segunda linha.

Experimente online

Isso usa nós de duas células para simular as fitas de A e B, com a saída de A ocupando células contíguas à esquerda do nó mais à esquerda.

Solução alternativa de 173 bytes:

1i>>
s > >[-]+> g
s < << g
1s \. >[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[<+>-]+< g
1a>[>>]+>
2s , ,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+< g

Experimente online

Originalmente, meu design era baseado em uma fita duplamente infinita, que exigia muito mais trabalho para mover para a esquerda (mover dados ao ultrapassar a célula mais à esquerda encontrada anteriormente) e fazer a transição de A para B (limpar os dados em vez de apenas passar pela célula à direita) encontrado anteriormente).

Obrigado a Sylwester e Dorian pelos truques e idéias.

— Mitch Schwartz
fonte
Isso parece ótimo. Infelizmente, ele falha no primeiro teste. Programa A ,[..,]e B do programa ,[...,].
— Dorian
Oh, isso é uma supervisão tola da minha parte, eu me apressei demais. É corrigível, mas devo excluí-lo por enquanto.
— 22718 Mitch
@Dorian Deve ser corrigido agora. (Vou continuar examinando.) Obrigado por apontar o erro e desculpe pelo inconveniente.
— 22418 Mitch
Estou ciente de que alguns bytes podem ser salvos, por exemplo, tendo s/x/>>/gno final, mas estou mais interessado em melhorias que reduzirão a saída no momento.
— 22718 Mitch
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.