Score rock-papier-ciseaux

70

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:

Xnor
la source
Est - ce qu'une seule entrée avec séparateur vide signifie par exemple "rockpaper"?
Emigna
1
@ Emigna Oui, mais en majuscule RockPaper.
xnor
15
C’était WAY plus amusant que je ne le pensais, mon seigneur, il ya des façons sympas de le faire.
Urne Magique Octopus, le
L'entrée peut-elle être un tableau des deux chaînes?
Luis Mendo
@ LuisMendo Oui.
xnor

Réponses:

73

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.

Explication de l'équation

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.

Urne Magique De Pieuvre
la source
3
Ne pourriez - vous faire plus court en utilisant que -sin(x) = sin(-x), cela signifie simplement inverser l'ordre aet bdéposer le premier -? Autre que cela, coder en dur une approximation de 4/Pisemblable 1.273pourrait être suffisant, ou 1.3ou 9/7ou 5/4.
flawr
2
PS: Je propose aussi de faire un lien pour essayer en ligne afin que les gens comme moi peuvent jouer avec votre soumission =)
flawr
3
Vous pouvez enregistrer 1 octet avec sin(b-a)au lieu de -sin(a-b). Super trouvaille!
Titus
2
Économisez 7 autres octets en multipliant par 1.3au lieu de 4/Math.PI; c'est suffisamment exact.
Titus
1
@carusocomputingXX=ASCII=Y=Wanted output RR=82-82=0=0 PP=83-83=0=0 SS=80-80=0=0
CraigR8806 Le
44

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

Quentin
la source
Ne faites simplement rien de tel que calculer -f(i)pour calculer le score de l'autre joueur - une sortie inattendue en résultera!
nneonneo
4
@nneonneo -(f(i))devrait bien fonctionner. Les macros sont amusantes!
nwp
18

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!

flawr
la source
16

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 .

Trauma numérique
la source
15

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!

Dennis
la source
14

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

Greg Martin
la source
1
"Il s'avère que ..." Vous avez un oeil pour ces choses
ngenisis
12

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.

Gareth
la source
Vous pouvez utiliser un lambda anonyme et sauvegarder 2 caractères.
GB
@GB Si je ne nomme pas la fonction, comment dois-je l'appeler? Cela sent la triche pour moi. Mais merci pour l’autre astuce - j’avais jeté un coup d’œil à cela, mais j’avais repoussé cette idée parce que ScissorsScissors a 16 ans, mais je vois que cela n’a pas d’importance. :-)
Gareth
@Dennis Vous ne pouvez pas l'appeler sans l'assigner. Pour moi, c'est comme tricher et injuste pour les langues sans fonctions anonymes qui doivent définir un nom.
Gareth
Sûr que vous pouvez. tio.run/nexus/…
Dennis
10

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 .

Dennis
la source
9

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.

