ความท้าทายนี้สร้างขึ้นเพื่อเฉลิมฉลองภาษาลับแรกของฉันแบ็คแฮนด์ !

แบ็คแฮนด์เป็นภาษาหนึ่งมิติที่มีโฟลว์ตัวชี้ที่ไม่ใช่เชิงเส้น ตัวชี้ย้ายทีละสามขั้นตอนดำเนินการตามคำสั่งที่สามทุกครั้งเท่านั้น

โปรแกรม1..1..+..O..@จะเพิ่ม 1 + 1 และเอาท์พุท 2 ก่อนที่จะยุติ คำแนะนำระดับกลางถูกข้ามไปดังนั้น1<>1()+{}O[]@เป็นโปรแกรมเดียวกันทั้งหมด

เมื่อตัวชี้กำลังจะก้าวออกจากจุดสิ้นสุดของเทปมันจะกลับทิศทางและทำตามขั้นตอนในลักษณะอื่นดังนั้นจึง1.@1.O+.เป็นโปรแกรมเดียวกัน โปรดทราบว่ามันจะนับคำสั่งสิ้นสุดเพียงครั้งเดียวเท่านั้น สิ่งนี้ทำให้เราสามารถบีบอัดโปรแกรมเชิงเส้นส่วนใหญ่ได้เช่น1O+1@

ความท้าทายของคุณที่นี่คือการเขียนโปรแกรมหรือฟังก์ชั่นที่รับสายและส่งคำสั่งที่จะถูกดำเนินการหากโปรแกรมตีความเช่น Backhand (คุณไม่จำเป็นต้องจัดการกับคำแนะนำ Backhand จริง ๆ ) คุณจะต้องส่งออกเท่านั้นจนกว่าตัวชี้จะตกลงบนอักขระตัวสุดท้ายของสตริง (ซึ่งการดำเนินการตามปกติจะย้อนกลับ)

แต่รอนั่นไม่ใช่ทั้งหมด! เมื่อโปรแกรมของคุณถูกตีความในลักษณะนี้โค้ดผลลัพธ์ควรออกด้านล่างอย่างใดอย่างหนึ่ง:

