Учитывая два строковых ввода «Камень», «Бумага» или «Ножницы», определите результат раунда RPS . Выведите 1, если первый игрок выиграет, -1, если второй игрок выиграет, или 0 для ничьей.

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

Вы должны использовать точные строки «Камень», «Бумага» и «Ножницы» в качестве входных данных. Вы можете выбрать, будет ли выбор первого игрока (последовательно) первым или вторым. В качестве альтернативы вы можете принять их как один ввод с односимвольным или пустым разделителем. На вход гарантируется одна из 9 возможных пар из трех вариантов в вашем формате ввода.

Выходными данными должны быть числа 1, 0 или -1 или их строковое представление. Поплавки в порядке. Так есть +1, +0,и -0.

Связанный: Кодирование игры RPS

Leaderboard:

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 байт

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

Попробуйте онлайн!

Оказывается, игра «камень, бумага, ножницы» имеет довольно крутое свойство.
Учитывая строки a и b, берут первую букву каждой, это приводит к двум из следующего:R,P,S

Исчерпывающий список возможных значений (при комбинировании двух вариантов):

XX=ASCII=Y=Wanted output
RR=82-82=0=0
PP=80-80=0=0
SS=83-83=0=0
RS=82-83=-1=1
RP=82-80=2=-1
PS=80-83=-3=-1
PR=80-82=-2=1
SR=83-82=1=-1
SP=83-80=3=1

Реорганизация списка в:

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

Дает нам последовательность, которая выглядит обратно синусоидальной, и вы на самом деле можете представить эту формулу примерно как (и, приблизительно, я имею в виду едва ли достаточно, чтобы работать, вы могли бы получить уравнение, которое не работает, но стоит больше байтов):

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

Упрощение с 4 / pi до 1,3 было сначала предложено @flawr, а затем протестировано @titus для общей экономии 6 байт.

Используя свойства двойного скругления groovy, это приводит к правильному выводу для ножниц для рок-бумаги.

05AB1E , 10 байтов (не конкурируют)

