给定两个字符串“ Rock”，“ Paper”或“ Scissors”的输入，确定RPS回合的结果。如果第一个玩家获胜，则输出1；如果第二个玩家获胜，则输出-1；如果平局，则输出0。

Rock Rock -> 0
Rock Paper -> -1
Rock Scissors -> 1
Paper Rock -> 1
Paper Paper -> 0
Paper Scissors -> -1
Scissors Rock -> -1
Scissors Paper -> 1
Scissors Scissors -> 0

您必须使用准确的字符串“ Rock”，“ Paper”和“ Scissors”作为输入。您可以选择（一致）第一还是第二是第一位玩家的选择。您也可以将它们作为带有单个字符或空分隔符的单个输入。在您的输入格式中，保证输入是三种选择的9种可能的配对之一。

输出应为数字1、0或-1或其字符串表示形式。漂浮物很好。那么是+1，+0,和-0。

Groovy，67 56 50字节

{a,b->Math.sin(1.3*((int)b[0]-(int)a[0])).round()}

在线尝试！

事实证明，剪刀石头布具有非常酷的特性。
给定字符串a和b，取每个字符串的首字母，这将导致以下两个：R,P,S

可能值的详尽列表如下（将2个选项合并时）：

XX=ASCII=Y=Wanted output
RR=82-82=0=0
PP=80-80=0=0
SS=83-83=0=0
RS=82-83=-1=1
RP=82-80=2=-1
PS=80-83=-3=-1
PR=80-82=-2=1
SR=83-82=1=-1
SP=83-80=3=1

将清单重新整理为：

-3->-1
-2->1
-1->1
0->0
1->-1
2->-1
3->1

给我们一个看起来反正弦的序列，您实际上可以将该公式表示为近似值（并且大约等于我的意思是勉强可以工作，您可以得到一个方程式，该方程式是死的，但要花费更多的字节）：

-sin((4*a[0]-b[0])/PI).roundNearest() = sin(1.3*(b[0]-a[0])).roundNearest()

首先由@flawr建议将4 / pi简化为1.3 ，然后由@titus测试以节省6个字节。

使用groovy的双舍入属性，可以为石头剪刀布提供正确的输出。

05AB1E，10个字节（非竞争）

