Bestimmen Sie das Ergebnis der RPS-Runde, wenn Sie zwei Zeichenfolgen "Rock", "Paper" oder "Scissors" eingeben . Geben Sie 1 aus, wenn der erste Spieler gewinnt, -1, wenn der zweite Spieler gewinnt, oder 0 für ein Unentschieden.

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

Sie müssen die exakten Zeichenfolgen "Rock", "Paper" und "Scissors" als Eingaben verwenden. Sie können wählen, ob die Wahl des ersten Spielers (konsistent) zuerst oder zweitens gegeben wird. Sie können sie alternativ als einzelne Eingabe mit einem einzelnen Zeichen oder einem leeren Trennzeichen verwenden. Die Eingabe ist garantiert eine der 9 möglichen Paarungen der drei Auswahlmöglichkeiten in Ihrem Eingabeformat.

Die Ausgabe sollte eine Zahl 1, 0 oder -1 oder eine Zeichenfolgendarstellung sein. Schwimmer sind in Ordnung. So sind +1, +0,und -0.

Verwandte: Codierung eines RPS-Spiels

Bestenliste:

var QUESTION_ID=106496,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/106496/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Groovy, 67 56 50 Bytes

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

Probieren Sie es online!

Es stellt sich heraus, dass das Stein-, Papier- und Scherenspiel eine ziemlich coole Eigenschaft hat.
Nehmen Sie für die Zeichenfolgen a und b jeweils den ersten Buchstaben, so ergeben sich zwei der folgenden Ergebnisse:R,P,S

Die vollständige Liste der möglichen Werte ist (wenn 2 Auswahlmöglichkeiten kombiniert werden):

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

Reorganisation der Liste zu:

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

Gibt uns eine Folge, die umgekehrt sinusförmig aussieht, und Sie können diese Formel tatsächlich als ungefähr darstellen (und mit ungefähr meine ich, gerade noch genug, um zu arbeiten, könnten Sie eine Gleichung erhalten, die tot ist, aber mehr Bytes kostet):

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

Die Vereinfachung von 4 / pi auf 1.3 wurde zuerst von @flawr vorgeschlagen und dann von @titus auf eine Gesamteinsparung von 6 Bytes getestet .

Unter Verwendung der doppelten Rundungseigenschaften von Groovy ergibt sich die richtige Ausgabe für Stein-Papier-Scheren.

05AB1E , 10 Bytes (nicht konkurrierend)

