Componga dos programas de Brainfuck

10

Dada 2 fragmentos de código brainfuck Ay B, de salida de algún código brainfuck Cque tiene el mismo comportamiento que se ejecuta Bcon la entrada del Aresultado s. Tenga en cuenta que Cdebe funcionar para cualquier entrada que coincida con los siguientes supuestos, como si se le hubiera dado A.

Puedes asumir:

  1. Entrada finita.
  2. tanto A como B se detienen.
  3. EOF es consistentemente 0 o consistentemente -1.
  4. Permitir o rechazar constantemente las celdas a la izquierda
  5. Cinta sin límites (de lo contrario, el requisito puede ser imposible)
  6. Constantemente envoltura de 8 bits o entero ilimitado
  7. Ninguna secuencia (entrada o salida para A o B) contiene el byte que representa EOF
  8. Los códigos A y B pueden contener caracteres que posiblemente aparezcan en su C, y +-[]<>,.

Por ejemplo (EOF = 0)

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

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

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

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

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

son pruebas válidas

El código más corto en cada idioma gana. El ganador en Brainfuck será aceptado.

code-golf  code-generation  brainfuck 
— l4m2
fuente
77
Shortest code in each language winy Shortest Brainfuck solution will be acceptedson dos criterios ganadores diferentes.
— Mego
2
@Mego, quise decir que si respondes en un ataque mental y ganas, eres aceptado
— l4m2
1
También. ¿Puedes dar más detalles 4.Consistently allow or disallow cells to left? La respuesta inicial requiere que las celdas de la izquierda en la respuesta funcionen, pero no permita que A, B y C no se muevan pasado el primer byte. Mis diallows de respuesta se mueven hacia la izquierda en la respuesta, A, B y C. Si las reglas para mi programa y C pueden ser diferentes de A y B, entonces seguramente puedo acortar mucho mi respuesta.
— Sylwester
1
Todo el enunciado del problema es sobre A, B y C, y solo las dos últimas oraciones hacen referencia al lenguaje de la respuesta. Quizás el autor tenía la intención de que la respuesta tuviera el mismo sabor que A, B y C, pero eso no sería mi culpa. Los solucionadores no deben ser castigados por la falta de previsión de los autores del problema. En cualquier caso, es realmente trivial agregar algunos >segundos al comienzo de mi respuesta para que cumpla con un sabor más restrictivo (pero para el golf, también deberíamos considerar alternativas). Además, me parece claro que A, B y C deben tener el mismo sabor entre sí.
— Mitch Schwartz
1
Tal vez estoy entendiendo completamente mal el desafío, pero los casos de prueba # 3 y # 4 parecen chocar.
— James

Respuestas:

8

brainfuck, 526 bytes

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

Formateado:

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

Con respecto a A, B y C: EOF = 0, las celdas a la izquierda del inicio no están permitidas, celdas de envoltura de 8 bits.

Espera A seguido de ?seguido de B.

Pruébalo en línea

(Esta respuesta se puede hacer compatible con un intérprete de brainfuck que no permite ir a la izquierda desde el principio a costa de un byte al transcribir y/<>/></y anteponer a >).

