Dati due input di stringa di "Rock", "Paper" o "Scissors", determinare il risultato del round RPS . Uscita 1 se vince il primo giocatore, -1 se vince il secondo giocatore o 0 per un pareggio.

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

È necessario utilizzare le stringhe esatte "Rock", "Paper" e "Scissors" come input. Puoi scegliere se la scelta del primo giocatore viene (coerentemente) data prima o seconda. In alternativa, puoi prenderli come input singolo con un carattere singolo o un separatore vuoto. L'ingresso è garantito uno dei 9 possibili abbinamenti delle tre scelte nel formato di input.

L'output dovrebbe essere un numero 1, 0 o -1, o la sua rappresentazione di stringa. I galleggianti vanno bene. Così sono +1, +0,e -0.

Correlati: Codificare un gioco RPS

Classifica:

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 byte

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

Provalo online!

Si scopre che il gioco del rock, della carta e delle forbici ha una proprietà piuttosto interessante.
Date le stringhe a e b, prendi la prima lettera di ciascuna, questo si traduce in due delle seguenti:R,P,S

L'elenco completo dei possibili valori sono (Quando vengono combinate 2 scelte):

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

Riorganizzare l'elenco in:

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

Ci dà una sequenza che sembra inversamente sinusoidale e puoi effettivamente rappresentare questa formula come approssimativamente (e per circa intendo appena appena abbastanza per funzionare, potresti ottenere un'equazione che è morta ma costa più byte):

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

La semplificazione di 4 / pi a 1.3 è stata suggerita prima da @flawr e poi testata da @titus per un risparmio totale di 6 byte.

Usando le doppie proprietà di arrotondamento di Groovy, questo produce l'output corretto per le forbici da roccia.

05AB1E , 10 byte (non competitivi)

Ç¥13T/*.½ò

Provalo online!

La stessa risposta è stata trasferita su 05AB1E utilizzando i nuovi comandi aggiunti il ​​26/10/2017.

C, 50 35 byte

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

Chiama fcon una stringa contenente entrambi i giocatori, senza separatore, e restituirà se vince il primo.

Spiegazione:

Osservando le nove possibili stringhe, si scopre che le coppie di lettere sulle colonne 7 e 8 sono uniche:

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

Il cast offset e selvaggio per short*recuperare queste coppie di lettere e interpretarle come numeri:

29285
29545
21107
107
25968
21363
29555
27491
20595

Poi è stata una questione di forza bruta per trovare le 51e 4resti, che viene successivamente applicata ridurre questi numeri per:

3 0 0 1 1 1 2 2 2

Che è semplicemente perfetto per affrontare l'ennesimo residuo alla fine e compensare il risultato.

Guardalo dal vivo su Coliru

MATLAB / Octave , 63 54 52 byte

È molto conveniente che i codici ASCII delle prime lettere di Rock,Paper,Scissorssiano R=82,P=80,S=83. Se sottraggiamo 79otteniamo convenientemente 3,1,4, che useremo ora come indici di matrice: qui una matrice 4x4 è hardcoded, dove la i,j-esima voce corrisponde al risultato se si inseriscono i valori di poco prima:

     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)

Provalo online!

Pure Bash, 31

Prendendo in prestito la formula di Dennis :

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

Provalo online .

Risposta precedente:

Pure Bash, 43 35

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

• Ottenere la lunghezza della stringa di ogni argomento ( 4, 5,8 rispettivamente, per il Rock, Paper, Scissors)

• XOR ciascuna con 3 invia 7, 6, 11(che quando presa mod 3 dare 1, 0, 2)

• Quindi sottrarre e giocherellare con mod 3 per ottenere il risultato desiderato.

Provalo online .

Python , 40 30 byte

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

Provalo online!

sfondo

Ho iniziato con il modello di funzione

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

e ha eseguito una ricerca della forza bruta per parametri adeguati utilizzando il seguente programma, quindi ne ha scelto uno con un'implementazione di lunghezza minima.

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

Provalo online!

Mathematica, 32 byte

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

Funzione senza nome che accetta una coppia ordinata di elenchi di caratteri, ad esempio {{"R","o","c","k"},{"P","a","p","e","r"}}, e di ritorno -1|0|1.

Volevo che il codice evitasse non solo le tre parole di input, ma anche il nome della funzione troppo lunga ToCharacterCode; quindi ho lavorato con la lunghezza4,5,8 delle parole di input e cercato una breve funzione di quelle lunghezze che davano risposte distinte modulo 3. (La divisione intera per 2 è matematicamente promettente, ma quelle funzioni hanno nomi troppo lunghi in Mathematica).

Si scopre che prendendo il fattoriale di (la lunghezza - 3) si danno le risposte 1,2,120, che sono 1,-1,0modulo 3. Quindi calcoliamo, modulo 3, la differenza dei due valori (tramite il prodotto punto {1,-1}.{x,y} = x-y, che è un buon modo quando il due valori sono in un elenco).

Rubino, 36 35 30 byte

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

Provalo su ideone.com

Uscita di prova:

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

Sfrutta il fatto che 7 dei 9 risultati corretti vengono generati semplicemente effettuando un confronto lessicografico utilizzando l'operatore dell'astronave <=>. Il (a+b)[12]solo inverte gli input al confronto se gli input sono Papere Scissors(e anche Scissors Scissors- ma questo è in 0entrambi i casi).

Grazie a Horváth Dávid per avermi salvato un personaggio e grazie a GB per avermi salvato un altro 5.

Python , 39 36 34 33 byte

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

Provalo online!

Come funziona

Diamo un'occhiata ad alcuni valori della lunghezza di sei copie di x e una copia di 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

Possiamo codificare i risultati ( {-1, 0, 1} ) mappandoli nel set {0, 1, 2, 3} . Ad esempio, la mappatura t ↦ 2 - t raggiunge questo ed è il suo contrario .

Denotiamo il risultato di x ed y da o (x, y) . Poi:

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₂

Fortunatamente, i bit nelle ultime colonne sono tutti d'accordo tra loro, quindi possiamo OR per formare un singolo intero n e recuperare o (x, y) come 2 - (((n ≫ o (x, y))% 4) . Il valore di n è 94 .

Retina , 35 31 byte

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

Provalo online!

Spiegazione

Funziona in due passaggi. Innanzitutto, stampiamo i segni meno per gli input rilevanti. Quindi stampiamo una 0cravatta e una 1altrimenti.

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

Sono due fasi. Nel )secondo stadio li raggruppano insieme, *li rende una corsa a secco (il che significa che la stringa di input verrà ripristinata dopo che sono stati elaborati, ma il risultato verrà stampato) e \sopprime la stampa di un avanzamento riga finale. Le due fasi insieme stamperanno a- se applicabile.

La prima fase è una Gfase rappresentante che mantiene solo la linea se contiene uno k P, r So s R. Questi corrispondono ai casi in cui dobbiamo produrre -1. Se non è uno di questi casi, l'input verrà sostituito con una stringa vuota.

Il secondo stadio sostituisce .+(l'intera stringa, ma solo se contiene almeno un carattere) con -. Quindi questo stampa un -per quei tre casi e nient'altro.

D`\w+
 .

Sono altre due fasi. Il primo stadio è Dun'eduplicazione. Abbina le parole e rimuove i duplicati. Quindi se e solo se l'input è un pareggio, questo lascia cadere la seconda parola.

Il secondo stadio conta il numero di partite di ., che è uno spazio seguito da qualsiasi personaggio. Se l'input è stato un pareggio e la seconda parola è stata rimossa, ciò si traduce in 0. Altrimenti, la seconda parola è ancora in atto e c'è una corrispondenza, quindi viene stampata 1.

05AB1E , 18 17 15 10 9 byte

6 byte salvati con il trucco della lunghezza di input di Digital Trauma

€g3^Æ>3%<

Accetta input come [SecondPlayersChoice,FirstPlayersChoice]

Provalo online! o Convalida tutti i casi di test

Soluzione alternativa a 9 byte: íø¬ÇÆ>3%<

Spiegazione

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

Soluzione precedente a 15 byte

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

Provalo online! o Convalida tutti i casi di test

Spiegazione

 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 byte

L€Iµ-*×Ṡ

Provalo online! (suite di test, esegue il cast di numeri interi per maggiore chiarezza)

Come funziona

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 byte

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

Provalo online!

Grazie mille a @Dennis per avermi permesso di prendere in prestito il suo codice di prova online e per avermi salvato 6 byte.

modificare

@ hashcode55 - Praticamente come lo descrivi. (x! = y, -1) è una sequenza di due elementi e [x [0] + y [0] in 'RPSR'] sta calcolando quale elemento prendere. Se la prima lettera di x + la prima lettera di y è nell'elenco dei caratteri, verrà valutata True o 1, quindi verrà restituito (x! = Y, -1) [1]. In caso contrario (x! = Y, -1) [0]. È qui che diventa un po 'complicato. Il primo elemento è di per sé efficacemente un altro if. Se x! = Y il primo elemento sarà True, altrimenti sarà False, quindi se x [0] + y [0] in 'RPSR' è falso, verrà restituito True o False a seconda che x == y. Il + è un po 'subdolo e grazie ancora a @Dennis per questo. X! = Y restituirà un vero o falso letterale. Abbiamo bisogno di un 1 o uno 0. Non so ancora come, ma il + fa questa conversione. Posso solo supporre che usando un operatore matematico su Vero / Falso lo costringe a essere visto come l'equivalente intero. Ovviamente il + davanti a -1 restituirà comunque -1.

Spero che sia di aiuto!

JavaScript (ES6), 46 38 byte

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

Si avvale del fatto che Rock-Paper-Scissors è ciclico. JavaScript non ha né astronave né operatori ternari bilanciati, altrimenti la risposta sarebbe (a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3.

Modifica: salvato 8 byte grazie a @WashingtonGuedes.

MATL , 14 13 byte

TTt_0vic1Z)d)

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Se il codice ASCII della lettera iniziale della prima stringa viene sottratto da quello della seconda stringa otteniamo il valore nella colonna D in basso. Prendendo modulo 5 fornisce il valore M . Il valore finale tra parentesi è il risultato desiderato, 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)

Quindi se calcoliamo D e poi M , per ottenere R dobbiamo solo mappare da 0 a 0; 1 e 2 a 1; 3 e 4 a −1. Questo può essere fatto indicizzando in un array di cinque voci pari a 0, 1 o −1. Poiché l'indicizzazione in MATL è basata su 1 e modulare, l'array dovrebbe essere [1, 1, −1, −1, 0](la prima voce ha indice 1, l'ultima ha indice 5 o equivalentemente 0). Infine, l'operazione modulo 5 può fortunatamente essere evitata, poiché è implicitamente eseguita dall'indicizzazione modulare.

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 byte

0XXWW]rcrc-=

I due ingressi sono separati da spazio. Il loro ordine è invertito rispetto a quello nel testo della sfida.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Traduzione della mia risposta MATL . Questo sfrutta il fatto che in CJam c(convertito in char) applicato su una stringa prende il suo primo carattere. Inoltre, l'array per il mapping è diverso perché l'indicizzazione in CJam è basata su 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 byte

rW=rW=-J+3%(

Prendi il codice ascii dell'ultimo carattere di ogni stringa, quindi restituisce:

(a1 - a2 + 19) % 3 - 1

Provalo qui !

Python 3, 54 byte

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

Provalo online!

Java 7, 82 byte

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

Spiegazione:

• La seconda lettere sono o, ae c, con i decimali ASCII 111, 97e 99.
• Se li sottraggiamo l'uno dall'altro per i casi di test, otteniamo i seguenti risultati:
  • 0 (Rock, Rock)
  • 14 (Rock, carta)
  • 12 (Carta, forbici)
  • -14 (Carta, Rock)
  • 0 (Carta, carta)
  • -2 (Carta, forbici)
  • -2 (Forbici, roccia)
  • 2 (Forbici, carta)
  • 0 (Forbici, forbici)
• Se prendiamo modulo 5 per ciascuno, otteniamo 4, 2, -4, -2, -2, 2.
• Diviso per 2 xè ora il seguente per i casi di test:
  • x = 0 (Rock, Rock)
  • x = 2 (Rock, Paper)
  • x = 1 (carta, forbici)
  • x = -2 (Carta, Rock)
  • x = 0 (carta, carta)
  • x = -1 (carta, forbici)
  • x = -1 (Forbici, Roccia)
  • x = 1 (forbici, carta)
  • x = 0 (forbici, forbici)
• Solo 2e -2sono errati e avrebbero dovuto essere -1e 1invece. Quindi se x%2 != x(tutto sopra 1o sotto -1) ci dividiamo -2per sistemare questi due "casi limite".

Codice di prova:

Provalo qui.

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

Produzione:

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

dc, 18

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

Provalo online .

Si noti che i due argomenti vengono passati (separati da spazio) su una riga a STDIN. Gli arg sono racchiusi tra parentesi quadre [ ]poiché è così che dcpiacciono le sue stringhe.

dcha una gestione delle stringhe molto limitata, ma risulta che una delle cose che puoi fare è usare il Zcomando per ottenere una lunghezza della stringa, che fortunatamente è distinta per "Rock", "Paper" e "Scissors", e può essere abbastanza semplicemente aritmetica manipolato per dare il risultato desiderato.

PHP, 34 byte

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

Pyth, 16

t%+7h.+mx3ldQ3

Probabilmente potrebbe essere più breve.

        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 byte

Salvato 1 byte, grazie 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;

Accetta due stringhe come input e genera un numero intero. C'è un pareggio, se le due stringhe sono uguali, altrimenti controlla il primo carattere delle stringhe, al fine di determinare quale giocatore vince.

JavaScript, 37 , 32 , 31 byte

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

Se a è uguale a b, output zero.

Altrimenti, xo il risultato del controllo se la lunghezza non è maggiore di 12 (confronto di forbici e carta) con il confronto di un maggiore di b.
Se restituisce 1, restituiscilo.

Se restituisce 0, utilizzare l'operatore OR per sostituire con -1.

Lotto, 116 byte

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

32 byte di codice + -pflag.

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

Per eseguirlo:

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

Hai salvato 3 byte usando la regex della risposta Retina di Martin Ender . (il mio regex precedente era /R.*P|P.*S|S.*R/)

Spiegazione:

Innanzitutto, /(.+) \1/controlla se l'input contiene il doppio della stessa parola, in tal caso, il risultato è 0. Altrimenti, si /k P|r S|s R/occupa del caso in cui si trova la risposta -1. Se quest'ultimo regex è falso, allora -/k P|r S|s R/è falso, quindi torniamo 1.

Gelatina , 9 byte

L€^3Iæ%1.

Questo utilizza l'algoritmo della risposta di Bash di @ DigitalTrauma .

Provalo online!

Come funziona

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 byte

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

Provalo qui!

_{Ispirato alla soluzione di carusocomputing}

Vecchia soluzione a 53 byte

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

Provalo online!

_{Grazie ancora, ETHproductions!}

PHP, 55 53 byte

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

• accetta i valori ASCII delle prime lettere (dagli argomenti della riga di comando): 82,80,83
• % 6: 4,2,5
• % 4: 0,2,1
• differenza (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

versione sinusoidale, 49 46 byte

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

un porto golfizzato di risposta carusocomputing :

3 byte salvati da @utente59178

Perl, 25 byte

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

Codice 24 byte +1 byte per -p opzione.

L'ingresso dovrebbe essere su stdin senza separatori, ad esempio:

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

Il primo regexp cerca la vittoria del primo giocatore, il secondo la sua perdita. La differenza è stampata.

Scala, 148 byte

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

Per fortuna, poiché sono richiesti i punti e virgola per separare più comandi sulla stessa linea, Scala trae vantaggio dall'avere un codice di golf formattabile!

In questo tentativo di golf ho imparato che puoi sostituirlo

"somestring".charAt(index) 

con

"somestring"(index) 

perché Scala ti consente di trattare le stringhe come matrici allo scopo di ottenere caratteri.