Buat dua program Brainfuck

10

Diberikan 2 potongan kode brainfuck Adan B, output beberapa kode brainfuck Cyang memiliki perilaku yang sama seperti berjalan Bdengan input Ahasil s. Catatan yang Charus bekerja untuk input apa pun yang cocok dengan asumsi berikut, seolah-olah itu diberikan kepada A.

Anda dapat mengasumsikan:

  1. Input terbatas.
  2. A dan B berhenti.
  3. EOF konsisten 0 atau konsisten -1.
  4. Secara konsisten mengizinkan atau melarang sel ke kiri
  5. Pita tidak terikat (jika tidak, persyaratannya tidak mungkin)
  6. Pembungkus 8-bit atau bilangan bulat tanpa batas secara konsisten
  7. Tidak ada aliran (input atau output untuk A atau B) yang mengandung byte yang mewakili EOF
  8. Kode A dan B dapat berisi karakter yang mungkin muncul di C Anda, dan +-[]<>,.

Misalnya (EOF = 0)

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

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

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

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

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

adalah tes yang valid

Kode terpendek di setiap bahasa menang. Pemenang di Brainfuck akan diterima.

code-golf code-generation brainfuck l4m2
sumber
7
Shortest code in each language windan Shortest Brainfuck solution will be accepteddua kriteria kemenangan yang berbeda.
Mego
2
@Mego Maksud saya jika Anda menjawab di brainfuck dan Anda menang, Anda diterima
l4m2
1
Juga. dapatkah Anda menguraikan 4.Consistently allow or disallow cells to left. Jawaban terkemuka membutuhkan sel di sebelah kiri dalam jawaban untuk bekerja tetapi melarang A, B, dan C untuk tidak bergerak melewati byte pertama. Jawaban saya memungkinkan untuk pindah ke jawaban, A, B, dan C. Jika aturan untuk program saya dan C dapat berbeda dari A, dan B maka saya pasti dapat mempersingkat jawaban saya.
Sylwester
1
Seluruh pernyataan masalah adalah tentang A, B, dan C, dan hanya dua kalimat terakhir yang membuat referensi ke bahasa jawabannya. Mungkin si penulis memang berniat agar jawabannya sama dengan A, B, dan C, tetapi itu bukan salah saya. Pemecah seharusnya tidak dihukum karena kurangnya tinjauan ke masa depan penulis. Bagaimanapun, itu benar-benar sepele untuk menambahkan beberapa >s pada awal jawaban saya untuk membuatnya memenuhi rasa yang lebih ketat (tetapi untuk golf, kita juga harus mempertimbangkan alternatif). Juga, tampak jelas bagi saya bahwa A, B, dan C harus memiliki rasa yang sama satu sama lain.
Mitch Schwartz
1
Mungkin saya benar-benar salah memahami tantangan, tetapi kasus uji # 3 dan # 4 tampaknya berbenturan.
James

Jawaban:

8

brainfuck, 526 byte

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

Diformat:

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

Sehubungan dengan A, B, dan C: EOF = 0, sel-sel kiri mulai dilarang, sel pembungkus 8-bit.

Harapkan A diikuti oleh ?diikuti oleh B.

Cobalah online

(Jawaban ini dapat dibuat sesuai dengan interpreter brainfuck yang tidak memungkinkan untuk meninggalkan awal dengan biaya satu byte dengan mentransliterasi y/<>/></dan mengawali a >.)

