反手称赞

13

挑战是为了庆祝我的第一种深奥的语言，反手！

反手是具有非线性指针流的一维语言。指针一次移动三步，仅每第三条指令执行一次。

程序1..1..+..O..@将在终止前加1 + 1，并输出2。中间指令被跳过，因此1<>1()+{}O[]@完全相同的程序。

当指针将要离开磁带末端时，它会反转方向并以另一种方式前进，因此1.@1.O+.同一程序也是如此。注意，它仅对结束指令计数一次。这使我们可以压缩大多数线性程序，例如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)
"---!---!"       -> "-!-----!"

当然还有一个用Backhand编写的参考程序（这可能有点问题，好吧，我想我已经解决了）。

规则。

  • 禁止标准漏洞
  • 第一个程序的输入将仅包含可打印的ASCII和换行符（即字节0x20- 0x7E以及0x0A）
  • 您可以选择将第二个程序从第一个程序转换为字节还是UTF-8字符。
  • 第二程序：
    • 情况确实不是事，所以你的输出可能是pErFectLy OKay，如果你想。
    • 任意数量的尾随/前导空格（换行符，制表符，空格）也可以。
    • 第二个程序应与第一个程序使用相同的语言，但不必使用相同的格式（程序/功能）
    • 我很乐意将多余短语的评论中的建议包括在内（只要它们不太短）
  • 因为这是代码高尔夫球，所以您的目标是为您的语言获得最短的答案！
  • 在两周内，我将为最短的反手答案提供200英镑的悬赏。
code-golf  source-layout 
— 乔·金
source
沙盒（已删除）
— Jo King
1
建议的测试用例：（"---!---!"或任何最后一个字符出现多次的字符串）
— TFeld
当您的程序本身以这种方式解释时-由什么解释？
— ngm
4
假设我编写了一个R程序（因为这是我在这里所做的几乎所有事情。）我的R程序必须将Backhanded代码转换为Backhanded指令序列。另外，我的R程序在输入自身时必须成为另一个R程序，该程序在运行时会在这些字符串上输出（对于R而言，由R解释程序解释）。它是否正确？
— ngm
1
@ngm是的。-----
— user202729

Answers:

4

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'
— ngm
source
4

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')
— 场
source
3

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"}。

— 乔·金
source
3

05AB1E，43 40 38 37 字节

由于@Emigna， -2字节（40→38）。

„€€Ã€„Ѐ€µ'€Ý)\[û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. （第二循环迭代）N©：STACK变为["perfectly okay", 1]
  9. （第二循环迭代）I：["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退出程序，并使其他所有操作均无效。）

在线尝试。

— 凯文·克鲁伊森
source
当然/应该是“ \”吗？
— Emigna '18 -10-3
1
使用N>3*©而不是XU保存2。我还觉得应该有某种方法可以在循环中进行所有打印，这将节省更多的字节。
— Emigna
@Emigna是的，/ 应该是\ ..并且感谢-2。我确实感觉可以进一步打高尔夫球。打印每个第三个值（包括弹跳）的基本功能似乎过长。
— 凯文·克鲁伊森
@Emigna非常丑陋，但是[ûDN3*©è?®IgD#<ÖNĀ*#事先没有if-else，比if-else with循环短2个字节。不幸的是，我们仍然需要q反手程序的，因此它也是38个字节。但我有一种感觉，休息，绝对可以以某种方式改进牢记单字符输入，指数0，可分通过长度为1的同时..
— 凯文Cruijssen
1

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"//…
— Arnauld
source
1

果冻，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)
— 乔纳森·艾伦
source
1

符文附魔，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:

因为我们必须避免在主程序中进行循环切换。

已知的问题：

  • 巨大的输入。由于Runic的IP堆栈限制，推送非常大的输入字符串将导致IP在完成之前过期。可以通过生成其他IP并将它们合并来最小化（例如，它处理abcdefghijklmnopqrstuvwxyz但不处理其自身的全部来源）。不管发生多少合并，都有一个限制。可以按原样处理多达58个字节的输入（此外，增加IP的数量需要弄清楚如何在不使用更多空间的情况下合并它们）。可以在回路返回行上再容纳两个IP条目（从未压缩版本U开始在行的右边\y<<，或者在压缩版本开始的行的左边y<<），将输入最大长度增加到78。
  • 带空格的输入字符串需要转义空格（例如1\ \ 1\ \ +\ \ O\ \ @）。这是语言输入解析的限制。
  • 无法提供由字符串组成的输入，这些字符串看起来像以任意数量的0s 开头的整数（如在堆栈上变成数字时，将0丢失）。同样，限制了语言的输入解析。

怎么运行的

条目：

  1. 结合4条指令指针
  2. 读取输入，分成字符，添加换行符，反向输入主循环。

主循环（任何弹出堆栈的地方都带有dup）：

  1. 打印堆栈顶部
  2. 比较换行。正确：切换循环并向左旋转堆栈两次。
  3. 比较@。正确：终止。（执行终止命令）
  4. 向右旋转纸叠
  5. 比较换行。正确：终止。（执行最右边的命令）
  6. 向右旋转纸叠
  7. 比较换行。正确：切换循环并将堆栈左移三次。
  8. 向右旋转纸叠
  9. 返回循环顶部

次循环：

  • 与主循环相同，仅开关向右旋转，向左旋转
— Draco18s不再信任SE
source
错误，您是否要创建反手多语种？第二个程序应该是运行第一个程序并将其作为输入的结果。然后，该程序的结果（当以您的原始语言运行，即Runic）应为短语之一。从问题中， 您不需要处理任何实际的反手指令
— Jo King
您的第二个程序不打印任何内容。它只是错误
— 乔金
这就是将转换应用于原始程序时得到的。然后应打印其中一个短语。也许您应该对该问题进行二读，或者看看其他答案
— Jo King
*请尝试再次阅读。* ...不，尚未看到它... *请再试一次。*哦！基督，我一点都不明白。我将其读为“当您的程序读取自己的源代码作为输入时 ”
— Draco18s不再信任SE SE
@JoKing是这个正确的呢？
— Draco18s不再信任SE
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.