Dadas dos entradas de cadena de "Piedra", "Papel" o "Tijera", determine el resultado de la ronda RPS . Salida 1 si gana el primer jugador, -1 si gana el segundo jugador o 0 para un empate.

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

Debe utilizar las cadenas exactas "Piedra", "Papel" y "Tijeras" como entradas. Puedes elegir si la opción de los primeros jugadores se da (consistentemente) primero o segundo. Alternativamente, puede tomarlos como una sola entrada con un solo carácter o un separador vacío. La entrada tiene garantizado uno de los 9 emparejamientos posibles de las tres opciones en su formato de entrada.

La salida debe ser un número 1, 0 o -1, o su representación de cadena. Las carrozas están bien. Así son +1, +0,y -0.

Relacionado: Codificación de un juego RPS

Tabla de clasificación:

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

Pruébalo en línea!

Resulta que el juego de piedra, papel y tijera tiene una propiedad bastante genial.
Dadas las cadenas ayb, tome la primera letra de cada una, esto da como resultado dos de los siguientes:R,P,S

La lista exhaustiva de valores posibles es (cuando se combinan 2 opciones):

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

Reorganizando la lista para:

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

Nos da una secuencia que parece inversamente sinusoidal, y en realidad puede representar esta fórmula como aproximadamente (y con aproximadamente me refiero a apenas lo suficiente para funcionar, podría obtener una ecuación que está activa pero cuesta más bytes):

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

La simplificación de 4 / pi a 1.3 fue sugerida primero por @flawr y luego probada por @titus para un ahorro total de 6 bytes.

Usando las propiedades de redondeo doble de groovy, esto da como resultado la salida correcta para piedra-papel-tijera.

05AB1E , 10 bytes (no competir)

