编写一个程序，使用三种语言来玩剪刀石头布。

程序的任何版本的输入始终是字符串rock或paper或之一scissors。

程序必须使用第一语言输出击败输入的石头剪刀布选择：

Input     Output
rock      paper
paper     scissors
scissors  rock

程序必须使用第二种语言输出与输入相关联的剪刀布选择：

Input     Output
rock      rock
paper     paper
scissors  scissors

程序必须使用第三种语言输出输给输入的石头剪刀布选择：

Input     Output
rock      scissors
paper     rock
scissors  paper

以字节为单位的最短代码获胜。决胜局是最高投票的答案。

的输入和/或输出可任选地具有一个尾随的换行符但否则应该只是纯rock/ paper/ scissors字符串。您可以使用大写ROCK，PAPER，SCISSORS如果需要的话。

您不能使用同一语言的不同版本（例如Python 2和3）。

Python，brainfuck和JavaScript，103个 99字节_{^{不足100个字节！}}

0,[.5,];p=["rock","scissors","paper"]
1//1;lambda x:p[p.index(x)-1];"""
x=>p[-~p.indexOf(x)%3]//"""

在Python中，它定义了一个击败输入的函数，在Brainfuck中，它只是一个简单的cat程序，而在JavaScript中，它丢失了。这是一个为函数命名的版本f，还提示在JavaScript和Python 3中输入：

0,[.5,];p=["rock","scissors","paper"]
1//1;f=lambda x:p[p.index(x)-1];"""
f=x=>p[-~p.indexOf(x)%3]//"""

1//1;"""
console.log(f(prompt())) // JavaScript
1//1"""; print(f(input())) # Python

在线尝试（旧版本）：Python， brainfuck，JavaScript

说明：

在Python中，"""..."""是一个多行字符串，可以用作任何标记。当独立放置时，它什么也没做。我用它来“隐藏” Python中的JavaScript代码。这同样适用于该(0,[.5,])位，它只是包含一个元组0和列表5，也是1//1一部分，//在Python是整数除法，而是开始在JavaScript评论。这是去除这些标记的代码：

p=["rock","scissors","paper"]
lambda x:p[p.index(x)-1]

第一行是不言自明的，它只是定义了列表p以包含剪刀石头布中的不同选择。第二行定义的未命名函数，它接受一个参数，x以及返回的跳动的选择x（例如，在前面的元件p）

在JavaScript中，//表示单行注释。与Python相似，单个标记将被忽略，因此除去这些标记的代码为：

p=["rock","scissors","paper"]
x=>p[-~p.indexOf(x)%3]

这与Python相似，首先设置列表p以包含选项，然后定义一个匿名函数以给出失败的选择。-~x与相同，x+1但具有更高的优先级，因此我可以跳过括号。

在Brainfuck中，除+-,.[]<>除去每个字符外，保留以下内容：

,[.,][,,]
[.-]
>[-.]

该命令,读取输入的一个字节，将其.打印并[...]在值非零时循环。然后，该程序将读取输入并一次打印一个字符，直到\0找到该字符为止。由于我们的代码中没有，因此我们可以忽略程序的其余部分。实际上，这只是回显用户键入的内容，从而有效地绑定了用户。

Python 2，Ruby，Retina，90 83字节

-7字节归功于Value Ink

s=['rock','paper','scissors']
print s[s.index((0and gets or input()))+(0and-2or-1)]

在线尝试：Python， Ruby，Retina

在Ruby中获胜，在Python中败北，并在Retina中取得联系。该解决方案利用了0在Ruby 中为真但在Python 中为假的事实。它还在Python和Ruby中都使用了负索引。

V，脑防弹和Python 2，97，86，81，77，75个字节

o='rock paper scissors'.split()
lambda s:o[o.index(s)-1]#ddt.C rHd*wywVp

感谢@ nmjcman101，节省了两个字节！

这太好玩了！我非常喜欢这个答案，因为它是我喜欢的语言的简要介绍：我最喜欢的编辑器，我最喜欢的非神秘语言和我编写的语言。（从技术上讲，python 3更好，但python 2更好¯\_(ツ)_/¯）。

在线尝试！在Python中进行了修改（稍作修改，以便您可以看到输出），它会打印输给输入的内容。

在线尝试！在Brain-Flak中，它打印与输入的关系。

在线尝试！在V中，它会打印出优于输入的内容。

由于V依赖于不可打印的ASCII字符，因此这是一个十六进制转储：