Ç¥13T/*.½ò

Попробуйте онлайн!

Тот же ответ перенесен на 05AB1E с использованием новых команд, добавленных 26.10.2017.

C, 50 35 байт

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

Вызовите fсо строкой, содержащей обоих игроков, без разделителя, и он вернет, победит ли первый.

Объяснение:

Глядя на девять возможных строк, получается, что пары букв в столбцах 7 и 8 уникальны:

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

Смещение и дикое приведение, чтобы short*получить эти пары букв и интерпретировать их как числа:

29285
29545
21107
107
25968
21363
29555
27491
20595

Тогда это был вопрос грубой силы, чтобы найти 51и 4остатки, которые применялись последовательно, чтобы уменьшить эти числа до:

3 0 0 1 1 1 2 2 2

Который просто идеален, чтобы закрепить еще один остаток в конце и компенсировать результат.

Смотрите это в прямом эфире на Колиру

MATLAB / Octave , 63 54 52 байта

Очень удобно, что ASCII-коды первых букв Rock,Paper,Scissorsявляются R=82,P=80,S=83. Если мы вычтем, 79мы получим удобно 3,1,4, что мы теперь будем использовать как матричные индексы: Здесь матрица 4x4 жестко закодирована, где i,j-ая запись соответствует результату, если вы вставляете значения из только что:

     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)

Попробуйте онлайн!

Чистый Баш, 31

Заимствование по формуле Денниса :

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

Попробуйте онлайн .

Предыдущий ответ:

Чистый Баш, 43 35

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

• Получить длину строки каждого Arg ( 4, 5, 8соответственно , для Rock, Paper, Scissors)

• Исключающий каждый с 3 , чтобы дать 7, 6, 11(который при приеме мод 3 дают 1, 0, 2)

• Затем вычтите и возитесь с модом 3, чтобы получить желаемый результат.

Попробуйте онлайн .

Python , 40 30 байт

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

Попробуйте онлайн!

Фон

Я начал с шаблона функции

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

и выполнил поиск подходящих параметров методом грубой силы, используя следующую программу, затем выбрал программу с минимальной длиной реализации.

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

Попробуйте онлайн!

Mathematica, 32 байта

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

Безымянная функция принимает упорядоченную пару списков символов, например {{"R","o","c","k"},{"P","a","p","e","r"}}, и возвращает -1|0|1.

Я хотел, чтобы код избегал не только трех входных слов, но и слишком длинного имени функции ToCharacterCode; поэтому 4,5,8вместо этого я работал с длиной входных слов и искал короткую функцию из тех длин, которые давали четкие ответы по модулю 3. (Целочисленное деление на 2 математически многообещающе, но эти функции имеют слишком длинные имена в Mathematica.)

Оказывается, что взятие факториала (длина - 3) дает ответы 1,2,120, которые являются 1,-1,0по модулю 3. Затем мы просто вычисляем, по модулю 3, разницу двух значений (через скалярное произведение {1,-1}.{x,y} = x-y, что является хорошим способом, когда два значения находятся в списке).

Рубин, 36 35 30 байт

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

Попробуйте это на ideone.com

Тестовый вывод:

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

Используется тот факт, что 7 из 9 правильных результатов получены путем лексикографического сравнения с использованием оператора космического корабля <=>. (a+b)[12]Просто переворачивает входные данные для сравнения , если входы Paperи Scissors(а также Scissors Scissors- но это 0либо наоборот).

Спасибо Хорвату Давиду за то, что он спас мне персонажа, и благодаря Великобритании за то, что он спас мне еще 5.

Python , 39 36 34 33 байта

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

Попробуйте онлайн!

Как это устроено

Давайте рассмотрим несколько значений длины шести копий x и одной копии y по модулю 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

Мы можем кодировать результаты ( {-1, 0, 1} ), отображая их в набор {0, 1, 2, 3} . Например, отображение t - 2 - t достигает этого и является его собственным обратным.

Обозначим результат x и y через o (x, y) . Затем:

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₂

К счастью, все биты в последних столбцах согласуются друг с другом, поэтому мы можем ИЛИ использовать их, чтобы сформировать одно целое число n и получить o (x, y) как 2 - ((n ≫ o (x, y))% 4) , Значение n составляет 94 .

Retina , 35 31 байт

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

Попробуйте онлайн!

объяснение

Это работает в два этапа. Сначала мы печатаем знаки минуса для соответствующих входных данных. Затем мы печатаем 0для связи, а для 1других.

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

Это два этапа. На )втором этапе они группируются вместе, что *делает их пробным прогоном (что означает, что входная строка будет восстановлена ​​после того, как они были обработаны, но результат будет напечатан) и \подавляет печать завершающего перевода строки. Две стадии вместе напечатают, -если применимо.

Первый этап является Gэтапом Rep , который только держит линию , если она содержит либо k P, r Sили s R. Они соответствуют случаям, когда нам нужно выводить -1. Если это не один из этих случаев, ввод будет заменен пустой строкой.

Второй этап заменяет .+(всю строку, но только если она содержит хотя бы один символ) с -. Так что это печатает -для этих трех случаев и ничего другого.

D`\w+
 .

Это еще два этапа. Первый этап - это Dобучение. Он сопоставляет слова и удаляет дубликаты. Таким образом, если и только если ввод является связующим, это отбрасывает второе слово.

Второй этап подсчитывает количество совпадений ., которое представляет собой пробел, за которым следует любой символ. Если вход был привязан, а второе слово было удалено, это приводит к 0. В противном случае второе слово остается на месте, и есть одно совпадение, поэтому оно печатается 1вместо.

05AB1E , 18 17 15 10 9 байт

6 байтов, сохраненных с помощью трюка с длиной входного сигнала Digital Trauma

€g3^Æ>3%<

Принимает вход как [SecondPlayersChoice,FirstPlayersChoice]

Попробуйте онлайн! или проверить все тесты

Альтернативное 9-байтовое решение: íø¬ÇÆ>3%<

объяснение

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

Предыдущее 15-байтовое решение

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

Попробуйте онлайн! или проверить все тесты

объяснение

 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

Желе , 8 байт

L€Iµ-*×Ṡ

Попробуйте онлайн! (набор тестов, приведен к целому числу для ясности)

Как это устроено

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 байт

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

Попробуйте онлайн!

Огромное спасибо @Dennis за предоставленную мне возможность заимствовать его тестовый код Try it и за то, что он сэкономил мне 6 байтов

редактировать

@ hashcode55 - Как вы и описали. (x! = y, -1) - двухэлементная последовательность, и [x [0] + y [0] в 'RPSR'] вычисляет, какой элемент взять. Если первая буква x + первая буква y находится в списке символов, она будет иметь значение True или 1, поэтому будет возвращено (x! = Y, -1) [1]. Если это не так (x! = Y, -1) [0]. Это где это становится немного сложнее. Первый элемент сам по себе является фактически другим, если. Если x! = Y, то первый элемент будет True, в противном случае он будет False, поэтому, если x [0] + y [0] в 'RPSR' - false, то будет возвращено либо True, либо False, в зависимости от того, будет ли x == y. + Немного подлый и еще раз спасибо @Dennis за это. X! = Y вернет буквальное значение True или False. Нам нужно 1 или 0. Я до сих пор не знаю, как, но + делает это преобразование. Я могу только предположить, что с помощью математического оператора True / False он заставляет его рассматриваться как целочисленный эквивалент. Очевидно, что + перед -1 все равно вернет -1.

Надеюсь это поможет!

JavaScript (ES6), 46 38 байт

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

Использует тот факт, что Rock-Paper-Scissors является циклическим. В JavaScript нет ни космического корабля, ни сбалансированных троичных операторов, в противном случае ответ будет (a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3.

Изменить: Сохранено 8 байт благодаря @WashingtonGuedes.

MATL , 14 13 байт

TTt_0vic1Z)d)

Попробуйте онлайн! Или проверьте все тестовые случаи .

объяснение

Если код ASCII начальной буквы первой строки вычитается из кода второй строки, мы получаем значение в столбце D ниже. Принимая по модулю 5 дает значение М . Конечное значение в скобках желаемый результат, 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)

Таким образом, если мы вычисляем D и затем M , чтобы получить R, нам нужно только отобразить 0 в 0; 1 и 2 к 1; 3 и 4 до -1. Это можно сделать путем индексации в массиве из пяти записей, равных 0, 1 или -1. Поскольку индексирование в MATL основано на 1 и является модульным, массив должен быть таким [1, 1, −1, −1, 0](первая запись имеет индекс 1, последняя имеет индекс 5 или эквивалентно 0). Наконец, к счастью, операции по модулю 5 можно избежать, поскольку она неявно выполняется модульной индексацией.

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 байт

0XXWW]rcrc-=

Два входа разделены пробелом. Их порядок обратен по отношению к этому в тексте вызова.

Попробуйте онлайн! Или проверьте все тестовые случаи .

объяснение

Перевод моего ответа MATL . Это использует тот факт, что в CJam c(преобразовать в символ) применяется к строке принимает свой первый символ. Кроме того, массив для отображения отличается, потому что индексирование в CJam основано на 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 байт

rW=rW=-J+3%(

Возьмите код ascii последнего символа каждой строки, затем вернитесь:

(a1 - a2 + 19) % 3 - 1

Проверьте это здесь !

Python 3, 54 байта

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

Попробуйте онлайн!

Java 7, 82 байта

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

Объяснение:

• Вторые буквы o, aи c, с десятичными знаками ASCII 111, 97и 99.
• Если мы вычтем их друг от друга для тестовых случаев, мы получим следующие результаты:
  • 0 (Рок, Рок)
  • 14 (Рок, Бумага)
  • 12 (Бумага, ножницы)
  • -14 (Бумага, камень)
  • 0 (Бумага, бумага)
  • -2 (Бумага, ножницы)
  • -2 (Ножницы, Камень)
  • 2 (Ножницы, бумага)
  • 0 (Ножницы, Ножницы)
• Если взять по модулю 5 для каждого, мы получаем 4, 2, -4, -2, -2, 2.
• xТеперь делим на 2 следующее для тестовых случаев:
  • х = 0 (камень, камень)
  • х = 2 (камень, бумага)
  • х = 1 (бумага, ножницы)
  • х = -2 (бумага, камень)
  • х = 0 (бумага, бумага)
  • х = -1 (бумага, ножницы)
  • х = -1 (ножницы, камень)
  • х = 1 (ножницы, бумага)
  • х = 0 (ножницы, ножницы)
• Только 2и -2неправильны, и должны были быть -1и 1вместо. Так что, если x%2 != x(все выше 1или ниже -1) мы разделим, -2чтобы исправить эти два «крайних случая».

Тестовый код:

Попробуй это здесь.

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

Выход:

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

18 лет

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

Попробуйте онлайн .

Обратите внимание, что два аргумента передаются (через пробел) в одну строку в STDIN. Аргументы заключены в квадратные скобки, так [ ]как это dcнравится его строки.

dcимеет очень ограниченную обработку строк, но оказывается, что вы можете использовать одну из Zкоманд, чтобы получить длину строки, которая, к счастью, отличается для "Rock", "Paper" и "Scissors" и может быть довольно просто арифметически манипулировать, чтобы дать желаемый результат.

PHP, 34 байта

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

Pyth, 16

t%+7h.+mx3ldQ3

Вероятно, может быть короче.

        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

Интернет .

C #, 85 84 байта

Сохранено 1 байт, благодаря 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;

Он принимает две строки в качестве входных данных и выводит целое число. Существует связь, если две строки равны, в противном случае он проверяет первый символ строк, чтобы определить, какой игрок выигрывает.

JavaScript, 37 , 32 , 31 байт

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

Если a равно b, выведите ноль.

В противном случае, xor результат проверки, если длина не больше 12 (сравнение ножниц и бумаги) со сравнением больше, чем b.
Если это возвращает 1, верните его.

Если он возвращает 0, используйте оператор OR для замены на -1.

Пакетный, 116 байт

@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 байта

32 байта кода + -pфлаг.

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

Чтобы запустить это:

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

Сохранено 3 байта с использованием регулярного выражения ответа Retina Мартина Эндера . (мое предыдущее регулярное выражение было /R.*P|P.*S|S.*R/)

Объяснение:

Во-первых, /(.+) \1/проверяется, содержит ли вход дважды одно и то же слово, и если да, результат равен 0. В противном случае /k P|r S|s R/имеет дело со случаем, когда ответ -1. Если это последнее регулярное выражение ложно, то -/k P|r S|s R/ложно, поэтому мы возвращаемся 1.

Желе , 9 байт

L€^3Iæ%1.

При этом используется алгоритм из ответа Bash @ DigitalTrauma .

Попробуйте онлайн!

Как это устроено

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 байт

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

Попробуй это здесь!

_{Вдохновленный решением carusocomputing}

Старое 53-байтовое решение

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

Попробуйте онлайн!

_{Еще раз спасибо, ETHproductions!}

PHP, 55 53 байта

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

• принимает значения ascii первых букв (из аргументов командной строки): 82,80,83
• % 6: 4,2,5
• % 4: 0,2,1
• разница (ба):
  • PS: 1-2, SR: 2-0, RP: 2-0 → -1 или 2; + 3,% 3 -> 2
  • SP: 2-1, RS: 0-2, PR: 0-2 -> -2 или 1; + 3,% 3 -> 1
  • RR, PP, SS: 0; + 3,% 3: 0
• (3-2 * х): -1,1,3
• % 3: -1,1,0

синусоидальная версия, 49 46 байт

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

гольф-порт Карусокомпьютинг ответит :

3 байта сохранены пользователем @ user59178

Perl, 25 байт

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

Код 24 байта +1 байт для -pварианта.

Ввод должен быть в stdin без разделителей, например:

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

Первое регулярное выражение ищет первую победу игрока, второе - его поражение. Разница напечатана.

Scala, 148 байт

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

К счастью, поскольку для разделения нескольких команд на одной строке требуются точки с запятой, Scala выигрывает от наличия форматируемого гольф-кода!

В этой попытке в гольф я узнал, что вы можете заменить

"somestring".charAt(index) 

с участием

"somestring"(index) 

потому что Scala позволяет вам рассматривать строки как массивы с целью получения символов.