Рок-бумага-ножницы

70

Учитывая два строковых ввода «Камень», «Бумага» или «Ножницы», определите результат раунда 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:

XNOR
источник
Означает ли один вход с пустым разделителем, например, «каменная бумага»?
Emigna
1
@ Emigna Да, но с большой буквы RockPaper.
xnor
15
Это было НАСТОЛЬКО веселее, чем я ожидал, мой лорд, есть несколько классных способов сделать это.
Волшебная урна осьминога
Может ли ввод быть массивом из двух строк?
Луис Мендо
@ LuisMendo Да.
xnor

Ответы:

73

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.

Урна волшебного осьминога
источник
3
Не могли бы вы сделать его короче, используя , что -sin(x) = sin(-x)это означает, что только изменение порядка aи bи опуская ведущий -? Кроме этого, приближение жесткого кодирования из 4/PiLike 1.273может быть достаточным, или , 1.3или , 9/7или 5/4.
flawr
2
PS: Я также предлагаю сделать ссылку, чтобы попробовать ее в Интернете, чтобы такие люди, как я, могли поиграть с вашей отправкой =)
flawr
3
Вы можете сохранить 1 байт sin(b-a)вместо -sin(a-b). Отличная находка!
Тит
2
Сохраните еще 7 байтов, умножив на 1.3вместо 4/Math.PI; это достаточно точно.
Тит
1
@carusocomputingXX=ASCII=Y=Wanted output RR=82-82=0=0 PP=83-83=0=0 SS=80-80=0=0
CraigR8806
44

C, 50 35 байт

#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

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

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

Quentin
источник
Просто не делайте ничего похожего на вычисление -f(i)для подсчета очков другого игрока - результат будет неожиданным!
nneonneo
4
@nneonneo -(f(i))должно работать нормально. Макросы это весело!
NWP
18

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)

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

flawr
источник
16

Чистый Баш, 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, чтобы получить желаемый результат.

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

Цифровая травма
источник
15

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

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

Деннис
источник
14

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, что является хорошим способом, когда два значения находятся в списке).

Грег Мартин
источник
1
«Оказывается ...» У вас есть глаза на эти вещи
ngenisis
12

Рубин, 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.

Gareth
источник
Вы можете использовать анонимную лямбду и сохранить 2 символа.
ГБ
@ GB Если я не назову функцию как ее назвать? Это попахивает мне изменой. Но спасибо за другой совет - я посмотрел на это, но отклонил его, потому что ScissorsScissors 16, но я вижу, что это на самом деле не имеет значения. :-)
Гарет
@ Денис Вы не можете назвать это, не назначая это. Мне кажется, что это измена и несправедливо по отношению к языкам без анонимных функций, которые должны определять имя.
Гарет
Что вы можете. tio.run/nexus/…
Деннис
10

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 .

Деннис
источник
9

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вместо.

