Skomponuj dwa programy Brainfuck

10

Biorąc pod uwagę 2 fragmenty kodu pieprzenia mózgu Ai Bwypisz trochę kodu pieprzenia mózgu, Cktóry zachowuje się tak samo, jak uruchamianie Bz wejściem Awyniku s. Zauważ, że Cmusi działać dla wszystkich danych wejściowych, które pasują do następujących założeń, tak jakby je podano A.

Możesz założyć:

  1. Skończone dane wejściowe.
  2. zatrzymują się zarówno A, jak i B.
  3. EOF jest konsekwentnie 0 lub konsekwentnie -1.
  4. Konsekwentnie zezwól lub nie zezwól komórkom na opuszczenie
  5. Nieograniczona taśma (w przeciwnym razie wymaganie może być niemożliwe)
  6. Konsekwentnie 8-bitowe zawijanie lub nieograniczona liczba całkowita
  7. Żaden strumień (wejściowy lub wyjściowy dla A lub B) nie zawiera bajtu reprezentującego EOF
  8. Kod A i B mogą zawierać znaki, które prawdopodobnie występują w twoim C, i +-[]<>,.

Np. (EOF = 0)

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

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

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

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

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

są ważnymi testami

Najkrótszy kod w każdym języku wygrywa. Zwycięzca w Brainfuck zostanie przyjęty.

code-golf  code-generation  brainfuck 
— l4m2
źródło
7
Shortest code in each language wini Shortest Brainfuck solution will be acceptedsą dwoma różnymi kryteriami wygranej.
— Mego
2
@Mego mi chodziło jeśli odpowiesz w brainfuck i wygrasz, masz akceptowane
— l4m2
1
Również. można rozwinąć 4.Consistently allow or disallow cells to left. Odpowiedź wiodąca wymaga, aby komórki po lewej stronie w odpowiedzi działały, ale nie zezwalaj, aby A, B i C nie poruszały się po pierwszym bajcie. Moje diody odpowiedzi przesuwają się w lewo w odpowiedzi A, B i C. Jeśli reguły mojego programu i C mogą różnić się od A i B, to z pewnością mogę znacznie skrócić moją odpowiedź.
— Sylwester
1
Całe stwierdzenie problemu dotyczy A, B i C. Tylko dwa ostatnie zdania odnoszą się do języka odpowiedzi. Być może autor chciał, aby odpowiedź była tego samego smaku co A, B i C, ale to nie byłaby moja wina. Rozwiązania nie powinny być karane za brak przewidywania autorów problemów. W każdym razie, naprawdę trywialne jest dodanie kilku >s na początku mojej odpowiedzi, aby dostosować ją do bardziej restrykcyjnego smaku (ale w golfa powinniśmy również rozważyć alternatywy). Wydaje mi się również jasne, że A, B i C muszą mieć ten sam smak.
— Mitch Schwartz
1
Może zupełnie nie rozumiem wyzwania, ale przypadki testowe 3 i 4 wydają się kolidować.
— James

Odpowiedzi:

8

pieprzenie mózgu, 526 bajtów

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

Sformatowany:

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

W odniesieniu do A, B i C: EOF = 0, komórki pozostawione od początku są niedozwolone, 8-bitowe zawijanie komórek.

Oczekuje A, a ?następnie B.

Wypróbuj online

(Ta odpowiedź może być zgodna z tłumaczem, który nie pozwala y/<>/></odejść od początku kosztem jednego bajta przez transliterację i przygotowanie a >.)