00000000: 6f3d 2772 6f63 6b20 7061 7065 7220 7363  o='rock paper sc
00000010: 6973 736f 7273 272e 7370 6c69 7428 290a  issors'.split().
00000020: 6c61 6d62 6461 2073 3a6f 5b6f 2e69 6e64  lambda s:o[o.ind
00000030: 6578 2873 292d 315d 231b 6464 742e 4320  ex(s)-1]#.ddt.C 
00000040: 720e 1b48 642a 7779 7756 70              r..Hd*wywVp

说明：

蟒蛇

在python中，这非常简单。我们定义了三个元素的列表，并在输入之前返回该元素。由于-1返回back元素，因此它可以循环工作，而且非常简单明了。然后，后面的所有内容#均为评论。

脑爆裂

这在脑筋急转弯中也非常简单。如果我们必须赢或输，这可能是数百个字节。但这实际上以0字节为单位。在程序启动时，所有输入都被加载到堆栈中。在程序结束时，将隐式打印整个堆栈。

删除所有不相关的字符后，brain-flak看到的代码是

()[()]

它的简单计算结果为1 + -1，但是由于根本没有使用此值，因此它是NOOP。

V

这是有点奇怪的地方。命名python列表o似乎是任意的，但绝对不是。在V中，o打开换行符，并使我们进入插入模式。然后，

='rock paper scissors'.split()
lambda s:o[o.index(s)-1]#

被插入缓冲区。之后，相关代码为：

<esc>ddxxf'C r<C-n><esc>Hd*wywVp

说明：

<esc>                          " Return to normal mode
     dd                        " Delete this line. Now the cursor is on '='
       t.                      " Move the cursor forward to the "'"
         C                     " Delete everything after the "'", and enter insert mode
           r                   " From insert mode, enter '<space>r'
            <C-n>              " Autocomplete the current word based on what is currently in the buffer
                               " Since only one word starts with 'r', this will insert 'rock'
                 <esc>         " Leave back to normal mode
                      H        " Go to the first line (where the input is)
                       d*      " Delete everything up until the next occurence of the input
                         w     " Move forward one word
                          yw   " Yank the word under the cursor
                            Vp " And paste that word over the current line, delete everything else

CJam，Retina，PHP，92 86 85字节

ECHO["rock",0,"scissors","paper"][ORD(READLINE())%4];
#];"scissors  paper rock"S/rci=

应该使用-r标志在PHP中运行。

在CJam中尝试

在视网膜中尝试

在PHP中尝试

贾姆

在CJam中，所有大写字母都是预定义的变量。在第一行中，许多这些值以及一些字符串和数组文字被压入堆栈。执行一些增量，减量和其他操作。

毕竟，堆栈被包装在一个数组（]）中并被丢弃（;），因此其他所有内容都无关紧要。CJam的主要程序很简单：

"scissors  paper rock"S/rci=

"scissors  paper rock"        e# Push this string
                      S/      e# Split it on spaces
                        r     e# Read the input
                         c    e# Cast to char (returns the first character in the string)
                          i   e# Cast to int (its codepoint)
                           =  e# Get the index of the split array (CJam has modular arrays)

视网膜

这几乎就像在作弊...

Retina会使用替换ECHO["rock",0,"scissors","paper"][ORD(READLINE())%4];输入中正则表达式的任何匹配项#];"scissors paper rock"S/rci=。此正则表达式匹配不管结果如何，它肯定不匹配任何东西rock，paper或者scissors，让则不进行替换。然后，未修改的输入将隐式输出。

的PHP

第二行是注释，因此将被忽略。

第一行使用与CJam部分相同的算法，但是结果的顺序不同。

C，C ++，Python；227个 226 216字节

感谢@Mat，节省了一个字节！

#include<stdio.h>/*
f=lambda a:"rock"if a[0]=="r"else"paper"if a[0]=="p"else"scissors"
"""*/
int f(char*b){puts(sizeof'b'-1?*b=='r'?"paper":*b=='s'?"rock":"scissors":*b=='r'?"scissors":*b=='s'?"paper":"rock");}
//"""

定义f所有语言的功能。用C赢，用Python赢，用C ++输。就像C ++总是^{/ s}

/*和之间的部分*/是C和C ++中的注释块，而它是Python中的lambda函数声明。它基本上比较函数参数的第一个字符，并返回以该字母开头的移动。