• (Mostly) works
• Turing complete
• 'Recreational' (คำพูดที่สามารถเป็นได้ทั้ง'หรือ"แต่ไม่ใช่ทั้งสอง)
• Perfectly okay
• Only a few bugs

ตัวอย่างเช่นหากซอร์สโค้ดของคุณคือcode 2 backhandโปรแกรมce cankb od2ahdควรส่งออกหนึ่งในวลีเหล่านี้

กรณีทดสอบ:

"1  1  +  O  @"  -> "11+O@"
"1O+1@"          -> "11+O@"
"HoreWll dlo!"   -> "Hello World!"
"abcdefghijklmnopqrstuvwxyz" -> "adgjmpsvyxurolifcbehknqtwz"
"0123456789"     -> "0369"  (not "0369630369")
"@"              -> "@"
"io"             -> "io"  (Cat program in Backhand)
"!?O"            -> "!?O" (Outputs random bits forever in Backhand)
"---!---!"       -> "-!-----!"

และแน่นอนว่าโปรแกรมอ้างอิงที่เขียนด้วยแบ็คแฮนด์ ( อาจเป็นรถบักกี้เอาล่ะฉันคิดว่าฉันคงซ่อมแล้ว)

กฎระเบียบ

• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• อินพุตของโปรแกรมแรกจะมีเฉพาะ ASCII ที่พิมพ์ได้และขึ้นบรรทัดใหม่ (นั่นคือไบต์0x20- 0x7Eและ 0x0A)
• คุณสามารถเลือกได้ว่าโปรแกรมที่สองของคุณจะถูกแปลงจากไบต์แรกหรือตามตัวอักษร UTF-8
• โปรแกรมที่สอง:
  • เคสไม่สำคัญดังนั้นผลลัพธ์ของคุณอาจเป็นไปได้pErFectLy OKayหากคุณต้องการ
  • จำนวนของช่องว่างต่อท้าย / นำหน้า (ขึ้นบรรทัดใหม่แท็บช่องว่าง) ก็ไม่เป็นไร
  • โปรแกรมที่สองควรเป็นภาษาเดียวกันกับภาษาแรก แต่ไม่จำเป็นต้องเป็นรูปแบบเดียวกัน (โปรแกรม / ฟังก์ชั่น)
  • ฉันยินดีที่จะรวมข้อเสนอแนะจากความคิดเห็นเกี่ยวกับวลีพิเศษ (ตราบใดที่ไม่สั้นเกินไป)
• เนื่องจากนี่คือcode-golfเป้าหมายของคุณคือการได้รับคำตอบสั้น ๆ สำหรับภาษาของคุณ!
• ในสองสัปดาห์ฉันจะให้รางวัล 200 ค่าหัวกับคำตอบแบ็คแฮนด์ที่สั้นที่สุด

R , 187 ไบต์

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g=function(x,n=nchar(x),i=c(1:n,(n-1):1,2:n),j=seq(1,3*n-2,3),k=i[j][1:which(i[j]==n)[1]])cat(substring(x,k,k),sep='') 

ลองออนไลน์!

จำเป็นต้องใช้พื้นที่เดียวในตอนท้ายเพื่อ\nไม่ให้พิมพ์ออกมาเมื่อใช้กับโปรแกรม

คำอธิบาย

ส่วนที่ 1:

Ungolfed:

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g <- function(x) {
  n <- nchar(x)                      # number of characters in string
  i <- c(1:n, (n - 1):1, 2:n)        # index: 1 to n, n-1 back to 1, 2 to n
  j <- seq(1, 3 * n - 2, 3)          # every third element of i
  k <- i[j][1:which(i[j] == n)[1]]   # the elements of i at indices j, up to the first appearance of n
  cat(substring(x, k, k), sep = "")  # extract from x the characters at indices k, and paste them together
}

ส่วนที่ 2:

ฟังก์ชั่นสร้างสิ่งนี้เมื่อมันทำงานกับโปรแกรมทั้งหมด:

cat('Perfectly okay')#=ni(ncr)=1,-:2)=q,n,,i]:i(j=[]assi(k)e' 

Python 2 , 163 130 127 121 115 99 96 ไบต์

i=input() ###
print(i+i[-2:0:-1]+i)[:len(i)*(len(i)%3%2or 3):3]  

#'p lr+yi  n'ottk(ca'eyPf'er)

ลองออนไลน์!

ขาออก:

int #rt+-01i:n)l(%2 : 
print('Perfect' + # 33o3ie*(l)]:2i(i
#(p=iu)#pni[:-+[ei(n)%r)]
'ly okay')

Perl 6 , 101 86 ไบต์

ว้าวขอบคุณ -25 ไบต์สำหรับ nwellnhof โดยการปรับปรุงโปรแกรมครั้งแรกอย่างมาก

##
{S:g/(.).?.?/$0/}o{.comb%3-1??.chop~.flip~S/.//!!$_} #
#}{ "" s( kM ro os wt  l )y.

ลองออนไลน์!

ฉันหวังว่าผู้คนจำนวนมากใช้ประโยชน์จากการฟื้นตัวเช่นนี้ โปรแกรมแบ็คแฮนด์คือ

#{g.?//{o%1.o.iS/!}
{"(Mostly) works"}#_!.~l~h?-bco0?.(:
#S/).$}.m3?cpfp//$ #        .

{"(Mostly) works"}ซึ่งความเห็นออกไปเพียงแค่

05AB1E , 43 40 38 37 ไบต์

-2 ไบต์ (40 → 38) ขอบคุณที่@Emigna

„€€Ã€„Ѐ€µ'€Ý)\[ûDN3*©è  ?®IgD#<ÖNĀ*#

ลองมันออนไลน์ (PS: เปลี่ยนภาษาจาก05AB1E (ดั้งเดิม)เป็น05AB1Eสำหรับกรณีทดสอบ0123456789รุ่นเดิมเร็วขึ้น แต่จะแสดงผลลัพธ์ที่ไม่ถูกต้องสำหรับการป้อนตัวเลขด้วยศูนย์นำหน้า)

โปรแกรม 'แบ็คแฮนด์' จะกลายเป็น:

„ÃеÝ[N© I#N#

ซึ่งจะแสดงผลเป็นperfectly okayตัวพิมพ์เล็กเต็ม

ลองออนไลน์

โปรแกรมฐานคำอธิบาย:

„€€Ã€           # Push the string "the pointed"
„Ѐ€µ           # Push the string "dm one"
'€Ý            '# Push the string "been"
     )          # Wrap the entire stack in a list
      \         # And remove that list from the stack again
[               # Start an infinite loop
 û              #  Palindromize the string at the top of the stack
                #   i.e. "1O+1@" becomes "1O+1@1+O1" the first iteration,
                #        and "1O+1@1+O1O+1@1+O1" the next iteration, etc.
  D             #  Duplicate the palindromized string
 N3*            #  0-indexed index of the loop multiplied by 3
    ©           #  Save it in the register (without popping)
     è?         #  Index into the string and print the character
  Ig            #  If the length of the input is exactly 1:
     #          #   Stop the infinite loop
 ®  D <Ö        #  If the value from the register is divisible by the length - 1
          *     #  And
        NĀ      #  The 0-indexed index of the loop is NOT 0:
           #    #   Stop the infinite loop

คำอธิบายโปรแกรม 'backhanded':

„ÃÐµÝ           # Push the string "perfectly okay"
     [          # Start an infinite loop
      N©        #  Push the index, and store it in the register (without popping)
          I     #  Push the input (none given, so nothing happens)
           #    #  If the top of the stack is 1, stop the infinite loop
            N   #  Push the index again
             #  #  If the top of the stack is 1, stop the infinite loop

ทีละขั้นตอนต่อไปนี้เกิดขึ้น:

1. „ÃеÝ: STACK กลายเป็น ["perfectly okay"]
2. [: เริ่มวนซ้ำไม่สิ้นสุด
3. (การวนซ้ำลูปแรก) N©: STACK กลายเป็น["perfectly okay", 0]
4. (การวนซ้ำลูปแรก) I: STACK ยังคงอยู่["perfectly okay", 0]เนื่องจากไม่มีอินพุต
5. (การวนซ้ำลูปแรก) #: STACK กลายเป็น["perfectly okay"]และลูปจะดำเนินต่อ
6. (การวนซ้ำลูปแรก) N: STACK กลายเป็น["perfectly okay", 0]
7. (การวนซ้ำลูปแรก) #: STACK กลายเป็น["perfectly okay"]และลูปจะดำเนินต่อ
8. (การวนซ้ำลูปที่สอง) N©: STACK จะกลายเป็น["perfectly okay", 1]
9. (การวนซ้ำลูปที่สอง) I: STACK ยังคงอยู่["perfectly okay", 1]เนื่องจากไม่มีอินพุต
10. (การวนซ้ำลูปที่สอง) #: STACK กลายเป็น["perfectly okay"]และการวนซ้ำจะหยุดลงเนื่องจาก1(ความจริง)
11. พิมพ์ด้านบนสุดของสแต็กไปยัง STDOUT โดยปริยาย: perfectly okay

ดูขั้นตอนที่นี่ด้วยดีบักเกอร์บน TIO ที่เปิดใช้งาน

ดู 05AB1E นี้เคล็ดลับของฉัน (ส่วนวิธีการใช้พจนานุกรม? )จะเข้าใจว่าทำไม„€€Ã€„Ѐ€µ'€Ýมีthe pointed, dm oneและbeenและเป็น„ÃеÝperfectly okay

รุ่น 38 ไบต์เก่า:

„€€Ã€„Ѐ€µ'€Ý)\ giqë¬?[ûDN>3*©è?®Ig<Ö#

ลองมันออนไลน์ (PS: เปลี่ยนภาษาจาก05AB1E (ดั้งเดิม)เป็น05AB1Eสำหรับกรณีทดสอบ0123456789และ@รุ่นดั้งเดิมนั้นเร็วกว่า แต่มันแสดงผลลัพธ์ที่ไม่ถูกต้องสำหรับอินพุตตัวเลขด้วยอินพุตศูนย์หรืออินพุตอินพุตเดี่ยว)

โปรแกรม 'แบ็คแฮนด์' จะกลายเป็น:

„ÃÐµÝ q?D3èIÖ<®©>û¬i\€€„€€€€')gë[N*?g#

(ในกรณีที่qออกจากโปรแกรมและทำให้ทุกอย่างไม่มีตัวเลือก)

ลองออนไลน์

Python 2 , 130 ไบต์

p='r'#i  n  t  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  # 
s=input();S=s+s[-2:0:-1]+s
print S[:len(~-len(s)%3and S or s):3]

ลองออนไลน์!

JavaScript (ES6), 130 ไบต์

พยายามครั้งแรก ไม่ค่อยพอใจ

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/(g=p=>(c=y[p])?m++%3?g(p+d):y[p+1]?c+g(p+d):c:g(p-d-d,d=-d))(m=0,d=1)

ลองออนไลน์!

เมื่อโค้ดถูกประมวลผลด้วยตัวเองอักขระต่อไปนี้จะถูกแยก:

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/…
^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^

ซึ่งจะช่วยให้:

f=>"Perfectly okay"//…

เยลลี่ 34 ไบต์

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€

ลิงก์แบบเต็มโปรแกรมหรือลิงก์แบบ monadic ยอมรับรายการของอักขระที่พิมพ์หรือให้ผลตอบแทน (ตามลำดับ)

ลองออนไลน์! หรือดูการทดสอบในตัว

โค้ดแบ็คแฮนด์ที่แยกวิเคราะห์แล้ว:

Jȧ“N2s]Ỵ»ị@€

โปรแกรมเต็มรูปแบบหรือการพิมพ์การเชื่อมโยง niladic หรือผลผลิต (ตามลำดับ) ทัวริงสมบูรณ์

อย่างไร?

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€ - Main Link: list of characters   e.g. 'abcd'
J                                  - range of length                      [1,2,3,4]
 ŒḄ                                - bounce                         [1,2,3,4,3,2,1]
    `                              - use as both arguments of:
   ȧ                               -   logical AND [x AND x = x]
      “”                           - literal empty list of characters
     ȯ                             - logical OR [when x is truthy: x OR y = x]
        N                          - negate  }
         N                         - negate  } together a no-op
             ¡                     - repeat this...
            2                      - ... two times:
          ŒḄ                       -   bounce                       [1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1]
              3                    - literal three
               s@                  - split into (threes)            [[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1]]
                 ”]                - literal ']' character
                   ȧ               - logical AND [']' is truthy so a no-op]
                    Z              - transpose                      [[1,4,1,4,1,4,1,4,1],[2,3,2,3,2,3,2,3],[3,2,3,2,3,2,3,2]]
                     Ỵ             - split at new lines [no newline characters exist in this list of ints so effectively wrap in a list]
                      Ḣ            - head [undo that wrap]
                       Ḣ           - head [get the first of the transposed split indices]
                                   -                                [1,4,1,4,1,4,1,4,1]
                         `         - use as both arguments of:
                        »          -   maximum [max(x, x) = x]
                          Q        - de-duplicate                   [1,4]
                            ⁸      - chain's left argument (the input)
                           ị       - index into it                  "ad"
                               11€ - literal eleven for €ach (of input)
                             ȧ@    - logical AND with swapped args [[11,11,...,11] is truthy]
                                   -                                "ad"
                                   - (as a full program implicit print)

โค้ดแบ็คแฮนด์ที่แยกวิเคราะห์แล้ว:

Jȧ“N2s]Ỵ»ị@€ - Main Link: no arguments
J            - range of length (of an implicit 0, treated as [0]) -> [1]
  “N2s]Ỵ»    - compression of "Turing complete"
 ȧ           - logical AND [[1] is truthy] -> "Turing complete"
           € - for each character in the list of characters:
          @  -   with swapped arguments (an implicit 0 is on the right, so f(0, "Turing complete"))
         ị   -     index into
             - (as a full program implicit print)

Runic Enchantmentsขนาด 294 ไบต์

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                                  /{\!?   =ka:{;!?=ka\
v   R                         R {{R:ak=?!\:$:'@=?!;{:/
v/?!/:$:'@=?!;}:ak= ?!;}:ak=?!\}\        }
y\=ka:L                      }{ /        }
\iuakrU      y<<              !  }}}L {{{L

ลองออนไลน์!

เวอร์ชันที่ไม่บีบอัด (และเกือบอ่านได้):

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                               ;           /                                 \
/y<<         R                         R {{R:ak=?!\:$:'@=?!;{:ak=?!\{:ak=?!\{/
RiuakrR:ak=?!/:$:'@=?!;}:ak= ?!/}:ak=?!\}\        }                ;
\y<<  U                               }{ /        }
      \                                !          L                     }}}L

ลองออนไลน์!

อันนี้ ... ใกล้จะถึงแล้ว

การบีบอัดมันเพิ่มเติมนั้นจะต้องมีการหาวิธีในการจัดการกับจุดต่าง ๆ ของการวนลูปโดยไม่ทำให้มันชนกับสิ่งอื่น บรรทัดแรก (ซึ่งเป็นเพียงส่วนเดียวที่จำเป็นต้องส่งผ่านเป็นอินพุตไปยังตัวเอง) จะต้องแยกจากกัน: สตริงทั้งหมดไม่สามารถพอดีกับบรรทัดที่สองโดยไม่ทำให้เกิดปัญหา ( _สำหรับพื้นที่ที่ต้องการ):

Needed string:
>; "  O  n  l  y  _  a  _  F  e  w  _  B  u  g  s
Best fit:
>; "  O  n  l  y  _  a  _  F  e  w/{_\!?   =ka:{;!?=ka\
Collision:                             ↑

ที่?ไม่สามารถย้ายออกไปจาก!ที่ตัวเองไม่สามารถย้ายออกไปจาก\และไม่มีข้อความที่ยอมให้การใด ๆ ของทั้งสามตัวละครที่ตำแหน่งนี้

ทางเลือกอื่นคือใช้การเปลี่ยนเส้นทางของโฟล แต่สิ่งนี้นำไปสู่ปัญหาบนบรรทัดล่าง:

Last usable character:
            ↓
>"Only a Few Bugs"@
/.../
ur         }{L
              ↑
Earliest available free space:

เนื่องจากเราต้องหลีกเลี่ยงการวนซ้ำสลับในโปรแกรมหลัก

ปัญหาที่พบ:

• อินพุตที่มีขนาดใหญ่มาก เนื่องจากข้อ จำกัด IP ของ Runic การกดสตริงอินพุตที่มีขนาดใหญ่มากจะทำให้ IP หมดอายุก่อนที่จะเสร็จสิ้น สิ่งนี้สามารถลดลงได้โดยการวางไข่ IP เพิ่มเติมและรวมเข้าด้วยกัน (ตัวอย่างเช่นมันจัดการabcdefghijklmnopqrstuvwxyzแต่ไม่ใช่แหล่งทั้งหมดของตัวเอง) และมีข้อ จำกัด ไม่ว่าจะมีการรวมกันกี่ครั้ง สามารถจัดการอินพุตได้มากถึง 58 ไบต์ตามที่เป็นอยู่ (นอกจากนี้การเพิ่มจำนวน IP ต้องใช้การหาวิธีผสานรวมโดยไม่ต้องใช้พื้นที่มากขึ้น) สามารถใส่รายการ IP ได้อีกสองรายการในบรรทัดวนกลับ (ทางด้านขวาของUบรรทัดที่เริ่มต้น\y<<ในเวอร์ชันที่ไม่มีการบีบอัดหรืออีกหนึ่งรายการที่เหลืออยู่บนบรรทัดด้านบนy<<ในรุ่นบีบอัด) เพิ่มความยาวสูงสุดเป็น 78
• สตริงอินพุตที่มีช่องว่างจำเป็นต้องเว้นช่องว่าง (เช่น1\ \ 1\ \ +\ \ O\ \ @) นี่เป็นข้อ จำกัด ของการแยกวิเคราะห์อินพุตของภาษา
• ไม่สามารถระบุอินพุตที่ประกอบด้วยสตริงที่ดูเหมือนจำนวนเต็มเริ่มต้นด้วยจำนวน0s ใด ๆ(เมื่อเปลี่ยนเป็นตัวเลขบนสแต็กการ0สูญเสีย) ข้อ จำกัด ของการแยกวิเคราะห์อินพุตของภาษาอีกครั้ง

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

รายการ:

1. รวม 4 พอยน์เตอร์คำแนะนำ
2. อ่านอินพุตแบ่งเป็นอักขระผนวกบรรทัดใหม่ย้อนกลับป้อนลูปหลัก

Main loop (สิ่งใดที่ปรากฏสแต็กนำหน้าด้วย dup):

1. พิมพ์ด้านบนของสแต็ก
2. เปรียบเทียบกับ newline True: สลับลูปและหมุนสแต็กซ้ายสองครั้ง
3. @เปรียบเทียบกับ จริง: ยุติ (ยกเลิกคำสั่งที่เรียกใช้)
4. หมุนสแต็กไปทางขวา
5. เปรียบเทียบกับ newline จริง: ยุติ (ดำเนินการคำสั่งขวาสุด)
6. หมุนสแต็กไปทางขวา
7. เปรียบเทียบกับ newline จริง: สลับลูปและหมุนสแต็กซ้ายสามครั้ง
8. หมุนสแต็กไปทางขวา
9. กลับไปที่ด้านบนของวง

ห่วงรอง:

• เหมือนกันกับวงหลักสลับเฉพาะหมุนไปทางขวาด้วยซ้ายหมุน