ภาษาที่มีประโยชน์มากในแหล่งที่มีข้อ จำกัด และความท้าทายอื่น ๆ คือUnaryซึ่งเป็นอนุพันธ์ของสมองที่โปรแกรมจะเขียนด้วยตัวละครเพียงตัวเดียว งานของคุณคือการเขียนโปรแกรมเพื่อแปลงโปรแกรมจาก brainfuck เป็นเอกและโปรแกรมที่จะทำตรงข้ามทั้งสองโปรแกรมในภาษาเดียวกัน คะแนนของคุณจะเป็นผลรวมของความยาวของโปรแกรมทั้งสอง

คุณแปลงจาก brainfuck เป็น unary ได้อย่างไร?

• ก่อนอื่นแปลงโค้ด brainfuck ให้คุณเป็นไบนารี่ตามตารางนี้:

• ตอนนี้เชื่อมต่อรหัสเป็นเลขฐานสองยักษ์หนึ่งตัวตามลำดับของรหัส
• เติม a 1เข้ากับสตริงเพื่อให้แน่ใจว่าเลขฐานสองที่ไม่ซ้ำกัน
• แปลงจากเลขฐานสองเป็นตัวเลขโดยใช้ตัวอักษรใดก็ได้
• Ex: +.จะเป็น000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (84 ศูนย์)

Brainfuck -> ข้อมูลจำเพาะของนารี

• เนื่องจากโปรแกรมที่ได้จะมีขนาดใหญ่มากพิมพ์ไม่ได้เป็นโปรแกรมจริง แต่เป็นเพียงความยาวของโปรแกรมผลลัพธ์
• ใช้โปรแกรม brainfuck เป็นสตริงผ่าน stdin, ฟังก์ชัน arg ฯลฯ และส่งออกความยาว
• โปรแกรมจะใช้ได้ตลอดเวลาและมีเพียง 8 ตัวอักษรในนั้น

ยูนารี -> ข้อมูลจำเพาะของ Brainfuck

• คุณจะต้องใช้การย้อนกลับของอัลกอริทึมข้างต้น
• อีกครั้งเนื่องจากมีขนาดใหญ่มากคำถามอินพุตจะเป็นตัวเลขที่อธิบายความยาวของรหัสยูนารี
• กฎ I / O เดียวกันเช่นเคย
• โปรแกรมจะใช้ได้ตลอดเวลาและมีเพียง 8 ตัวอักษรในนั้น

กรณีทดสอบ

• สวัสดีชาวโลก - ++++++[>++++++++++++<-]>.>++++++++++[>++++++++++<-]>+.+++++++..+++.>++++[>+++++++++++<-]>.<+++[>----<-]>.<<<<<+++[>+++++<-]>.>>.+++.------.--------.>>+.=239234107117088762456728667968602154633390994619022073954825877681363348343524058579165785448174718768772358485472231582844556848101441556
• ฟีโบนักชี - ++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++>++++++++++++++++>>+<<[>>>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>[<+>-]>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<<<++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<<<<<<.>.>>[>>+<<-]>[>+<<+>-]>[<+>-]<<<-]<<++...=13067995222095367150854793937817629722033205198624522624687536186118993888926522550140580142585590431635487113180955099384652678100247403485397450658564826143160529351955621991895221530908461364045400531236124980271740502887704217664044858614821622360156740992393765239123681327824577149595724956207165558106099868913919959549896553103116795519592552089266360725543244154867904980260

นี่คือรหัส - กอล์ฟคะแนนต่ำสุดเป็นไบต์ชนะ!

ใครบ้างที่ต้องการทางออกใน Unary? ; P

Pyth, 17 + 17 = 34 ไบต์

BF -> เอกนารี, 17 ไบต์

i+1xL"><+-.,[]"z8

ยูนารี -> BF, 17 ไบต์

s@L"><+-.,[]"tjQ8

brainfuck , 563 335 318 316 296 + 529 373 366 336 = 632 ไบต์

