Thử thách này được tạo ra để kỷ niệm ngôn ngữ bí truyền đầu tiên của tôi, Backhand !

Backhand là ngôn ngữ một chiều với luồng con trỏ phi tuyến tính. Con trỏ di chuyển ba bước một lần, chỉ thực hiện mỗi lệnh thứ ba.

Chương trình 1..1..+..O..@sẽ thêm 1 + 1 và đầu ra 2 trước khi kết thúc. Các hướng dẫn trung gian được bỏ qua, do đó, 1<>1()+{}O[]@chính xác là cùng một chương trình.

Khi con trỏ chuẩn bị rời khỏi phần cuối của băng, nó sẽ đảo ngược hướng và bước theo cách khác, đó 1.@1.O+.là cùng một chương trình. Lưu ý rằng nó chỉ đếm hướng dẫn kết thúc một lần. Điều này cho phép chúng tôi nén hầu hết các chương trình tuyến tính xuống, chẳng hạn như1O+1@

Thách thức của bạn ở đây là viết một chương trình hoặc hàm lấy một chuỗi và xuất ra các hướng dẫn sẽ được thực thi nếu chương trình được diễn giải như Backhand (bạn không cần phải xử lý bất kỳ hướng dẫn Backhand thực tế nào). Bạn chỉ xuất ra cho đến khi con trỏ hạ cánh xuống ký tự cuối cùng của chuỗi (tại thời điểm đó, việc thực thi thường sẽ đi lùi).

Nhưng chờ đã , đó không phải là tất cả! Khi chính chương trình của bạn được diễn giải theo kiểu này, mã kết quả sẽ xuất ra một trong các cách sau:

• (Mostly) works
• Turing complete
• 'Recreational' (dấu ngoặc kép có thể là 'hay ", nhưng không phải tất cả)
• Perfectly okay
• Only a few bugs

Ví dụ, nếu mã nguồn của bạn là code 2 backhand, thì chương trình ce cankb od2ahdsẽ xuất ra một trong những cụm từ này.

Các trường hợp thử nghiệm:

"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)
"---!---!"       -> "-!-----!"

Và một chương trình tham khảo được viết bằng, tất nhiên, Backhand ( điều này có thể là một lỗi nhỏ Được rồi, tôi nghĩ rằng tôi đã sửa nó).

Quy tắc.

• Lỗ hổng tiêu chuẩn bị cấm
• Đầu vào của chương trình đầu tiên sẽ chỉ chứa ASCII có thể in và các dòng mới (nghĩa là byte 0x20- 0x7Ecũng như 0x0A)
• Bạn có thể chọn xem chương trình thứ hai của bạn được chuyển đổi từ đầu tiên theo byte hay bằng ký tự UTF-8.
• Chương trình thứ hai:
  • Trường hợp không không quan trọng, vì vậy đầu ra của bạn có thể là pErFectLy OKaynếu bạn muốn.
  • Bất kỳ số lượng dấu vết / khoảng trắng hàng đầu (dòng mới, tab, khoảng trắng) cũng được.
  • Chương trình thứ hai phải cùng ngôn ngữ với ngôn ngữ thứ nhất, mặc dù không nhất thiết phải cùng định dạng (chương trình / chức năng)
  • Tôi rất vui khi bao gồm các đề xuất từ ​​các nhận xét về các cụm từ bổ sung (miễn là chúng không quá ngắn)
• Vì đây là môn đánh gôn , mục tiêu của bạn là có được câu trả lời ngắn nhất cho ngôn ngữ của bạn!
• Trong hai tuần, tôi sẽ trao 200 tiền thưởng cho câu trả lời Backhand ngắn nhất.

R , 187 byte

 # 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='') 

Hãy thử trực tuyến!

Không gian duy nhất ở cuối là cần thiết để \nkhông bao giờ được in khi chương trình được áp dụng cho chính nó.

Giải trình

Phần 1:

Ung dung:

 # 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
}

Phần 2:

Hàm tạo ra điều này khi nó hoạt động trên toàn bộ chương trình:

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

Python 2 , 163 130 127 121 115 99 96 byte

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)

Hãy thử trực tuyến!

