Puntuación piedra-papel-tijera

70

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:

Mostrar fragmento de código

code-golf  game 
— xnor
fuente
¿ Una sola entrada con separador vacío significa, por ejemplo, "papel de roca"?
— Emigna
1
@Emigna Sí, pero en mayúscula como RockPaper.
— xnor
15
Eso fue MUCHO más divertido de lo que había anticipado, mi señor, hay algunas maneras geniales de hacer esto.
— Urna de pulpo mágico
¿Puede la entrada ser una matriz de las dos cadenas?
— Luis Mendo
@LuisMendo Sí.
— xnor

Respuestas:

73

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.

Ecuación Explicación

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.

— Urna de pulpo mágico
fuente
3
¿No podría hacerlo más corto usando ese -sin(x) = sin(-x), eso significa simplemente invirtiendo el orden de ay by soltando el líder -? Aparte de eso, codificar una aproximación 4/Pisimilar 1.273podría ser suficiente, o 1.3o 9/7o 5/4.
— flawr
2
PD: También sugiero que
— hagas
3
Puede guardar 1 byte con en sin(b-a)lugar de -sin(a-b). Gran descubrimiento!
— Titus el
2
Ahorre otros 7 bytes multiplicando por en 1.3lugar de 4/Math.PI; eso es suficientemente exacto.
— Titus el
1
@carusocomputingXX=ASCII=Y=Wanted output RR=82-82=0=0 PP=83-83=0=0 SS=80-80=0=0
— CraigR8806
44

C, 50 35 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

— Quentin
fuente
Simplemente no hagas nada como calcular -f(i)para calcular el puntaje del otro jugador, ¡resultará un resultado inesperado!
— nneonneo
44
@nneonneo -(f(i))debería funcionar bien. ¡Las macros son divertidas!
— nwp
18

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!

— falla
fuente
16

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 .

— Trauma digital
fuente
15

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!

— Dennis
fuente
14

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

— Greg Martin
fuente
1
"Resulta que ..." Tienes ojo para estas cosas
— ngenisis
12

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.

— Gareth
fuente
Puede usar una lambda anónima y guardar 2 caracteres.
— GB
@GB Si no le doy un nombre a la función, ¿cómo se supone que debo llamarla? Eso huele a trampas para mí. Pero gracias por el otro consejo: lo había visto pero lo rechacé porque ScissorsScissors tiene 16 años, pero veo que en realidad no importa. :-)
— Gareth
— Dennis
@ Dennis No puedes llamarlo sin asignarlo. Me parece una trampa, e injusto en idiomas sin funciones anónimas que tienen que definir un nombre.
— Gareth el
Seguro que puede. tio.run/nexus/…
— Dennis
10

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 .

— Dennis
fuente
9

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.