Ç¥13T/*.½ò

Probieren Sie es online!

Dieselbe Antwort wurde mit den neuen Befehlen, die am 26.10.2017 hinzugefügt wurden, auf 05AB1E portiert.

C, 50 35 Bytes

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

Rufe fmit einer Zeichenkette, die beide Spieler enthält, ohne Trennzeichen, und es wird zurückgegeben, ob der erste gewinnt.

Erläuterung:

Anhand der neun möglichen Zeichenfolgen wird deutlich, dass die Buchstabenpaare in den Spalten 7 und 8 eindeutig sind:

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

Der Offset und der Savage Cast, short*um diese Buchstabenpaare abzurufen und als Zahlen zu interpretieren:

29285
29545
21107
107
25968
21363
29555
27491
20595

Dann war es eine Frage der Brute-Force, die 51und die 4Reste zu finden , die diese Zahlen sukzessive reduzierten, um:

3 0 0 1 1 1 2 2 2

Das ist einfach perfekt, um am Ende noch einen Rest festzunageln und das Ergebnis zu kompensieren.

Sehen Sie es live auf Coliru

MATLAB / Octave , 63 54 52 Bytes

Es ist sehr praktisch, dass die ASCII-Codes der ersten Buchstaben von Rock,Paper,Scissorssind R=82,P=80,S=83. Wenn wir subtrahieren, erhalten 79wir bequem 3,1,4, was wir jetzt als Matrixindizes verwenden: Hier wird eine 4x4-Matrix fest codiert, wobei der i,j-te Eintrag dem Ergebnis entspricht, wenn Sie die Werte von gerade vorher eingeben:

     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)

Probieren Sie es online!

Pure Bash, 31

Die Formel von Borrowing @ Dennis :

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

Probieren Sie es online aus .

Vorherige Antwort:

Pure Bash, 43 35

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

• Holen Sie sich die String - Länge jeden arg ( 4, 5, 8jeweils für Stein, Papier, Schere)

• XOR mit jeweils 3 zu geben 7, 6, 11(die , wenn mod 3 give genommen 1, 0, 2)

• Dann subtrahieren und mit Mod 3 fummeln, um das gewünschte Ergebnis zu erzielen.

Probieren Sie es online aus .

Python , 40 bis 30 Bytes

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

Probieren Sie es online!

Hintergrund

Ich habe mit der Funktionsvorlage begonnen

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

und führte mit dem folgenden Programm eine Brute-Force-Suche nach geeigneten Parametern durch und wählte dann einen mit einer Implementierung mit minimaler Länge aus.

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)
]

Probieren Sie es online!

Mathematica, 32 Bytes

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

Unbenannte Funktion, die ein geordnetes Paar von Listen von Zeichen aufnimmt, z. B. {{"R","o","c","k"},{"P","a","p","e","r"}}und zurückgibt -1|0|1.

Ich wollte, dass der Code nicht nur die drei Eingabewörter, sondern auch den viel zu langen Funktionsnamen vermeidet ToCharacterCode. Also habe ich 4,5,8stattdessen mit der Länge der eingegebenen Wörter gearbeitet und nach einer kurzen Funktion dieser Längen gesucht, die eindeutige Antworten Modulo 3 ergab.

Es stellt sich heraus, dass die Fakultät von (die Länge - 3) die Antworten ergibt 1,2,120, die 1,-1,0Modulo 3 sind . Dann berechnen wir Modulo 3, die Differenz der beiden Werte (über das Skalarprodukt {1,-1}.{x,y} = x-y, was ein guter Weg ist, wenn die zwei Werte sind in einer Liste).

Ruby, 36 35 30 Bytes

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

Probieren Sie es auf ideone.com

Testausgang:

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

Nutzt die Tatsache, dass 7 der 9 korrekten Ergebnisse nur durch einen lexikografischen Vergleich mit dem Raumschiffoperator generiert werden <=>. Das (a+b)[12]kehrt nur die Eingaben zum Vergleich um, wenn die Eingaben Paperund sind Scissors(und auch Scissors Scissors- aber das ist auch so 0oder so).

Dank an Horváth Dávid für die Rettung eines Charakters und dank an GB für die Rettung weiterer 5.

Python , 39 36 34 33 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Werfen wir einen Blick auf einige Werte der Länge von sechs Kopien von x und einer Kopie von y modulo 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

Wir können die Ergebnisse ( {-1, 0, 1} ) codieren , indem wir sie der Menge {0, 1, 2, 3} zuordnen . Zum Beispiel erreicht die Abbildung t ↦ 2 - t dies und ist ihre eigene Inverse.

Wir bezeichnen das Ergebnis von x und y mit o (x, y) . Dann:

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₂

Glücklicherweise stimmen die Bits in den letzten Spalten alle überein, sodass wir sie ODER-verknüpfen können, um eine einzelne Ganzzahl n zu bilden und o (x, y) als 2 - ((n ≫ o (x, y))% 4 abzurufen. ) . Der Wert von n ist 94 .

Retina , 35-31 Bytes

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

Probieren Sie es online!

Erläuterung

Dies funktioniert in zwei Schritten. Zuerst drucken wir die Minuszeichen für die relevanten Eingaben. Dann drucken wir ein 0für Krawatten und ein 1anderes.

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

Dies sind zwei Stufen. Das )in der zweiten Stufe gruppiert sie, das *macht sie zu einem Trockenlauf (was bedeutet, dass die Eingabezeichenfolge wiederhergestellt wird, nachdem sie verarbeitet wurden, aber das Ergebnis gedruckt wird) und \unterdrückt das Drucken eines nachfolgenden Zeilenvorschubs. In den beiden Schritten wird -gegebenenfalls ein ausgedruckt.

Die erste Stufe ist eine Grep Stufe , die nur die Leitung hält , wenn er entweder enthält k P, r Soder s R. Diese entsprechen den Fällen, in denen wir ausgeben müssen -1. Wenn dies nicht der Fall ist, wird die Eingabe durch eine leere Zeichenfolge ersetzt.

Die zweite Stufe ersetzt .+(die gesamte Zeichenfolge, jedoch nur, wenn sie mindestens ein Zeichen enthält) mit -. Dies gibt also ein -für diese drei Fälle und sonst nichts aus.

D`\w+
 .

Dies sind zwei weitere Stufen. Die erste Stufe ist eine DVervielfältigung. Es vergleicht Wörter und entfernt Duplikate. Wenn und nur wenn die Eingabe ein Gleichstand ist, wird das zweite Wort gelöscht.

In der zweiten Stufe wird die Anzahl der Übereinstimmungen gezählt. Hierbei .handelt es sich um ein Leerzeichen, auf das ein beliebiges Zeichen folgt. Wenn die Eingabe ein Gleichstand war und das zweite Wort entfernt wurde, führt dies zu 0. Andernfalls ist das zweite Wort noch vorhanden und es gibt eine Übereinstimmung, sodass es 1stattdessen gedruckt wird.

05AB1E , 18 17 15 10 9 Bytes

6 Bytes werden mit dem Eingabe-Längen-Trick von Digital Trauma gespeichert

€g3^Æ>3%<

Übernimmt die Eingabe als [SecondPlayersChoice,FirstPlayersChoice]

Probieren Sie es online! oder Validiere alle Testfälle

Alternative 9-Byte-Lösung: íø¬ÇÆ>3%<

Erläuterung

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

Vorherige 15-Byte-Lösung

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

Probieren Sie es online! oder Validiere alle Testfälle

Erläuterung

 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

Gelee , 8 Bytes

L€Iµ-*×Ṡ

Probieren Sie es online! (Testsuite, aus Gründen der Übersichtlichkeit in Ganzzahl umgewandelt)

Wie es funktioniert

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.

Python 2 , 46 40 Bytes

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

Probieren Sie es online!

Vielen Dank an @Dennis für das Ausleihen seines Online-Testcodes Try it und das Speichern von 6 Byte.

Bearbeiten

@ hashcode55 - Ziemlich genau wie du es beschreibst. (x! = y, -1) ist eine Folge von zwei Elementen und [x [0] + y [0] in 'RPSR'] berechnet, welches Element genommen werden soll. Befindet sich der erste Buchstabe von x + der erste Buchstabe von y in der Zeichenliste, wird er mit True oder 1 bewertet, sodass (x! = Y, -1) [1] zurückgegeben wird. Wenn nicht, dann ist (x! = Y, -1) [0]. Hier wird es etwas knifflig. Das erste Element ist an sich effektiv ein anderes, wenn. Wenn x! = Y ist, ist das erste Element True, andernfalls ist es False. Wenn x [0] + y [0] in 'RPSR' false ist, wird entweder True oder False zurückgegeben, je nachdem, ob x == y ist. Das + ist ein bisschen hinterhältig und nochmals vielen Dank an @Dennis für dieses. Das x! = Y gibt ein wahres oder falsches Literal zurück. Wir brauchen eine 1 oder eine 0. Ich weiß immer noch nicht genau, aber das + macht diese Konvertierung. Ich kann nur annehmen, dass durch die Verwendung eines mathematischen Operators für Wahr / Falsch erzwungen wird, dass er als ganzzahliges Äquivalent angesehen wird. Offensichtlich wird das + vor dem -1 immer noch -1 zurückgeben.

Hoffe das hilft!

JavaScript (ES6), 46 38 Byte

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

Nutzt die Tatsache, dass Stein-Papier-Scheren zyklisch sind. JavaScript hat weder Raumschiffe noch ausgeglichene ternäre Operatoren, sonst wäre die Antwort (a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3.

Bearbeiten: 8 Bytes dank @WashingtonGuedes gespeichert.

MATL , 14 13 Bytes

TTt_0vic1Z)d)

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Wenn der ASCII-Code des Anfangsbuchstabens der ersten Zeichenfolge von dem der zweiten Zeichenfolge subtrahiert wird, erhalten wir den Wert in der Spalte D unten. Unter Modulo 5 ergibt den Wert M . Der endgültige Wert in Klammern ist das gewünschte Ergebnis, 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)

Wenn wir also D und dann M berechnen , müssen wir nur 0 bis 0 abbilden , um R zu erhalten . 1 und 2 zu 1; 3 und 4 bis -1. Dies kann durch Indizieren in ein Array von fünf Einträgen erfolgen, die 0, 1 oder -1 entsprechen. Da die Indexierung in MATL 1-basiert und modular ist, sollte das Array [1, 1, −1, −1, 0](der erste Eintrag hat Index 1, der letzte Index 5 oder gleichwertig 0) sein. Schließlich kann die Modulo 5-Operation zum Glück vermieden werden, da sie implizit durch die modulare Indizierung ausgeführt wird.

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

CJam , 12 Bytes

0XXWW]rcrc-=

Die beiden Eingänge sind durch Leerzeichen getrennt. Ihre Reihenfolge ist in Bezug auf das im Aufforderungstext umgekehrt.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Übersetzung meiner MATL-Antwort . Hierbei wird die Tatsache ausgenutzt, dass in CJam c( in Zeichen konvertieren), das auf eine Zeichenfolge angewendet wird, das erste Zeichen verwendet wird. Das Array für die Zuordnung unterscheidet sich auch, da die Indizierung in CJam auf 0 basiert.

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

CJam, 15 14 12 Bytes

rW=rW=-J+3%(

Nehmen Sie den ASCII-Code des letzten Zeichens jeder Zeichenfolge und geben Sie Folgendes zurück:

(a1 - a2 + 19) % 3 - 1

Teste es hier !

Python 3, 54 Bytes

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

Probieren Sie es online!

Java 7, 82 Bytes

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

Ungolfed:

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

Erläuterung:

• Die zweiten Buchstaben sind o, aund cmit den ASCII - Dezimalzahlen 111, 97und 99.
• Wenn wir diese für die Testfälle voneinander subtrahieren, erhalten wir die folgenden Ergebnisse:
  • 0 (Rock, Rock)
  • 14 (Stein, Papier)
  • 12 (Papier, Schere)
  • -14 (Papier, Stein)
  • 0 (Papier, Papier)
  • -2 (Papier, Schere)
  • -2 (Schere, Rock)
  • 2 (Schere, Papier)
  • 0 (Schere, Schere)
• Wenn wir modulo 5 für jeden nehmen, erhalten wir 4, 2, -4, -2, -2, 2.
• Geteilt durch 2 xergibt sich nun für die Testfälle:
  • x = 0 (Rock, Rock)
  • x = 2 (Stein, Papier)
  • x = 1 (Papier, Schere)
  • x = -2 (Papier, Stein)
  • x = 0 (Papier, Papier)
  • x = -1 (Papier, Schere)
  • x = -1 (Schere, Stein)
  • x = 1 (Schere, Papier)
  • x = 0 (Schere, Schere)
• Nur die 2und -2sind falsch und sollten -1und 1stattdessen gewesen sein. Also, wenn x%2 != x(alles darüber 1oder darunter -1) wir teilen -2, um diese beiden 'Randfälle' zu beheben.

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

dc, 18

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

Probieren Sie es online aus .

Beachten Sie, dass die beiden Argumente in einer Zeile an STDIN übergeben werden (durch Leerzeichen getrennt). Die Argumente sind in eckigen Klammern angegeben, [ ]da dcdie Zeichenfolgen so beliebt sind.

dcDie Handhabung von Strings ist sehr begrenzt, aber es hat sich herausgestellt, dass Sie den ZBefehl verwenden können, um eine Stringlänge zu erhalten, die sich zum Glück für "Rock", "Paper" und "Scissors" unterscheidet und recht einfach arithmetisch sein kann manipuliert, um das gewünschte Ergebnis zu erzielen.

PHP, 34 Bytes

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

Pyth, 16

t%+7h.+mx3ldQ3

Wahrscheinlich könnte kürzer sein.

        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

Online .

C #, 85 84 Bytes

Dank TheLethalCoder 1 Byte gespart

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;

Es akzeptiert zwei Zeichenfolgen als Eingabe und gibt eine Ganzzahl aus. Wenn die beiden Saiten gleich sind, gibt es einen Gleichstand, andernfalls wird nach dem ersten Charakter der Saiten gesucht, um festzustellen, welcher Spieler gewinnt.

JavaScript, 37 , 32 , 31 Bytes

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

Wenn a gleich b ist, wird Null ausgegeben.

Andernfalls xoder das Ergebnis der Prüfung, ob die Länge nicht größer als 12 ist (Vergleich von Schere und Papier) mit dem Vergleich von a größer als b.
Wenn dies 1 zurückgibt, geben Sie es zurück.

Wenn 0 zurückgegeben wird, verwenden Sie den OR-Operator, um ihn durch -1 zu ersetzen.

Batch, 116 Bytes

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

Perl, 33 Bytes

32 Byte Code + -pFlag.

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

Um es auszuführen:

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

3 Bytes mit dem Regex von Martin Enders Retina- Antwort gespeichert . (mein vorheriger regulärer Ausdruck war /R.*P|P.*S|S.*R/)

Erläuterung:

Zunächst wird /(.+) \1/überprüft , ob die Eingabe enthält zweimal das gleiche Wort, wenn ja, ist das Ergebnis 0. Ansonsten /k P|r S|s R/befasst sich mit dem Fall, in dem die Antwort ist -1. Wenn dieser letzte reguläre Ausdruck falsch ist, dann -/k P|r S|s R/ist er falsch, also kehren wir zurück 1.

Gelee , 9 Bytes

L€^3Iæ%1.

Hierbei wird der Algorithmus aus der Bash-Antwort von @ DigitalTrauma verwendet .

Probieren Sie es online!

Wie es funktioniert

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].

Japt , 19 Bytes

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

Probieren Sie es hier aus!

_{Inspiriert von der Lösung von carusocomputing}

Alte 53-Byte-Lösung

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

Probieren Sie es online!

_{Nochmals vielen Dank, ETHproductions!}

PHP, 55 53 Bytes

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

• Nimmt die ASCII-Werte der ersten Buchstaben (aus Befehlszeilenargumenten): 82,80,83
• % 6: 4,2,5
• % 4: 0,2,1
• Unterschied (ba):
  • PS: 1-2, SR: 2-0, RP: 2-0 -> -1 oder 2; + 3,% 3 -> 2
  • SP: 2-1, RS: 0-2, PR: 0-2 → -2 oder 1; + 3,% 3 -> 1
  • RR, PP, SS: 0; + 3,% 3: 0
• (3-2 * x): -1,1,3
• % 3: -1,1,0

Sinus-Version, 49 46 Bytes

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

Ein Golf-Hafen der Antwort von Carusocomputing :

3 Bytes gespeichert von @ user59178

Perl, 25 Bytes

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

Code 24 Byte + 1 Byte für die -pOption.

Die Eingabe sollte auf stdin ohne Trennzeichen erfolgen, zB:

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

Der erste reguläre Ausdruck sucht nach dem Gewinn des ersten Spielers, der zweite nach seinem Verlust. Der Unterschied wird gedruckt.

Scala, 148 Bytes

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)}

Da Semikolons erforderlich sind, um mehrere Befehle in derselben Zeile zu trennen, profitiert Scala von formatierbarem Golfcode!

Bei diesem Golfversuch habe ich gelernt, dass Sie ersetzen können

"somestring".charAt(index) 

mit

"somestring"(index) 

weil Sie mit Scala Zeichenfolgen als Arrays behandeln können, um Zeichen zu erhalten.