La idea básica es utilizar una serie de reemplazos de cadenas para simular las cintas de A y B utilizando nodos de 2 celdas, con especial atención a la sustitución .en A y ,en B para que el flujo de datos intermedio se mantenga en un bloque de celdas a la izquierda de la cinta simulada. El esquema de reemplazo de cadenas es:

  • Insertar >>antes de A

  • En A y B, reemplace >con >[-]+>y <con<<

  • En A, reemplace .con>[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[+<->]+</

  • Insertar >[>>]+>después de A y antes de B

  • En B, reemplace ,con,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+<*

— Mitch Schwartz
fuente
,[>,]<[.<]?,[...,]la entrada 12345vuelve 111, incluso con suficiente >antes?
— l4m2
@ l4m2 Hmm, está funcionando para mí en TIO . ( ,[>,]<[.<]no es válido pero lo >,[>,]<[.<]es)
— Mitch Schwartz
Entonces, ¿cuál es su "permite ir a la izquierda de la celda de inicio"?
— l4m2
1
Entonces, ¿su respuesta necesita un BF que comience en el medio de una cinta infinita, pero la naturaleza de A y B se limita al estándar donde uno comienza en la primera celda en una cinta infinita a la derecha?
— Sylwester
1
Para esta solución, no se permite ir a la izquierda de la celda de inicio en A, B y C, pero está permitido en el programa (podemos llamarlo D por conveniencia) que toma A y B y luego produce C. No creo que esto sea muy notable, y es una elección natural dada la naturaleza de la solución. Ir a la izquierda del inicio tiene consecuencias importantes en el contexto de A, B y C, pero es bastante trivial para D, y subjetivamente lo convierte en una experiencia de golf más agradable, así como un puntaje ligeramente más corto, y tampoco debería prueba más tediosa, ya que es fácil anteponer >s a D según sea necesario.
— Mitch Schwartz
6

brainfuck , 1287 bytes

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

Pruébalo en línea!

¡Aquí está! El código brainfuck que compone dos códigos brainfuck. Utilizar un "!" para separar los dos fragmentos de código de entrada. Por ejemplo fragmento A: >,[>,]<[.<], snippet B: ,[...,]. Entrada para mi programa: >,[>,]<[.<]!,[...,]. No terminará si no "!" es encontrado.

Esto hace esencialmente lo mismo que mi versión de VBA. El código que se genera es el mismo que en la versión de VBA (tenga en cuenta que los ejemplos en la publicación de VBA se realizaron antes del último cambio en los fragmentos de brainfuck).

Explicación

Este es mi código fuente:

[ 
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
]
— dorio
fuente
1
— l4m2
@ l4m2: Lo siento, cometí un pequeño error en los datos de prueba. Escribí >[,>]<[.<]!,[...,], por lo que el fragmento A no genera nada. Por supuesto, debe ser >,[>,]<[.<]!,[...,]para un ejemplo de trabajo.
— Dorian
5

VBA, 512 489 479 bytes

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

Explicación

El código VBA cambia el código de brainfuck de una manera, que la salida del fragmento A se almacenará en una lista y la entrada del fragmento B se leerá de esa lista.

Primero inicializa algunas variables 

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

Luego lee el fragmento A y reemplaza cada <por <<<[+]-<<, cada >por >>>>>>>[+]-<<y cada .por la rutina de almacenamiento

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

después de eso, elimina la memoria del fragmento A y realiza cambios en la lista almacenada, por lo que puede leerse como entrada para el fragmento B:

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

Luego se leerá el fragmento B, <se reemplazará por <<<<<cada >, se reemplazará por >>>>>cada y ,se reemplazará por la rutina de lectura de la lista:

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

Código fuente de Brainfuck

Esta es mi fuente para las porciones de cerebro del código. Explicaré eso en detalle más adelante.

[
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

Salida para el caso de prueba 1: f ",[..,]",",[...,]"

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

Pruébalo en línea!

Salida para el caso de prueba 2: f ">,[>,]<[.<]",",[...,]"

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

Pruébalo en línea!

Salida para el caso de prueba 3: f ",.",",."

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

Pruébalo en línea!

Caso de prueba complejo: Fragmento A: Construir triángulo alfabético ¡ >+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<] Pruébelo en línea!

Fragmento B: orden de entrada en orden ascendente ¡ >>,[>>,]<<[[-<+<]>[>[>>]<[.[-]<[[>>+<<-]<]>>]>]<<] Pruébelo en línea!

Resultado:

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

Pruébalo en línea!

— dorio
fuente
Gracias. Sé que esto es bastante poco golfista. Solo quería proporcionar el primer código de trabajo. También hará cambios en la parte del código del brainfuck.
— Dorian
5

Brainfuck , 785 bytes

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

Pruébalo en línea!

Para dividir A de BI optó por /.

Explicación:

El código real que genera esto es sólo una lectura de circuito con una bandera para A / B y un interruptor que reduce la entrada a buscar >, <, /, ,, y ., y de lo contrario sólo la salida de la entrada. En realidad, es solo un transpilador donde el código transpilado vive dentro de una estructura de datos para que no interfiera con los datos almacenados de A o entre sí. El /solo mueve la celda activa a la primera celda no utilizada. Originalmente lo limpié, pero eso hace que el programa y la salida sean más grandes.

El resultado del programa tiene el siguiente modelo de memoria:

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

El cse desmorona. czsiempre 0señala dónde se encuentra el puntero en mis datos BF emulados. El valor activo es -1 mientras que todas las celdas visitadas tendrán 1. En operaciones como aprinty breadalgunas ctienen un significado especial.

La impresión de código A omite todas las celdas de 1 byte para dejar espacio para una entrada de byte más, que es copias con una copia de seguridad en el siguiente desmoronamiento de bytes para volver a copiar.

La lectura del código B obtiene la entrada de la entrada. Aquí ser destructivo está bien y cuando "lees" el último byte obtienes 0 como EOF independientemente de la implementación.

Comencé como código extendido BrainFuck haciendo resultado EBF. La mayor parte de la depuración se realizó en los archivos de resultados y luego se actualizó a la fuente que lo generó. Luego simplemente ejecuté las operaciones de forma independiente para obtener la salida de BF, pero noté la respuesta de Dorian, que me ganó mucho tiempo, así que seguí jugando al golf con la fuente de EBF para una salida de BF más pequeña. La fuente original es bastante legible y simple en comparación con otras cosas que he hecho con ella:

: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
fuente
Si lo he entendido correctamente, [->+]en el programa C se produce un error para entradas como ->->,./,., y esto podría solucionarse utilizando [->>+](asegurándose de que el puntero se inicia en una celda con la paridad deseada). Porque [-<+], ¿creo que puedes cambiar el esquema de navegación para que todas las salidas de A sean distintas de cero?
— Mitch Schwartz
No estoy seguro de lo que quieres decir. Cuando A es ->->,.y B es ,., ¿su intérprete preferido produce la misma C que TIO, y C funciona como se espera en su intérprete? Porque falla en TIO . (Escribí esto en respuesta a un comentario que ahora se elimina.)
— Mitch Schwartz
@ MitchSchwartz Gracias por tu comentario. Estaba un poco engreído ya que no esperaba escanear -1los datos del usuario, pero de hecho lo hice en la línea "ir a la celda activa, ponerlo a cero". He actualizado mi respuesta y luego agregué un byte: -O pero al menos funciona. Por cierto. Si no estoy usando para la exploración -1al cual se deben recuperar de entrada en B voy a tener que mover el byte activo con una copia >[-<+]<y por lo tanto añadir más caracteres de lo que se ahorra al sustituir +[-<+]-con [<]. Si no copia, no podrá saber si el byte que compiló se terminó y copie todos los bytes.
— Sylwester
Bueno, mi mención de en [-<+]realidad también se refería a la eliminación de errores (en lugar de guardar bytes), para entradas como -./,>++++++[<++++++>-]<., que deberían imprimirse en #lugar de %. :) Pero también veo algunas oportunidades para guardar bytes. ¡Buena suerte! Trataré de optimizar mi solución de cinta doblemente infinita, aunque ver lo que hiciste me hace pensar que tal vez la cinta derecha-infinita es más golfista al final.
— Mitch Schwartz
Entonces, después de examinar su código más de cerca, descubrí que nuestras configuraciones son muy similares, y que el uso de una cinta derecha-infinita es mucho mejor para el golf que mi cinta doblemente infinita. Consulte mi reciente actualización de sed para obtener una solución que combine nuestras ideas. Siento que jugar al golf C es la parte más interesante de este problema, pero también hay espacio para acortar el programa de reemplazo de cuerdas fuera de eso ...
— 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 con EOF = 0, las celdas a la izquierda del inicio no están permitidas, celdas de envoltura de 8 bits.

Espera el programa A en la primera línea y B en la segunda línea.

Pruébalo en línea

Esto utiliza nodos de 2 celdas para simular las cintas de A y B, con la salida de A ocupando celdas contiguas a la izquierda del nodo más a la izquierda.

Solución alternativa de 173 bytes:

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

Pruébalo en línea

Originalmente, mi diseño se basaba en una cinta doblemente infinita, que requería mucho más trabajo para moverse hacia la izquierda (mover datos al pasar más allá de la celda más a la izquierda encontrada anteriormente) y pasar de A a B (borrar los datos en lugar de simplemente pasar por la celda más a la derecha previamente encontrado).

Gracias a Sylwester y Dorian por trucos e ideas.

— Mitch Schwartz
fuente
Esto se ve genial. Desafortunadamente falla en la primera prueba. Programa A ,[..,]y B del programa ,[...,].
— Dorian
Oh, esto es un descuido tonto de mi parte, me apresuré demasiado. Es reparable pero debería eliminarlo por ahora.
— Mitch Schwartz
@Dorian Debería arreglarse ahora. (Seguiré buscándolo.) Gracias por señalar el error y disculpe las molestias.
— Mitch Schwartz
Soy consciente de que algunos bytes se pueden guardar, por ejemplo, al tenerlos s/x/>>/gal final, pero estoy más interesado en las mejoras que acortarán la salida por ahora.
— Mitch Schwartz
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.