— Martin Ender
fuente
Aquí hay un enfoque diferente basado en las longitudes de cadena de entrada. Es más largo que el tuyo, pero me pregunto si podría jugar más.
— Trauma digital el
@DigitalTrauma es una idea realmente genial, pero no veo nada para acortarla. Creo que debería publicarlo de todos modos (y si mueve la primera línea al encabezado, TIO no lo incluirá en el recuento de bytes).
— Martin Ender
8

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
— Emigna
fuente
Le ganaste a mi diversión :( Ç¥13T/*.½ò¿POR QUÉ FUNCIONA? NADIE SABE.
— Magic Octopus Urn
@MagicOctopusUrn: Uuuh, eso sí que es raro. ¿Cuál sería el formato de entrada para que devuelva un int como salida?
— Emigna
— Urna de pulpo mágico
@MagicOctopusUrn: Oh sí, me olvidé de eso. Mi respuesta favorita a este desafío :)
— Emigna
6

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.
— Dennis
fuente
6

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!

— ElPedro
fuente
¡Hola! ¿Me puede decir cómo funciona esta sintaxis? Adivinando lógicamente, (x!=y,-1)esto funciona como si, si la lista genera un verdadero, entonces -1 más x!=y. ¿Cuál es el uso de ese +signo? ¡Una fuente que documente este tipo de sintaxis sería realmente útil!
— hashcode55
@ hashcode55: agregué una explicación a mi respuesta.
— ElPedro
Para responder a su incertidumbre sobre el +- en este caso, es un plus unario, como +10, y es esencialmente una forma corta de convertir a un entero.
— FlipTack
Gracias @FlipTack. Supuse que eso era lo que estaba haciendo, pero gracias por la explicación adecuada.
— elpedro
@ElPedro ¡Muchas gracias! Eso realmente me ayudó.
— hashcode55
5

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.

— Neil
fuente
1
@WashingtonGuedes ¡Puedo hacerlo incluso mejor que eso!
— Neil
Podrías curry para ahorrar 1 byte
— MayorMonty
Traté de ejecutarlo y siempre devuelvo 0
— Vitim.us
5

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
— Luis Mendo
fuente
5

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
— Luis Mendo
fuente
5

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í !

— Arnaud
fuente
4

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
— Kevin Cruijssen
fuente
¿Por qué la segunda carta por curiosidad? Tuve el mismo enfoque (un poco) pero usé la primera letra.
— Urna mágica del pulpo
@carusocomputing Bueno, noté que la mayoría de las otras personas usaban la primera letra o la longitud, y querían probar algo más. Usé por primera vez la tercera letras ( c, p, i) con los valores ASCII 99, 112y 105, como parecían más útil, y se dio cuenta que se convertiría en 4, 2, 0 si lo hiciera módulo 5. Sólo entonces pensé que tenía que restar ambos, por lo los 4, 2 y 0 no fueron de mucha utilidad. Después de un poco de confusión / prueba y error, probé la segunda letra y obtuve resultados más útiles con el mismo módulo 5 todavía presente. Luego llegué rápidamente a la solución que presenté anteriormente. :)
— Kevin Cruijssen
@carusocomputing Quería probar un enfoque único, y teniendo en cuenta que soy bastante malo en este tipo de soluciones, no es tan corto como otras soluciones, pero sigue siendo único (que era mi objetivo inicial). :)
— Kevin Cruijssen
4

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.

— Trauma digital
fuente
3

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 .

— Trauma digital
fuente
3

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.

— Horváth Dávid
fuente
Ahorre un byte usando curry, es decira=>b=>...
— TheLethalCoder
3

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.

— Grax32
fuente
¿Podría escribir esto como una función curry a=>b=>para guardar un byte?
— FlipTack
Si. Gracias @FlipTack
— Grax32
2

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
— Neil
fuente
2

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.

— Dada
fuente
2

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].
— Dennis
fuente
Maldición, estaba a punto de empezar a leer sobre Jelly. Oh bueno, aquí está en Pyth . +1.
— Trauma digital
2

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!

— Oliver
fuente
1
Puede comenzar usando en ©lugar de &&, cambiando el Ug0 ca Ug c(lo mismo con V) y reemplazando -1con J. Sin embargo, todavía es un poco más largo que la respuesta de JS , tal vez pueda tomar algunas ideas de eso
— ETHproductions
@ETHproductions ¡Gracias! No sé cómo me olvido©
— Oliver
1
En realidad solo puedes hacer W=Uc. No sé por qué sigo olvidando que cfunciona en cualquier cadena: P
— ETHproductions
2

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

— Titus
fuente
1
Para la versión sinusoidal para puede guardar 3 bytes al reemplazar round(x)con2*x^0
— user59178
2

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.

— mik
fuente
1

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.

— Archimago
fuente
Esto se puede jugar inmensamente. Para empezar, se le permite hacer una función en lugar de un programa completo en la mayoría de los desafíos aquí, por lo que en lugar de que todo el objeto extienda la aplicación y tire de argumentos, intente algo como: def g (a: Seq, b: Seq) = ...
— Ethan
Además, no necesita imprimir el valor. Devolverlo es suficiente, lo cual es genial al jugar al golf en Scala, ya que el regreso es gratuito. Y puede mejorarlo aún más utilizando el truco publicado en la respuesta Groovy, que funciona casi de manera idéntica en Scala.
— Ethan
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.