Đầu ra:

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

Perl 6 , 101 86 byte

Wow, -25 byte nhờ nwellnhof bằng cách cải thiện mạnh mẽ chương trình đầu tiên

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

Hãy thử trực tuyến!

Tôi hy vọng nhiều người tận dụng sự phục hồi như thế này. Chương trình Backhanded là

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

Mà bình luận ra chỉ {"(Mostly) works"}.

05AB1E , 43 40 38 37 byte

-2 byte (40 → 38) nhờ @Emigna .

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

Hãy thử trực tuyến . (PS: Chuyển ngôn ngữ từ 05AB1E (di sản) sang 05AB1E cho trường hợp thử nghiệm 0123456789. Phiên bản kế thừa nhanh hơn, nhưng hiển thị kết quả không chính xác cho đầu vào số có số 0 đứng đầu.)

Chương trình 'trái tay' sẽ trở thành:

„ÃеÝ[N© I#N#

Mà sẽ xuất ra perfectly okaychữ thường.

Hãy thử trực tuyến.

Chương trình cơ sở giải thích:

„€€Ã€           # 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

Chương trình giải thích 'trái tay':

„ÃÐµÝ           # 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

Từng bước một xảy ra như sau:

1. „ÃеÝ: STACK trở thành ["perfectly okay"]
2. [: Bắt đầu vòng lặp vô hạn
3. (lặp lại vòng lặp đầu tiên) N©: STACK trở thành["perfectly okay", 0]
4. (lặp lại vòng lặp đầu tiên) I: STACK vẫn còn ["perfectly okay", 0]vì không có đầu vào
5. (lặp lại vòng lặp đầu tiên) #: STACK trở thành ["perfectly okay"]và vòng lặp tiếp tục
6. (lặp lại vòng lặp đầu tiên) N: STACK trở thành["perfectly okay", 0]
7. (lặp lại vòng lặp đầu tiên) #: STACK trở thành ["perfectly okay"]và vòng lặp tiếp tục
8. (lặp lại vòng lặp thứ hai) N©: STACK trở thành["perfectly okay", 1]
9. (Lặp lại vòng lặp thứ hai) I: STACK vẫn còn ["perfectly okay", 1]vì không có đầu vào
10. (Lặp lại vòng lặp thứ hai) #: STACK trở thành ["perfectly okay"]và vòng lặp bị phá vỡ vì 1(sự thật)
11. Hoàn toàn in phần trên cùng của ngăn xếp thành STDOUT: perfectly okay

Xem các bước ở đây với trình gỡ lỗi trên TIO được bật.

Xem mẹo 05AB1E này của tôi (phần Làm thế nào để sử dụng từ điển? ) Để hiểu tại sao „€€Ã€„Ѐ€µ'€Ýlà the pointed, dm onevà beenvà „ÃеÝlà perfectly okay.

Phiên bản 38 byte cũ:

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

Hãy thử trực tuyến . (PS: Chuyển ngôn ngữ từ 05AB1E (di sản) sang 05AB1E cho các trường hợp thử nghiệm 0123456789và @. Phiên bản kế thừa nhanh hơn, nhưng nó hiển thị kết quả không chính xác cho đầu vào số với đầu vào số 0 hoặc đầu vào đơn.)

Chương trình 'trái tay' sẽ trở thành:

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

(Trường hợp qthoát khỏi chương trình và làm cho mọi thứ khác không hoạt động.)

Hãy thử trực tuyến.

Python 2 , 130 byte

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]

Hãy thử trực tuyến!

JavaScript (ES6), 130 byte

Nỗ lực sớm. Không thỏa mãn lắm.

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)

Hãy thử trực tuyến!

Khi mã được xử lý bởi chính nó, các ký tự sau được tách ra:

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

cung cấp cho:

f=>"Perfectly okay"//…

Thạch , 34 byte

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

Một chương trình đầy đủ hoặc liên kết đơn âm chấp nhận một danh sách các ký tự in hoặc sinh ra (tương ứng).

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Mã phân tích cú pháp Backhand là:

Jȧ“N2s]Ỵ»ị@€

