Verfassen Sie zwei Brainfuck-Programme

10

Gegeben 2 Gehirnfick Code - Schnipsel Aund B, Ausgabe einige Gehirnfick Code , Cdie das gleiche Verhalten hat wie Laufen Bmit dem Eingang des As Ergebnis. Beachten Sie, dass dies Cfür alle Eingaben funktionieren muss, die den folgenden Annahmen entsprechen, als ob sie gegeben wären A.

Sie können annehmen:

  1. Endliche Eingabe.
  2. sowohl A als auch B halten an.
  3. EOF ist konsistent 0 oder konsistent -1.
  4. Erlaube oder verbiete konsequent, dass Zellen nach links gehen
  5. Ungebundenes Band (andernfalls ist die Anforderung möglicherweise nicht möglich)
  6. Konsequent 8-Bit-Wrapping oder unbegrenzte Ganzzahl
  7. Kein Stream (Eingabe oder Ausgabe für A oder B) enthält das Byte, das EOF darstellt
  8. Code A und B können Zeichen enthalten, die möglicherweise in Ihrem C und erscheinen +-[]<>,.

ZB (EOF = 0)

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

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

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

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

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

sind gültige Tests

Der kürzeste Code in jeder Sprache gewinnt. Der Gewinner in Brainfuck wird akzeptiert.

code-golf  code-generation  brainfuck 
— 14 m2
quelle
7
Shortest code in each language winund Shortest Brainfuck solution will be acceptedsind zwei verschiedene Gewinnkriterien.
— Mego
2
@ Mego Ich meinte, wenn Sie in Brainfuck antworten und gewinnen, werden Sie akzeptiert
— l4m2
1
Ebenfalls. können Sie näher darauf eingehen 4.Consistently allow or disallow cells to left. Die führende Antwort erfordert, dass die Zellen links in der Antwort funktionieren, A, B und C jedoch nicht das erste Byte passieren dürfen. Meine Antwort wird in Antwort A, B und C nach links verschoben. Wenn die Regeln für mein Programm und C von A und B abweichen können, kann ich meine Antwort sicherlich stark verkürzen.
— Sylwester
1
Die gesamte Problemstellung bezieht sich auf A, B und C, und nur die letzten beiden Sätze beziehen sich auf die Sprache der Antwort. Vielleicht hatte der Autor vor, dass die Antwort den gleichen Geschmack wie A, B und C hat, aber das wäre nicht meine Schuld. Löser sollten nicht für mangelnde Weitsicht der Problemautoren bestraft werden. Auf jeden Fall ist es wirklich trivial, >am Anfang meiner Antwort ein paar s hinzuzufügen , damit sie einem restriktiveren Geschmack entspricht (aber für Golf sollten wir auch Alternativen in Betracht ziehen). Außerdem scheint mir klar zu sein, dass A, B und C den gleichen Geschmack haben müssen.
— Mitch Schwartz
1
Vielleicht verstehe ich die Herausforderung völlig falsch, aber die Testfälle Nr. 3 und Nr. 4 scheinen aufeinander zu stoßen.
— James

Antworten:

8

Brainfuck, 526 Bytes

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

Formatiert:

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

In Bezug auf A, B und C: EOF = 0 sind vom Start übrig gebliebene Zellen nicht zugelassen, 8-Bit-Wrapping-Zellen.

Erwartet A gefolgt von ? gefolgt von B.

Probieren Sie es online aus

(Diese Antwort kann mit einem Brainfuck-Interpreter kompatibel gemacht werden, der es nicht erlaubt, durch Transliteration auf Kosten eines Bytes vom Start wegzugehen y/<>/></ und vorangestellt wird >.)

