Tantangan ini dibuat untuk merayakan bahasa esoteris pertamaku, Backhand !

Backhand adalah bahasa satu dimensi dengan aliran penunjuk non-linear. Pointer bergerak tiga langkah sekaligus, hanya menjalankan setiap instruksi ketiga.

Program 1..1..+..O..@akan menambahkan 1 + 1 dan output 2 sebelum mengakhiri. Instruksi perantara dilewati, begitu 1<>1()+{}O[]@juga program yang sama.

Ketika pointer akan keluar dari ujung kaset, itu sebaliknya membalikkan arah dan melangkah ke arah lain, begitu [email protected]+.juga program yang sama. Perhatikan bahwa itu hanya menghitung instruksi akhir sekali. Ini memungkinkan kita untuk mengompres sebagian besar program linier ke bawah, seperti1O+1@

Tantangan Anda di sini adalah menulis program atau fungsi yang mengambil string, dan menampilkan instruksi yang akan dieksekusi jika program ditafsirkan seperti Backhand (Anda tidak perlu menangani instruksi Backhand yang sebenarnya). Anda hanya akan output sampai pointer mendarat pada karakter terakhir dari string (di mana titik eksekusi biasanya akan mundur).

Tapi tunggu , itu belum semuanya! Ketika program Anda sendiri diinterpretasikan dengan cara ini, kode yang dihasilkan harus menampilkan salah satu di bawah ini:

• (Mostly) works
• Turing complete
• 'Recreational' (kutipan bisa berupa 'atau ", tetapi tidak keduanya)
• Perfectly okay
• Only a few bugs

Misalnya, jika kode sumber Anda code 2 backhand, maka program ce cankb od2ahdharus menampilkan salah satu dari frasa ini.

Kasus uji:

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

Dan program referensi yang ditulis, tentu saja, Backhand ( ini mungkin agak buggy Oke, saya pikir saya sudah memperbaikinya).

Aturan

• Celah Standar dilarang
• Input dari program pertama hanya akan berisi ASCII dan baris baru yang dapat dicetak (yaitu, byte 0x20- 0x7Edan 0x0A)
• Anda dapat memilih apakah program kedua Anda dikonversi dari yang pertama dengan byte atau karakter UTF-8.
• Program kedua:
  • Case tidak masalah, jadi output Anda bisa jadi pErFectLy OKayjika Anda mau.
  • Berapapun spasi / spasi spasi awal (baris baru, tab, spasi) juga oke.
  • Program kedua harus bahasa yang sama dengan yang pertama, meskipun tidak harus format yang sama (program / fungsi)
  • Saya senang memasukkan saran dari komentar pada frasa tambahan (asalkan tidak terlalu pendek)
• Karena ini kode-golf , tujuan Anda adalah mendapatkan jawaban terpendek untuk bahasa Anda!
• Dalam dua minggu, saya akan memberikan hadiah 200 untuk jawaban Backhand terpendek.

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

Cobalah online!

Satu ruang di bagian akhir dibutuhkan agar \ntidak pernah dicetak ketika program diterapkan pada dirinya sendiri.

Penjelasan

Bagian 1:

Tidak Disatukan:

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

Bagian 2:

Fungsi menghasilkan ini ketika bekerja di seluruh program:

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)

Cobalah online!

Output:

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 terima kasih kepada nwellnhof dengan secara drastis memperbaiki program pertama

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

Cobalah online!

Saya berharap lebih banyak orang mengambil keuntungan dari rebound seperti ini. Program Backhanded adalah

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

Yang berkomentar saja {"(Mostly) works"}.

05AB1E , 43 40 38 37 byte

-2 byte (40 → 38) berkat @Emigna .

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

Cobalah online . (PS: Alihkan bahasa dari 05AB1E (legacy) ke 05AB1E untuk test case 0123456789. Versi legacy lebih cepat, tetapi ini menunjukkan hasil yang salah untuk input angka dengan angka nol di depan.)

Program 'backhanded' akan menjadi:

„ÃеÝ[N© I#N#

Yang akan ditampilkan perfectly okaydalam huruf kecil penuh.

Cobalah online.

Program dasar penjelasan:

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

Penjelasan program '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

Langkah demi langkah hal berikut terjadi:

1. „ÃеÝ: STACK menjadi ["perfectly okay"]
2. [: Mulai infinite loop
3. (iterasi loop pertama) N©: STACK menjadi["perfectly okay", 0]
4. (iterasi loop pertama) I: STACK tetap ["perfectly okay", 0]karena tidak ada input
5. (iterasi loop pertama) #: STACK menjadi ["perfectly okay"], dan loop berlanjut
6. (iterasi loop pertama) N: STACK menjadi["perfectly okay", 0]
7. (iterasi loop pertama) #: STACK menjadi ["perfectly okay"], dan loop berlanjut
8. (iterasi loop kedua) N©: STACK menjadi["perfectly okay", 1]
9. (iterasi loop kedua) I: STACK tetap ["perfectly okay", 1]karena tidak ada input
10. (iterasi loop kedua) #: STACK menjadi ["perfectly okay"], dan loop terputus karena 1(kebenaran)
11. Secara implisit mencetak bagian atas tumpukan ke STDOUT: perfectly okay

Lihat langkah-langkah di sini dengan debugger di TIO diaktifkan.

Lihat ini ujung 05AB1E saya (bagian Cara menggunakan kamus? ) Untuk memahami mengapa „€€Ã€„Ѐ€µ'€Ýadalah the pointed, dm one, dan beendan „ÃеÝadalah perfectly okay.

Versi 38-byte lama:

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

Cobalah online . (PS: Alihkan bahasa dari 05AB1E (legacy) ke 05AB1E untuk kasus uji 0123456789dan @. Versi legacy lebih cepat, tetapi ini menunjukkan hasil yang salah untuk input angka dengan nol di depan atau input char tunggal.)

Program 'backhanded' akan menjadi:

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

(Di mana qkeluar dari program dan membuat segala sesuatu yang lain tanpa operasi.)

Cobalah online.

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]

Cobalah online!

JavaScript (ES6), 130 byte

Upaya awal. Tidak terlalu memuaskan.

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)