Мартин Эндер
источник
Вот другой подход, основанный на длине входной строки. Это дольше, чем у вас, но мне интересно, можно ли его еще раз проиграть?
Цифровая травма
@DigitalTrauma это действительно хорошая идея, но я не вижу ничего, чтобы сократить ее. Я думаю, что вы должны опубликовать его в любом случае (и если вы переместите первую строку в заголовок, то TIO не будет включать его в число байтов).
Мартин Эндер
8

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
Emigna
источник
Вы победили мою забавную :( Ç¥13T/*.½òПОЧЕМУ ЭТО РАБОТАЕТ? НИКТО НЕ ЗНАЕТ.
Волшебная Урна Осьминога
@MagicOctopusUrn: Uuuh, это конечно странный. Каким будет формат ввода, чтобы он возвращал int в качестве вывода?
Emigna
['R','P']: P Это порт этого.
Волшебная урна осьминога
@MagicOctopusUrn: О да, я забыл об этом. Мой любимый ответ на этот вызов :)
Emigna
6

Желе , 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.
Деннис
источник
6

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.

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

ElPedro
источник
Здравствуй! Подскажите, пожалуйста, как работает этот синтаксис? Логично предположить, что (x!=y,-1)это работает как если, если список генерирует истину, то -1 в противном случае x!=y. Какая польза от этого +знака? Источник, документирующий этот вид синтаксиса, был бы очень полезен!
hashcode55
@ hashcode55 - я добавил пояснение к своему ответу.
ElPedro
Чтобы ответить на вашу неуверенность по поводу ... +в данном случае, это унарный плюс, например +10, и, по сути, это короткий способ преобразования в целое число.
FlipTack
Спасибо @FlipTack. Кинда догадалась, что именно это и делает, но спасибо за правильное объяснение.
ElPedro
@ElPedro Большое спасибо! Это действительно помогло мне.
hashcode55
5

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.

Нил
источник
1
@WashingtonGuedes Я могу сделать даже лучше, чем это!
Нил
Вы можете карри, чтобы сохранить 1 байт
MayorMonty
я пытался запустить его и всегда возвращать 0
Vitim.us
5

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
Луис Мендо
источник
5

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
Луис Мендо
источник
5

CJam, 15 14 12 байт

rW=rW=-J+3%(

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

(a1 - a2 + 19) % 3 - 1

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

Arnaud
источник
4

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
Кевин Круйссен
источник
Почему второе письмо из любопытства? У меня был такой же подход (вроде), но я использовал первую букву.
Волшебная урна осьминога
@carusocomputing Ну, я заметил, что большинство других людей использовали либо первую букву, либо длину, и хотел попробовать что-то еще. Я впервые использовал третьи буквы ( c, p, i) со значениями ASCII 99, 112и 105, как казалось , наиболее полезными, и заметил , что это стало бы 4, 2, 0 , если я сделал по модулю 5. Только тогда я понял , я должен был вычесть как, так 4, 2 и 0 были не очень полезны. После некоторых недоразумений / проб и ошибок я попробовал второе письмо и получил более полезные результаты с тем же модулем 5, который все еще присутствует. Тогда я быстро пришел к решению, которое я представил выше. :)
Кевин Круйссен
@carusocomputing Хотел попробовать уникальный подход, и, учитывая, что я довольно плохо разбираюсь в подобных решениях, он не такой короткий, как некоторые другие решения, но все же уникальный (что и было моей первоначальной целью). :)
Кевин Круйссен
4

18 лет

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

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

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

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

Цифровая травма
источник
4

PHP, 34 байта

<?=md5("BMn$argv[1]$argv[2]")%3-1;
user63956
источник
3

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

Интернет .

Цифровая травма
источник
3

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;

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

Хорват Давид
источник
Сохраните один байт с помощью каррирования, т.е.a=>b=>...
TheLethalCoder
3

JavaScript, 37 , 32 , 31 байт

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

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

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

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

Grax32
источник
Не могли бы вы написать это как функцию a=>b=>с карри для сохранения байта?
FlipTack
Да. Спасибо @FlipTack
Grax32
2

Пакетный, 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
Нил
источник
2

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.

папа
источник
2

Желе , 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].
Деннис
источник
Черт возьми, я собирался начать читать о Желе. Ну что ж , вот оно в пите . +1.
Цифровая травма
2

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!

Оливер
источник
1
Вы могли бы начать с использованием ©вместо &&, меняя Ug0 cк Ug c( то же самое с V) и заменить -1с J. Это все еще немного дольше, чем ответ JS, хотя, возможно, вы можете взять некоторые идеи из этого
ETHproductions
@ETHproductions Спасибо! Я не знаю, как я про это забываю©
Оливер
1
На самом деле вы можете просто сделать W=Uc. Я не знаю, почему я постоянно забываю, что cработает на любой строке: P
ETHproductions
2

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

Titus
источник
1
Для синусоидальной версии можно сохранить 3 байта, заменив round(x)на2*x^0
user59178
2

Perl, 25 байт

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

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

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

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

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

МИК
источник
1

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 позволяет вам рассматривать строки как массивы с целью получения символов.

Архимаг
источник
Это может быть безмерно. Для начала, в большинстве задач вам разрешено выполнять функцию вместо полной программы, поэтому вместо целого объекта расширяет возможности приложения и извлекает из аргументов попробуйте что-то вроде: def g (a: Seq, b: Seq) = ...
Итан
Кроме того, вам не нужно печатать значение. Возврат достаточно, что здорово при игре в гольф на Scala, так как возврат бесплатный. И вы можете улучшить его еще больше, используя трюк, опубликованный в ответе Groovy, который работает почти одинаково в Scala.
Итан