"""s 之间的部分是Python中的多行字符串，而C和C ++均为函数声明。sizeof'b'-1确定当前语言是否为C ++语言。如果大小不为1，则为真值，否则为假值。在C中，字符文字是4字节长的类型，而在C ++中，它们是单字节类型。然后，在确定了语言之后，它仅查看输入的第一个字母并相应地输出。

C

在线尝试！

C ++

在线尝试！

蟒蛇

在线尝试！

C ++，R，C; 252个 240 226 220 209字节

#define b/*
M=function()cat(readline())
#*/
#import<stdio.h>
#define M()main(){int i=0;char t[9];char*u;char*s[]={"rock","paper","scissors"};scanf("%s",t);for(;*t-*s[i++];);puts(s[(i+=sizeof('a')==1)%3]);}
M()

利用C和C ++之间的区别，字符文字的大小在C中为4字节，在C ++中为1字节。

C ++：

在线尝试！

R：

结果：

> #define b/*
> M=function()cat(readline())
> #*/
> #import<stdio.h>
> #define M()main(){int i=0;char t[9];char*u;char*s[]={"rock","paper","scissors"};scanf("%s",t);for(;*t-*s[i++];);puts(s[(i+=sizeof('a')==1)%3]);}
> M()
rock
rock

C：

在线尝试！

Gawk，Retina，Perl；68个字节

{eval"\$_=uc<>"}{$_=/[Sk]/?"paper":/[Pc]/?"rock":"scissors"}{print}

（以换行符结尾）

高克（获奖者）

为Perl着想一些垃圾，然后根据其包含a 或a来更改行内容（$_，$0因为变量_未定义，所以这是相同的），然后打印结果。忽略有关转义序列的任何警告，我打算这样做。kc

{a_string_that_is_ignored}
{$_ = /[Sk]/ ? "paper" : /[Pc]/ ? "rock" : "scissors"}
{print}

视网膜（领带）

与Basic Sunset和其他方法相同的技巧：用第二行的内容替换第一行中某些愚蠢的正则表达式的匹配项，从而使输入通过。

Perl（失败者）

读取一行并将其转换为大写，然后根据包含的字母选择一个单词，然后打印结果。第一步和最后一步都使用eval来包装，以将它们从awk中隐藏起来。

$_ = uc <>;
$_ = /[Sk]/ ? "paper" : /[Pc]/ ? "rock" : "scissors";
print $_

视网膜Gawk ，perl -p；57个字节

我输入此作为奖励，是因为按照perl -p此站点上的常规规则，命令行切换应该是该程序的一部分，这将使它不是一门好事。

{eval"\$_=uc"}$_=/[Sk]/?"paper":/[Pc]/?"rock":"scissors"

再次使用Retina的最后换行符。这次，通过perl -p自动打印输出，可以显着减少perl开销。我可以让分配$_在awk中触发隐式打印。

> <>，视网膜，Python的2：144 127 123字节

@Loovjo通过删除空格节省了1个字节

@ mbomb007通过使用input代替来节省了4个字节raw_input

#v"PAPER"v?%4-2{"SCISSORS"v?%2:i
#>ooooo; >oooooooo<"ROCK"~<
a="KRS".index(input()[-1])
print["SCISSORS","ROCK","PAPER"][a]

在TNB上发布的挑战，我决定尝试这种语言组合。

> <>

在线尝试！

IP开始向右移动。

#                      Reflect the IP so that it now moves left and it wraps around the grid
i:                     Take one character as input and duplicate it

输入中可能使用的字符为PRS（因为程序仅采用第一个字符）。他们的ASCII值是80，81和82。

2%                     Take the modulo 2 of the character. Yields 0, 1, 0 for P, R, S respectively
?v                     If this value is non-zero (ie the input was ROCK), go down, otherwise skip this instruction

如果输入是固定的，则将发生以下情况：

<                      Start moving to the left
~                      Pop the top most value on the stack (which is the original value of R and not the duplicate)
"KCOR"                 Push these characters onto the stack
<                      Move left
oooo                   Output "ROCK" as characters (in turn these characters are popped)
o                      Pop the top value on the stack and output it; but since the stack is empty, the program errors out and exits promptly.

否则，如果输入为SCISSORS或PAPER，则IP将会遇到以下情况：

"SROSSICS"             Push these characters onto the stack
{                      Shift the stack, so the the original value of the first char of the input would come to the top
2-4%                   Subtract 2 and take modulo 4 of the ASCII-value (yields 2, 0 for P, S respectively)
?v                     If it is non-zero, go down, otherwise skip this instruction

如果输入为PAPER，则：

>ooooooooo             Output all characters on the stack (ie "SCISSORS")
<                      Start moving left
o                      Pop a value on the stack and output it; since the stack is empty, this gives an error and the program exits.

否则（如果输入为SCISSORS）：

"REPAP"                Push these characters onto the stack
v>ooooo;               Output them and exit the program (without any errors).

视网膜

在线尝试！

在这种情况下，视网膜将两行中的每对视为一对匹配和替换。例如，它尝试将与第一行匹配的任何内容替换为第二行，但是由于第一行从不匹配，因此从不将其替换为任何内容，从而保留了输入。

Python 2

在线尝试！

Python程序需要将输入放在"s 之间。

前两行是Python中的注释。

a="KRS".index(input()[-1])             # Get the index of the last character of the input in "KRS"
print["SCISSORS","ROCK","PAPER"][a]    # Print the ath index of that array

Ruby，Clojure，Common Lisp-251字节

(print(eval '(if()({(quote SCISSORS)(quote PAPER)(quote PAPER)(quote ROCK)(quote ROCK)(quote SCISSORS)}(read))(eval(quote(nth(position(read)(quote("SCISSORS""PAPER""ROCK")):test(quote string-equal))(quote(ROCK SCISSORS PAPER))))))))
;'['"'+gets+'"']))

带有空格的可读性更高的版本：

(print(eval '(if() ; distinguish between CLojure and Common Lisp
    ({(quote SCISSORS)(quote PAPER)(quote PAPER)
       (quote ROCK)(quote ROCK)(quote SCISSORS)}(read)) ; use hash-map as a function
    (eval(quote(nth ; find index of the input arg in the list
       (position(read)(quote("SCISSORS""PAPER""ROCK")):test(quote string-equal))  
    (quote(ROCK SCISSORS PAPER))))))))
 ;'['"'+gets+'"'])) ; ruby indexation

Clojure总是赢，Ruby总是赢，Common Lisp总是输。

对于Ruby，'s 内的所有内容都是字符串。它跨越两行。然后，它使用[]带有字符串参数的运算符，如果字符串中存在字符串，则返回字符串本身。结果被打印出来，Ruby只是镜像输入。

第二行是对Clojure和Common Lisp的注释。必须使用一堆eval和quote，因为Clojure需要确保所有符号均有效。最好重用代码，但是nth函数甚至在这些语言中也具有不同的签名。基本上，对于Clojure，其if()评估结果为true，并且当使用从stdin中读取的参数调用可能变体的哈希映射时，它会转到第一个分支。Common Lisp转到第二个分支，它从stdin中找到参数在列表中的位置，并从结果列表中返回相应的项。

我想Common Lisp零件可以打更多。

在线查看：Ruby，Common Lisp，Clojure

Scala，Javascript和Ook，167个字节

s=>{var a="paper,scissors,rock".split(",")/*/**/a[-1]="rock"
return a[a.indexOf(s)-1];`*/a((a.indexOf(s)+1)%3)//`//Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!
}

在Scala中 尝试一下在Javascript中 尝试一下Ook的Brainfuck版本

Scala-胜利

s=>{                                                      //define an anonymous function
  var a="paper,scissors,rock".split(",")                  //generate the array
  /* /* */ a[-1]="rock"                                   //scala supports nested comments,
  return a[a.indexOf(s)-1];`                              //so this comment...
  */                                                      //...ends here
  a((a.indexOf(s)+1)%3)                                   //return the winning string
  //`//Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!  //another comment
}

Javascript-失败

s=>{                                                   //define an anonymous function
  var a="paper,scissors,rock".split(",")               //generate the array
  /*/**/                                               //a comment
  a[-1]="rock"                                         //put "rock" at index -1
  return a[a.indexOf(s)-1];                            //return the string that loses
  `*/a((a.indexOf(s)+1)%3)//`                          //a string
  //Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!  //a comment
}

好的 -领带

Ook部分是,[.,]翻译成Ook 的简单的Brainfuck猫程序。

s=>{var a="paper,scissors,rock".split(",")/*/**/a[-1]="rock"   //random stuff
return a[a.indexOf(s)-1];`*/a((a.indexOf(s)+1)%3)//`//         //more random stuff
Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!              //the program
}                                                              //random stuff