Cobalah online!

Ketika kode diproses dengan sendirinya, karakter berikut ini diisolasi:

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

pemberian yang mana:

f=>"Perfectly okay"//…

Jelly , 34 byte

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

Program penuh atau tautan monadik yang menerima daftar karakter yang dicetak atau dihasilkan (masing-masing).

Cobalah online! Atau lihat test-suite .

Kode Backhand-parsed adalah:

Jȧ“N2s]Ỵ»ị@€

Program penuh atau tautan niladic yang mencetak atau menghasilkan (masing-masing) Turing selesai .

Bagaimana?

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)

kode Backhand-parsed adalah:

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)

Pesona Rise , 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

Cobalah online!

Versi tidak terkompresi (dan hampir dapat dibaca):

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

Cobalah secara Online!

Ini ... sedekat yang aku bisa.

Menekannya lebih jauh akan membutuhkan mencari cara untuk menangani berbagai titik pertukaran bertukar tanpa membuatnya bertabrakan dengan hal-hal lain. Baris pertama (yang merupakan satu-satunya bagian yang harus dilewati sebagai input untuk dirinya sendiri) harus tetap terpisah: seluruh string tidak dapat masuk pada baris kedua tanpa menimbulkan masalah ( _untuk spasi yang diperlukan):

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

Itu ?tidak dapat dipindahkan dari !yang itu sendiri tidak dapat dipindahkan dari \dan tidak ada pesan yang diizinkan yang memungkinkan salah satu dari ketiga karakter ini pada posisi ini.

Alternatifnya adalah dengan menggunakan pengalihan aliran, tetapi itu mengarah ke masalah di baris bawah:

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

Karena kita harus menghindari loop switch di program utama.

Masalah Dikenal:

• Input yang sangat besar. Karena batas tumpukan IP Runic, mendorong string input yang sangat besar akan menyebabkan IP berakhir sebelum menyelesaikan. Ini dapat diminimalkan dengan menelurkan IP tambahan dan menggabungkannya (misalnya, ia menangani abcdefghijklmnopqrstuvwxyztetapi tidak keseluruhan sumbernya sendiri). Dan ada batasan terlepas dari berapa banyak penggabungan yang terjadi. Dapat menangani hingga 58 byte input apa adanya (selain itu, meningkatkan jumlah IP memerlukan mencari tahu cara membuatnya bergabung tanpa menggunakan lebih banyak ruang). Dapat memuat dua entri IP lagi pada loop-return line (di sebelah kanan pada Uon-line yang dimulai \y<<pada versi yang tidak terkompresi, atau satu kiri pada baris di atas y<<dalam versi yang dikompresi) meningkatkan panjang max input menjadi 78.
• String input dengan spasi harus memiliki ruang yang lolos (misalnya 1\ \ 1\ \ +\ \ O\ \ @). Ini adalah batasan parsing input bahasa.
• Tidak dapat memasok input yang terdiri dari string yang terlihat seperti bilangan bulat yang dimulai dengan sejumlah 0s (seperti ketika diubah menjadi angka di tumpukan, 0hilang). Sekali lagi, keterbatasan penguraian input bahasa.

Bagaimana itu bekerja

Masuk:

1. Gabungkan 4 petunjuk instruksi
2. Baca input, pisahkan karakter, tambahkan baris baru, balikkan, masukkan loop utama.

Loop utama (apa pun yang muncul stack didahului oleh dup):

1. Cetak bagian atas tumpukan
2. Bandingkan dengan baris baru. Benar: alihkan loop dan putar tumpukan ke kiri dua kali.
3. Dibandingkan dengan @ . Benar: hentikan. (Hentikan perintah yang dijalankan)
4. Putar tumpukan ke kanan
5. Bandingkan dengan baris baru. Benar: hentikan. (Perintah paling kanan dieksekusi)
6. Putar tumpukan ke kanan
7. Bandingkan dengan baris baru. Benar: alihkan loop dan putar tumpukan ke kiri sebanyak tiga kali.
8. Putar tumpukan ke kanan
9. Kembali ke atas lingkaran

Lingkaran sekunder:

• Identik dengan loop utama, hanya berganti putar ke kanan dengan memutar ke kiri