Một chương trình đầy đủ hoặc in liên kết niladic hoặc năng suất (tương ứng) Turing hoàn thành .

Làm sao?

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)

mã phân tích cú pháp Backhand là:

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 bùa mê , 294 byte

>; "  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

Hãy thử trực tuyến!

Phiên bản không nén (và gần như có thể đọc được):

>; "  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

Hãy thử trực tuyến!

Đây là ... gần như tôi có thể nhận được.

Nén nó hơn nữa sẽ yêu cầu tìm ra cách xử lý các điểm hoán đổi vòng lặp khác nhau mà không khiến chúng va chạm với những thứ khác. Dòng đầu tiên (là phần duy nhất cần được truyền làm đầu vào cho chính nó) được yêu cầu giữ riêng biệt: toàn bộ chuỗi không thể vừa với dòng thứ hai mà không gây ra sự cố ( _đối với khoảng trắng bắt buộc):

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:                             ↑

Điều đó ?không thể được di chuyển khỏi cái !mà chính nó không thể được di chuyển khỏi\ và không có tin nhắn nào được phép cho phép bất kỳ ba ký tự nào ở vị trí này.

Thay thế sẽ là sử dụng chuyển hướng dòng chảy, nhưng điều đó dẫn đến một vấn đề ở dòng dưới:

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

Vì chúng ta phải tránh chuyển đổi vòng lặp trong chương trình chính.

Các vấn đề đã biết:

• Đầu vào cực lớn. Do giới hạn ngăn xếp IP của Runic, việc đẩy các chuỗi đầu vào rất lớn sẽ khiến IP hết hạn trước khi hoàn thành. Điều này có thể được giảm thiểu bằng cách sinh ra các IP bổ sung và hợp nhất chúng (ví dụ: nó xử lý abcdefghijklmnopqrstuvwxyznhưng không phải toàn bộ nguồn của chính nó). Và có một giới hạn bất kể có bao nhiêu sự hợp nhất xảy ra. Có thể xử lý tối đa 58 byte đầu vào (ngoài ra, việc tăng số lượng IP yêu cầu tìm ra cách để chúng hợp nhất mà không cần sử dụng nhiều dung lượng hơn). Có thể vừa với hai mục IP khác trên dòng trả về vòng lặp (ở bên phải của Udòng bắt đầu \y<<trong phiên bản không nén hoặc một bên trái trên dòng phía trên y<<trong phiên bản nén) nâng độ dài tối đa đầu vào lên 78.
• Các chuỗi đầu vào có khoảng trắng cần phải có khoảng trắng được thoát (ví dụ 1\ \ 1\ \ +\ \ O\ \ @). Đây là một hạn chế của phân tích cú pháp đầu vào của ngôn ngữ.
• Không thể cung cấp đầu vào bao gồm các chuỗi trông giống như số nguyên bắt đầu bằng bất kỳ số 0s nào (như khi biến thành số trên ngăn xếp, số 0bị mất). Một lần nữa, giới hạn phân tích cú pháp đầu vào của ngôn ngữ.

Làm thế nào nó hoạt động

Nhập cảnh:

1. Kết hợp 4 con trỏ chỉ dẫn
2. Đọc đầu vào, chia thành các ký tự, nối một dòng mới, đảo ngược, nhập vòng lặp chính.

Vòng lặp chính (bất cứ điều gì xuất hiện ngăn xếp đều có trước một bản sao):

1. In đầu ngăn xếp
2. So sánh với dòng mới. Đúng: chuyển vòng lặp và xoay ngăn xếp hai lần.
3. So sánh với @. Đúng: chấm dứt. (Chấm dứt lệnh thực thi)
4. Xoay chồng phải
5. So sánh với dòng mới. Đúng: chấm dứt. (Lệnh ngoài cùng bên phải được thực thi)
6. Xoay chồng phải
7. So sánh với dòng mới. Đúng: chuyển vòng lặp và xoay ngăn xếp ba lần trái.
8. Xoay chồng phải
9. Trở về đầu vòng lặp

Vòng lặp thứ cấp:

• Đồng nhất với vòng lặp chính, chỉ chuyển đổi xoay phải với xoay trái