じゃんけんのスコア

70

「Rock」、「Paper」、または「Scissors」の2つの文字列入力を指定して、RPSラウンドの結果を決定します。最初のプレイヤーが勝った場合は1、2番目のプレイヤーが勝った場合は-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」を使用する必要があります。最初のプレイヤーの選択が（一貫して）最初に与えられるか2番目に与えられるかを選択できます。または、単一文字または空の区切り文字を使用して、単一の入力として受け取ることもできます。入力は、入力形式の3つの選択肢の9つの可能な組み合わせのいずれかであることが保証されています。

出力は、数値1、0、または-1、またはそのストリング表現でなければなりません。フロートは大丈夫です。そうです+1、+0,そして-0。

関連：RPSゲームのコーディング

リーダーボード：

コードスニペットを表示

code-golf  game 
— xnor
ソース
ない空のセパレータを単一の入力は、例えば、「rockpaper」を意味しますか？
— エミグナ
1
@Emignaはい、ただし大文字で始まるRockPaper。
— -xnor
15
それは私が予想していたよりもずっと楽しかったです。
— 魔法のタコUr
入力は2つの文字列の配列にできますか？
— ルイスメンドー
@LuisMendoはい。
— -xnor

回答:

73

Groovy、67 56 50バイト

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

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

じゃんけんゲームにはかなりクールな特性があることがわかりました。
文字列aとbが与えられ、それぞれの最初の文字を取得すると、次の2つの結果になります。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()

4 / piを1.3に単純化することが最初に@flawrによって提案され、次に@titusによってテストされ、合計で6バイト節約されました。

方程式の説明

groovyの二重丸めプロパティを使用すると、じゃんけんの正しい出力が得られます。

05AB1E、10バイト（非競合）