Martin Ender
la source
Voici une approche différente basée sur les longueurs de chaîne d'entrée. C'est plus long que le tien, mais je me demande si ça pourrait encore être joué au golf?
Digital Trauma
@ DigitalTrauma c'est une idée vraiment chouette, mais je ne vois rien qui puisse la raccourcir. Je pense que vous devriez le poster quand même (et si vous déplacez la première ligne dans l'en-tête, TIO ne l'inclura pas dans le nombre d'octets).
Martin Ender
8

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
Emigna
la source
Vous avez vaincu mon amusement :( Ç¥13T/*.½òPOURQUOI CELA FONCTIONNE-T-IL? PERSONNE NE SAIT.
Urne Octopus Magique
@ MagicOctopusUrn: Uuuh, c'est vraiment bizarre. Quel serait le format d'entrée pour qu'il renvoie un int en sortie?
Emigna
['R','P']: P C'est un port de ça.
Urne Magic Octopus
@ MagicOctopusUrn: Oh oui, j'ai oublié celui-là. Ma réponse préférée à ce défi :)
Emigna
6

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.
Dennis
la source
6

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!

ElPedro
la source
Salut! Pouvez-vous s'il vous plaît me dire comment cette syntaxe fonctionne? Logiquement, (x!=y,-1)cela fonctionne comme si, si la liste générait un vrai, alors -1 sinon x!=y. Quelle est l'utilisation de ce +signe? Une source documentant ce type de syntaxe serait vraiment utile!
hashcode55
@ hashcode55 - J'ai ajouté une explication à ma réponse.
ElPedro
Pour répondre à votre incertitude à propos du +- dans ce cas, il s’agit d’un avantage unaire +10, et constitue essentiellement un moyen rapide de convertir en entier.
FlipTack
Merci @ FlipTack. Kinda a deviné que c'était ce qu'il faisait mais merci pour l'explication appropriée.
ElPedro
@ ElPedro Merci beaucoup! Cela m'a vraiment aidé.
hashcode55
5

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.

Neil
la source
1
@WashingtonGuedes je peux faire encore mieux que ça!
Neil
Vous pouvez curry pour économiser 1 octet
MayorMonty
J'ai essayé de l'exécuter et je reviens toujours 0
Vitim.fr
5

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
Luis Mendo
la source
5

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
Luis Mendo
la source
5

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 !

Arnaud
la source
4

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
Kevin Cruijssen
la source
Pourquoi la deuxième lettre par curiosité? J'avais la même approche (un peu) mais j'utilisais la première lettre.
Magic Octopus Urn
@carusocomputing Eh bien, j'ai remarqué que la plupart des autres personnes utilisaient la première lettre ou la longueur du texte et souhaitaient essayer autre chose. J'ai d' abord utilisé les troisièmes lettres ( c, p, i) avec les valeurs ASCII 99, 112et 105, comme ils semblaient les plus utiles, et a remarqué qu'il deviendrait 4, 2, 0 si je ne modulo 5. Alors seulement, je me suis dit que je devais soustraire les deux, donc les 4, 2 et 0 ne sont pas d'une grande utilité. Après quelques tâtonnements / essais et erreurs, j'ai essayé la deuxième lettre et obtenais des résultats plus utiles avec le même modulo 5 toujours présent. Puis je suis rapidement venu à la solution que j'ai présentée ci-dessus. :)
Kevin Cruijssen Le
@carusocomputing Voulait essayer une approche unique, et considérant que je suis assez mauvais pour ce type de solutions, ce n'est pas aussi court que certaines autres solutions, mais il reste unique (ce qui était mon objectif initial). :)
Kevin Cruijssen Le
4

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

Trauma numérique
la source
4

PHP, 34 octets

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

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 .

Trauma numérique
la source
3

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.

Horváth Dávid
la source
Économisez un octet en utilisant currying, c'esta=>b=>...
TheLethalCoder le
3

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.

Grax32
la source
Pourriez-vous écrire cela comme une fonction a=>b=>au curry pour sauvegarder un octet?
FlipTack
Oui. Merci @FlipTack
Grax32
2

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
Neil
la source
2

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.

Dada
la source
2

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].
Dennis
la source
Bon sang, j'étais sur le point de commencer à lire sur Jelly. Eh bien, la voici en python . +1
Digital Trauma
2

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!

Oliver
la source
1
Vous pouvez commencer par utiliser à la ©place de &&, changer le Ug0 cen Ug c(même avec V) et le remplacer -1par J. C'est encore un peu plus long que la réponse du JS , vous pouvez peut-être en tirer quelques idées
ETHproductions
@ETHproductions Merci! Je ne sais pas comment j'oublie©
Oliver
1
En fait, vous pouvez simplement faire W=Uc. Je ne sais pas pourquoi j'oublie constamment que ça cmarche sur n'importe quelle corde: P
ETHproductions
2

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

Titus
la source
1
Pour la version sine de can peut économiser 3 octets en remplaçant round(x)par2*x^0
user59178
2

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.

mik
la source
1

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.

Archimage
la source
Cela peut être joué au golf immensément. Pour commencer, vous êtes autorisé à faire une fonction au lieu d'un programme complet dans la plupart des défis ici, alors au lieu de tout l'objet qui étend l'application et en tirant des arguments, essayez quelque chose comme: def g (a: Seq, b: Seq) = ...
Ethan
De plus, vous n'avez pas besoin d'imprimer la valeur. Le retour est suffisant, ce qui est excellent pour le golf Scala, puisque le retour est gratuit. Et vous pouvez encore l'améliorer en utilisant le truc publié dans la réponse Groovy, qui fonctionne presque de la même manière dans Scala.
Ethan