เนื่องจากนี่เป็นวิธีการแก้ปัญหาที่ขาดหายไปในภาษาที่เกี่ยวข้องนี่คือวิธีแก้ปัญหาใน brainfuck และ Golunar ฉันไม่สามารถโพสต์คำตอบด้วยเอกภาพเพราะจะต้องมีหน่วยความจำที่น่าอัศจรรย์กว่าสองเท่ากว่าอะตอมในจักรวาล ^^

รูทีน "back" จะไม่ตรวจสอบว่ารหัส Golunar / Unary นั้นถูกต้องหรือไม่ ถ้า bit count mod 3! = 1 จะมีการพิมพ์วนซ้ำ ">" จำนวนมาก

ขอบคุณ Nitrodon ที่ช่วยให้ฉันได้รับต่ำกว่า 300 chars สำหรับรหัส bf ไปยัง unary

brainfuck ถึงเอก

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

ลองออนไลน์!

และกลับมา

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

ลองออนไลน์!

Golunar / เลขหลัก, 509 303 288 286 268 + 478 337 331 304 = 572 ไบต์

brainfuck ถึงเอก

2845581296974449674357817038179762273623136917867627972159702240227366875240878616687779429553529795902322625321040063298921498529640547483869509829184440577052825434462245755576011912505085065586076069824710351537537205287083477698633592357950165322060367940923703887

และกลับมา

3775574485023133646619269732540391678811443648964274086227256847322821618228135493733703990523803451383315165001915937932498966394771849173263120467073642011339214182483748816052890450078070151307011943625602391238338941712116968736593594971620990210178757280976709140113340322124688909388916094040773207

รหัสที่มา

brainfuck ถึงเอก

[
unary:
><+-.,[]
01234567

62 > 62
60 < -2
45 - 15
43 + 2
44 , 1
46 . 2
91 [ 45
93 ] 2

tape (while reading input): Left tape end marker/LTE, [binary data], input, 15, (15 multiplicator)
tape (while base conversion): LTE, [binary data], Value Start/VS, [decimal digits]

decimal digits: digit used/DU, value
]

-                       set LTE
>+                      set leading 1
>>>>,[                  while input
  >+++[>+++++<-]        set 15 (multiplicator)
  >[<+<---->>-]         set 15 and decrease input by 60

                    check for greater than
                        set current bits = 000 (greater than)
  <<--[                 if input != 62 try next char

                    check for less than
  <+>                   set current bits = 001 (less than)
  ++[                   if input != 60 try next char

                    check for minus
  <<+>>                 set current bits = 011 (minus)
  >[<+>-]<[             if input != 45 try next char

                    check for plus
  <->                   set current bits = 010 (plus)
  ++[                   if input != 43 try next char

                    check for comma
  <<<+>->+>             set current bits = 101 (comma)
  -[                    if input != 44 try next char

                    check for dot
  <->                   set current bits = 100 (dot)
  --[                   if input != 46 try next char

                    check for left bracket
  <<+>>                set current bits = 110 (left bracket)
  >+++++++++[<----->-]<[   if input != 91 go to next char


                    use right bracket
  <+>                   set current bits = 111 (right bracket)
  --                    decrease input by 2 / should be 0 now

  ]]]]]]]               close all ifs
  >[-]>>                delete 15 if still existant
  ,                     input next character
]
<<<<+[<+]>[>]           add one to each bit and delete LTE (for shorter search routine)

                    Start of binary to decimal routine

-                       set value start marker (VS)
>+                      set digit used marker (DU)
[<]                     go to LTE

                    binary to decimal loop: use "double and add algorithm" to calculate the digits of the decimal value
