Avec deux entrées de chaîne de type "Rock", "Paper" ou "Scissors", déterminez le résultat du cycle RPS . Sortie 1 si le premier joueur gagne, -1 si le deuxième joueur gagne ou 0 en cas d'égalité.

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

Vous devez utiliser les chaînes exactes "Rock", "Paper" et "Scissors" comme entrées. Vous pouvez choisir si le choix du premier joueur est (systématiquement) donné en premier ou en second. Vous pouvez également les prendre comme une seule entrée avec un séparateur à caractère unique ou vide. L'entrée est garantie par l'un des 9 appariements possibles des trois choix dans votre format d'entrée.

La sortie doit être un nombre 1, 0 ou -1, ou sa représentation sous forme de chaîne. Les flotteurs sont bien. Sont donc +1, +0,et -0.

Connexes: codage d'un jeu RPS

Classement:

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 octets

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

Essayez-le en ligne!

Il se trouve que le jeu de la pierre, du papier et des ciseaux a une propriété plutôt cool.
Étant donné les chaînes a et b, prenez la première lettre de chacune, cela donne deux des éléments suivants:R,P,S

La liste exhaustive des valeurs possibles est (Lorsque 2 choix sont combinés):

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

Réorganiser la liste pour:

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

Nous donne une séquence qui semble inversement sinusoïdale, et vous pouvez en fait représenter cette formule comme approximativement (et par approximativement, je veux dire à peine assez pour fonctionner, vous pourriez obtenir une équation sans faille mais qui coûte plus d'octets):

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

La simplification de 4 / pi à 1,3 a d'abord été suggérée par @flawr , puis testée par @titus pour une économie totale de 6 octets.

En utilisant les propriétés de double arrondi de groovy, il en résulte une sortie correcte pour les ciseaux à papier rock.

05AB1E , 10 octets (non-concurrence)

Ç¥13T/*.½ò

Essayez-le en ligne!

Même réponse portée à 05AB1E à l'aide des nouvelles commandes ajoutées le 26/10/2017.

C, 50 35 octets

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

Appelez favec une chaîne contenant les deux joueurs, sans séparateur, et il retournera si le premier gagne.

Explication:

En regardant les neuf chaînes possibles, il s’avère que les paires de lettres des colonnes 7 et 8 sont uniques:

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

La distribution offset et sauvage permet de short*récupérer ces paires de lettres et de les interpréter comme des nombres:

29285
29545
21107
107
25968
21363
29555
27491
20595

Ensuite, il a fallu la force brute pour trouver le 51et les 4restes, qui ont été appliqués successivement pour réduire ces nombres à:

3 0 0 1 1 1 2 2 2

Ce qui est parfait pour ajouter encore un reste à la fin et compenser le résultat.

Voir en direct sur Coliru

MATLAB / Octave , 63 54 52 octets

Il est très pratique que les codes ASCII des premières lettres Rock,Paper,Scissorssoient R=82,P=80,S=83. Si nous soustrayons 79nous obtenons commodément 3,1,4, ce que nous utiliserons maintenant comme indices matriciels: Ici, une matrice 4x4 est codée en dur, où l' i,jentrée -th correspond au résultat si vous insérez les valeurs juste avant:

     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)

Essayez-le en ligne!

Pure Bash, 31 ans

Emprunter @ la formule de Dennis :

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

Essayez-le en ligne .

Réponse précédente:

Pure Bash, 43 35

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

• Obtenez la longueur de chaîne de chaque arg ( 4, 5, 8respectivement pour Roche, papier, ciseaux)

• XOR chacun avec 3 à envoyer 7, 6, 11(qui, pris mod 3 donnent 1, 0, 2)

• Ensuite, soustrayez et modifiez le mod 3 pour obtenir le résultat souhaité.

Essayez-le en ligne .

Python , 40 à 30 octets

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

Essayez-le en ligne!

Contexte

J'ai commencé avec le modèle de fonction

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

et a lancé une recherche brute-force pour les paramètres appropriés en utilisant le programme suivant, puis en a choisi un avec une implémentation de longueur minimale.

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

Essayez-le en ligne!

Mathematica, 32 octets

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

Fonction sans nom prenant une paire ordonnée de listes de caractères, telles que {{"R","o","c","k"},{"P","a","p","e","r"}}, et retournant -1|0|1.

Je voulais que le code évite non seulement les trois mots d'entrée, mais également le nom de la fonction trop longue ToCharacterCode; J'ai donc 4,5,8plutôt travaillé avec la longueur des mots d'entrée et cherché une fonction courte de ces longueurs donnant des réponses distinctes modulo 3. (La division entière par 2 est mathématiquement prometteuse, mais ces fonctions ont des noms trop longs dans Mathematica.)

Il se trouve que prendre la factorielle de (la longueur - 3) donne les réponses 1,2,120, qui sont 1,-1,0modulo 3. Ensuite, nous calculons simplement, modulo 3, la différence des deux valeurs (via le produit scalaire {1,-1}.{x,y} = x-y, ce qui est un bon moyen lorsque le deux valeurs sont dans une liste).

Ruby, 36 35 30 octets

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

Essayez-le sur ideone.com

Test de sortie:

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

Tirant parti du fait que 7 des 9 résultats corrects sont générés simplement en effectuant une comparaison lexicographique à l’aide de l’opérateur de vaisseau spatial <=>. Le (a+b)[12]simple inverse les entrées à la comparaison si les entrées sont Paperet Scissors(et aussi Scissors Scissors- mais c'est l' 0inverse).

Merci à Horváth Dávid de m'avoir sauvé un personnage et à GB de m'avoir sauvé 5 autres personnages.

Python , 39 36 34 33 octets

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

Essayez-le en ligne!

Comment ça fonctionne

Jetons un coup d'œil à quelques valeurs de la longueur de six copies de x et d'une copie de 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

Nous pouvons coder les résultats ( {-1, 0, 1} ) en les mappant dans l'ensemble {0, 1, 2, 3} . Par exemple, la cartographie t ↦ 2 - t y parvient et constitue son propre inverse.

Notons le résultat de x et y par o (x, y) . Ensuite:

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₂

Heureusement, les bits des dernières colonnes sont tous en accord, nous pouvons donc OU former un seul entier n et récupérer o (x, y) sous la forme 2 - ((n ≫ o (x, y))% 4) . La valeur de n est 94 .

Retina , 35 à 31 octets

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

Essayez-le en ligne!

Explication

Cela fonctionne en deux étapes. Tout d'abord, nous imprimons les signes moins pour les entrées correspondantes. Ensuite, nous imprimons un 0pour les cravates et un 1autre.

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

Ceci est deux étapes. Dans )la deuxième étape, ils sont regroupés, *ils sont traités à sec (ce qui signifie que la chaîne d'entrée sera restaurée après leur traitement, mais le résultat sera imprimé) et \supprimera l'impression d'un saut de ligne suivi. Les deux étapes ensemble imprimeront un -si applicable.

La première étape est une Gétape de représentant qui ne garde que la ligne si elle contient soit k P, r Sou s R. Celles-ci correspondent aux cas où nous devons sortir -1. Si ce n'est pas le cas, l'entrée sera remplacée par une chaîne vide.

La deuxième étape remplace .+(la chaîne entière, mais seulement si elle contient au moins un caractère) par -. Donc, cela affiche un -pour ces trois cas et rien autrement.

D`\w+
 .

Ceci est deux autres étapes. La première étape est une Déduplication. Il correspond aux mots et supprime les doublons. Donc, si et seulement si l'entrée est une égalité, le deuxième mot est supprimé.

La deuxième étape compte le nombre de correspondances de ., qui est un espace suivi de tout caractère. Si la saisie était à égalité et que le deuxième mot a été supprimé, cela se traduit par 0. Sinon, le deuxième mot est toujours en place et il y a une correspondance. Il est donc imprimé 1.

05AB1E , 18 17 15 10 9 octets

6 octets enregistrés avec l' astuce de longueur d'entrée de Digital Trauma

€g3^Æ>3%<

Prend en tant que [SecondPlayersChoice,FirstPlayersChoice]

Essayez-le en ligne! ou valider tous les cas de test

Solution alternative à 9 octets: íø¬ÇÆ>3%<

Explication

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

Solution précédente de 15 octets

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

Essayez-le en ligne! ou valider tous les cas de test

Explication

 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

Gelée , 8 octets

L€Iµ-*×Ṡ

Essayez-le en ligne! (suite de tests, convertit en entier pour plus de clarté)

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

Un grand merci à @Dennis de m'avoir permis d'emprunter son code d'essai Try it en ligne et de m'avoir sauvé 6 octets.

Modifier

@ hashcode55 - à peu près comme vous le décrivez. (x! = y, -1) est une séquence de deux éléments et [x [0] + y [0] in'RPSR '] calcule quel élément prendre. Si la première lettre de x + la première lettre de y figure dans la liste des caractères, elle sera évaluée à True ou à 1, si bien que (x! = Y, -1) [1] sera renvoyé. Si ce n'est pas alors (x! = Y, -1) [0]. C'est là que ça devient un peu délicat. Le premier élément est en soi un autre si. Si x! = Y, le premier élément sera True, sinon ce sera False. Par conséquent, si x [0] + y [0] in'RPSR 'est false, alors True ou False sera renvoyé selon que x == y. Le + est un peu sournois et merci encore à @Dennis pour celui-ci. Le x! = Y retournera un littéral vrai ou faux. Nous avons besoin d'un 1 ou d'un 0. Je ne sais toujours pas comment mais le + effectue cette conversion. Je ne peux que supposer que l'utilisation d'un opérateur mathématique sur True / False l'oblige à être considéré comme l'équivalent entier. Evidemment, le + devant le -1 retournera toujours -1.

J'espère que cela t'aides!

JavaScript (ES6), 46 38 octets

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

Exploite le fait que Rock-Paper-Scissors est cyclique. JavaScript n'a ni vaisseau spatial ni opérateurs ternaires équilibrés, sinon la réponse serait (a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3.

Edit: 8 octets sauvegardés grâce à @WashingtonGuedes.

MATL , 14 à 13 octets

TTt_0vic1Z)d)

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Si le code ASCII de la lettre initiale de la première chaîne est soustrait de celui de la deuxième chaîne, nous obtenons la valeur dans la colonne D ci-dessous. La prise modulo 5 donne la valeur M . La valeur finale entre parenthèses est le résultat souhaité, 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)

Ainsi, si nous calculons D , puis M , pour obtenir R, il suffit de mapper 0 à 0; 1 et 2 à 1; 3 et 4 à −1. Cela peut être fait en indexant dans un tableau de cinq entrées égales à 0, 1 ou -1. Comme l'indexation dans MATL est basée sur 1 et modulaire, le tableau doit être [1, 1, −1, −1, 0](la première entrée a l'index 1, la dernière a l'index 5 ou l'équivalent 0). Enfin, l'opération modulo 5 peut heureusement être évitée, car elle est implicitement réalisée par l'indexation modulaire.

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 octets

0XXWW]rcrc-=

Les deux entrées sont séparées par des espaces. Leur ordre est inversé par rapport à celui du texte de contestation.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Traduction de ma réponse MATL . Cela exploite le fait que dans CJam c(conversion en caractère) appliqué sur une chaîne prend son premier caractère. En outre, le tableau pour le mappage est différent car l'indexation dans CJam est basée sur 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

CJam, 15 14 12 octets

rW=rW=-J+3%(

Prenez le code ascii du dernier caractère de chaque chaîne, puis retourne:

(a1 - a2 + 19) % 3 - 1

Testez-le ici !

Python 3, 54 octets

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

Essayez-le en ligne!

Java 7, 82 octets

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

Explication:

• Les deuxièmes lettres sont o, aet c, avec les décimales ASCII 111, 97et 99.
• Si nous les soustrayons les uns des autres pour les cas de test, nous obtenons les résultats suivants:
  • 0 (Rock, Rock)
  • 14 (Rock, Papier)
  • 12 (Papier, ciseaux)
  • -14 (Papier, rock)
  • 0 (Papier, papier)
  • -2 (Papier, ciseaux)
  • -2 (Ciseaux, Rock)
  • 2 (Ciseaux, papier)
  • 0 (Ciseaux, ciseaux)
• Si nous prenons modulo 5 pour chacun, nous obtenons 4, 2, -4, -2, -2, 2.
• Divisé par 2 xest maintenant le suivant pour les cas de test:
  • x = 0 (Rock, Rock)
  • x = 2 (pierre, papier)
  • x = 1 (papier, ciseaux)
  • x = -2 (papier, pierre)
  • x = 0 (papier, papier)
  • x = -1 (papier, ciseaux)
  • x = -1 (Ciseaux, Roche)
  • x = 1 (ciseaux, papier)
  • x = 0 (ciseaux, ciseaux)
• Seuls les 2et -2sont incorrects, et auraient dû être -1et à la 1place. Donc, si x%2 != x(tout ce qui est au 1- dessus ou au -dessous -1), nous divisons par -2pour résoudre ces deux «cas extrêmes».

Code de test:

Essayez ici.

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

Sortie:

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

dc, 18

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

Essayez-le en ligne .

Notez que les deux arguments sont passés (séparés par des espaces) sur une ligne à STDIN. Les arguments sont entre crochets [ ]car c'est ainsi dcque ses chaînes sont appréciées.

dcLa manipulation des cordes est très limitée, mais il s'avère qu'une des choses que vous pouvez faire est d'utiliser la Zcommande pour obtenir une longueur de chaîne, qui heureusement est distincte pour "Rock", "Paper" et "Scissors", et peut être assez simplement arithmétiquement. manipulé pour donner le résultat souhaité.

PHP, 34 octets

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

Pyth, 16

t%+7h.+mx3ldQ3

Probablement pourrait être plus court.

        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

En ligne .

C #, 85 84 octets

Enregistré 1 octet, grâce à TheLethalCoder

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;

Il accepte deux chaînes en entrée et génère un entier. Il y a égalité, si les deux chaînes sont égales, sinon, le premier caractère des chaînes est vérifié, afin de déterminer quel joueur gagne.

JavaScript, 37 , 32 , 31 octets

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

Si a est égal à b, affiche le zéro.

Sinon, xou le résultat de la vérification si la longueur n’est pas supérieure à 12 (comparaison des ciseaux et du papier) avec la comparaison d’un nombre supérieur à b.
Si cela retourne 1, retournez-le.

S'il renvoie 0, utilisez l'opérateur OR pour le remplacer par -1.

Lot, 116 octets

@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 octets

32 octets de code + -pdrapeau.

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

Pour l'exécuter:

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

Sauvegardé de 3 octets en utilisant l'expression régulière de la réponse Retina de Martin Ender . (mon regex précédent était /R.*P|P.*S|S.*R/)

Explication:

Tout d’abord, /(.+) \1/vérifie si l’entrée contient deux fois le même mot. Le cas échéant, le résultat est 0. Sinon, /k P|r S|s R/traite du cas où la réponse est -1. Si cette dernière expression rationnelle est fausse, alors elle -/k P|r S|s R/est fausse, alors nous revenons 1.

Gelée , 9 octets

L€^3Iæ%1.

Ceci utilise l'algorithme de la réponse Bash de @ DigitalTrauma .

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Essayez-le ici!

_{Inspiré par la solution de carusocomputing}

Ancienne solution à 53 octets

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

Essayez-le en ligne!

_{Merci encore, ETHproductions!}

PHP, 55 53 octets

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

• prend les valeurs ascii des premières lettres (à partir des arguments de la ligne de commande): 82,80,83
• % 6: 4,2,5
• % 4: 0,2,1
• différence (ba):
  • PS: 1-2, SR: 2-0, RP: 2-0 -> -1 ou 2; + 3% 3 -> 2
  • SP: 2-1, RS: 0-2, PR: 0-2 -> -2 ou 1; + 3% 3 -> 1
  • RR, PP, SS: 0; + 3% 3: 0
• (3-2 * x): -1,1,3
• % 3: -1,1,0

version sinusoïdale, 49 46 octets

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

La réponse de carusocomputing au port de golf :

3 octets enregistrés par @ user59178

Perl, 25 octets

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

Code 24 octets +1 octet pour l' -poption.

L'entrée doit être sur stdin sans séparateurs, par exemple:

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

La première expression rationnelle cherche le premier joueur à gagner, la seconde sa perte. La différence est imprimée.

Scala, 148 octets

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

Heureusement, étant donné que les points-virgules sont nécessaires pour séparer plusieurs commandes sur la même ligne, Scala bénéficie d'un code de golf formatable!

Dans cette tentative de golf, j'ai appris que vous pouvez remplacer

"somestring".charAt(index) 

avec

"somestring"(index) 

parce que Scala vous permet de traiter les chaînes comme des tableaux dans le but d’obtenir des caractères.