Ç¥13T/*.½ò

在线尝试！

使用2017年10月26日添加的新命令将相同的答案移植到05AB1E。

— 魔术章鱼缸
source

3

你能不能把它缩短了通过使用-sin(x) = sin(-x)，这意味着刚刚逆转的顺序a和b拖放领先-？除此之外，硬编码的近似值4/Pi像1.273可能是足够的，或1.3或9/7或5/4。

— 瑕疵

2

PS：我也建议您建立一个链接以在线尝试，这样像我这样的人可以玩弄您提交的内容=）

— 瑕疵的

3

您可以使用sin(b-a)代替保存1个字节-sin(a-b)。很棒的发现！

— 泰特斯（Titus）

2

通过乘以1.3而不是4/Math.PI; 保存另外7个字节。足够准确。

— 泰特斯

1

@carusocomputingXX=ASCII=Y=Wanted output RR=82-82=0=0 PP=83-83=0=0 SS=80-80=0=0

— CraigR8806

44

C，50 35字节

#define f(i)*(short*)(i+7)%51%4%3-1

f用包含两个玩家的字符串调用，不带分隔符，它将返回第一个是否获胜。

说明：

通过查看九个可能的字符串，结果发现第7列和第8列上的字母对是唯一的：

       vv
RockPaper
PaperScissors
ScissorsRock
RockRock         // Sneakily taking advantage of the terminating zero
PaperPaper
ScissorsScissors
RockScissors
PaperRock
ScissorsPaper
       ^^

offset和savage强制转换以short*检索这些字母对，并将它们解释为数字：

然后，要查找51和的4余数就成了蛮力的问题，然后依次将这些数减少为：

3 0 0 1 1 1 2 2 2

完美地解决了最后的剩余问题，并抵消了结果。

在Coliru上实时观看

— 昆汀
source

只是不做任何事情-f(i)来计算其他玩家的得分，否则会产生意外的输出！

— nneonneo

4

@nneonneo -(f(i))应该工作正常。宏很有趣！

— nwp

18

MATLAB / Octave，63 54 52字节

这是非常方便的的第一个字母的ASCII码Rock,Paper,Scissors是R=82,P=80,S=83。如果减去，79我们会很方便地得到3,1,4它，现在我们将其用作矩阵索引：这里是4x4矩阵的硬编码，i,j如果您插入之前的值，则-th项对应于结果：

     1   2   3   4
  +---------------
1 |  0   0   1  -1
2 |  0   0   0   0
3 | -1   0   0   1
4 |  1   0  -1   0

A(5,5)=0;A(4:7:18)=1;A=A-A';@(x,y)A(x(1)-79,y(1)-79)

在线尝试！

— 瑕疵
source

16

Pure Bash，31岁

借用@Dennis的公式：

a=$1$1$2
echo $[(${#a}^67)%3-1]

在线尝试。

先前的答案：

纯净重击，43 35

echo $[(7+(${#2}^3)-(${#1}^3))%3-1]

获取每个arg的串长度（4，5，8分别为摇滚，剪子，布）
XOR每个具有3至给7，6，11（其中，当采取模3给予1，0，2）
然后减去并用mod 3摆弄以获得所需的结果。

在线尝试。

— 数字创伤
source

15

Python，40 30字节

lambda x,y:(len(2*x+y)^67)%3-1

在线尝试！

背景

我从功能模板开始

lambda x,y:(len(a*x+b*y)^c)%d-e

并使用以下程序对合适的参数进行了蛮力搜索，然后选择了具有最小长度的实现。

RPS = 'Rock Paper Scissors'.split()
g = lambda x,y:2-(94>>len(6*x+y)%7)%4
r = range(1,10)
R = range(100)

def f(a, b, c, d, e):
    h = lambda x,y:(len(a*x+b*y)^c)%d-e
    return all(g(x, y) == h(x, y) for x in RPS for y in RPS)

[
    print('%2d ' * 5 % (a, b, c, d, e))
    for e in r
    for d in r
    for c in R
    for b in r
    for a in r
    if f(a, b, c, d, e)
]

在线尝试！

— 丹尼斯
source

14

Mathematica，32个字节

Mod[{1,-1}.(Length/@#-3)!,3,-1]&

未命名函数采用一对有序的字符列表，例如{{"R","o","c","k"},{"P","a","p","e","r"}}，然后返回-1|0|1。

我希望代码不仅避免输入三个单词，而且还要避免太长的函数名ToCharacterCode；因此我4,5,8改用输入单词的长度，并寻找一个简短的函数，这些长度给出模3的不同答案。

事实证明，取（长度– 3）的阶乘给出的答案1,2,120为1,-1,0模3。然后我们以模3计算两个值的差（通过点积{1,-1}.{x,y} = x-y，这是当列表中有两个值）。

— 格雷格·马丁
source

1

“事实证明……”您对这些事情都有关注

— ngenisis

12

Ruby，36 35 30字节

a=->a,b{(a+b)[12]?a<=>b:b<=>a}

在ideone.com上尝试

测试输出：

a=->a,b{(a+b)[12]?a<=>b:b<=>a}

puts a.call("Rock", "Rock")
puts a.call("Rock", "Paper")
puts a.call("Rock", "Scissors")
puts a.call("Paper", "Rock")
puts a.call("Paper", "Paper")
puts a.call("Paper", "Scissors")
puts a.call("Scissors", "Rock")
puts a.call("Scissors", "Paper")
puts a.call("Scissors", "Scissors")

0
-1
1
1
0
-1
-1
1
0

利用以下事实：仅通过使用飞船运算符进行字典比较即可生成9个正确结果中的7个<=>。在(a+b)[12]刚刚反转输入到比较如果输入Paper和Scissors（还有Scissors Scissors-但是这0两种方式圆）。

感谢HorváthDávid为我节省了角色，也感谢GB为我节省了另外5个字符。

— 加雷斯
source

您可以使用匿名lambda并保存2个字符。

— GB

@GB如果我不给函数命名，我应该怎么称呼它？有点欺骗我。但是，感谢其他提示-我看过但拒绝了，因为ScissorsScissors是16，但我认为这实际上并不重要。:-)

— Gareth

那不是作弊。默认情况下允许使用匿名函数。

— 丹尼斯，

@Dennis如果不进行分配就无法调用它。感觉上像是在欺骗我，对没有必须定义名称的匿名函数的语言不公平。

— Gareth

你当然可以。tio.run/nexus/…–

— 丹尼斯

10

Python，39 36 34 33字节

lambda x,y:2-(94>>len(6*x+y)%7)%4

在线尝试！

这个怎么运作

让我们来看看一式六份长度的几个值X和一个副本Ÿ模7。

                                l(x,y) =:
x        y        len(x) len(y) len(6*x+y)%7
--------------------------------------------
Rock     Rock          4      4            0
Rock     Paper         4      5            1
Rock     Scissors      4      8            4
Paper    Rock          5      4            6
Paper    Paper         5      5            0
Paper    Scissors      5      8            3
Scissors Rock          8      4            3
Scissors Paper         8      5            4
Scissors Scissors      8      8            0

通过将结果映射到集合{0，1，2，3 }中，我们可以对结果（{-1，0，1}）进行编码。例如，映射t↦2-t实现了这一点，并且是它自己的逆。

让我们用o（x，y）表示x和y的结果。然后：

x        y        l(x,y) o(x,y) 2-o(x,y) (2-o(x,y))<<l(x,y)
-----------------------------------------------------------
Rock     Rock          0      0        2                10₂
Rock     Paper         1     -1        3               110₂
Rock     Scissors      4      1        1            010000₂
Paper    Rock          6      1        1          01000000₂
Paper    Paper         0      0        2                10₂
Paper    Scissors      3     -1        3             11000₂
Scissors Rock          3     -1        3             11000₂
Scissors Paper         4      1        1            010000₂
Scissors Scissors      0      0        2                10₂

幸运的是，最后几列中的位都彼此一致，因此我们可以对其进行“或”运算以形成单个整数n并以2-（（n≫ o（x，y））％4）的形式获取o（x，y ）。。n的值是94。

— 丹尼斯
source

9

视网膜，35 31字节

G`k P|r S|s R
*\)`.+
-
D`\w+
 .

在线尝试！

说明

这分两个步骤进行。首先，我们为相关输入打印减号。然后我们打印一个0领带，1否则打印一个。

G`k P|r S|s R
*\)`.+
-

这是两个阶段。所述)在第二阶段组在一起时，*使它们的干燥运行（这意味着它们被处理后的输入串将被恢复，但结果将被打印）和\抑制拖尾换行的打印。-如果适用，这两个阶段将一起打印一个。

第一阶段是Grep阶段，如果它包含，或k P，则仅保留该行。这些对应于我们需要输出的情况。如果不是这些情况之一，则输入将替换为空字符串。r Ss R-1

第二阶段用替换.+（整个字符串，但仅当它包含至少一个字符时）-。因此，这-将为这三种情况打印a ，否则不显示其他任何内容。

D`\w+
 .

这是另外两个阶段。第一阶段是D复习。它匹配单词并删除重复项。因此，当且仅当输入为平局时，这会丢弃第二个单词。

第二阶段计算的匹配数目，该数目 .是一个空格，后跟任何字符。如果输入是平局，并且第二个单词被删除，则结果为0。否则，第二个单词仍然存在，并且存在一个匹配项，因此将其打印出来1。

— 马丁·恩德
source

这是基于输入字符串长度的另一种方法。它比您的更长，但我想知道它是否还能打下去？

— Digital Trauma

@DigitalTrauma确实是个好主意，但我看不出有什么可以缩短它的。我认为您还是应该张贴它（如果将第一行移到标题中，那么TIO将不会在字节数中包括它）。

— Martin Ender

8

05AB1E，18 17 15 10 9字节

Digital Trauma的 输入长度技巧可节省6个字节

€g3^Æ>3%<

输入为 [SecondPlayersChoice,FirstPlayersChoice]

在线尝试！或验证所有测试用例

备用9字节解决方案： íø¬ÇÆ>3%<

说明

€g          # length of each in input
  3^        # xor 3
    Æ       # reduce by subtraction
     >      # increment
      3%    # modulus 3
        <   # decrement

以前的15字节解决方案

A-D{„PSÊiR}Ç`.S

在线尝试！或验证所有测试用例

说明

 A-               # remove the lowercase alphabet from the input (leaves a 2 char string)
   D{             # sort a copy of the leftover
     „PSÊ         # check if the copy isn't "PS" (our special case)
         iR}      # if true, reverse the string to get the correct sign
            Ç`    # convert the two letters to their character codes
              .S  # compare their values

— 艾米尼亚
source

你打我的乐趣一个:( Ç¥13T/*.½ò？WHY IT WORKS没有人知道。

— 魔术八达通瓮

@MagicOctopusUrn：嗯，那肯定是一个怪异的东西。返回一个int作为输出的输入格式是什么？

— Emigna

['R','P']：P 这是此端口。

— 魔术章鱼缸

@MagicOctopusUrn：哦，是的，我忘了那个。我对这个挑战的最喜欢的回答：)

— Emigna '18

6

果冻，8字节

L€Iµ-*×Ṡ

在线尝试！（测试套件，为了清楚起见，强制转换为整数）

这个怎么运作

L€Iµ-*×Ṡ  Main link. Argument: A (string array)

L€        Take the length of each string.
  I       Increments; compute the forward difference of the length.
   µ      Begin a new chain with the difference d as argument.
    -*    Compute (-1)**d.
      ×Ṡ  Multiply the result with the sign of d.

— 丹尼斯
source

6

Python 2中，46 40个字节

lambda x,y:+(x!=y,-1)[x[0]+y[0]in'RPSR']

在线尝试！

非常感谢@Dennis，让我借用他的“在线试用”测试代码并为我节省了6个字节。

编辑

@ hashcode55-与您描述的差不多。（x！= y，-1）是两个元素序列，[RPSR']中的[x [0] + y [0]正在计算采用哪个元素。如果x的第一个字母+ y的第一个字母在字符列表中，则它将求值为True或1，因此将返回（x！= y，-1）[1]。如果不是，则（x！= y，-1）[0]。这是有点棘手的地方。如果实际上，第一个元素本身就是另一个。如果x！= y，则第一个元素为True，否则为False，因此，如果“ RPSR”中的x [0] + y [0]为false，则根据x == y返回True还是False。+有点偷偷摸摸，再次感谢@Dennis。x！= y将返回原义的True或False。我们需要1或0。我仍然不太清楚如何进行转换，但是+会进行转换。我只能假定通过在True / False上使用数学运算符来强制将其视为等效的整数。显然，-1前面的+仍将返回-1。

希望这可以帮助！

— 埃尔佩德罗
source

嗨！您能告诉我这种语法如何工作吗？从逻辑上讲(x!=y,-1)，如果列表生成了true，则返回-1 x!=y。这个+标志有什么用？记录这种语法的源将非常有帮助！

— hashcode55

@ hashcode55-我在回答中添加了解释。

— ElPedro

要回答有关+- 的不确定性，在这种情况下，这是一元加号，例如+10，本质上是转换为整数的一种简便方法。

— FlipTack

谢谢@FlipTack。Kinda猜测这就是这样做的结果，但感谢您的正确解释。

— ElPedro

@ElPedro非常感谢！那确实帮助了我。

— hashcode55

5

JavaScript（ES6），46 38字节

(a,b)=>(4+!b[4]+!b[5]-!a[4]-!a[5])%3-1

利用“剪刀石头布”是循环的这一事实。JavaScript没有宇宙飞船，也没有平衡的三元运算符，否则答案是(a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3。

编辑：感谢@WashingtonGuedes，节省了8个字节。

— 尼尔
source

1

@WashingtonGuedes我可以做得更好！

— 尼尔

您可以咖喱保存1个字节

— -MayorMonty

我尝试运行它并始终返回0

— Vitim.us

5

MATL，14 13字节

TTt_0vic1Z)d)

在线尝试！或验证所有测试用例。

说明

如果从第二个字符串的第一个字母的首字母减去ASCII码，我们将在下面的D列中获得该值。以模5给出的值中号。括号中的最终值是所期望的结果，- [R 。

                        D        M     R
                       ---      ---   ---
Rock Rock          ->   0   ->   0   ( 0) 
Rock Paper         ->  −2   ->   3   (−1)
Rock Scissors      ->   1   ->   1   ( 1)
Paper Rock         ->   2   ->   2   ( 1)
Paper Paper        ->   0   ->   0   ( 0)
Paper Scissors     ->   3   ->   3   (−1)
Scissors Rock      ->  −1   ->   4   (−1)
Scissors Paper     ->  −3   ->   2   ( 1)
Scissors Scissors  ->   0   ->   0   ( 0)

因此，如果我们先计算D然后计算M，则要获得R，我们只需要将0映射到0即可；1和2到1；3和4至-1。这可以通过索引五个等于0、1或-1的条目的数组来完成。由于MATL中的索引是基于1的且是模块化的，因此数组应为[1, 1, −1, −1, 0]（第一个条目的索引为1，最后一个条目的索引为5或等效为0）。最后，很幸运地可以避免模5运算，因为它是由模块化索引隐式执行的。

TT     % Push [1 1]
t_     % Duplicate, negate: pushes [−1 −1]
0      % Push 0
v      % Concatenate vertically into the 5×1 array [1; 1; −1; −1; 0]
i      % Input cell array of strings
c      % Convert to 2D char array, right-padding with zeros if necessary
1Z)    % Take the first column. Gives a 2×1 array of the initial letters
d      % Difference
)      % Index into array. Implicit display

— 路易斯·门多
source

5

CJam，12个字节

0XXWW]rcrc-=

两个输入以空格分隔。与挑战文本中的顺序相反。

在线尝试！或验证所有测试用例。

说明

我的MATL答案的翻译。这利用了以下事实：在c字符串中应用的CJam （转换为char）采用其第一个字符。同样，用于映射的数组也不同，因为CJam中的索引是基于0的。

0XXWW    e# Push 0, 1, 1, -1, -1
]        e# Pack into an array
rc       e# Read whitespace-separated token as a string, and take its first char
rc       e# Again
-        e# Subtract code points of characters
=        e# Index into array. Implicitly display

— 路易斯·门多
source

5

CJam，15 14 12字节

rW=rW=-J+3%(

取每个字符串的最后一个字符的ascii代码，然后返回：

(a1 - a2 + 19) % 3 - 1

在这里测试！

— 阿诺
source

5

Python 3，54个字节

lambda o,t:(o!=t)*[-1,1]['RPS'['PS'.find(t[0])]!=o[0]]

在线尝试！

4

Java 7，82个字节

int c(String...a){int x=(a[0].charAt(1)-a[1].charAt(1))%5/2;return x%2==x?x:x/-2;}

取消高尔夫：

int c(String... a){
   int x = (a[0].charAt(1) - a[1].charAt(1)) % 5 / 2;
   return x%2 == x
           ? x
           : x / -2;
}

说明：

第二个字母o，a并且c，与ASCII小数111，97和99。
如果我们在测试用例中将它们彼此相减，则会得到以下结果：
- 0 （摇滚）
- 14 （摇滚，纸）
- 12 （纸，剪刀）
- -14 （纸，石头）
- 0 （纸，纸）
- -2 （纸，剪刀）
- -2 （剪刀，摇滚）
- 2 （剪刀，纸）
- 0 （剪刀，剪刀）
如果我们把模5对每个，我们得到4，2，-4，-2，-2，2。
x现在将测试用例除以2 所得的值：
- x = 0（摇滚）
- x = 2（岩石，纸质）
- x = 1（纸，剪刀）
- x = -2（纸，石头）
- x = 0（纸，纸）
- x = -1（纸，剪刀）
- x = -1（剪刀，摇滚）
- x = 1（剪刀，纸）
- x = 0（剪刀，剪刀）
只有2和-2是不正确的，而应该是-1和1。因此，如果x%2 != x（高于1或低于所有-1），我们除以-2固定这两个“边缘情况”。

测试代码：

在这里尝试。

class M{
  static int c(String...a){int x=(a[0].charAt(1)-a[1].charAt(1))%5/2;return x%2==x?x:x/-2;}

  public static void main(String[] a){
    String R = "Rock",
           P = "Paper",
           S = "Scissors";
    System.out.println(c(R, R)); // 0
    System.out.println(c(R, P)); // -1
    System.out.println(c(R, S)); // 1
    System.out.println(c(P, R)); // 1
    System.out.println(c(P, P)); // 0
    System.out.println(c(P, S)); // -1
    System.out.println(c(S, R)); // -1
    System.out.println(c(S, P)); // 1
    System.out.println(c(S, S)); // 0
  }
}

输出：

— 凯文·克鲁伊森
source

为什么第二封信出于好奇？我有相同的方法（有点），但是使用了第一个字母。

— 魔术章鱼缸

@carusocomputing好吧，我注意到其他大多数人都使用了首字母或长度，并想尝试其他方法。我第一次使用三字母（c，p，i）与ASCII值99，112并且105，因为他们似乎是最有用的，并且发现它会变成4,2，0，如果我做模5.只有这样，我想我不得不减去两个动作，所以4、2和0没什么用。经过一些摸索/试错后，我尝试了第二个字母，并且在仍然存在相同的模5的情况下获得了更多有用的结果。然后，我迅速找到了上面介绍的解决方案。:)

— Kevin Cruijssen

@carusocomputing想要尝试一种独特的方法，并且考虑到我在这类解决方案上表现很差，它不及其他解决方案那么短，但仍然是独一无二的（这是我最初的目标）。:)

— Kevin Cruijssen

4

直流，18

1?Z9+2/rZ1+2/-3%-p

在线尝试。

请注意，两个args在一行上传递（以空格分隔）到STDIN。args包含在方括号中，[ ]因为这就像dc它的字符串一样。

dc具有非常有限的字符串处理，但事实证明，你可以做的事情之一是使用Z命令来获得一个字符串的长度，这幸运的是截然不同的“摇滚”，“纸张”和“剪刀”，可相当简单算术操纵以产生期望的结果。

— 数字创伤
source

4

PHP，34字节

<?=md5("BMn$argv[1]$argv[2]")%3-1;

— 用户名
source

3

珀斯，16岁

t%+7h.+mx3ldQ3

可能会更短。

        x3ld      # lambda to get string length then XOR with 3
       m    Q     # map over the input (array of 2 strings)
     .+           # difference of the two results
    h             # flatten one-element array
  +7              # add 7
 %           3    # mod 3
t                 # subtract 1 and implicit print

网上。

— 数字创伤
source

3

C＃，85 84字节

感谢TheLethalCoder，节省了1个字节

a=>b=>a==b?0:(a[0]=='R'&b[0]=='S')|(a[0]=='P'&b[0]=='R')|(a[0]=='S'&b[0]=='P')?1:-1;

它接受两个字符串作为输入，并输出一个整数。如果两个字符串相等，则平局，否则检查字符串的第一个字符，以确定哪个玩家获胜。

— 霍瓦斯·戴维德
source

通过使用currying即保存一个字节a=>b=>...

— TheLethalCoder

3

JavaScript中，37，32，31个字节

a=>b=>a==b?0:!(a+b)[12]^a>b||-1

如果a等于b，则输出零。

否则，将检查长度是否大于12的结果（剪刀和纸的比较）与x进行比较。
如果返回1，则将其返回。

如果返回0，则使用OR运算符替换为-1。

— Grax32
source

您可以将此作为编写函数a=>b=>来保存字节的功能吗？

— FlipTack

是。谢谢@FlipTack

— Grax32 '17

2

批处理，116字节

@if %1==%2 echo 0&exit/b
@for %%a in (RockScissors PaperRock ScissorsPaper)do @if %%a==%1%2 echo 1&exit/b
@echo -1

— 尼尔
source

2

Perl，33个字节

32个字节的代码+ -p标志。

$_=/(.+) \1/?0:-/k P|r S|s R/||1

要运行它：

perl -pe '$_=/(.+) \1/?0:-/k P|r S|s R/||1' <<< "Rock Paper"

使用Martin Ender的Retina answer的正则表达式节省了3个字节。（我以前的正则表达式是/R.*P|P.*S|S.*R/）

说明：

首先，/(.+) \1/检查输入是否包含两次相同的单词，如果是，则结果为0。否则，/k P|r S|s R/处理答案为的情况-1。如果最后一个正则表达式为false，-/k P|r S|s R/则为false，因此我们返回1。

— 达达
source

2

果冻，9个字节

L€^3Iæ%1.

这使用@DigitalTrauma的Bash答案中的算法。

在线尝试！

这个怎么运作

L€^3Iæ%1.  Main link. Argument: A (string array)

L€         Take the length of each string.
  ^3       XOR the lengths bitwise with 3.
    I      Increments; compute the forward difference of both results.
     æ%1.  Balanced modulo 1.5; map the results into the interval (-1.5, 1.5].

— 丹尼斯
source

该死，我正要开始阅读果冻。哦，这是在pyth中。+1。

— Digital Trauma

2

Japt，19个字节

-Ms(4*(Uc -Vc)/MP¹r

在这里尝试！

_{受到carusocomputing解决方案的启发}

旧的53字节解决方案

W=Ug c X=Vg c W¥X?0:W¥82©X¥83?1:W¥80©X¥82?1:W¥83©X¥80?1:J

在线尝试！

_{再次感谢ETHproductions！}

— 奥立佛
source

1

— ETHproductions'Jan 11''11

— Oliver

1

其实你可以做W=Uc。我不知道为什么我一直忘记c对任何字符串都有效：P

— ETHproductions

2

PHP，55 53字节

<?=(3-(ord($argv[2])%6%4-ord($argv[1])%6%4+3)%3*2)%3;

接受第一个字母的ascii值（来自命令行参数）：82,80,83
％6：4、2、5
％4：0,2,1
差异（ba）：
- PS：1-2，SR：2-0，RP：2-0-> -1或2; + 3，％3-> 2
- SP：2-1，RS：0-2，PR：0-2-> -2或1; + 3，％3-> 1
- RR，PP，SS：0; + 3，％3：0
（3-2 * x）：-1,1,3
％3：-1,1,0

正弦版本，49 46字节

<?=2*sin(1.3*(ord($argv[2])-ord($argv[1])))|0;

高尔夫球场的carusocomputing的答案：

@ user59178保存了3个字节

— 提图斯
source

1

对于正弦版本，可以通过替换round(x)为“2*x^0

— user59178”

2

Perl，25个字节

$_=/kS|rR|sP/-/kP|rS|sR/

代码24字节+1字节（-p可选）。

输入应该在没有分隔符的stdin上，例如：

echo PaperRock | perl -pe'$_=/kS|rR|sP/-/kP|rS|sR/'

第一个正则表达式搜索第一个玩家获胜，第二个则寻找他的失败。差异被打印出来。

— k
source

1

Scala，148个字节

object R extends App{val t=Seq('R','P','S')
val(a,b)=(args(0)(0),args(1)(0))
print(if(a==b)0 else if(t.indexOf(a)%3==(t.indexOf(b)-1)%3)-1 else 1)}

值得庆幸的是，由于需要分号来分隔同一行上的多个命令，因此Scala受益于具有可格式化的高尔夫球代码！

在这次打高尔夫球的尝试中，我了解到您可以更换

"somestring".charAt(index)

与

"somestring"(index)

因为Scala允许您将字符串视为数组以获取字符。

— 大法师
source

这可以打很多球。对于初学者，在大多数挑战中，您可以执行功能而不是执行完整的程序，因此，代替整个对象扩展应用程序并从args中提取，请尝试如下操作：def g（a：Seq，b：Seq） = ...

— Ethan

此外，您无需打印该值。归还就足够了，这对于打Scala高尔夫来说非常棒，因为归还是免费的。您还可以使用Groovy答案中发布的技巧来进一步改进它，该技巧在Scala中几乎相同。

— 伊桑（Ethan）

得分剪刀石头布

Groovy，67 56 50字节

05AB1E，10个字节（非竞争）

C，50 35字节

说明：

MATLAB / Octave，63 54 52字节

Pure Bash，31岁

纯净重击，43 35

Python，40 30字节

背景

Mathematica，32个字节

Ruby，36 35 30字节

Python，39 36 34 33字节

这个怎么运作

视网膜，35 31字节

说明

05AB1E，18 17 15 10 9字节

果冻，8字节

这个怎么运作

Python 2中，46 40个字节

JavaScript（ES6），46 38字节

MATL，14 13字节

说明

CJam，12个字节

说明

CJam，15 14 12字节

Python 3，54个字节

Java 7，82个字节

直流，18

PHP，34字节

珀斯，16岁

C＃，85 84字节

JavaScript中，37，32，31个字节

批处理，116字节

Perl，33个字节

果冻，9个字节

这个怎么运作

Japt，19个字节

PHP，55 53字节

Perl，25个字节

Scala，148个字节