İki Brainfuck programı oluşturun

10

Verilen 2 brainfuck kod parçacığı Ave s sonucu girişi ile çalışan aynı davranışı olan Bbazı brainfuck kodu çıktı . Aşağıdaki varsayımlarla eşleşen herhangi bir girdi için, verilmiş gibi çalışması gerektiğini unutmayın .CBACA

Varsayabilirsiniz:

  1. Sonlu giriş.
  2. hem A hem de B durur.
  3. EOF sürekli olarak 0 veya sürekli olarak -1'dir.
  4. Hücrelerin sürekli olarak soluna izin verme veya izin verme
  5. Sınırsız bant (aksi takdirde gereksinim imkansız olabilir)
  6. Sürekli olarak 8 bit sarma veya sınırsız tam sayı
  7. Hiçbir akış (A veya B için giriş veya çıkış) EOF'u temsil eden baytı içermiyor
  8. Kod A ve B, C'nizde görünmesi muhtemel karakterler içerebilir ve +-[]<>,.

Örn (EOF = 0)

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

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

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

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

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

geçerli testlerdir

Her dilde en kısa kod kazanır. Brainfuck'ta kazanan kabul edilecektir.

code-golf  code-generation  brainfuck 
— l4m2
kaynak
7
Shortest code in each language winve Shortest Brainfuck solution will be acceptediki farklı kazanma kriteri.
— Mego
2
@Mego Ben Brainfuck cevap ve kazanmak, demek
— istedim
1
Ayrıca. üzerinde durur musun 4.Consistently allow or disallow cells to left. Başlıca yanıt, yanıtta soldaki hücrelerin çalışmasını gerektirir, ancak A, B ve C'ye izin vermemek için ilk baytı geçti. Cevap kadranlarım A, B ve C cevaplarında sola hareket eder. Programım ve C için kurallar A ve B'den farklı olabilirse, cevabımı kesinlikle kısaltabilirim.
— Sylwester
1
Sorun bildiriminin tamamı A, B ve C ile ilgilidir ve yalnızca son iki cümle cevabın diline atıfta bulunur. Belki de yazar, cevabın A, B ve C ile aynı lezzette olmasını istemiştir, ancak bu benim hatam olmaz. Çözücüler sorunlu yazarların öngörü eksikliği nedeniyle cezalandırılmamalıdır. Her halükarda, >daha kısıtlayıcı bir lezzete uyması için cevabımın başına birkaç s eklemek gerçekten önemsizdir (ancak golf için alternatifleri de düşünmeliyiz). Ayrıca, A, B ve C'nin birbiriyle aynı lezzette olması gerektiği açık.
— Mitch Schwartz
1
Belki de bu meydan okumayı tamamen yanlış anlıyorum, ancak test örnekleri # 3 ve # 4 çatışıyor gibi görünüyor.
— James

Yanıtlar:

8

brainfuck, 526 bayt

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

biçimlendirilmiş:

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

A, B ve C: EOF = 0 ile ilgili olarak, başlangıçtan kalan hücreler izin verilmeyen 8 bitlik sarma hücrelerine sahiptir.

Bekleyen A ve ?ardından B.

Çevrimiçi deneyin

(Bu cevap, bir bayt maliyetinde başlangıçtan sola gitmeye izin y/<>/></vermeyen bir beyin sineği yorumlayıcısı ile uyumlu hale getirilebilir ve a >.)

Temel fikir, A ve B kasetlerini 2 hücreli düğümler kullanarak simüle etmek için bir dizi dize değiştirme kullanmaktır ve ara veri akışının bir blokta tutulması için .A ve ,B'de değiştirmeye özellikle dikkat edilir . simüle edilen bandın solundaki hücreler. Dize değiştirme şeması:

  • >>A'dan önce ekle

  • A ve B her ikisinde de, yerine >ile >[-]+>ve <ile<<

  • A .ile değiştirin>[-]-[>>]+[[>+<-]<[>+<-]<]>+[->>+]<[>>>-<<+[<<]<+>>>[>>]+<<<-]>[+<->]+</

  • >[>>]+>A'dan sonra ve B'den önce takın

  • B'de, yerine ,ile,[,]>,<<[<<]<[[>]>>[>>]<+<[<<]<[<]>-]>[>]>>[>>]+<*

— Mitch Schwartz
kaynak
,[>,]<[.<]?,[...,]girdi , daha önce bile yeterliyse 12345geri döner ? 111>
— l4m2
@ l4m2 Hmm, benim için çalışıyor TIO üzerinde . ( ,[>,]<[.<]geçerli değil ama geçerli >,[>,]<[.<].)
— Mitch Schwartz
Peki "başlangıç ​​hücresinin soluna gitmenize izin veriyor" nedir?
— l4m2
1
Yani cevabınızın sonsuz bir bandın ortasında başlayan bir BF'ye ihtiyacı var, ancak A ve B'nin doğası, sağdaki sonsuz bantta ilk hücrede başlayan standartla sınırlı mı?
— Sylwester
1
Bu çözüm için, başlangıç ​​hücresinin soluna A, B ve C'de izin verilmez, ancak A ve B'yi alan ve sonra C üreten programda (kolaylık için D diyebiliriz) izin verilir. Bunun çok dikkat çekici olduğunu ve çözümün doğası göz önüne alındığında doğal bir seçim olduğunu düşünmüyorum. Başlangıç ​​sola gitmenin A, B ve C bağlamında önemli sonuçları vardır, ancak D için oldukça önemsizdir ve öznel olarak daha keyifli bir golf deneyimi ve biraz daha kısa bir skor sağlar ve ayrıca >gerektiğinde D' ye başlaması kolay olduğu için daha sıkıcı bir test .
— Mitch Schwartz
6

