Dadas duas entradas de string de "Rock", "Paper" ou "Scissors", determine o resultado da rodada RPS . Saída 1 se o primeiro jogador vencer, -1 se o segundo jogador vencer, ou 0 para um 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

Você deve usar as seqüências exatas "Rock", "Paper" e "Scissors" como entradas. Você pode escolher se a escolha dos primeiros jogadores é (consistentemente) dada em primeiro ou segundo. Como alternativa, você pode tomá-los como uma única entrada com um separador de caractere ou vazio. A entrada é garantida com um dos 9 pares possíveis das três opções no seu formato de entrada.

A saída deve ser um número 1, 0 ou -1 ou sua representação de sequência. Carros alegóricos são bons. Assim são +1, +0,e -0.

Relacionados: Codificando um jogo de RPS

Entre os melhores:

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

Experimente online!

Acontece que o jogo de pedra, papel e tesoura tem uma propriedade bem legal.
Dadas as seqüências aeb, pegue a primeira letra de cada uma, isso resulta em dois dos seguintes itens:R,P,S

A lista exaustiva de valores possíveis é (quando duas opções são combinadas):

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 a lista para:

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

Nos fornece uma sequência que parece inversamente sinusoidal, e você pode realmente representar essa fórmula como aproximadamente (e por aproximadamente eu quero dizer apenas o suficiente para funcionar, você pode obter uma equação que está morta, mas custa mais bytes):

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

A simplificação de 4 / pi para 1,3 foi sugerida primeiro por @flawr e depois testada por @titus para uma economia total de 6 bytes.

Usando as propriedades de duplo arredondamento do groovy, isso resulta na saída correta para pedra-papel-tesoura.

05AB1E , 10 bytes (não concorrência)