Ç¥13T/*.½ò

Pruébalo en línea!

Misma respuesta portada a 05AB1E usando los nuevos comandos agregados 26/10/2017.

C, 50 35 bytes

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

Llame fcon una cadena que contenga ambos jugadores, sin separador, y devolverá si gana el primero.

Explicación:

Al observar las nueve cadenas posibles, resulta que los pares de letras en las columnas 7 y 8 son únicos:

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

El elenco offset y salvaje para short*recuperar estos pares de letras e interpretarlos como números:

29285
29545
21107
107
25968
21363
29555
27491
20595

Luego fue una cuestión de fuerza bruta para encontrar el 51y los 4restos, que se aplicaron sucesivamente para reducir estos números a:

3 0 0 1 1 1 2 2 2

Lo cual es perfecto para agregar otro resto al final y compensar el resultado.

Véalo en vivo en Coliru

MATLAB / Octave , 63 54 52 bytes

Es muy conveniente que los códigos ASCII de las primeras letras de Rock,Paper,Scissorssean R=82,P=80,S=83. Si restamos 79, obtenemos convenientemente 3,1,4, que usaremos ahora como índices matriciales: aquí una matriz 4x4 está codificada, donde la i,jentrada enésima corresponde al resultado si conecta los valores de antes:

     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)

Pruébalo en línea!

Pure Bash, 31

Pedir prestado la fórmula de @ Dennis :

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

Pruébalo en línea .

Respuesta anterior:

Pure Bash, 43 35

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

• Obtener la longitud de cadena de cada arg ( 4, 5, 8respectivamente, para piedra, papel, tijeras)

• XOR cada uno con 3 para dar 7, 6, 11(que cuando se toma mod 3 elasticidad 1, 0, 2)

• Luego reste y toque el mod 3 para obtener el resultado deseado.

Pruébalo en línea .

Python , 40 30 bytes

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

Pruébalo en línea!

Antecedentes

Empecé con la plantilla de funciones.

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

y ejecuté una búsqueda de fuerza bruta para parámetros adecuados utilizando el siguiente programa, luego seleccionó uno con una implementación de longitud mínima.

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

Pruébalo en línea!

Mathematica, 32 bytes

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

Función sin nombre que toma un par ordenado de listas de caracteres, como, por ejemplo {{"R","o","c","k"},{"P","a","p","e","r"}}, y regresa -1|0|1.

Quería que el código evitara no solo las tres palabras de entrada, sino también el nombre de función demasiado largo ToCharacterCode; así que trabajé con la longitud 4,5,8de las palabras de entrada en su lugar, y busqué una función corta de esas longitudes que dieron respuestas distintas módulo 3. (La división entera por 2 es matemáticamente prometedora, pero esas funciones tienen nombres demasiado largos en Mathematica).

Resulta que tomar el factorial de (la longitud - 3) da las respuestas 1,2,120, que son el 1,-1,0módulo 3. Luego, simplemente calculamos, el módulo 3, la diferencia de los dos valores (a través del producto punto {1,-1}.{x,y} = x-y, que es una buena manera cuando el dos valores están en una lista).

Ruby, 36 35 30 bytes

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

Pruébalo en ideone.com

Prueba de salida:

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

Aprovecha el hecho de que 7 de los 9 resultados correctos se generan simplemente haciendo una comparación lexicográfica utilizando el operador de la nave espacial <=>. El (a+b)[12]solo invierte las entradas a la comparación si las entradas son Papery Scissors(y también Scissors Scissors, pero eso es todo lo 0contrario).

Gracias a Horváth Dávid por salvarme un personaje y gracias a GB por salvarme otros 5.

Python , 39 36 34 33 bytes

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

Pruébalo en línea!

Cómo funciona

Echemos un vistazo a algunos valores de la longitud de seis copias de xy una copia de y módulo 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

Podemos codificar los resultados ( {-1, 0, 1} ) asignándolos al conjunto {0, 1, 2, 3} . Por ejemplo, el mapeo t ↦ 2 - t logra esto y es su propio inverso.

Denotemos el resultado de x e y por o (x, y) . Entonces:

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₂

Afortunadamente, todos los bits en las últimas columnas coinciden entre sí, por lo que podemos OR para formar un solo entero n y recuperar o (x, y) como 2 - ((n ≫ o (x, y))% 4) . El valor de n es 94 .

Retina , 35 31 bytes

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

Pruébalo en línea!

Explicación

Esto funciona en dos pasos. Primero, imprimimos los signos menos para las entradas relevantes. Luego imprimimos un 0para corbatas y un 1otro.

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

Estas son dos etapas. En )la segunda etapa los agrupa, los *convierte en una ejecución en seco (lo que significa que la cadena de entrada se restaurará después de que se procesaron, pero el resultado se imprimirá) y \suprime la impresión de un avance de línea final. Las dos etapas juntas imprimirán un -si corresponde.

La primera etapa es una Getapa de rep que sólo mantiene la línea si contiene ya sea k P, r So s R. Estos corresponden a los casos en los que necesitamos salida -1. Si no es uno de esos casos, la entrada se reemplazará con una cadena vacía.

La segunda etapa reemplaza .+(toda la cadena, pero solo si contiene al menos un carácter) con -. Entonces esto imprime un -para esos tres casos y nada más.

D`\w+
 .

Estas son dos etapas más. La primera etapa es una Deduplicación. Coincide con palabras y elimina duplicados. Entonces, si y solo si la entrada es un empate, esto deja caer la segunda palabra.

La segunda etapa cuenta el número de coincidencias de ., que es un espacio seguido de cualquier personaje. Si la entrada fue un empate y se eliminó la segunda palabra, esto da como resultado 0. De lo contrario, la segunda palabra todavía está en su lugar, y hay una coincidencia, por lo que se imprime en su 1lugar.

05AB1E , 18 17 15 10 9 bytes

6 bytes guardados con el truco de longitud de entrada de Digital Trauma

€g3^Æ>3%<

Toma entrada como [SecondPlayersChoice,FirstPlayersChoice]

Pruébalo en línea! o validar todos los casos de prueba

Solución alternativa de 9 bytes: íø¬ÇÆ>3%<

Explicación

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

Solución anterior de 15 bytes

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

Pruébalo en línea! o validar todos los casos de prueba

Explicación

 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

Jalea , 8 bytes

L€Iµ-*×Ṡ

Pruébalo en línea! (conjunto de pruebas, conversiones al entero para mayor claridad)

Cómo funciona

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

Pruébalo en línea!

Muchas gracias a @Dennis por permitirme tomar prestado su código de prueba en línea Pruébalo y por ahorrarme 6 bytes.

Editar

@ hashcode55: más o menos como lo describe. (x! = y, -1) es una secuencia de dos elementos y [x [0] + y [0] en 'RPSR'] está calculando qué elemento tomar. Si la primera letra de x + la primera letra de y está en la lista de caracteres, entonces se evaluará como Verdadero o 1, de modo que (x! = Y, -1) [1] se devolverá. Si no es así (x! = Y, -1) [0]. Aquí es donde se pone un poco complicado. El primer elemento es en sí mismo efectivamente otro if. Si x! = Y, el primer elemento será Verdadero; de lo contrario, será Falso, por lo que si x [0] + y [0] en 'RPSR' es falso, se devolverá Verdadero o Falso dependiendo de si x == y. El + es un poco astuto y gracias de nuevo a @Dennis por este. La x! = Y devolverá un verdadero o falso literal. Necesitamos un 1 o un 0. Todavía no sé cómo pero el + hace esta conversión. Solo puedo suponer que al usar un operador matemático en Verdadero / Falso está obligando a que se vea como el equivalente entero. Obviamente, el + delante del -1 aún devolverá -1.

¡Espero que esto ayude!

JavaScript (ES6), 46 38 bytes

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

Hace uso del hecho de que Rock-Paper-Scissors es cíclico. JavaScript no tiene nave espacial ni operadores ternarios balanceados, de lo contrario la respuesta sería (a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3.

Editar: guardado 8 bytes gracias a @WashingtonGuedes.

MATL , 14 13 bytes

TTt_0vic1Z)d)

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Si el código ASCII de la letra inicial de la primera cadena se resta del de la segunda cadena, obtenemos el valor en la columna D a continuación. Tomando modulo 5 da el valor M . El valor final entre paréntesis es el resultado deseado, 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)

Por lo tanto, si calculamos D y luego M , para obtener R solo necesitamos asignar 0 a 0; 1 y 2 a 1; 3 y 4 a −1. Esto se puede hacer indexando en una matriz de cinco entradas igual a 0, 1 o -1. Dado que la indexación en MATL está basada en 1 y es modular, la matriz debería ser [1, 1, −1, −1, 0](la primera entrada tiene el índice 1, la última tiene el índice 5 o equivalente 0). Finalmente, la operación del módulo 5 se puede evitar afortunadamente, porque la indexación modular la lleva a cabo implícitamente.

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

Las dos entradas están separadas por espacios. Su orden se invierte con respecto a eso en el texto del desafío.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Traducción de mi respuesta MATL . Esto explota el hecho de que en CJam c(convertir a char) aplicado en una cadena toma su primer carácter. Además, la matriz para la asignación es diferente porque la indexación en CJam está basada en 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 bytes

rW=rW=-J+3%(

Tome el código ascii del último carácter de cada cadena, luego devuelve:

(a1 - a2 + 19) % 3 - 1

¡Pruébalo aquí !

Python 3, 54 bytes

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

Pruébalo en línea!

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

Sin golf:

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

Explicación:

• Las segundas letras son o, ay c, con los decimales ASCII 111, 97y 99.
• Si los restamos unos de otros para los casos de prueba, tenemos los siguientes resultados:
  • 0 (Rock, Rock)
  • 14 (Piedra, papel)
  • 12 (Papel, tijeras)
  • -14 (Papel, roca)
  • 0 (Papel, papel)
  • -2 (Papel, tijeras)
  • -2 (Tijeras, piedra)
  • 2 (Tijeras, papel)
  • 0 (Tijeras, tijeras)
• Si tomamos módulo 5 para cada uno, obtenemos 4, 2, -4, -2, -2, 2.
• Dividido por 2 xes ahora el siguiente para los casos de prueba:
  • x = 0 (roca, roca)
  • x = 2 (roca, papel)
  • x = 1 (papel, tijeras)
  • x = -2 (papel, roca)
  • x = 0 (papel, papel)
  • x = -1 (papel, tijeras)
  • x = -1 (tijeras, piedra)
  • x = 1 (tijeras, papel)
  • x = 0 (tijeras, tijeras)
• Solo el 2y -2son incorrectos, y deberían haberlo sido -1y en su 1lugar. Entonces, si x%2 != x(todo arriba 1o abajo -1) nos dividimos -2para arreglar estos dos 'casos límite'.

Código de prueba:

Pruébalo aquí.

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

Salida:

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

dc, 18

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

Pruébalo en línea .

Tenga en cuenta que los dos argumentos se pasan (separados por espacios) en una línea a STDIN. Los argumentos están contenidos entre corchetes, [ ]ya que así es como dcle gustan sus cadenas.

dctiene un manejo de cadenas muy limitado, pero resulta que una de las cosas que puede hacer es usar el Zcomando para obtener una longitud de cadena, que afortunadamente es distinta para "Piedra", "Papel" y "Tijeras", y puede ser bastante simple aritméticamente manipulado para dar el resultado deseado.

PHP, 34 bytes

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

Pyth, 16

t%+7h.+mx3ldQ3

Probablemente podría ser más corto.

        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 línea .

C #, 85 84 bytes

Guardado 1 byte, gracias a 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;

Acepta dos cadenas como entrada y genera un número entero. Hay un empate, si las dos cadenas son iguales, de lo contrario, comprueba el primer carácter de las cadenas, para determinar qué jugador gana.

JavaScript, 37 , 32 , 31 bytes

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

Si a es igual a b, salida cero.

De lo contrario, xor el resultado de verificar si la longitud no es mayor a 12 (comparación de tijeras y papel) con la comparación de a mayor que b.
Si esto devuelve 1, devuélvelo.

Si devuelve 0, use el operador OR para reemplazar con -1.

Lote, 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 bytes de código + -pbandera.

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

Para ejecutarlo:

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

Ahorró 3 bytes usando la expresión regular de la respuesta Retina de Martin Ender . (mi expresión regular anterior era /R.*P|P.*S|S.*R/)

Explicación:

Primero, /(.+) \1/verifica si la entrada contiene el doble de la misma palabra, si es así, el resultado es 0. De lo contrario, /k P|r S|s R/trata el caso donde está la respuesta -1. Si esta última expresión regular es falsa, entonces -/k P|r S|s R/es falsa, entonces volvemos 1.

Jalea , 9 bytes

L€^3Iæ%1.

Esto usa el algoritmo de la respuesta Bash de @ DigitalTrauma .

Pruébalo en línea!

Cómo funciona

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

Pruébalo aquí!

_{Inspirado en la solución de carusocomputing}

Solución antigua de 53 bytes

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

Pruébalo en línea!

_{Gracias de nuevo, ETHproductions!}

PHP, 55 53 bytes

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

• toma los valores ascii de las primeras letras (de los argumentos de la línea de comando): 82,80,83
• % 6: 4,2,5
• % 4: 0,2,1
• diferencia (ba):
  • PS: 1-2, SR: 2-0, RP: 2-0 -> -1 o 2; + 3,% 3 -> 2
  • SP: 2-1, RS: 0-2, PR: 0-2 -> -2 o 1; + 3,% 3 -> 1
  • RR, PP, SS: 0; + 3,% 3: 0
• (3-2 * x): -1,1,3
• % 3: -1,1,0

versión sinusoidal, 49 46 bytes

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

La respuesta de un puerto de golf de carusocomputing :

3 bytes guardados por @ user59178

Perl, 25 bytes

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

Código 24 bytes +1 byte para la -popción.

La entrada debe estar en stdin sin separadores, por ejemplo:

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

La primera expresión regular busca la victoria del primer jugador, la segunda la pérdida. La diferencia está impresa.

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

Afortunadamente, dado que se requieren puntos y comas para separar múltiples comandos en la misma línea, ¡Scala se beneficia de tener un código de golf formatable!

En este intento de golf aprendí que puedes reemplazar

"somestring".charAt(index) 

con

"somestring"(index) 

porque Scala le permite tratar las cadenas como matrices con el fin de obtener caracteres.