Die Grundidee besteht darin, eine Reihe von String-Ersetzungen zu verwenden, um die Bänder von A und B unter Verwendung von 2-Zellen-Knoten zu simulieren, wobei besonderes Augenmerk auf das Ersetzen .in A und ,in B gelegt wird, damit der Zwischendatenstrom in einem Block von gehalten wird Zellen links vom simulierten Band. Das Zeichenfolgenersetzungsschema lautet:

  • >>Vor A einfügen

  • Sowohl bei A und B, ersetzen >mit >[-]+>und <mit<<

  • In A, ersetzen .mit>[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[+<->]+</

  • >[>>]+>Nach A und vor B einfügen

  • In B, ersetzen ,mit,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+<*

— Mitch Schwartz
quelle
,[>,]<[.<]?,[...,]Eingabe 12345kehrt zurück 111, auch mit genug >vorher?
— 14 m2
@ l4m2 Hmm, es funktioniert für mich auf TIO . ( ,[>,]<[.<]ist nicht gültig, aber >,[>,]<[.<]ist.)
— Mitch Schwartz
Also, was ist dein "es erlaubt, links von der Startzelle zu gehen"?
— 14 m2
1
Ihre Antwort benötigt also eine BF, die in der Mitte eines unendlichen Bandes beginnt, aber die Natur von A und B ist auf den Standard beschränkt, bei dem man in der ersten Zelle auf einem unendlichen Band rechts beginnt?
— Sylwester
1
Für diese Lösung ist es in A, B und C nicht zulässig, links von der Startzelle zu gehen, aber es ist in dem Programm (wir können es der Einfachheit halber D nennen) zulässig, das A und B nimmt und dann C erzeugt. I don Ich denke nicht, dass dies sehr bemerkenswert ist und angesichts der Art der Lösung eine natürliche Wahl ist. Links vom Start zu gehen hat große Konsequenzen im Kontext von A, B und C, ist aber für D ziemlich trivial und sorgt subjektiv für ein angenehmeres Golferlebnis sowie eine etwas kürzere Punktzahl und sollte auch nicht erzielt werden Testen Sie mühsamer, da es einfach ist, >s nach Bedarf vor D zu stellen.
— Mitch Schwartz
6

Brainfuck , 1287 Bytes

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

Probieren Sie es online aus!

Hier ist es! Der Brainfuck-Code, der zwei Brainfuck-Codes zusammensetzt. Benutze einen "!" um die beiden Eingabecode-Schnipsel zu trennen. Zum Beispiel Snippet A : >,[>,]<[.<], Snippet B :.,[...,] . Eingabe für mein Programm : >,[>,]<[.<]!,[...,]. Es wird nicht beendet, wenn kein "!" gefunden.

Dies entspricht im Wesentlichen meiner VBA-Version. Der generierte Code ist der gleiche wie in der VBA-Version (beachten Sie, dass die Beispiele im VBA-Beitrag vor der letzten Änderung in den Brainfuck-Snippets erstellt wurden).

Erläuterung

Dies ist mein Quellcode:

[ 
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
quelle
1
— 14 m2
@ l4m2: Entschuldigung, ich habe einen kleinen Fehler in den Testdaten gemacht. Ich habe geschrieben >[,>]<[.<]!,[...,], also gibt Snippet A nichts aus. Natürlich muss es >,[>,]<[.<]!,[...,]ein funktionierendes Beispiel sein.
— Dorian
5

VBA, 512 489 479 Bytes

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

Erläuterung

Der VBA-Code ändert den Brainfuck-Code so, dass die Ausgabe von Snippet A in einer Liste gespeichert und die Eingabe von Snippet B aus dieser Liste gelesen wird.

Zunächst werden einige Variablen initialisiert 

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

Dann liest es Snippet A und ersetzt jedes <By <<<[+]-<<, jedes >By >>>>>>>[+]-<<und jedes .durch die Speicherroutine

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

Danach wird der Speicher von Snippet A gelöscht und die gespeicherte Liste geändert, sodass sie als Eingabe für Snippet B gelesen werden kann:

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

Dann wird Snippet B gelesen, jedes <wird ersetzt durch <<<<<, jedes >wird ersetzt durch >>>>>und jedes ,wird durch die Listenleseroutine ersetzt:

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

Brainfuck Quellcode

Dies ist meine Quelle für die Brainfuck-Teile des Codes. Ich werde das später im Detail erklären.

[
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

Ausgabe für Testfall 1: f ",[..,]",",[...,]"

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

Probieren Sie es online aus!

Ausgabe für Testfall 2: f ">,[>,]<[.<]",",[...,]"

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

Probieren Sie es online aus!

Ausgabe für Testfall 3: f ",.",",."

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

Probieren Sie es online aus!

Komplexer Testfall: Snippet A: Alphabet-Dreieck >+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<] erstellen Probieren Sie es online aus!

Snippet B: Eingabe in aufsteigender Reihenfolge >>,[>>,]<<[[-<+<]>[>[>>]<[.[-]<[[>>+<<-]<]>>]>]<<] sortieren Probieren Sie es online aus!

Ergebnis:

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

Probieren Sie es online aus!

— Dorian
quelle
Vielen Dank. Ich weiß, das ist so ziemlich ungolfed. Ich wollte nur den ersten Arbeitscode bereitstellen. Nimmt auch Änderungen am Brainfuck-Teil des Codes vor.
— Dorian
5

Brainfuck , 785 Bytes

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

Probieren Sie es online aus!

Um A von BI zu trennen, entschied man sich /.

Erklärung:

Der tatsächliche Code, der diese erzeugt , ist nur ein Lese-Schleife mit einem Flag für die A / B und einen Schalter, der den Eingang zu suchen , verringert >, <, /, ,, und .und ansonsten nur der Ausgang - Eingang. Es ist eigentlich nur ein Transpiler, bei dem der transpilierte Code innerhalb einer Datenstruktur lebt, so dass er die gespeicherten Daten von A oder einander nicht stört. Das verschiebt /gerade die aktive Zelle in die erste nicht verwendete Zelle. Ich habe es ursprünglich aufgeräumt, aber das macht das Programm und die Ausgabe größer.

Das Programmergebnis hat folgendes Speichermodell:

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

Das cbröckelt. czist immer 0Es zeigt, wo in meinen emulierten BF-Daten der Zeiger ist. Der aktive Wert ist -1, während alle besuchten Zellen haben 1. Bei Operationen wie aprintund erhalten breadmanche ceine besondere Bedeutung.

Beim A-Code-Druck werden alle Zellen 1 Byte übersprungen, um Platz für eine weitere Byte-Eingabe zu lassen, bei der Kopien mit einer Sicherung in den nächsten Bytes zum Zurückkopieren zerbröckeln.

Beim Lesen des B-Codes werden Eingaben von Eingaben abgerufen. Hier ist es in Ordnung, destruktiv zu sein, und wenn Sie das letzte Byte "lesen", erhalten Sie unabhängig von der Implementierung 0 als EOF.

Ich begann als Extended BrainFuck- Code, der das EBF-Ergebnis ergab. Das meiste Debugging wurde für die Ergebnisdateien durchgeführt und dann auf die Quelle aktualisiert, die es generiert hat. Dann habe ich die Operationen einfach unabhängig ausgeführt, um die BF-Ausgabe zu erhalten, aber ich habe Dorians Antwort bemerkt, die mich in der Länge übertroffen hat, also habe ich die EBF-Quelle für eine kleinere BF-Ausgabe weiter gespielt. Die Originalquelle ist im Vergleich zu anderen Dingen, die ich damit gemacht habe, gut lesbar und einfach:

: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
quelle
Wenn ich es richtig verstanden habe, verursacht es [->+]in Programm C Fehler bei Eingaben wie ->->,./,., und dies könnte mithilfe von behoben werden [->>+](indem sichergestellt wird, dass der Zeiger auf einer Zelle mit der gewünschten Parität startet). Denn [-<+], ich glaube , Sie das Navigationsschema ändern können auf alles A die auszugebende ungleich Null verlassen?
— Mitch Schwartz
Ich bin mir nicht sicher was du meinst. Wenn A ist ->->,.und B ist ,., erzeugt Ihr bevorzugter Interpreter dasselbe C wie TIO, und funktioniert C bei Ihrem Interpreter wie erwartet? Weil es auf TIO fehlschlägt . (Ich schrieb dies als Antwort auf einen Kommentar, der jetzt gelöscht wird.)
— Mitch Schwartz
@MitchSchwartz Danke für deinen Kommentar. Ich war ein wenig übermütig, da ich nicht damit gerechnet hatte, nach -1Benutzerdaten zu suchen, aber tatsächlich tat ich dies in der Zeile "Gehe zu aktiver Zelle, stelle sie auf Null". Ich habe meine Antwort aktualisiert und dann ein Byte hinzugefügt: -O, aber zumindest funktioniert es. Übrigens. Wenn Im nicht - Scan verwendet für -1zu , wenn die Eingabe in B holen werde ich habe , um die aktive Byte mit einer Kopie zu bewegen >[-<+]<und damit füge ich mehr Zeichen , als ich durch den Austausch sparen +[-<+]-mit [<]. Wenn Sie nicht kopieren, können Sie nicht feststellen, ob das von Ihnen komponierte Byte fertig ist, und alle Bytes kopieren.
— Sylwester
Nun, meine Erwähnung bezog [-<+]sich eigentlich auch auf die Beseitigung von Fehlern (im Gegensatz zum Speichern von Bytes) für Eingaben wie -./,>++++++[<++++++>-]<., die #eher gedruckt als gedruckt werden sollten %. :) Aber ich sehe auch einige Möglichkeiten, Bytes zu speichern. Viel Glück! Ich werde versuchen, meine doppelt unendliche Bandlösung zu optimieren, obwohl ich sehe, dass das, was Sie getan haben, am Ende vielleicht richtig rechts ist.
— Mitch Schwartz
Nachdem ich Ihren Code genauer untersucht hatte, stellte ich fest, dass unsere Setups sehr ähnlich sind und dass Ihre Verwendung eines rechts-unendlichen Bandes für Golf weitaus besser ist als mein doppelt unendliches Band. In meinem letzten sed-Update finden Sie eine Lösung, die unsere Ideen kombiniert. Ich denke, dass Golf C der interessanteste Teil dieses Problems ist, aber es gibt auch etwas Raum, um das Saitenersatzprogramm außerhalb davon kürzer zu machen ...
— 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

Bei Aromen mit EOF = 0 sind Zellen, die vom Start übrig geblieben sind, nicht zulässig. 8-Bit-Umhüllungszellen.

Erwartet Programm A in der ersten Zeile und B in der zweiten Zeile.

Probieren Sie es online aus

Dies verwendet Knoten mit zwei Zellen, um die Bänder von A und B zu simulieren, wobei die Ausgabe von A zusammenhängende Zellen links vom Knoten ganz links belegt.

Alternative 173-Byte-Lösung:

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

Probieren Sie es online aus

Ursprünglich basierte mein Entwurf auf einem doppelt unendlichen Band, das erheblich mehr Arbeit erforderte, um sich nach links zu bewegen (Daten beim Überqueren der zuvor angetroffenen Zelle ganz links zu bewegen) und von A nach B zu wechseln (Daten zu löschen, anstatt nur an der Zelle ganz rechts vorbeizukommen zuvor angetroffen).

Vielen Dank an Sylwester und Dorian für Tricks und Ideen.

— Mitch Schwartz
quelle
Das sieht gut aus. Leider schlägt es beim ersten Test fehl. Programm A ,[..,]und Programm B ,[...,].
— Dorian
Oh, das ist ein dummes Versehen von meiner Seite, ich habe mich zu sehr beeilt. Es ist reparabel, aber ich sollte es vorerst löschen.
— Mitch Schwartz
@ Dorian Es sollte jetzt behoben sein. (Ich werde weiter darüber nachdenken.) Vielen Dank, dass Sie auf den Fehler hingewiesen haben, und entschuldigen Sie die Unannehmlichkeiten.
— Mitch Schwartz
Ich bin mir bewusst, dass einige Bytes beispielsweise s/x/>>/gam Ende gespeichert werden können , aber ich bin mehr an Verbesserungen interessiert, die die Ausgabe vorerst verkürzen.
— Mitch Schwartz
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.