>+[                     if not on VS then
  [->+]-                restore current bit value and go to VS
  >                     go to first DU
  [                     digit doubling loop
    ->                  remove DU and go to corresponding digit
    [
      <++>-             decrement current value and add 2 to temp value four times
      [
        <++>-
        [
          <++>-
          [
            <++>-
            [                   if value was greater than 4 then
              <---- ----        subtract 8 from temp
              >>[-]++           set next digit temp = 2 (DU plus 1)
              <-                decrement current digit
              [<++>-]           set temp = remaining value * 2
            ]
          ]
        ]
      ]
    ]
    <[>+<-]             set current digit = temp
    +                   set DU
    >>                  go to next digit
  ]                     end of digit doubling loop
  <<[<<]>[<]>           go to current bit
  -[                    if bit is 2 (used plus 1)
    [->+]-              delete bit and go to VS
    >>+                 increment least significant digit
    <[<<]>[<]           go to current bit
  ]
  >+                    if not on VS then repeat  
]                   end of binary to decimal loop

>[>>]<                  go to most significant digit
<[                  printing loop: for each DU print corresponding value
  +++++++[>++++++<-]>.  add 48 to value (ASCII 0) and print
  <<<                   go to next DU
]

และกลับมา

[
tape: left tape end marker/LTE(-1), [digits], digit end marker/DE(0), carry, SB(-1), [binary data], 60, 15
digits: digit used marker/DU(1), digit, remainder, solution, 0
        else]                                    [exit else, exit if
binary data: value (, else, exit if, exit else)
]

                    input decimal value
->>                     set LTE
,[                      while input
  <++++++[>--------<-]  decrease input by 48
  +                     set DU
  >>>>> >,              input next digit
]
>->-                    set start of bits (SB) and first CCB
<<<+[-<+]>              delete LTE and go to first DU

                    division loop: calculate the remainders of the input divided by 2 repeatedly to get the (inverted) bits
[
                        divide each digit by 2
  [                     for each DU
    -                   delete DU (for exit if)
    >                   go to digit
    [->+<               dec digit / set remainder
      [->->+>]          if digit gt 0: dec digit / del remainder / inc solution / goto 0
                        pointer: (value(0) remainder is set) or (0 solution gt 1)
      <[<<<]            go to DU
      >                 go to digit
    ]
    <+                  set DU
    >>>[-<<+>>]         move solution to digit
    <[                  if remainder
      >>>>              go to next digit
      +++++ +++++       add 10 to digit/carry
      <<<<-             go back and delete remainder
    ]
    >>>                 go to next DU
  ]

                    append new bit
  >>>+[->+]             go to and delete CCB
  >-                    set new CCB
  <+[-<+]-<             go to carry
  [                     if carry
    >>+[->+]-<+         set last bit
    +[-<+]-<[-]         go to and clear carry
  ]

                    check if first digit became 0 / neccessary to check if value has been completely processed
  < <<<<<[<<<<<]>>>>>   go to first DU
  >[                    if digit gt 0
    <<                  go to exit if
  ]<[                   else
    -                   delete DU
    >>>                 go to exit else of next digit
  ]
  >>                    go to DU / DE if all digits processed
]                   end of division loop

                    decode binary values
>>>+[->+]               go to and delete CCB (after last bit)
<-                      delete leading 1
<                       go to first bit


                    Start of bit decoder
[
unary:
><+-.,[]
01234567

62 > 62
60 < -2
43 + -17
45 - 2
46 . 1
44 , -2
91 [ 47
93 ] 2

tape: start of bytes marker/SB(-1), [binary data], 60(print char/PC), 15
]

+[-                     while not SB

                    Set least significant to octal value of three bits
  [<++>-]               if first bit set add 2 to second bit
  <[<++>-]              for each second bit add 2 to third bit

  >+++[>+++++<-]        multiplier 15
  >[<+<++++>>-]         setup table 60 15

                    run through the 8 possibilities

                    0 greater than
  <<++                  set PC = 62 (greater than)
  <[                    if value gt 0 go to next char

                    1 less than
  >--                   set PC = 60 (less than)
  <-[                   if value gt 1 go to next char

                    2 plus
  >>[<->-]<--           set PC = 43 (plus)
  <-[                   if value gt 1 go to next char

                    3 minus
  >++                   set PC = 45 (minus)
  <-[                   if value gt 1 go to next char

                    4 dot
  >+                    set PC = 46 (dot)
  <-[                   if value gt 1 go to next char

                    5 comma
  >--                   set PC = 44 (comma)
  <-[                   if value gt 1 go to next char

                    6 left bracket
  >+[>+<-]>[<++>-]<+    set PC = 91 (left bracket) (inc (45) / double (90) / inc (91))
  <-[                   if value gt 1 go to next char

                    7 right bracket
  >++                   set PC = 93 (right bracket)
  <-                    decrease value the last time to exit if

  ]]]]]]]               close all ifs
  >.[-]                 print char and clear PC
  >[-]                  clear 15 if still existant

  <<<                   go to next bits
  +                     repeat if not SB
]