Ç¥13T/*.½ò

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

新しいコマンドを使用して05AB1Eに移植された同じ回答が2017年10月26日に追加されました。

— 魔法のタコUr
ソース
3
あなたが使用することによって、それを短くすることができなかったこと-sin(x) = sin(-x)、それだけの順番を逆転させることを意味するaとbし、大手ドロップ-？それ以外は、近似ハードコーディング4/Piのようなこと1.273や、十分な可能性が1.3または9/7または5/4。
— -flawr
2
PS：リンクを作成してオンラインで試すことをお勧めします。そうすれば、私のような人があなたの投稿で遊ぶことができます=）
— flawr
3
のsin(b-a)代わりに1バイトを保存できます-sin(a-b)。素晴らしい発見！
— タイタス
2
;の1.3代わりにを掛けてさらに7バイト節約します4/Math.PI。それは十分に正確です。
— タイタス
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セパレータなしで両方のプレーヤーを含む文字列で呼び出します。最初の方が勝つかどうかを返します。

説明：

考えられる9つの文字列を見ると、列7と8の文字のペアが一意であることがわかります。

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

short*これらの文字のペアを取得し、それらを数字として解釈するためのオフセットと野avなキャスト：

29285
29545
21107
107
25968
21363
29555
27491
20595

それから、51と4残りを見つけることは総当たりの問題であり、これらを適用してこれらの数を連続的に減らします：

3 0 0 1 1 1 2 2 2

これは最後にさらに残りを追加して、結果を相殺するのに最適です。

Coliruでライブを見る

— クエンティン
ソース
-f(i)他のプレイヤーのスコアを計算するために計算するようなことはしないでください-予期しない出力が発生します！
— -nneonneo
4
@nneonneo -(f(i))は正常に動作するはずです。マクロは楽しいです！
— nwp
18

MATLAB / オクターブ、63 54 52バイト

最初の文字のASCII-コードがあることは非常に便利ですRock,Paper,ScissorsですR=82,P=80,S=83。減算79すると、便利3,1,4になります。これをマトリックスインデックスとして使用します。ここでは、4x4-matrixがハードコーディングさi,jれています。

     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)

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

— フレア
ソース
16

Pure Bash、31

@Dennis の式を借りる：

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

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

前の答え：

ピュアバッシュ、43 35

echo $[(7+(${#2}^3)-(${#1}^3))%3-1]
  • 各引数の文字列の長さを取得します（4、5、8それぞれロック、紙用、はさみ）

  • XOR 3とそれぞれ与えるために7、6、11（MOD 3ギブを取っときに1、0、2）

  • 次に、mod 3を減算して調整し、目的の結果を取得します。

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

— デジタル外傷
ソース
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)
]

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

— デニス
ソース
14

Mathematica、32バイト

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

名前のない関数は、などの文字のリストの順序付きペアを取得して{{"R","o","c","k"},{"P","a","p","e","r"}}返し-1|0|1ます。

3つの入力語だけでなく、あまりにも長い関数名も回避するコードが欲しかったToCharacterCode。そのため4,5,8、代わりに入力語の長さで作業し、3を法とする明確な答えを与えるそれらの長さの短い関数を探しました（2による整数除算は数学的には有望ですが、それらの関数はMathematicaでは長すぎます）。

（長さ– 3）の階乗を取ると、3 1,2,120を1,-1,0法とする答えが得られることがわかります。次に、3を法として、2つの値の差を計算します（ドット積を介して{1,-1}.{x,y} = x-y、 2つの値がリストにあります）。

— グレッグ・マーティン
ソース
1
「判明...」あなたはこれらのことに目を向けています
— -ngenisis
12

ルビー、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と、さらに5枚保存してくれたGBに感謝します。

— ガレス
ソース
匿名のラムダを使用して、2文字を保存できます。
— GB
@GB関数に名前を付けないと、どのように呼び出すのですか？それは私にごまかします。しかし、他のヒントに感謝します-ScissorsScissorsは16であるため、私はそれを見ましたが、それを拒否しましたが、実際にはそれは問題ではないと思います。:
— ガレス
それは不正行為ではありません。匿名関数はデフォルトで許可されています。
— デニス
@Dennis割り当てることなく呼び出すことはできません。私にはごまかしているように感じ、名前を定義する必要がある匿名関数のない言語では不公平です。
— ガレス
もちろんできます。tio.run/nexus/…–
— デニス
10

Python、39 36 34 33バイト

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

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

使い方

xの6 つのコピーと7を法とするyの 1つのコピーの長さのいくつかの値を見てみましょう。

                                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

我々は結果（符号化することができる{-1、0、1}のセットにそれらをマッピングすることによって）{0、1、2、3} 。たとえば、マッピングt↦2-tはこれを達成し、それ自体が逆です。

のがの結果表すと、XとYをすることにより、O（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₂

幸いなことに、最後の列のビットはすべて一致しているため、それらをORして単一の整数nを形成し、o（x、y）を2-（（n≫ o（x、y））％4）として取得できます。nの値は94です。

— デニス
ソース
9

網膜、35 31バイト

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

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

説明

これは2つのステップで機能します。まず、関連する入力にマイナス記号を印刷します。次に0、同点の1場合とそうでない場合を印刷します。

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

これは2つの段階です。)一緒に第二段階のグループそれらに、*それらドライランなる（それらが処理された後に、入力文字列が復元されることを意味するが、結果は印刷される）と\後続改行の印刷を抑制する。-該当する場合、2つのステージが一緒に印刷されます。

第一段階は、Gそれはどちらかが含まれている場合にのみ行を保持するrep段階k P、r Sまたはs R。これらは、出力する必要がある場合に対応します-1。これらのケースのいずれでもない場合、入力は空の文字列に置き換えられます。

2番目のステージは.+（文字列全体。ただし、少なくとも1つの文字が含まれている場合のみ）で置き換えられ-ます。したがって-、これらの3つのケースに対してa が出力され、それ以外は何も出力されません。

D`\w+
 .

これはさらに2つの段階です。最初の段階はD教育です。単語と一致し、重複を削除します。したがって、入力が同点の場合にのみ、2番目の単語が削除されます。

2番目の段階では、の一致数をカウントし .ます。これは、任意の文字が続くスペースです。入力が同点で、2番目の単語が削除された場合、結果はになり0ます。それ以外の場合、2番目の単語はまだ存在し、一致するものが1つあるため、1代わりに出力されます。

— マーティン・エンダー
ソース
入力文字列の長さに基づいた別のアプローチを次に示します。それはあなたのものよりも長いですが、それ以上ゴルフを打つことができるのだろうか？
— デジタル外傷
@DigitalTraumaは本当にすてきなアイデアですが、短縮するものは見当たりません。とにかくそれを投稿する必要があると思います（そして、最初の行をヘッダーに移動すると、TIOはそれをバイトカウントに含めません）。
— マーティンエンダー
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
— エミグナ
ソース
あなたは私の楽しみの1を打つ:( Ç¥13T/*.½ò？ITワークスなぜ誰も知らない。
— マジックタコ壺
@MagicOctopusUrn：うーん、それは確かに奇妙なものです。出力としてintを返すための入力形式は何でしょうか？
— エミグナ
— 魔法のタコUr
@MagicOctopusUrn：そうそう、私はそのことを忘れていました。この挑戦に対する私のお気に入りの答え:)
— エミグナ
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.
— デニス
ソース
6

パイソン2、46の 40バイト

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

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

@Dennisに、Try itオンラインテストコードを借りさせてくれて、6バイト節約してくれてありがとう。

編集

@ hashcode55-ほぼ説明どおり。（x！= y、-1）は2要素のシーケンスであり、[x [0] + y [0] in'RPSR ']はどの要素を取るかを計算しています。xの最初の文字+ yの最初の文字が文字リストにある場合、Trueまたは1に評価されるため、（x！= y、-1）[1]が返されます。そうでない場合、（x！= y、-1）[0]。ここで少し注意が必要です。最初の要素自体は事実上別の場合です。x！= yの場合、最初の要素はTrueになり、それ以外の場合はFalseになります。x[0] + y [0] in'RPSR 'がfalseの場合、x == yかどうかに応じてTrueまたはFalseが返されます。+は少しこっそりしていて、この@Dennisに再び感謝します。x！= yは、リテラルのTrueまたはFalseを返します。1または0が必要です。まだ方法はわかりませんが、+はこの変換を行います。True / Falseで数学演算子を使用することで、整数と等価と見なされることを強制していると仮定することができます。-1の前の+は明らかに-1を返します。

お役に立てれば！

— エルペドロ
ソース
こんにちは！この構文がどのように機能するか教えてください。論理的に推測すると、(x!=y,-1)これはifのように機能し、リストがtrueを生成する場合は-1 elseを生成しますx!=y。その+サインの使用は何ですか？この種の構文を文書化したソースは本当に役立つでしょう！
— hashcode55
@ hashcode55-回答に説明を追加しました。
— エルペドロ
+- についての不確実性に答えるために、この場合、それはのような単項プラスであり、+10本質的に整数に変換する短い方法です。
— FlipTack
ありがとう@FlipTack。ちょっとそれはそれがやっていることだと推測したが、適切な説明をありがとう。
— エルペドロ
@ElPedroどうもありがとう！それは確かに私を助けました。
— hashcode55
5

JavaScript（ES6）、46 38バイト

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

Rock-Paper-Scissorsは周期的であるという事実を利用します。JavaScriptには、宇宙船も平衡三元演算子もありません(a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3。そうでなければ、答えはになります。

編集：@WashingtonGuedesのおかげで8バイト保存されました。

— ニール
ソース
1
@WashingtonGuedesそれよりももっと上手くできる！
— ニール
1バイトを節約するためにカレーできます
— MayorMonty
私はそれを実行してみましたが、常に0を返します
— Vitim.us
5

MATL、14 13バイト

TTt_0vic1Z)d)

オンラインでお試しください！または、すべてのテストケースを確認します。

説明

最初の文字列の最初の文字のASCIIコードを2番目の文字列のASCIIコードから減算すると、下のD列に値が表示されます。5を法とすると、値Mが得られます。括弧内の最終値は、目的の結果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に等しい5つのエントリの配列にインデックスを付けることで実行できます。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
— ルイス・メンドー
ソース
5

CJam、12バイト

0XXWW]rcrc-=

2つの入力はスペースで区切られています。それらの順序は、チャレンジテキストの順序と逆になっています。

オンラインでお試しください！または、すべてのテストケースを確認します。

説明

私の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
— ルイス・メンドー
ソース
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;
}

説明：

  • 2番目の文字はo、aおよびc、ASCIIの10進数で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これら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
  }
}

出力：

0
-1
1
1
0
-1
-1
1
0
— ケビン・クルーッセン
ソース
なぜ好奇心から2番目の手紙ですか？私は同じアプローチ（ちょっと）を持っていましたが、最初の手紙を使いました。
— 魔法のタコUr
@carusocomputingまあ、私は他のほとんどの人が最初の文字または長さのいずれかを使用していることに気づき、他の何かを試してみたいと思いました。私は最初の三文字を（使用c、p、iASCII値で）99、112そして105そう、彼らは最も有用なように見えたとして、それは私がモジュロ5をした場合は4、2、0のみ、私は、私は両方を減算しなければならなかった考え出しなる気づきました4、2、および0はあまり役に立ちませんでした。いくつかのいじくりまわし/試行錯誤の後、2番目の文字を試し、同じモジュロ5がまだ存在する状態でより有用な結果を得ていました。その後、私はすぐに上記のソリューションに到達しました。:)
— ケビンクルーイッセン
@carusocomputing独自のアプローチを試してみたかったのですが、この種のソリューションがかなり苦手だと考えると、他のソリューションほど短くはありませんが、それでも独自のアプローチです（当初の目標でした）。:)
— ケビンクルーッセン
4

dc、18

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

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

2つの引数が1行で（スペースで区切られて）STDINに渡されることに注意してください。[ ]これはdc文字列が好きなので、引数は角括弧に含まれています。

dc文字列の処理は非常に限られていますが、できることの1つは、Zコマンドを使用して文字列の長さを取得することです。目的の結果が得られるように操作されます。

— デジタル外傷
ソース
3

Pyth、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

オンライン。

— デジタル外傷
ソース
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;

2つの文字列を入力として受け入れ、整数を出力します。2つのストリングが等しい場合、同点があります。それ以外の場合、どちらのプレーヤーが勝つかを判断するために、ストリングの最初の文字をチェックします。

— ホルバース・ダヴィッド
ソース
カリー化を使用して1バイトを保存するa=>b=>...
— -TheLethalCoder
3

JavaScriptが、37、32、31のバイト

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

aがbに等しい場合、ゼロを出力します。

それ以外の場合、長さが12以下（はさみと紙の比較）であるかどうかをチェックした結果と、bより大きいものを比較します。
これが1を返す場合、それを返します。

0を返す場合は、OR演算子を使用して-1に置き換えます。

— Grax32
ソース
これをa=>b=>バイトを保存するカリー化された関数として書くことができますか？
— FlipTack
はい。ありがとう@FlipTack
— Grax32
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
— ニール
ソース
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/入力に同じ単語が2回含まれているかどうかをチェックします。含まれている場合、結果は0です。それ以外/k P|r S|s R/の場合は、答えがの場合を扱い-1ます。この最後の正規表現が偽の場合、-/k P|r S|s R/偽であるため、を返し1ます。

— ダダ
ソース
2

ゼリー、9バイト

L€^3Iæ%1.

これは、@ DigitalTraumaのBash answerのアルゴリズムを使用します。

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

使い方

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].
— デニス
ソース
くそー、私はゼリーについて読み始めようとしていました。まあ、ここにあります。+1。
— デジタル外傷
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、ありがとうございました！

— オリバー
ソース
1
©代わりにを使用して開始し&&、Ug0 ctoをUg c（と同じV）に変更し、で置き換えること-1ができJます。ただし、JSの回答よりもかなり長いです。おそらく、そこからいくつかのアイデアを得ることができます
— -ETHproductions
@ETHproductionsありがとう！どうやって忘れているのかわからない©
— オリバー
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´sのゴルフ場の答え：

@ user59178で3バイト節約

— タイタス
ソース
1
置き換えることにより、3つのバイトを保存することができため、正弦バージョンのためround(x)に2*x^0
— user59178
2

Perl、25バイト

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

-pオプションとして24バイト+1バイトをコーディングします。

入力は、セパレータなしの標準入力である必要があります。例：

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

最初の正規表現は最初のプレーヤーの勝利を検索し、2番目のプレーヤーは損失を検索します。違いが印刷されます。

— ミク
ソース
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では、文字を取得する目的で文字列を配列として扱うことができるためです。

— アーチメイジ
ソース
これは非常にゴルフすることができます。手始めに、ここでのほとんどの課題で完全なプログラムの代わりに関数を実行することが許可されているので、オブジェクト全体がアプリの事を拡張して引数からプルする代わりに、次のようなものを試してください：def g（a：Seq、b：Seq） =
— イーサン
また、値を印刷する必要はありません。それを返すことは十分であり、Scalaをゴルフするときは素晴らしいです。さらに、Groovyの回答に掲載されているトリックを使用して、Scalaでもほぼ同じように機能させることで、さらに改善できます。
— イーサン
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.