Podstawową ideą jest użycie szeregu zamian ciągów w celu symulacji taśm A i B za pomocą węzłów 2-komórkowych, ze szczególnym uwzględnieniem zamiany .w A i ,B, tak aby pośredni strumień danych był przechowywany w bloku komórki po lewej stronie symulowanej taśmy. Schemat zamiany łańcucha to:

  • Wstaw >>przed A

  • Zarówno A i B, wymienić >z >[-]+>oraz <z<<

  • W A, wymienić .z>[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[+<->]+</

  • Wstaw >[>>]+>po A i przed B

  • W B, wymienić ,z,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+<*

— Mitch Schwartz
źródło
,[>,]<[.<]?,[...,]12345zwraca dane wejściowe 111, nawet z wystarczającą ilością >wcześniej?
— l4m2
@ l4m2 Hmm, działa dla mnie na TIO . ( ,[>,]<[.<]nie jest ważny, ale >,[>,]<[.<]jest.)
— Mitch Schwartz
Więc jakie jest twoje „pozwala przejść na lewo od komórki początkowej”?
— l4m2
1
Więc twoja odpowiedź wymaga BF, który zaczyna się w środku nieskończonej taśmy, ale natura A i B jest ograniczona do standardu, w którym zaczyna się w pierwszej komórce na nieskończonej taśmie po prawej stronie?
— Sylwester
1
W przypadku tego rozwiązania przejście na lewo od komórki początkowej jest niedozwolone w A, B i C, ale jest dozwolone w programie (możemy nazwać to D dla wygody), który bierze A i B, a następnie produkuje C. Myślę, że jest to bardzo niezwykłe i jest to naturalny wybór, biorąc pod uwagę naturę rozwiązania. Przechodzenie na lewo od startu ma poważne konsekwencje w kontekście A, B i C, ale jest dość trywialne dla D i subiektywnie zapewnia przyjemniejsze wrażenia z gry w golfa, a także nieco krótszy wynik, a także nie powinno powodować testowanie bardziej nużących, ponieważ >w razie potrzeby łatwo jest przejść do D.
— Mitch Schwartz,
6

pieprzenie mózgu , 1287 bajtów

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

Wypróbuj online!

Oto jest! Kod pieprzenia mózgu, który składa się z dwóch kodów pieprzenia mózgu. Użyć "!" aby oddzielić dwa fragmenty kodu wejściowego. Dla Przykładowy fragment A: >,[>,]<[.<],, fragment B: ,[...,]. Wejście do mojego programu: >,[>,]<[.<]!,[...,]. Nie zakończy się, jeśli nie będzie „!” jest znaleziony.

To robi się zasadniczo tak samo jak moja wersja VBA. Generowany kod jest taki sam, jak w wersji VBA (pamiętaj, że przykłady w poście VBA zostały stworzone przed ostatnią zmianą fragmentów „skurwysynu”).

Wyjaśnienie

To jest mój kod źródłowy:

[ 
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
]
— dorycki
źródło
1
— l4m2
@ l4m2: Przepraszam, popełniłem mały błąd w danych testowych. Napisałem >[,>]<[.<]!,[...,], więc fragment A nic nie wyświetla. Oczywiście musi to być >,[>,]<[.<]!,[...,]przykład roboczy.
— Dorian,
5

VBA, 512 489 479 bajtów

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

Wyjaśnienie

Kod VBA zmienia kod pieprzenia mózgu w taki sposób, że dane wyjściowe fragmentu A zostaną zapisane na liście, a dane wejściowe fragmentu B zostaną odczytane z tej listy.

Najpierw inicjuje niektóre zmienne 

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

Następnie odczytuje fragment A i zastępuje każdy <przez <<<[+]-<<każdy >przez >>>>>>>[+]-<<i każdy .przez procedurę przechowującego

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

następnie usuwa pamięć fragmentu A i wprowadza zmiany do listy przechowywanej, dzięki czemu można go odczytać jako dane wejściowe fragmentu B:

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

Następnie zostanie odczytany fragment B, każdy <zostanie zastąpiony przez <<<<<, każdy >zostanie zastąpiony przez >>>>>i każdy ,zostanie zastąpiony procedurą odczytu listy:

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

Kod źródłowy Brainfuck

To jest moje źródło fragmentów kodu, które mają przerobić mózg. Wyjaśnię to szczegółowo później.

[
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

Dane wyjściowe dla przypadku testowego 1: f ",[..,]",",[...,]"

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

Wypróbuj online!

Dane wyjściowe dla przypadku testowego 2: f ">,[>,]<[.<]",",[...,]"

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

Wypróbuj online!

Dane wyjściowe dla przypadku testowego 3: f ",.",",."

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

Wypróbuj online!

Złożony przypadek testowy: Fragment A: Zbuduj trójkąt alfabetu >+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<] Wypróbuj online!

Snippet B: Sortuj dane wejściowe w porządku rosnącym >>,[>>,]<<[[-<+<]>[>[>>]<[.[-]<[[>>+<<-]<]>>]>]<<] Wypróbuj online!

Wynik:

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

Wypróbuj online!

— dorycki
źródło
Dziękuję Ci. Wiem, że jest to prawie nie golfa. Chciałem tylko podać pierwszy działający kod. Wprowadzi również zmiany w części pieprzenia mózgu.
— Dorian
5

Brainfuck , 785 bajtów

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

Wypróbuj online!

Zdecydowałem się na podział A z BI /.

Wyjaśnienie:

Rzeczywisty kod, który generuje ten jest tylko do odczytu pętla z flagą na A / B i przełącznikiem, który redukuje wejście do poszukiwania >, <, /, ,, i ., a inaczej po prostu wyjścia do wejścia. W rzeczywistości jest to po prostu transpiler, w którym transpilowany kod żyje w strukturze danych, dzięki czemu nie koliduje z przechowywanymi danymi od A lub siebie nawzajem. Po /prostu przenosi aktywną komórkę do pierwszej nieużywanej komórki. Pierwotnie go wyczyściłem, ale dzięki temu program i wyjście są większe.

Wynik programu ma następujący model pamięci:

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

cJest kruszonką. czjest zawsze 0Wskazuje, gdzie w moich emulowanych danych BF jest wskaźnik. Aktywna wartość wynosi -1, podczas gdy wszystkie odwiedzane komórki będą miały 1. W operacjach takich jak aprinti breadniektóre cmają specjalne znaczenie.

Wydruk kodu A pomija wszystkie komórki 1 bajt, aby zostawić miejsce na jeszcze jeden bajt wejściowy, czyli kopie z kopią zapasową w kolejnych bajtach kruszą się, aby je skopiować.

Odczyt kodu B pobiera dane wejściowe z wejścia. Bycie destrukcyjnym jest w porządku, a kiedy „czytasz” ostatni bajt, dostajesz 0 jako EOF niezależnie od implementacji.

Zacząłem jako kod Extended BrainFuck, dzięki czemu wynik EBF. Większość debugowania przeprowadzono na plikach wynikowych, a następnie zaktualizowano źródło, które je wygenerowało. Potem po prostu uruchamiam operacje niezależnie, aby uzyskać wyjście BF, ale zauważyłem odpowiedź Doriana, która mnie pobiła, więc kontynuowałem grę w źródło EBF dla mniejszych wyników BF. Oryginalne źródło jest dość czytelne i proste w porównaniu do innych rzeczy, które z nim zrobiłem:

: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
źródło
Jeśli dobrze zrozumiałem, [->+]w programie C powoduje awarię takich danych wejściowych ->->,./,.i można to naprawić za pomocą [->>+](upewnienie się, że wskaźnik zaczyna się na komórce z pożądaną parzystością). Bo [-<+]myślę, że możesz zmienić schemat nawigacji, aby polegać na tym, że wszystkie wyniki A są niezerowe?
— Mitch Schwartz,
Nie jestem pewny co masz na myśli. Kiedy A jest, ->->,.a B jest,. , czy Twój preferowany tłumacz wytwarza takie samo C jak TIO i czy C działa zgodnie z oczekiwaniami na twoim tłumaczu? Ponieważ zawodzi w TIO . (Napisałem to w odpowiedzi na komentarz, który został teraz usunięty.)
— Mitch Schwartz,
@MitchSchwartz Dzięki za komentarz. Byłem trochę zarozumiały, ponieważ nie spodziewałem się skanować -1danych użytkownika, ale rzeczywiście zrobiłem to w wierszu „przejdź do aktywnej komórki, wyzeruj to”. Zaktualizowałem swoją odpowiedź, a następnie dodałem bajt: -O, ale przynajmniej działa. BTW. Jeśli nie używam skanowania -1do podczas pobierania danych wejściowych w B, będę musiał przenieść aktywny bajt z kopią>[-<+]< a zatem dodam więcej znaków niż zapisuję, zastępując +[-<+]-je [<]. Jeśli nie skopiujesz, nie będziesz w stanie wiedzieć, czy bajt, który podałeś, został zakończony i skopiujesz wszystkie bajty.
— Sylwester
Cóż, moja wzmianka o [-<+] faktycznie dotyczyła również eliminowania błędów (w przeciwieństwie do zapisywania bajtów) dla danych wejściowych, takich jak -./,>++++++[<++++++>-]<., które powinny być drukowane, #a nie %. :) Ale widzę też okazje do oszczędzania bajtów. Powodzenia! Spróbuję zoptymalizować moje podwójnie nieskończone rozwiązanie do taśm, chociaż zobaczenie, co zrobiłeś, sprawia, że ​​myślę, że może taśma z prawą nieskończonością jest bardziej golfowa.
— Mitch Schwartz,
Po dokładniejszym zbadaniu kodu odkryłem, że nasze ustawienia są bardzo podobne i że użycie taśmy nieskończonej po prawej stronie jest znacznie lepsze dla golfa niż moja podwójnie nieskończona taśma. Proszę zobaczyć moją ostatnią aktualizację sed dla rozwiązania, które łączy nasze pomysły. Czuję, że gra w golfa C jest najbardziej interesująca część tego problemu, ale jest też trochę miejsca, aby program wymiana łańcuch krótszy poza tym, że ...
— Mitch Schwartz
4

sed, 165 bajtów

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

W przypadku smaków o EOF = 0, komórki pozostawione od początku są niedozwolone, 8-bitowe owijanie komórek.

Oczekuje programu A w pierwszej linii i B w drugiej linii.

Wypróbuj online

Wykorzystuje 2-komórkowe węzły do ​​symulacji taśm A i B, przy czym dane wyjściowe A zajmują ciągłe komórki po lewej stronie lewego skrajnego węzła.

Alternatywne rozwiązanie 173 bajtów:

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

Wypróbuj online

Pierwotnie mój projekt był oparty na podwójnie nieskończonej taśmie, która wymagała znacznie więcej pracy, aby przejść w lewo (przenoszenie danych przy przechodzeniu poza poprzednio napotkaną lewą komórkę) i przejście z A do B (czyszczenie danych zamiast tylko przejścia obok prawej skrajnej komórki wcześniej napotkane).

Dzięki Sylwester i Dorian za sztuczki i pomysły.

— Mitch Schwartz
źródło
To wygląda świetnie. Niestety nie powiedzie się przy pierwszym teście. Program A ,[..,]i B programu ,[...,].
— Dorian
Och, to z mojej strony głupi nadzór, za bardzo się spieszyłem. Można to naprawić, ale na razie powinienem go usunąć.
— Mitch Schwartz,
@Dorian Należy to teraz naprawić. (Będę się nad tym zastanawiał.) Dziękujemy za zwrócenie uwagi na błąd i przepraszamy za niedogodności.
— Mitch Schwartz,
Wiem, że niektóre bajty można zaoszczędzić, np. Mając s/x/>>/gna samym końcu, ale bardziej interesują mnie ulepszenia, które na razie skrócą dane wyjściowe.
— Mitch Schwartz,
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.