З урахуванням двох рядкових входів "Rock", "Paper" або "Scissors", визначте результат раунду 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

Табло:

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>

Гроовий, 67 56 50 байт

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

Спробуйте в Інтернеті!

Виявляється, гра в скелі, папір, ножиці має досить класну властивість.
Враховуючи рядки a і b, візьміть першу літеру кожного, це призводить до двох з наступних:R,P,S

Вичерпний список можливих значень (Коли поєднано 2 варіанти):

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, щоб отримати бажаний результат.

Спробуйте в Інтернеті .

Пітон , 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)
]

Спробуйте в Інтернеті!

Математика, 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 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

Ми можемо кодувати результати ( {-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 .

Сітківка , 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 байтів, збережених за допомогою введення тривалості цифрової травми

€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 за те, що він дозволив мені запозичити його Спробуйте його онлайн-тестовий код та заощадив мені 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] in'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 ножиці мають циклічний характер. 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). Нарешті, операції modulo 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(перетвореному в char) застосований на рядку перший характер. Також масив для відображення відрізняється тим, що індексація в 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;}

Безголівки:

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 :
  • x = 0 (рок, рок)
  • x = 2 (рок, папір)
  • x = 1 (папір, ножиці)
  • x = -2 (папір, рок)
  • x = 0 (папір, папір)
  • x = -1 (папір, ножиці)
  • x = -1 (ножиці, скеля)
  • x = 1 (ножиці, папір)
  • x = 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;

Піта, 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

Якщо дорівнює b, вивести нуль.

В іншому випадку, xor результат перевірки, якщо довжина не більше 12 (порівняння ножиць і паперу) з порівнянням більше b.
Якщо це поверне 1, поверніть його.

Якщо він повертає 0, використовуйте оператор АБО для заміни -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;

відповідь на гольф у відповідь Carusocomputing :

3 байти, збережені користувачем @ user59178

Perl, 25 байт

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

Код 24 байти +1 байт для -p опції.

Вхід повинен бути на stdin без роздільників, наприклад:

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

Перший регулярний пошук шукає виграш першого гравця, другий - його втрату. Різниця друкується.

Скала, 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 дозволяє обробляти рядки як масиви з метою отримання символів.