この挑戦は、私の最初の難解な言語、バックハンドを祝うために作成されました！

バックハンドは、非線形ポインターフローを備えた1次元言語です。ポインターは一度に3ステップ移動し、3命令ごとにのみ実行します。

プログラム1..1..+..O..@は、終了する前に1 + 1を追加し、2を出力します。中間命令はスキップされるため1<>1()+{}O[]@、まったく同じプログラムです。

ポインタがテープの終わりから離れようとするとき、その代わりに方向を逆にして逆方向にステップするので1.@1.O+.、同じプログラムも同様です。終了命令は1回しかカウントされないことに注意してください。これにより、次のようなほとんどの線形プログラムを圧縮できます。1O+1@

ここでの課題は、文字列をとるプログラムまたは関数を記述し、プログラムがバックハンドのように解釈された場合に実行される命令を出力することです（実際のバックハンド命令を処理する必要はありません）。ポインターが文字列の最後の文字に到達するまでのみ出力します（この時点で、実行は通常逆方向になります）。

しかし、待ってください、それだけではありません！プログラム自体がこの方法で解釈されると、結果のコードは以下のいずれかを出力するはずです。

• (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のように）
• 2番目のプログラムを最初のプログラムからバイト単位で変換するか、UTF-8文字で変換するかを選択できます。
• 2番目のプログラム：
  • 大文字と小文字は区別されないため、必要にpErFectLy OKay応じて出力することができます。
  • 任意の量の末尾/先頭の空白（改行、タブ、スペース）も使用できます。
  • 2番目のプログラムは最初のプログラムと同じ言語である必要がありますが、必ずしも同じ形式（プログラム/機能）である必要はありません
  • 余分なフレーズに関するコメントからの提案を含めることができます（短すぎない限り）
• これはcode-golfであるため、あなたの目的はあなたの言語の最短の回答を得ることです！
• 2週間以内に、最短バックハンド回答に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：

ゴルフをしていない：

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

パイソン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バイト

うわー、最初のプログラムを大幅に改善することにより、nwellnhofのおかげで-25バイト

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

説明「バックハンド」プログラム：

„ÃÐµÝ           # 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. „ÃеÝ：スタックは ["perfectly okay"]
2. [：無限ループを開始
3. （最初のループ反復） N©：STACKは["perfectly okay", 0]
4. （最初のループの繰り返し）I：スタックが残る["perfectly okay", 0]入力がないため、ます
5. （最初のループ反復）#：STACKは["perfectly okay"]になり、ループは継続します
6. （最初のループ反復） N：STACKは["perfectly okay", 0]
7. （最初のループ反復）#：STACKは["perfectly okay"]になり、ループは継続します
8. （2回目のループ反復） N©：STACKは["perfectly okay", 1]
9. （2回目のループ反復）I：スタックが残る["perfectly okay", 1]入力がないため
10. （2回目のループ反復）#：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€

（それぞれ）印刷または生成される文字のリストを受け入れる完全なプログラムまたはモナドリンク。

オンラインでお試しください！またはテストスイートを見る。

バックハンドで解析されたコードは次のとおりです。

Jȧ“N2s]Ỵ»ị@€

完全なプログラムまたはニラディックリンクの印刷または生成（それぞれ）チューリング完了。

どうやって？

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)

ルーン文字のエンチャント、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

オンラインでお試しください！

これは...私が得ることができる限り近いものです。

さらに圧縮するには、さまざまなループスワッピングポイントを他の要素と衝突させずに処理する方法を見つける必要があります。最初の行（それ自体への入力として渡す必要がある唯一の部分）は、分離したままにする必要があります：文字列全体が問題を引き起こすことなく2行目に収まらない（_必要なスペースの場合）：

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

それ?から離れる!ことはできません。\。また、この位置でこれら3文字を許可するメッセージありません。

代替策はフローのリダイレクトを使用することですが、それは下の行の問題につながります：

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

メインプログラムでループ切り替えを回避する必要があるため。

既知の問題点：

• 非常に大きな入力。RunicのIPスタックの制限により、非常に大きな入力文字列をプッシュすると、完了する前にIPが期限切れになります。これは、追加のIPを生成してマージすることで最小化できます（たとえば、abcdefghijklmnopqrstuvwxyz独自のソース全体ではなく、処理します）。また、マージの数に関係なく制限があります。最大58バイトの入力をそのまま処理できます（さらに、IPの数を増やすには、より多くのスペースを使用せずにIPをマージする方法を見つける必要があります）。ループリターン行にさらに2つのIPエントリを収めることができます（非圧縮バージョンでU始まる行の右側\y<<、または1つ上の行の左側y<<、入力の最大長が78になります。
• スペースを含む入力文字列では、スペースをエスケープする必要があります（例：）1\ \ 1\ \ +\ \ O\ \ @。これは、言語の入力解析の制限です。
• 任意の数の0sで始まる整数のように見える文字列で構成される入力を提供することはできません（スタック上の数字に変換されると、0失われます）。繰り返しますが、言語の入力解析の制限。

使い方

エントリ：

1. 4つの命令ポインターを組み合わせる
2. 入力を読み取り、文字に分割し、改行を追加し、反転し、メインループに入ります。

メインループ（スタックをポップするものの前にdupがあります）：

1. スタックの一番上を印刷します
2. 改行と比較してください。True：ループを切り替え、スタックを左に2回回転します。
3. と比較してください@。True：終了します。（実行された終了コマンド）
4. スタックを右に回転
5. 改行と比較してください。True：終了します。（実行された一番右のコマンド）
6. スタックを右に回転
7. 改行と比較してください。True：ループを切り替え、スタックを左に3回回転します。
8. スタックを右に回転
9. ループの先頭に戻る

二次ループ：

• メインループと同じ、右回転と左回転のみを切り替える