Ide dasarnya adalah menggunakan serangkaian penggantian string untuk mensimulasikan rekaman A dan B menggunakan node 2-sel, dengan perhatian khusus diberikan untuk mengganti .dalam A dan ,B sehingga aliran data menengah disimpan dalam blok sel di sebelah kiri rekaman simulasi. Skema penggantian string adalah:

  • Masukkan >>sebelum A

  • Di A dan B, ganti >dengan >[-]+>dan <dengan<<

  • Di A, ganti .dengan>[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[+<->]+</

  • Masukkan >[>>]+>setelah A dan sebelum B

  • Di B, ganti ,dengan,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+<*

Mitch Schwartz
sumber
,[>,]<[.<]?,[...,]input 12345kembali 111, bahkan dengan cukup >sebelumnya?
l4m2
@ l4m2 Hmm, ini bekerja untuk saya di TIO . ( ,[>,]<[.<]tidak valid tetapi >,[>,]<[.<]benar.)
Mitch Schwartz
Jadi, apa "memungkinkan Anda untuk pergi ke kiri sel awal"?
14m2
1
Jadi jawaban Anda memerlukan BF yang dimulai di tengah pita tak terbatas, tetapi sifat A dan B terbatas pada standar di mana seseorang mulai pada sel pertama pada pita tak terbatas di sebelah kanan?
Sylwester
1
Untuk solusi ini, pergi ke kiri sel awal tidak diizinkan dalam A, B, dan C, tetapi diizinkan dalam program (kita dapat menyebutnya D untuk kenyamanan) yang mengambil A dan B dan kemudian menghasilkan C. Saya tidak berpikir ini sangat luar biasa, dan merupakan pilihan alami mengingat sifat solusinya. Pergi ke kiri mulai memiliki konsekuensi besar dalam konteks A, B, dan C, tetapi itu cukup sepele untuk D, dan secara subyektif membuat pengalaman golf yang lebih menyenangkan serta skor yang sedikit lebih pendek, dan juga tidak boleh membuat menguji lebih membosankan, karena mudah untuk menambahkan >ke D sesuai kebutuhan.
Mitch Schwartz
6

brainfuck , 1287 byte

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

Cobalah online!

Ini dia! Kode brainfuck yang menyusun dua kode brainfuck. Gunakan "!" untuk memisahkan dua potongan kode input. Misalnya potongan A: >,[>,]<[.<], snippet B: ,[...,]. Masukan untuk program saya: >,[>,]<[.<]!,[...,]. Itu tidak akan berakhir jika tidak ada "!" ditemukan.

Ini pada dasarnya sama dengan Versi VBA saya. Kode yang dihasilkan sama dengan di versi VBA (perhatikan bahwa contoh-contoh di posting VBA dibuat sebelum perubahan terbaru dalam cuplikan brainfuck).

Penjelasan

Ini adalah kode sumber saya:

[ 
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
sumber
1
Kenapa tidak ada output?
14m2
@ l4m2: Maaf, saya membuat sedikit kesalahan dalam data pengujian. Saya menulis >[,>]<[.<]!,[...,], jadi snippet A tidak menghasilkan apa-apa. Tentu saja itu harus >,[>,]<[.<]!,[...,]untuk contoh kerja.
Dorian
5

VBA, 512 489 479 byte

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

Penjelasan

Kode VBA mengubah kode brainfuck dengan cara, sehingga output snippet A akan disimpan dalam daftar dan input snippet B akan dibaca dari daftar itu.

Pertama menginisialisasi beberapa variabel 

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

Kemudian ia membaca snippet A dan menggantikan setiap <oleh <<<[+]-<<, setiap >oleh >>>>>>>[+]-<<dan setiap .oleh rutinitas penyimpanan

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

setelah itu menghapus memori snippet A dan membuat perubahan pada daftar tersimpan, sehingga dapat dibaca sebagai input untuk snippet B:

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

Kemudian potongan B akan dibaca, setiap <akan digantikan oleh <<<<<, setiap >akan digantikan oleh >>>>>dan setiap ,akan digantikan oleh rutin membaca daftar:

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

Brainfuck kode sumber

Ini adalah sumber saya untuk bagian-bagian dari kode. Saya akan menjelaskannya secara rinci nanti.

[
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

Output untuk test case 1: f ",[..,]",",[...,]"

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

Cobalah online!

Output untuk test case 2: f ">,[>,]<[.<]",",[...,]"

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

Cobalah online!

Output untuk test case 3: f ",.",",."

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

Cobalah online!

Kaset uji kompleks: Cuplikan A: Bangun segitiga alfabet >+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<] Cobalah online!

Cuplikan B: Urutkan input dalam urutan naik >>,[>>,]<<[[-<+<]>[>[>>]<[.[-]<[[>>+<<-]<]>>]>]<<] Coba online!

Hasil:

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

Cobalah online!

Dorian
sumber
Terima kasih. Saya tahu ini cukup banyak ungolfed. Saya hanya ingin memberikan kode kerja pertama. Akan membuat perubahan pada bagian brainfuck dari kode juga.
Dorian
5

Brainfuck , 785 byte

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

Cobalah online!

Untuk memisahkan A dari BI yang dipilih /.

Penjelasan:

Kode aktual yang menghasilkan ini hanya membaca loop dengan bendera untuk A / B dan sebuah saklar yang mengurangi masukan untuk mencari >, <, /, ,, dan .dan sebaliknya hanya output input. Ini sebenarnya hanya sebuah transpiler di mana kode yang ditransmisikan hidup dalam struktur data sedemikian rupa sehingga tidak mengganggu data yang disimpan dari A atau satu sama lain. The /hanya bergerak sel yang aktif ke sel yang tidak terpakai pertama. Saya awalnya membersihkannya, tetapi itu membuat program dan output lebih besar.

Hasil program memiliki model memori berikut:

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

Itu chancur. czselalu 0Ini menunjukkan di mana dalam data BF saya yang ditiru pointer adalah. Nilai aktif adalah -1 sedangkan semua sel yang dikunjungi akan memiliki 1. Dalam operasi suka aprintdan breadbeberapa cmendapatkan makna khusus.

Cetak kode-A melompati semua sel 1 byte untuk meninggalkan ruang untuk satu input byte lagi yang merupakan salinan dengan cadangan dalam byte berikutnya hancur untuk menyalin kembali.

B-code read mengambil input dari input. Di sini menjadi destruktif ok dan ketika Anda "membaca" byte terakhir Anda mendapatkan 0 sebagai EOF terlepas dari implementasinya.

Saya mulai sebagai kode Extended BrainFuck membuat hasil EBF. Sebagian besar debugging dilakukan pada file hasil dan kemudian memperbarui ke sumber yang membuatnya. Kemudian saya hanya menjalankan operasi independen untuk mendapatkan output BF, tapi saya perhatikan jawaban Dorian, yang panjangnya mengalahkan saya jadi saya terus bermain golf sumber EBF untuk output BF lebih kecil. Sumber aslinya cukup mudah dibaca dan sederhana dibandingkan dengan hal-hal lain yang telah saya lakukan dengannya:

: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
sumber
Jika saya mengerti dengan benar, [->+]dalam program C menyebabkan kegagalan untuk input seperti ->->,./,., dan ini bisa diperbaiki menggunakan [->>+](pastikan pointer dimulai pada sel dengan paritas yang diinginkan). Karena [-<+], saya pikir Anda dapat mengubah skema navigasi untuk mengandalkan semua output A menjadi nol?
Mitch Schwartz
Saya tidak yakin apa yang Anda maksud. Ketika A adalah ->->,.dan B adalah ,., apakah penerjemah pilihan Anda menghasilkan C yang sama dengan TIO, dan apakah C bekerja seperti yang diharapkan pada penerjemah Anda? Karena gagal di TIO . (Saya menulis ini sebagai tanggapan atas komentar yang sekarang dihapus.)
Mitch Schwartz
@MitchSchwartz Terima kasih atas komentar Anda. Saya sedikit sombong karena saya tidak berharap untuk memindai -1meskipun data pengguna, tetapi memang saya lakukan pada baris "pergi ke sel aktif, nol itu". Saya telah memperbarui jawaban saya dan kemudian saya menambahkan byte: -O tapi setidaknya itu berfungsi. BTW. Jika saya tidak menggunakan scan untuk -1ketika mengambil input dalam B saya harus memindahkan byte aktif dengan salinan >[-<+]<dan dengan demikian saya menambahkan lebih banyak karakter daripada saya simpan dengan mengganti +[-<+]-dengan [<]. Jika Anda tidak menyalin, Anda tidak akan dapat mengetahui apakah byte yang Anda masukkan sudah selesai dan salin semua byte.
Sylwester
Yah saya sebutkan tentang [-<+]sebenarnya juga dalam hal menghilangkan bug (sebagai lawan menghemat byte), untuk input seperti -./,>++++++[<++++++>-]<., yang harus dicetak #daripada %. :) Tapi saya melihat beberapa peluang untuk menghemat byte juga. Semoga berhasil! Saya akan mencoba untuk mengoptimalkan solusi pita ganda tak terbatas saya, meskipun melihat apa yang Anda lakukan membuat saya berpikir mungkin pita tak terbatas benar adalah lebih golf pada akhirnya.
Mitch Schwartz
Jadi, setelah memeriksa kode Anda lebih dekat, saya menemukan bahwa pengaturan kami sangat mirip, dan bahwa penggunaan pita tak terbatas kanan jauh lebih baik untuk golf daripada pita ganda tak terbatas saya. Silakan lihat pembaruan terbaru saya untuk solusi yang menggabungkan ide-ide kami. Saya merasa bahwa bermain golf C adalah bagian yang paling menarik dari masalah ini, tetapi ada juga ruang untuk membuat program penggantian string lebih pendek di luar itu ...
Mitch Schwartz
4

sed, 165 byte

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

Untuk citarasa dengan EOF = 0, sel-sel kiri mulai tidak diizinkan, sel pembungkus 8-bit.

Mengharapkan program A di baris pertama dan B di baris kedua.

Cobalah online

Ini menggunakan node 2-sel untuk mensimulasikan kaset A dan B, dengan output A menempati sel yang berdekatan di sebelah kiri node paling kiri.

Alternatif solusi 173-byte:

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

Cobalah online

Awalnya desain saya didasarkan pada pita ganda tak terbatas, yang membutuhkan lebih banyak pekerjaan untuk bergerak ke kiri (memindahkan data ketika melewati sel paling kiri yang sebelumnya ditemui) dan untuk transisi dari A ke B (membersihkan data alih-alih hanya berjalan melewati sel paling kanan sebelumnya ditemui).

Terima kasih kepada Sylwester dan Dorian untuk trik dan ide.

Mitch Schwartz
sumber
Ini terlihat hebat. Sayangnya gagal pada tes pertama. Program A ,[..,]dan Program B ,[...,].
Dorian
Oh, ini pengawasan konyol di pihak saya, saya terlalu terburu-buru. Itu diperbaiki tapi saya harus menghapusnya untuk saat ini.
Mitch Schwartz
@Dorian Itu harus diperbaiki sekarang. (Aku akan terus memeriksanya.) Terima kasih telah menunjukkan kesalahannya, dan maaf atas ketidaknyamanannya.
Mitch Schwartz
Saya sadar bahwa beberapa byte dapat disimpan dengan misalnya memiliki s/x/>>/gdi bagian paling akhir, tetapi saya lebih tertarik pada perbaikan yang akan mempersingkat output untuk saat ini.
Mitch Schwartz