Составьте две программы Brainfuck

10

Имея 2 фрагмента кода brainfuck Aи B, выведите некоторый код brainfuck, Cкоторый работает так же, как работает Bс вводом Aрезультата s. Обратите внимание, что это Cдолжно работать для любого ввода, который соответствует следующим предположениям, как если бы он был дан A.

Вы можете предположить:

  1. Конечный ввод.
  2. и A и B останавливаются.
  3. EOF постоянно 0 или последовательно -1.
  4. Последовательно разрешать или запрещать клетки слева
  5. Неограниченная лента (в противном случае требование может быть невозможно)
  6. Последовательное 8-битное упаковывание или неограниченное целое число
  7. Ни один поток (вход или выход для A или B) не содержит байта, представляющего EOF
  8. Код A и B могут содержать символы, которые возможно появляются в вашем C, и +-[]<>,.

Например (EOF = 0)

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

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

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

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

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

действительные тесты

Самый короткий код на каждом языке победит. Победитель в Brainfuck будет принят.

code-golf code-generation brainfuck l4m2
источник
7
Shortest code in each language winи Shortest Brainfuck solution will be acceptedдва разных критерия выигрыша.
Мего
2
@Mego Я имел в виду, если ты отвечаешь в мозге и выигрываешь, тебя принимают
l4m2
1
Также. не могли бы вы уточнить 4.Consistently allow or disallow cells to left. Ведущий ответ требует, чтобы ячейки слева в ответе работали, но запрещали A, B и C не перемещаться мимо первого байта. В ответах A, B и C. мои ответные индикаторы перемещаются влево. Если правила для моей программы и C могут отличаться от A и B, то я, безусловно, могу значительно сократить свой ответ.
Сильвестр
1
Все постановка задачи касается A, B и C, и только последние два предложения содержат ссылку на язык ответа. Возможно, автор действительно хотел, чтобы ответ был таким же, как у A, B и C, но это не моя вина. Решатели не должны быть наказаны за недостаток предвидения авторов проблемы. Во всяком случае, очень просто добавить несколько >секунд в начало моего ответа, чтобы он соответствовал более ограниченному аромату (но для гольфа мы должны также рассмотреть альтернативы). Кроме того, мне кажется, что A, B и C должны быть одинакового вкуса друг с другом.
Митч Шварц
1
Может быть, я совершенно не понимаю проблему, но контрольные примеры № 3 и № 4, кажется, конфликтуют.
Джеймс

Ответы:

8

брейкфук, 526 байт

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

отформатирован:

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

Что касается A, B и C: EOF = 0, ячейки слева от начала не разрешены, 8-битные ячейки переноса.

Ожидает А, а ?затем Б.

Попробуйте онлайн

(Этот ответ можно сделать совместимым с интерпретатором «мозгового потрясения», который не позволяет перейти влево от старта за счет одного байта путем транслитерации y/<>/></и добавления а >).