brainfuck , 1287 bayt

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

Çevrimiçi deneyin!

İşte burada! İki beyin kanadı kodu oluşturan beyin kanadı kodu. Kullanın "!" iki giriş kodu snippet'ini ayırmak için. Örnek pasajı A için: >,[>,]<[.<], B pasajı: ,[...,]. Benim program için Girdi: >,[>,]<[.<]!,[...,]. Hiçbir "!" bulunan.

Bu aslında VBA Sürümüm ile aynı. Oluşturulan kod, VBA sürümü ile aynıdır (VBA postundaki örneklerin, brainfuck snippet'lerindeki son değişiklikten önce yapıldığına dikkat edin).

açıklama

Bu benim kaynak kodum:

[ 
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
kaynak
1
— l4m2
@ l4m2: Üzgünüm, test verilerinde küçük bir hata yaptım. Ben yazdım >[,>]<[.<]!,[...,], bu yüzden snippet A hiçbir şey çıkarmıyor. Tabii ki >,[>,]<[.<]!,[...,]çalışan bir örnek için olmalı .
— Dorian
5

VBA, 512 489 479 bayt

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

açıklama

VBA kodu, beyin sıkışması kodunu, pasaj A'nın çıktısının bir listede saklanacağı ve pasaj B'nin girişinin bu listeden okunacağı şekilde değiştirir.

Önce bazı değişkenleri başlatır 

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

Sonra A pasajı okur ve her yerini <tarafından <<<[+]-<<her, >tarafından >>>>>>>[+]-<<her .depolanması rutin tarafından

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

bundan sonra snippet A'nın belleğini siler ve saklanan listede değişiklikler yapar, böylece snippet B için girdi olarak okunabilir:

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

Sonra Snippet B okunacak, her <biri değiştirilecek <<<<<, her >biri değiştirilecek >>>>>ve her ,biri liste okuma rutini ile değiştirilecektir:

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

Brainfuck kaynak kodu

Bu, kodun beyni bölümleri için kaynağım. Bunu daha sonra ayrıntılı olarak açıklayacağım.

[
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

Test senaryosu 1 için çıktı: f ",[..,]",",[...,]"

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

Çevrimiçi deneyin!

Test örneği 2 için çıktı: f ">,[>,]<[.<]",",[...,]"

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

Çevrimiçi deneyin!

Test durumu 3 için çıktı: f ",.",",."

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

Çevrimiçi deneyin!

Karmaşık test senaryosu : Snippet A: Alfabe üçgeni oluştur >+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<] Çevrimiçi deneyin!

Snippet B: Girdileri artan düzende sıralayın >>,[>>,]<<[[-<+<]>[>[>>]<[.[-]<[[>>+<<-]<]>>]>]<<] Çevrimiçi deneyin!

Sonuç:

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

Çevrimiçi deneyin!

— Dorian
kaynak
Teşekkür ederim. Bunun neredeyse hiç çözülmediğini biliyorum. Sadece ilk çalışma kodunu vermek istedim. Brainfuck'ta da kodun bir kısmında değişiklik yapacak.
— Dorian
5

Brainfuck , 785 bayt

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

Çevrimiçi deneyin!

A'yı BI'den ayırmak için tercih etti /.

Açıklama:

Bu oluşturur gerçek kod A / B için bir işaret ve aramaya giriş azaltan bir anahtar ile bir okuma döngüsüdür >, <, /, ,ve .aksi takdirde, sadece çıkış girişi. Aslında, sadece aktarılan kodun A veya birbirinden saklanan verilere müdahale etmeyecek şekilde bir veri yapısı içinde yaşadığı bir aktarıcıdır. /İlk kullanılmayan hücreye etkin hücreyi taşır. Başlangıçta temizledim, ama bu program ve çıktıyı daha büyük hale getiriyor.

Program sonucu aşağıdaki bellek modeline sahiptir:

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

cKırıntı olduğunu. czher zaman 0Öykünülen BF verilerimde işaretçinin nerede olduğunu gösterir. Ziyaret edilen tüm hücreler sahip olurken aktif değer -1'dir 1. Gibi operasyonlarda aprintve breadbazıları cözel bir anlam kazanır.

A-kodu yazdırma, bir sonraki bayttaki kopyalarla geri kopyalanacak şekilde kopyalanan bir bayt giriş için yer bırakmak üzere tüm hücreleri 1 bayt atlar.

B kodu okuma girişi girişten getirir. Burada yıkıcı olmak iyidir ve son baytı "okuduğunuzda" ne olursa olsun, uygulamadan EOF olarak 0 alırsınız.

EBF sonucu yapan Genişletilmiş BrainFuck kodu olarak başladım . Hata ayıklamanın çoğu sonuç dosyalarında yapıldı ve daha sonra onu oluşturan kaynağa güncelleştirildi. Sonra sadece BF çıktı almak için işlemleri bağımsız çalıştırmak, ama ben daha uzun BF çıktı için EBF kaynağı golf devam böylece beni uzun dövdü Dorian cevap, fark ettim. Orijinal kaynak, yaptığım diğer şeylere kıyasla oldukça okunabilir ve basit:

: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
kaynak
Düzgün anladım, [->+]C programında gibi girişler için hataya neden olur ->->,./,.ve bu düzeltilebilir [->>+](işaretçinin istenen eşlikli bir hücrede başladığından emin olun). Çünkü [-<+], navigasyon şemasını A'nın tüm çıktılarının sıfırdan farklı olacağı şekilde değiştirebileceğinizi düşünüyorum.
— Mitch Schwartz
Neyi kastettiğinden emin değilim. A ->->,.ve B olduğunda ,., tercih ettiğiniz tercüman TIO ile aynı C'yi üretir mi ve C tercümanınızda beklendiği gibi çalışıyor mu? Çünkü TIO'da başarısız oluyor . (Bunu şimdi silinmiş bir yoruma yanıt olarak yazdım.)
— Mitch Schwartz
@MitchSchwartz Yorumunuz için teşekkürler. Ben -1kullanıcı verileri olsa taramak için beklemiyordum çünkü biraz ukala , ama gerçekten "aktif hücreye gidin, sıfır" satırında yaptı. Cevabımı güncelledim ve sonra bir bayt ekledim: -O ama en azından işe yarıyor. BTW. Im için tarama kullanılmıyorsa -1B'de girdi getirirken i bir kopyası ile aktif byte hareket etmek zorunda kalacak >[-<+]<ve ben değiştirerek tasarruf daha böylece daha karakter eklemek +[-<+]-ile [<]. Kopyalamazsanız, oluşturduğunuz baytın bitip bitmediğini bilemez ve tüm baytları kopyalayamazsınız.
— Sylwester
Benim bahsettiğim [-<+]şey aslında (bayt tasarrufu yerine) hataları ortadan kaldırmak -./,>++++++[<++++++>-]<., bunun #yerine yazdırmak yerine %. :) Ama bayt tasarrufu için de bazı fırsatlar görüyorum. İyi şanslar! İki kat sonsuz bant çözümümü optimize etmeye çalışacağım, ancak ne yaptığınızı görmek belki de sağ sonsuz bantın daha golfçü olduğunu düşündürüyor.
— Mitch Schwartz
Kodunuzu daha yakından inceledikten sonra, kurulumlarımızın çok benzer olduğunu ve sağ sonsuz bir bant kullanımınızın golf için iki kat sonsuz banttan çok daha iyi olduğunu buldum. Fikirlerimizi birleştiren bir çözüm için lütfen en son sed güncellememe bakın. Golf C bu sorunun en ilginç parçası olduğunu hissediyorum, ama aynı zamanda dize değiştirme programı bunun dışında daha kısa yapmak için bir yer var ...
— Mitch Schwartz
4

sed, 165 bayt

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

EOF = 0 olan tatlar için, başlangıçta bırakılan hücreler izin verilmeyen 8 bitlik sarma hücrelerine sahiptir.

İlk satırda A programını ve ikinci satırda B'yi bekler.

Çevrimiçi deneyin

Bu, A ve B kasetlerini simüle etmek için 2 hücreli düğümleri kullanır, A çıkışı en soldaki düğümün solundaki bitişik hücreleri işgal eder.

Alternatif 173 baytlık çözüm:

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

Çevrimiçi deneyin

Başlangıçta tasarımım, sola hareket etmek (daha önce karşılaşılan en soldaki hücrenin ötesine geçerken verileri taşımak) ve A'dan B'ye geçmek (sadece en sağdaki hücreyi geçmek yerine verileri temizlemek) için daha fazla çalışma gerektiren iki kat sonsuz bir banda dayanıyordu. ).

Sylwester ve Dorian'a hileler ve fikirler için teşekkürler.

— Mitch Schwartz
kaynak
Harika görünüyor. Ne yazık ki ilk testte başarısız oluyor. Programı A ,[..,]ve program B ,[...,].
— Dorian
Oh, bu benim için aptalca bir gözetim, çok acele ettim. Düzeltilebilir ama şimdilik silmeliyim.
— Mitch Schwartz
@Dorian Şimdi düzeltilmelidir. (Bakmaya devam edeceğim.) Hatayı belirttiğiniz için teşekkürler ve rahatsızlık için özür dilerim.
— Mitch Schwartz
Bazı baytların, örneğin s/x/>>/gen sonunda bulunarak kaydedilebileceğinin farkındayım , ancak şimdilik çıktıyı kısaltacak iyileştirmelerle daha fazla ilgileniyorum.
— Mitch Schwartz
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.