Ç¥13T/*.½ò

Experimente online!

Mesma resposta portada para 05AB1E usando os novos comandos adicionados em 26/10/2017.

C, 50 bytes 35

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

Ligue fcom uma string contendo os dois jogadores, sem separador, e ele retornará se o primeiro vencer.

Explicação:

Observando as nove cadeias possíveis, verifica-se que os pares de letras nas colunas 7 e 8 são únicos:

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

O deslocamento e o elenco selvagem para short*recuperar esses pares de letras e interpretá-los como números:

29285
29545
21107
107
25968
21363
29555
27491
20595

Em seguida, era uma questão de força bruta encontrar os restos 51e 4, que eram aplicados sucessivamente para reduzir esses números a:

3 0 0 1 1 1 2 2 2

O que é perfeito para aplicar mais um restante no final e compensar o resultado.

Veja ao vivo em Coliru

MATLAB / Oitava , 63 54 52 bytes

É muito conveniente que os códigos ASCII das primeiras letras de Rock,Paper,Scissorssão R=82,P=80,S=83. Se subtrairmos 79, obtemos de forma conveniente 3,1,4, que usaremos agora como índices de matriz: Aqui uma matriz 4x4 é codificada, onde a i,j-ésima entrada corresponde ao resultado se você inserir os valores imediatamente 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)

Experimente online!

Pure Bash, 31

Empréstimos na fórmula de Dennis :

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

Experimente online .

Resposta anterior:

Pure Bash, 43 35

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

• Obter o comprimento da corda de cada arg ( 4, 5, 8respectivamente, para Rock, Paper, Scissors)

• XOR cada um com 3 a dar 7, 6, 11(que, quando tomado mod 3 dão 1, 0, 2)

• Subtraia e mexa no mod 3 para obter o resultado desejado.

Experimente online .

Python , 40 30 bytes

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

Experimente online!

fundo

Comecei com o modelo de função

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

e executou uma pesquisa de força bruta por parâmetros adequados usando o programa a seguir, depois selecionou um com uma implementação de tamanho mínimo.

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

Experimente online!

Mathematica, 32 bytes

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

Função sem nome, recebendo um par ordenado de listas de caracteres, como {{"R","o","c","k"},{"P","a","p","e","r"}}, e retornando -1|0|1.

Eu queria que o código evitasse não apenas as três palavras de entrada, mas também o nome da função muito longa ToCharacterCode; então trabalhei com o comprimento 4,5,8das palavras de entrada e procurei uma função curta daqueles comprimentos que davam respostas distintas no módulo 3. (A divisão inteira por 2 é matematicamente promissora, mas essas funções têm nomes muito longos no Mathematica.)

Acontece que tomar o fatorial de (o comprimento - 3) fornece as respostas 1,2,120, que são o 1,-1,0módulo 3. Em seguida, calculamos, no módulo 3, a diferença dos dois valores (via produto escalar {1,-1}.{x,y} = x-y, que é uma boa maneira quando o dois valores estão em uma lista).

Ruby, 36 35 30 bytes

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

Experimente em ideone.com

Saída de teste:

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

Aproveita o fato de que 7 dos 9 resultados corretos são gerados apenas fazendo uma comparação lexicográfica usando o operador de nave espacial <=>. O (a+b)[12]just inverte as entradas para a comparação se as entradas são Papere Scissors(e também Scissors Scissors- mas isso é 0inverso).

Agradeço a Horváth Dávid por me salvar um personagem e a GB por me salvar mais 5.

Python , 39 36 34 33 bytes

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

Experimente online!

Como funciona

Vamos dar uma olhada em alguns valores no comprimento de seis cópias de xe uma cópia 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 os resultados ( {-1, 0, 1} ) mapeando-os no conjunto {0, 1, 2, 3} . Por exemplo, o mapeamento t ↦ 2 - t consegue isso e é inverso.

Vamos denotar o resultado de x e y por o (x, y) . Então:

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₂

Felizmente, todos os bits das últimas colunas concordam entre si; portanto, podemos OR para formar um único inteiro n e recuperar o (x, y) como 2 - ((n ≫ o (x, y))% 4) . O valor de n é 94 .

Retina , 35 31 bytes

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

Experimente online!

Explicação

Isso funciona em duas etapas. Primeiro, imprimimos os sinais de menos para as entradas relevantes. Em seguida, imprimimos um 0para gravatas e 1outro.

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

Este é dois estágios. No )segundo estágio, agrupa-os, *faz com que sejam executados a seco (o que significa que a sequência de entrada será restaurada após o processamento, mas o resultado será impresso) e \suprime a impressão de um avanço de linha à direita. Os dois estágios juntos imprimirão um, -se aplicável.

A primeira fase é uma Gfase rep que só mantém a linha se contiver quer k P, r Sou s R. Eles correspondem aos casos em que precisamos produzir -1. Se não for um desses casos, a entrada será substituída por uma sequência vazia.

O segundo estágio substitui .+(a sequência inteira, mas apenas se contiver pelo menos um caractere) por -. Portanto, isso imprime um -para esses três casos e nada mais.

D`\w+
 .

Este é mais dois estágios. O primeiro estágio é uma Ddesduplicação. Combina palavras e remove duplicatas. Portanto, se e somente se a entrada estiver empatada, isso eliminará a segunda palavra.

O segundo estágio conta o número de correspondências de ., que é um espaço seguido por qualquer caractere. Se a entrada foi um empate e a segunda palavra foi removida, isso resulta em 0. Caso contrário, a segunda palavra ainda está no lugar e há uma correspondência, sendo impressa 1.

05AB1E , 18 17 15 10 9 bytes

6 bytes salvos com o truque de comprimento de entrada do Digital Trauma

€g3^Æ>3%<

Aceita entrada como [SecondPlayersChoice,FirstPlayersChoice]

Experimente online! ou Validar todos os casos de teste

Solução alternativa de 9 bytes: íø¬ÇÆ>3%<

Explicação

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

Solução anterior de 15 bytes

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

Experimente online! ou Validar todos os casos de teste

Explicação

 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

Gelatina , 8 bytes

L€Iµ-*×Ṡ

Experimente online! (suíte de teste, lança para inteiro para maior clareza)

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

Experimente online!

Muito obrigado ao @Dennis por me emprestar seu código de teste do Try it online e por me salvar 6 bytes.

Editar

@ hashcode55 - Praticamente como você descreve. (x! = y, -1) é uma sequência de dois elementos e [x [0] + y [0] em'RPSR '] está computando qual elemento levar. Se a primeira letra de x + a primeira letra de y estiver na lista de caracteres, ela será avaliada como True ou 1, então (x! = Y, -1) [1] será retornado. Se não for, então (x! = Y, -1) [0]. É aqui que fica um pouco complicado. O primeiro elemento é efetivamente outro se. Se x! = Y, o primeiro elemento será True; caso contrário, será False; portanto, se x [0] + y [0] em 'RPSR' for false, True ou False será retornado, dependendo de x == y. O + é um pouco sorrateiro e obrigado novamente a @Dennis por este. O x! = Y retornará um literal Verdadeiro ou Falso. Precisamos de 1 ou 0. Ainda não sei bem como, mas o + faz essa conversão. Só posso assumir que, usando um operador matemático em True / False, ele está forçando a ser visto como o equivalente inteiro. Obviamente, o + na frente do -1 ainda retornará -1.

Espero que isto ajude!

JavaScript (ES6), 46 38 bytes

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

Faz uso do fato de que pedra-papel-tesoura é cíclica. O JavaScript não possui naves espaciais nem operadores ternários equilibrados; caso contrário, a resposta seria (a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3.

Editar: salvou 8 bytes graças a @WashingtonGuedes.

MATL , 14 13 bytes

TTt_0vic1Z)d)

Experimente online! Ou verifique todos os casos de teste .

Explicação

Se o código ASCII da letra inicial da primeira string for subtraído do código da segunda string, obteremos o valor na coluna D abaixo. Tomando modulo 5 dá o valor M . O valor final entre parênteses é o resultado desejado, 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)

Assim, se calcularmos D e, em seguida , M , para obter R , precisamos apenas mapear 0 a 0; 1 e 2 a 1; 3 e 4 a -1. Isso pode ser feito indexando em uma matriz de cinco entradas iguais a 0, 1 ou -1. Como a indexação no MATL é baseada em 1 e modular, a matriz deve ser [1, 1, −1, −1, 0](a primeira entrada possui o índice 1, a última possui o índice 5 ou equivalente 0). Finalmente, a operação do módulo 5 pode ser evitada com sorte, porque é implicitamente realizada pela indexação modular.

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

As duas entradas são separadas por espaço. Sua ordem é revertida em relação à do texto do desafio.

Experimente online! Ou verifique todos os casos de teste .

Explicação

Tradução da minha resposta MATL . Isso explora o fato de que no CJam c(converter para char) aplicado a uma string obtém seu primeiro caractere. Além disso, a matriz para o mapeamento é diferente porque a indexação no CJam é baseada em 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%(

Pegue o código ascii do último caractere de cada string e retorne:

(a1 - a2 + 19) % 3 - 1

Teste aqui !

Python 3, 54 bytes

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

Experimente online!

Java 7, 82 bytes

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

Ungolfed:

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

Explicação:

• As segundas letras são o, ae c, com os decimais ASCII 111, 97e 99.
• Se subtraímos esses dados uns dos outros para os casos de teste, temos os seguintes resultados:
  • 0 (Rock, Rock)
  • 14 (Pedra, papel)
  • 12 (Papel, tesoura)
  • -14 (Papel, Pedra)
  • 0 (Papel, Papel)
  • -2 (Papel, tesoura)
  • -2 (Tesoura, Pedra)
  • 2 (Tesoura, Papel)
  • 0 (Tesoura, Tesoura)
• Se tomarmos modulo 5 para cada, obtemos 4, 2, -4, -2, -2, 2.
• Dividido por 2 xagora é o seguinte para os casos de teste:
  • x = 0 (Rocha, Rocha)
  • x = 2 (Rocha, Papel)
  • x = 1 (papel, tesoura)
  • x = -2 (Papel, Rocha)
  • x = 0 (papel, papel)
  • x = -1 (Papel, Tesoura)
  • x = -1 (Tesoura, Pedra)
  • x = 1 (tesoura, papel)
  • x = 0 (tesoura, tesoura)
• Somente o 2e -2está incorreto, e deveria ter sido -1e, em 1vez disso. Portanto, se x%2 != x(tudo acima 1ou abaixo -1) nos dividirmos -2para consertar esses dois 'casos extremos'.

Código do teste:

Experimente aqui.

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

Resultado:

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

dc, 18

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

Experimente online .

Observe que os dois argumentos são passados ​​(separados por espaço) em uma linha para STDIN. Os argumentos estão contidos entre colchetes, [ ]pois é assim que dcas cordas são curtidas.

dcO manuseio de cordas é muito limitado, mas uma das coisas que você pode fazer é usar o Zcomando para obter um comprimento de cordas, que felizmente é distinto para "Rock", "Paper" e "Scissors", e pode ser aritmeticamente simples manipulado para dar o resultado desejado.

PHP, 34 bytes

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

Pyth, 16

t%+7h.+mx3ldQ3

Provavelmente poderia ser mais curto.

        x3ld      # lambda to get string length then XOR with 3
       m    Q     # map over the input (array of 2 strings)
     .+           # difference of the two results
    h             # flatten one-element array
  +7              # add 7
 %           3    # mod 3
t                 # subtract 1 and implicit print

Online .

C #, 85 84 bytes

Guardado 1 byte, graças 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;

Ele aceita duas strings como entrada e gera um número inteiro. Existe um empate, se as duas cordas forem iguais, caso contrário, ele verifica o primeiro caractere das cordas, a fim de determinar qual jogador vence.

JavaScript, 37 , 32 , 31 bytes

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

Se a for igual a b, produza zero.

Caso contrário, xou o resultado de verificar se o comprimento não é maior que 12 (comparação de tesoura e papel) com a comparação de maior que b.
Se isso retornar 1, retorne-o.

Se retornar 0, use o operador OR para substituir por -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 + -psinalizador.

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

Para executá-lo:

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

Economizou 3 bytes usando o regex da resposta Retina de Martin Ender . (meu regex anterior era /R.*P|P.*S|S.*R/)

Explicação:

Primeiro, /(.+) \1/verifica se a entrada contém duas vezes a mesma palavra; se houver, o resultado é 0. Caso contrário, /k P|r S|s R/lida com o caso em que a resposta está -1. Se esse último regex é falso, então -/k P|r S|s R/é falso, então retornamos 1.

Geléia , 9 bytes

L€^3Iæ%1.

Isso usa o algoritmo da resposta Bash do @ DigitalTrauma .

Experimente online!

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

Japonês , 19 bytes

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

Experimente aqui!

_{Inspirado na solução de carusocomputing}

Solução antiga 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

Experimente online!

_{Mais uma vez obrigado, ETHproductions!}

PHP, 55 53 bytes

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

• usa os valores ascii das primeiras letras (dos argumentos da linha de comando): 82,80,83
• % 6: 4,2,5
• % 4: 0,2,1
• diferença (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

versão senoidal, 49 46 bytes

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

um porto de golfe de resposta de carusocomputing :

3 bytes salvos por @ user59178

Perl, 25 bytes

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

Codifique 24 bytes +1 byte para a -popção.

A entrada deve estar no stdin sem separadores, por exemplo:

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

O primeiro regexp procura a vitória do primeiro jogador, a segunda a derrota. A diferença é impressa.

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

Felizmente, como é necessário ponto e vírgula para separar vários comandos na mesma linha, o Scala se beneficia de ter um código de golfe formatável!

Nesta tentativa de golfe, aprendi que você pode substituir

"somestring".charAt(index) 

com

"somestring"(index) 

porque Scala permite tratar cadeias de caracteres como matrizes com o objetivo de obter caracteres.