Основная идея состоит в том, чтобы использовать серию замен строк, чтобы смоделировать ленты A и B, используя 2-ячеечные узлы, при этом особое внимание уделяется замене .в A и ,B, чтобы промежуточный поток данных сохранялся в блоке ячейки слева от моделируемой ленты. Схема замены строки:

  • Вставить >>перед А

  • В А и В, замените >с >[-]+>и <с<<

  • В А заменить .на>[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[+<->]+</

  • Вставить >[>>]+>после A и до B

  • В B заменить ,на,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+<*

Митч Шварц
источник
,[>,]<[.<]?,[...,]вход 12345возвращает 111, даже если достаточно >раньше?
l4m2
@ l4m2 Хм, это работает для меня на TIO . ( ,[>,]<[.<]не действителен, но >,[>,]<[.<]есть.)
Митч Шварц
Так какое у вас "это позволяет идти слева от стартовой ячейки"?
14 м2, 18
1
Таким образом, ваш ответ нуждается в BF, который начинается в середине бесконечной ленты, но природа A и B ограничена стандартом, где каждый начинается с первой ячейки на бесконечной ленте справа?
Сильвестр
1
Для этого решения переход слева от начальной ячейки запрещен в A, B и C, но это разрешено в программе (мы можем назвать это D для удобства), которая принимает A и B и затем производит C. Я не понимаю Не думаю, что это очень замечательно, и это естественный выбор, учитывая характер решения. Движение влево от старта имеет серьезные последствия в отношении A, B и C, но это довольно тривиально для D, и субъективно дает более приятный опыт игры в гольф, а также немного более короткий счет, и также не должно делать тестирование более утомительно, так как при необходимости легко добавлять >s к D.
Митч Шварц
6

брейкфук , 1287 байт

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

Попробуйте онлайн!

Вот! Код брейкфук, который составляет два кода брейкфук. Использовать "!" разделить два фрагмента входного кода. Например , сниппета A: >,[>,]<[.<], фрагмент B: ,[...,]. Вход для моей программы: >,[>,]<[.<]!,[...,]. Не прекратится, если нет "!" найден.

По сути, это то же самое, что и моя версия VBA. Сгенерированный код такой же, как и в версии VBA (обратите внимание, что примеры в посте VBA были сделаны до последнего изменения во фрагментах мозгового меха).

объяснение

Это мой исходный код:

[ 
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
]
Дориан
источник
1
Почему нет выхода?
м2
@ l4m2: Извините, я сделал небольшую ошибку в данных испытаний. Я написал >[,>]<[.<]!,[...,], поэтому фрагмент А ничего не выводит. Конечно, это должно быть >,[>,]<[.<]!,[...,]для рабочего примера.
Дориан
5

VBA, 512 489 479 байт

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

объяснение

Код VBA изменяет код brainfuck таким образом, что вывод фрагмента A будет сохранен в списке, а ввод фрагмента B будет считан из этого списка.

Сначала инициализирует некоторые переменные 

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

Затем он читает фрагмент A и заменяет каждый <на <<<[+]-<<, каждый >на >>>>>>>[+]-<<каждый .процедурой хранения

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

после этого он удаляет память фрагмента A и вносит изменения в сохраненный список, чтобы его можно было прочитать как ввод для фрагмента B:

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

Затем будет прочитан фрагмент B, каждый <будет заменен на <<<<<, каждый >будет заменен на >>>>>и каждый ,будет заменен процедурой чтения списка:

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

Brainfuck исходный код

Это мой источник фрагментов кода. Я объясню это подробно позже.

[
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

Выход для тестового примера 1: f ",[..,]",",[...,]"

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

Попробуйте онлайн!

Выход для тестового примера 2: f ">,[>,]<[.<]",",[...,]"

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

Попробуйте онлайн!

Выход для тестового примера 3: f ",.",",."

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

Попробуйте онлайн!

Сложный тестовый пример: фрагмент A: создайте алфавитный треугольник >+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<] Попробуйте онлайн!

Фрагмент кода B: сортировка ввода по возрастанию. >>,[>>,]<<[[-<+<]>[>[>>]<[.[-]<[[>>+<<-]<]>>]>]<<] Попробуйте онлайн!

Результат:

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

Попробуйте онлайн!

Дориан
источник
Спасибо. Я знаю, что это в значительной степени ungolfed. Я просто хотел предоставить первый рабочий код. Будут внесены изменения и в часть кода.
Дориан
5

Brainfuck , 785 байт

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

Попробуйте онлайн!

Чтобы разделить A от BI выбрал /.

Explaination:

Фактический код , который генерирует это только для чтения цикла с флагом для A / B и переключатель , который уменьшает вход для поиска >, <, /, ,, и .и в противном случае просто выходной вход. На самом деле это просто транспортер, в котором переносимый код находится внутри структуры данных, так что он не мешает сохраненным данным из A или друг друга. /Просто перемещает активную ячейку в первую неиспользуемую ячейку. Первоначально я очистил его, но это делает программу и вывод больше.

Результат программы имеет следующую модель памяти:

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

cЯвляется покрошить. czВсегда 0указывает, где в моих эмулированных данных BF указатель. Активное значение -1, в то время как все посещенные ячейки будут иметь 1. В операциях вроде aprintи breadнекоторые cприобретают особое значение.

Печать A-кода пропускает все ячейки на 1 байт, чтобы освободить место для ввода еще одного байта, который копируется, а резервная копия в следующих байтах рушится и копируется обратно.

Чтение B-кода извлекает ввод из ввода. Здесь деструктивно нормально, и когда вы «читаете» последний байт, вы получаете 0 как EOF независимо от реализации.

Я начинал как расширенный код BrainFuck, дающий результат EBF. Большая часть отладки выполнялась в файлах результатов, а затем обновлялась в источнике, который его сгенерировал. Затем я просто выполнял операции независимо, чтобы получить вывод BF, но я заметил ответ Дориана, который побил меня по длине, поэтому я продолжил игру с источником EBF для уменьшения выхода BF. Исходный код довольно читабелен и прост по сравнению с другими материалами, которые я сделал с ним:

: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
Сильвестер
источник
Если я правильно понял, [->+]в программе C происходит сбой для таких входов, как ->->,./,., и это можно исправить с помощью [->>+](убедившись, что указатель начинается на ячейке с желаемой четностью). Потому что [-<+], я думаю, вы можете изменить схему навигации, чтобы полагаться на все выходные данные А, отличные от нуля?
Митч Шварц
Я не уверен, что ты имеешь в виду. Когда A есть, ->->,.а B есть ,., выдает ли ваш предпочитаемый переводчик тот же C, что и TIO, и работает ли C так, как ожидается на вашем переводчике? Потому что это терпит неудачу на TIO . (Я написал это в ответ на комментарий, который сейчас удален.)
Митч Шварц
@MitchSchwartz Спасибо за ваш комментарий. Я был немного дерзким, так как не ожидал, что проверю -1пользовательские данные, но на самом деле я сделал строку «перейти к активной ячейке, обнулить ее». Я обновил свой ответ, а затем добавил байт: -O, но по крайней мере это работает. КСТАТИ. Если я не использую сканирование для -1при получении ввода в B, мне придется переместить активный байт с копией, >[-<+]<и, таким образом, я добавляю больше символов, чем сохраняю, заменяя их +[-<+]-на [<]. Если вы не скопируете, вы не сможете узнать, был ли завершен созданный вами байт, и скопировать все байты.
Сильвестр
Ну, мое упоминание [-<+]было на самом деле также в отношении устранения ошибок (в отличие от сохранения байтов), для ввода, например -./,>++++++[<++++++>-]<., который должен печатать, #а не %. :) Но я также вижу некоторые возможности для экономии байтов. Удачи! Я постараюсь оптимизировать мое решение с двойной бесконечностью ленты, хотя, смотря на то, что вы сделали, я думаю, что, возможно, правильная бесконечная лента в конечном итоге более удачна.
Митч Шварц
Итак, после более тщательного изучения вашего кода я обнаружил, что наши настройки очень похожи, и что использование правильной бесконечной ленты гораздо лучше для гольфа, чем моя дважды бесконечная лента. Пожалуйста, смотрите мое недавнее обновление sed для решения, которое объединяет наши идеи. Я чувствую, что игра в гольф C является наиболее интересной частью этой проблемы, но есть также возможность сократить программу замены струн за пределами этого ...
Митч Шварц
4

sed, 165 байт

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

Для ароматов с EOF = 0 ячейки слева от начала не разрешены, 8-битные оберточные ячейки.

Ожидается программа A в первой строке и B во второй строке.

Попробуйте онлайн

При этом используются 2-ячеечные узлы для имитации лент А и В, а выход А занимает непрерывные ячейки слева от самого левого узла.

Альтернативное 173-байтовое решение:

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

Попробуйте онлайн

Первоначально мой дизайн был основан на вдвойне бесконечной ленте, которая требовала значительно больше работы для перемещения влево (перемещение данных при прохождении за крайнюю левую ячейку, с которой встречались ранее) и перехода от A к B (очистка данных вместо простого прохождения мимо самой правой ячейки ранее встречался).

Спасибо Сильвестру и Дориану за трюки и идеи.

Митч Шварц
источник
Это выглядит великолепно. К сожалению, это не сработало в первом тесте. Программа A ,[..,]и B программы ,[...,].
Дориан
О, это глупый упущение с моей стороны, я слишком торопился. Это поправимо, но я должен удалить это пока.
Митч Шварц
@ Дориан Это должно быть исправлено сейчас. (Я буду продолжать его осматривать.) Спасибо, что указали на ошибку, и извините за неудобства.
Митч Шварц
Я знаю, что некоторые байты могут быть сохранены, например, s/x/>>/gв самом конце, но меня больше интересуют улучшения, которые пока сократят вывод.
Митч Шварц