Python 2, 80 79 63 55 + 86 64 = 119 ไบต์

ขอบคุณ Sp3000 สำหรับคำแนะนำ^{มากมาย}ของเขาซึ่งช่วยประหยัดได้มาก

Brainfuck to Unary, 78 77 61 53 + 2 = 55 ไบต์

เพิ่มสองไบต์ลงในบัญชีสำหรับการป้อนข้อมูลโดยรอบ "

print int(`[1]+map("><+-.,[]".find,input())`[1::3],8)

เป็นเอกสิทธิ์ของ Brainfuck, 86 64 ไบต์

print''.join("><+-.,[]"[int(i)]for i in oct(input())[2:]if'L'>i)

ตรวจสอบ ideone ที่นี่

CJam, 35 ไบต์

Brainfuck ถึง Unary, 17 ไบต์

1r"><+-.,[]"f#+8b

ลองออนไลน์

มันทำงานอย่างไร

 r                e# Read a whitespace-separated token from STDIN.
            f     e# For each character in the token:
  "><+-.,[]" #    e#     Find its index in this string.
1             +   e# Prepend a 1 to the results.
               8b e# Convert to integer, using base 8 conversion.

เอกภาพกับ Brainfuck, 18 ไบต์

ri8b"><+-.,[]"f=1>

ลองออนไลน์

มันทำงานอย่างไร

r                  e# Read a whitespace separated token from STDIN.
 i                 e# Interpret as integer.
  8b               e# Convert to array using base 8 conversion.
              f    e# For each digit:
    "><+-.,[]" =   e#     Select the corresponding character from the string.
                1> e# Discard the first character.

Bash + coreutils, 39 + 47 = 86

b2u.sh:

dc -e8i1`tr '<>+-.,[]' 0-7`p|tr -dc 0-9

u2b.sh:

dc -e8o?p|tr -dc 0-9|tr 0-7 '<>+-.,[]'|cut -c2-

ผลการทดสอบ:

$ echo "++++++[>++++++++++++<-]>.>++++++++++[>++++++++++<-]>+.+++++++..+++.>++++[>+++++++++++<-]>.<+++[>----<-]>.<<<<<+++[>+++++<-]>.>>.+++.------.--------.>>+." | ./b2u.sh
239234206933197750788456456928845900180965531636435002144714670872282710109774487453364223333807054152602699434658684117337034763550216789 
$ echo 239234206933197750788456456928845900180965531636435002144714670872282710109774487453364223333807054152602699434658684117337034763550216789 | ./u2b.sh
++++++[>++++++++++++<-[>.>++++++++++[>++++++++++<-[>+.+++++++..+++.>++++[>+++++++++++<-[>.<+++[>----<-[>.<<<<<+++[>+++++<-[>.>>.+++.------.--------.>>+.
$

Japt 13 + 13 = 26 ไบต์

Brainfuck ถึง Unary

i< n"><+-.,[]

ลองมัน!

คำอธิบาย:

i<               :Insert a "<" at the start of the string (representing 1)
   n             :Convert string to decimal by interpreting as:
    "><+-.,[]    : A base 8 number represented by the 8 characters of BF

เอกภาพกับ Brainfuck

s"><+-.,[]" Å

ลองมัน!

คำอธิบาย:

s                :Convert decimal to string representation of:
 "><+-.,[]"      : Base 8 using the BF characters to represent the 8 digits
            Å    :Remove the extra "<" at the front

หมายเหตุ

ฉันไม่พบเมตาโพสต์ แต่ถ้าหน่วยความจำของฉันทำหน้าที่ตอบถูกต้องได้รับอนุญาตให้ จำกัด I / O กับตัวเลขที่ภาษาของพวกเขาสามารถรองรับได้ตราบใดที่พวกเขาใช้อัลกอริทึมที่จะทำงานหากภาษาเริ่มรองรับตัวเลขขนาดใหญ่ ในกรณีนี้ความสามารถของ Japt ในการจัดการสตริงในฐานะ "ฐานnโดยใช้nอักขระเหล่านี้เป็นตัวเลข" สามารถใช้numberประเภทข้อมูลทางด้านอื่น ๆ ของการดำเนินการได้เท่านั้นดังนั้นกรณีทดสอบจะไม่สามารถทำงานได้สำเร็จ เอาท์พุทของโปรแกรมแรกและการป้อนข้อมูลของโปรแกรมที่สองจะบีบบังคับหมายเลขที่หนึ่งซึ่งสามารถแสดงเป็นnumberมากกว่าการใช้ตัวเลขจริง สำหรับตัวเลขที่สามารถแสดงได้อย่างสมบูรณ์แบบโดย Japt'snumberประเภทข้อมูลโปรแกรมเหล่านี้จะทำงานได้ตามที่ต้องการและหากการnumberเปลี่ยนแปลงประเภทข้อมูลเพื่อรองรับจำนวนที่มากขึ้นโปรแกรมเหล่านี้จะเริ่มสนับสนุนตัวเลขเหล่านั้นเช่นกัน

05AB1E , 33 (17 + 16) ไบต์

Brainfuck ถึง Unary-length:

"><+-.,[]"sSk1š8β

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

"><+-.,[]"           # Push string "><+-.,[]"
          s          # Swap to take the (implicit) input
           S         # Convert it to a list of characters
            k        # Check for each the index in the string
             1š      # Prepend a 1 to the list of indices
               8β    # Convert the list to Base-8 (and output implicitly)

ความยาวเอกสิทธิ์ของ Brainfuck

8в¦"><+-.,[]"sèJ

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

8в                  # Convert the (implicit) input-list from Base-8 to Base-10
  ¦                 # Remove the first 1
   "><+-.,[]"       # Push string "><+-.,[]"
             s      # Swap the list and string on the stack
              è     # Index each integer into this string
               J    # Join everything together (and output implicitly)

Dart , 77 + 142 = 219 ไบต์

f(s)=>BigInt.parse('1'+s.split('').map('><+-.,[]'.indexOf).join(''),radix:8);

F(n)=>BigInt.parse(n).toRadixString(8).split('').map((s)=>'><+-.,[]'.substring(int.parse(s),int.parse(s)+1)).join('').toString().substring(1);

ลองออนไลน์!

C (gcc) 254 ไบต์

#include"gmp.h"
f(i,o)char*i,*o;{mpz_t l;char*c="><+-.,[]";if(*i>47&*i<58)for(mpz_init_set_str(l,i,0),mpz_get_str(o,8,l);*o;*o++=o[1]?c[o[1]-48]:0);else for(mpz_init_set_si(l,1);mpz_get_str(o,10,l),*i;mpz_mul_si(l,l,8),mpz_add_ui(l,l,strchr(c,*i++)-c));}

ลองออนไลน์!

กำหนดทิศทางที่จะไปตามอินพุต ( i) เก็บผลลัพธ์ไว้ในบัฟเฟอร์ที่ผ่าน ( o) โปรดทราบว่าคอมไพเลอร์บางตัวอนุญาตให้บันทึกได้ 4 ไบต์ตามการกำหนดลำดับการนำไปปฏิบัติของ o ++ ในกรณีเหล่านี้โซลูชันที่ให้มาจะตัดทอนอักขระพิเศษออกจากการแปลง Unary-> BF และo[1]ทั้งหมดสามารถถูกแทนที่ด้วย*oเพื่อกู้คืนพฤติกรรม