Реализуем классические каменные ножницы для бумаги.

условия:

• пользователь будет вводить 'r', 'p' или 's'
• Программа выведет «R», «P» или «S» и результат
• Выбор программы ('r', 'p' или 's') должен быть псевдослучайным ( я смотрю на тебя, Говард )
• результат может быть представлен любым печатным символом, всегда должно быть три возможных результата для того, что пользователь вводит (пользователь выигрывает, проигрывает или является ничьей).
• что происходит, если пользователь ничего не вводит, или что-то другое, что 'r', 'p' или 's', не должно иметь значения.

Вам нужно:

• Укажите код для игры в гольф.
• Негольфированный код
• Как вы вызываете программу
• Пробный прогон

Я выберу ответ с меньшим количеством символов, если будет выбран галстук, будет выбран наиболее проголосовавший ответ.

Хорошая игра в гольф и, возможно, удача будет в твою пользу.

Я буду публиковать ответ сам на Java.

Для тех, кто живет в горе под скалой:

г = рок

р = бумага

s = ножницы

камень: побеждает ножницы, проигрывает с бумагой, галстук с камнем.

бумага: выигрывает, качается, проигрывает ножницами, галстук с бумагой.

ножницы: выигрывает на бумаге, проигрывает с камнем, галстук с ножницами.

Текущие позиции:

• UN: имя пользователя
• PL: язык программирования
• CC: Количество символов
• UV: до голосов

╔══════════════════╦════════════╦══════╦════╗
║        UN        ║     PL     ║  CC  ║ UV ║
╠══════════════════╬════════════╬══════╬════╣
║ Howard           ║ GolfScript ║    6 ║ 15 ║
║ primo            ║ Perl       ║   27 ║  7 ║
║ TwiNight         ║ APL        ║   31 ║  4 ║
║ primo            ║ Perl       ║   33 ║  7 ║
║ marinus          ║ APL        ║   36 ║  5 ║
║ primo            ║ Perl       ║   38 ║  7 ║
║ primo            ║ Perl       ║   48 ║  7 ║
║ manatwork        ║ Ruby       ║   54 ║ 13 ║
║ w0lf             ║ GolfScript ║   62 ║  4 ║
║ tmartin          ║ K          ║   67 ║  2 ║
║ Abhijit          ║ Python 3   ║   74 ║  5 ║
║ beary605         ║ Python 3   ║   76 ║  4 ║
║ rlemon           ║ javascript ║   85 ║  4 ║
║ ugoren           ║ C          ║   86 ║  3 ║
║ Egor Skriptunoff ║ LUA        ║   87 ║  4 ║
║ Shmiddty         ║ javascript ║   87 ║  3 ║
║ Fors             ║ Befunge    ║  107 ║  3 ║
║ Briguy37         ║ javascript ║  117 ║  2 ║
║ Vi.              ║ Clojure    ║  129 ║  1 ║
║ Henrik           ║ C#         ║  167 ║  4 ║
║ dystroy          ║ Go         ║  169 ║  1 ║
║ Praveen          ║ javascript ║  250 ║  0 ║
║ ryan             ║ javascript ║  256 ║  1 ║
║ primo            ║ ferNANDo   ║  259 ║  5 ║
║ anakata          ║ Java       ║  259 ║  1 ║
║ epoch            ║ Java       ║  387 ║  1 ║
║ jdstankosky      ║ LOLCODE    ║ 1397 ║ 15 ║
╚══════════════════╩════════════╩══════╩════╝

Я не могу выбрать ответ Говарда, так как это была (успешная) попытка изменить правила, но я изменяю их, чтобы сделать их более явными.

27-символьный ответ primo не может быть выбран, потому что он не является псевдослучайным

primo -p ответ, я пойду с «-p будет считаться как 3 байта: один для -, один для p и еще один необходимый пробел».

Спасибо всем, кто ответил, надеюсь, вы хорошо провели время!

ПРИМЕЧАНИЕ. Я буду пытаться редактировать это раз в две недели, корректировать таблицу и менять выбранный ответ, если кто-то превосходит текущий, поэтому, если вы только что пришли сюда, опубликуйте свой ответ, если хотите!

APL, 31

'TWL'[1+3|-/x⍳⎕←⍞,(?3)⌷x←'rps']

x←'rps' Назначить строку 'rps' вx

(?3)⌷ Выберите случайное целое число 1 ~ 3, выберите этот индекс x

⍞, Добавить пользовательский ввод к выбору машины

⎕← Вывод полученной строки

x⍳ Преобразовать в числовой массив по indexOf в x

-/ Разница двух чисел

1+|3 Модуль 3 и плюс 1

'TWL'[...] индексация от 'TWL'

Образец

r
rp
L

Пользователь выбирает рок, программа выбирает бумагу: Lose

ЛОЛКОД, 1397

Примечание: я подал заявку до того, как заметил, что требование выигрыша было изменено с популярности с гольф-тай-брейком на гольф с популярным тай-брейком.

Там нет строгого синтаксиса, но я уверен, что это приемлемо.

HAI
    I HAS A CRAZY, LUCKY, CHALLENGE, TREAT
    I HAS YUMMY ITZ "LOL U LOZED"
    I HAS MEH ITZ "NOWAI TIED"
    I HAS GROSS ITZ "OMG U WONNED"
    I HAS BURNT ITZ "LAME"
    GIMMEH CHALLENGE
    BTW I HOPE I R TEH WINZ
    LOL CRAZY IZ BETWEEN 1 AN 3
    I HAS A SUPA ITZ A BUKKIT
    LOL SUPA'Z 1 R "ROCK"
    LOL SUPA'Z 2 R "PAPER"
    LOL SUPA'Z 3 R "SCIZZORS"
    LOL LUCKY R SUPA'Z CRAZY
    GOT CHALLENGE, WTF?
        OMG "Rock"
            GOT LUCKY, WTF?
                OMG ROCK, LOL TREAT R MEH, GTFO
                OMG PAPER, LOL TREAT R YUMMY, GTFO
                OMG SCIZZORS, LOL TREAT R GROSS, GTFO
            OIC
        OMG "Paper"
            GOT LUCKY, WTF?
                OMG ROCK, LOL TREAT R GROSS, GTFO
                OMG PAPER, LOL TREAT R MEH, GTFO
                OMG SCIZZORS, LOL TREAT R YUMMY, GTFO
            OIC
        OMG "Scissors"
            GOT LUCKY, WTF?
                OMG ROCK, LOL TREAT R YUMMY, GTFO
                OMG PAPER, LOL TREAT R GROSS, GTFO
                OMG SCIZZORS, LOL TREAT R MEH, GTFO
            OIC
        OMGWTF
            VISIBLE "WHAT U SAYZ?", LOL TREAT R BURNT
            GTFO
    OIC
        BOTH SAEM TREAT AN BURNT, O RLY?
            YARLY
                VISIBLE "YOU BURNTED MAH TREAT!"
            NOWAI
                VISIBLE SMOOSH "I GUESSED " AN LUCKY
                VISIBLE TREAT
        KTHX
KTHXBAI

Если бы это было успешно выполнено как RockPaperScissors.LOL, вот то, что могли бы быть некоторые возможные случайные результаты:

• Вход: Rock- Выход:I GUESSED SCIZZORS U WONNED
• Вход: Paper- Выход:I GUESSED PAPER NOWAI TIED
• Вход: Scissors- Выход:I GUESSED ROCK LOL U LOZED
• Вход: Tuna- Выход:WHAT U SAYZ? YOU BURNTED MAH TREAT!

GolfScript

n"Draw"

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

Неуправляемая версия

n"Draw"

Как вызвать программу

Ввод (один символ 'r', 'p', 's') должен быть предоставлен в STDIN, возможно, завершается символом новой строки.

Пробный прогон

> echo r | ruby golfscript.rb rockpaperscissors.gsc
r
Draw

Пояснение к коду

Для всех, кто не знаком с GolfScript, я добавлю подробное объяснение того, как работает этот код. Код по существу состоит из трех частей.

### Computer's strategy ###
# The strategy used to play r/p/s. 
# The computer is so fast, it can really guess in an instance 
# what the player has played. Since the computer should 
# not play unfair, the best strategy is to always go for a 
# draw and choose the same move.
        # on the stack is player's move
        # choose to play the same -> now the computer's move is on the stack

### Fiddle with input ###
# The input may of may not be delimited by newline.
# In order to make the output readable, we'll give
# a newline here.
n       # Push a newline onto the stack

### Give the result ###
# We can skip a complicated calculation of the result
# since we chose to play draw anyways.
"Draw"  # Push the result onto the stack

# Output is printed automatically when GolfScript code terminates.

Заметки

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

• Обращайтесь только с правильным вводом и заставляйте пользователя вводить новую строку. Это спасет одного персонажа.
• У правил есть небольшая недостаточность, которая позволяет спасти другого персонажа, изменяя правила. Результат всегда может быть напечатан как «Win» - не было указано, что должен быть напечатан правильный результат. Но учтите, что игроки скоро разозлятся, если вы решите внедрить читерскую программу.
• Формат вывода не очень хорошо указан. Мы можем выбрать 0как вывод для ничьей. Таким образом, самой короткой действительной программой является односимвольный код 0.

Рубин: 61 54 символа

o="rps";p o[c=rand(3)],%w{Draw Win Lose}[c.-o.index$_]

Как-то объяснил:

Вся задача сводится к вычислению следующих результатов:

  ╲ machine
h  ╲| 0 1 2
u ──┼──────
m 0 │ 0 1 2 
a 1 │ 2 0 1
n 2 │ 1 2 0

Где цифры означают:

• Выбор: 0 рок, 1 бумага, 2 ножницы
• результат: 0 ничья, 1 победа, 2 поражения

Для этого я использовал формулу: machine_choice - human_choice. Это иногда приводит к отрицательному значению, но поскольку он используется только как индекс, а отрицательный индекс считается обратным, будет выбран правильный элемент массива.

# ┌── choosable object type
# │           ┌── machine's choice numeric code
# │           │                  ┌── result type
# │           │                  │                   ┌── human's choice
# │           │          ┌───────┴───────┐           │
  o="rps";p o[c=rand(3)],%w{Draw Win Lose}[c.-o.index$_]
#           └─────┬────┘                   └─────┬────┘  
#                 └── machine's choice letter    │
#                                                └── result numeric code

Используемые методы (другие, то Fixnumочевидные):

• Kernel.p (obj) → obj - «Для каждого объекта непосредственно записывается obj . inspectсопровождаемый новой строкой к стандартному выводу программы. ”
• Kernel.rand (max = 0) → number - «Если вызывается без аргумента или if max.to_i.abs == 0, rand возвращает псевдослучайное число с плавающей запятой в диапазоне от 0,0 до 1,0, включая 0,0 и исключая 1,0».
• String.index (substring [, offset]) → fixnum или nil - «Возвращает индекс первого вхождения данной подстроки или шаблона (regexp) в str .»

Ungolfed:

object_type = "rps";
result_type = %w{Draw Win Lose}

machine_choice = rand(3)
human_choice = $_

p object_type[machine_choice]

result_code = machine_choice - object_type.index(human_choice)
p result_type[result_code]

Образец прогона:

bash-4.2$ ruby -nle 'o="rps";p o[c=rand(3)],%w{Draw Win Lose}[c.-o.index$_]'
r
"p"
"Win"
p
"p"
"Draw"
s
"p"
"Lose"

C # (167 символов)

Моя самая первая попытка игры в гольф.

Golfed

using System;class P{static void Main(string[] i){var m="rspr";var a=m[Environment.TickCount%3];Console.WriteLine(a+" "+(i[0][0]==a?"T":m.Contains(i[0]+a)?"W":"L"));}}

Un-golfed

using System;

class P
{
    static void Main(string[] i)
    {
        var m = "rspr";
        var a = m[Environment.TickCount % 3];
        Console.WriteLine(a + " " + (i[0][0] == a ? "T" : m.Contains(i[0] + a) ? "W" : "L"));
    }
}

Образец запуска Приложению требуется один ввод символов в качестве аргумента 1 для приложения, либо r, sлибо p.

cmd > app.exe r

Все возможные результаты

• cmd > app.exe rдает вывод r T(рок, галстук)
• cmd > app.exe rдает вывод p L(бумага, потерянная)
• cmd > app.exe rдает вывод s W(ножницы, победа)
• cmd > app.exe p дает вывод r W (рок, победа)
• cmd > app.exe p дает вывод p T (бумага, галстук)
• cmd > app.exe p дает вывод s L (ножницы, потерянные)
• cmd > app.exe s дает вывод r L (рок, потерянный)
• cmd > app.exe s дает вывод p W (бумага, победа)
• cmd > app.exe sдает выходной s T(ножницы, галстук)

Perl 48 байт

$%=rand 3;print"$%
"^B,(Draw,Lose,Win)[$%-=<>^B]

Сценарий печатает результат с точки зрения компьютера, например, если игрок выбирает, rа компьютер выбирает s, результат - Lose. $%(номер страницы формата) используется для хранения перемещения компьютера, поскольку он может содержать только целочисленное значение, которое сохраняет преобразование типа int.

Ungolfed:

# choose a random move index 0, 1, or 2
$cindex = int(rand 3);
# convert this index to a move
# 0 => r, 1 => s, 2 => p
$cmove = "$cindex" ^ B;

# read the player's move
$pmove = <>;
# convert this move to its index
$pindex = $pmove ^ B;

# print computer's move
print $cmove, $/;
# compare indices, and output result
@result = (Draw, Lose, Win);
print $result[$cindex - $pindex];

Пример использования:

$ echo p | perl rps.pl
s
Win

$ echo r | perl rps.pl
r
Draw

$ echo s | perl rps.pl
p
Lose

Сценарий также можно запустить в интерактивном режиме, набрав свой ход, а затем Enter:

$ perl rps.pl
r
s
Lose

Правило растяжения

Perl 35 +3 байта

$_=($%=rand 3).(D,L,W)[$%-($_^B)]^B

Требуется -pключ командной строки (считается 3 байта). Каждый из результатов Win, Loseи Drawбыли отображены на W, L,D . Новая строка между выбором компьютера и результатом была исключена.

Пример использования:

$ echo r | perl -p rps.pl
sL

Perl 30 +3 байта

$_=($%=rand 3).($%-($_^B))%3^B

Еще раз требует -p. Здесь Win, Loseи Drawбыли отображены на 2, 1и 0соответственно. Это все еще технически совместимо, поскольку они являются печатными символами.

Пример использования:

$ echo r | perl -p rps.pl
s1

Perl 24 +3 байта

$_=$^T%3 .($^T-($_^B))%3^B

Требуется -p, WLD сопоставляется с 2, 1, 0как и раньше. Каждый из них ^Tдолжен быть заменен буквальным символом ascii 20. Этот, по общему признанию, немного растянут; $^Tвозвращает количество секунд с начала эпохи, когда скрипт был запущен. Все результаты возможны, но это не совсем квалифицируется как псевдослучайный.

Пример использования:

$ echo r | perl -p rps.pl
s1

APL ( 38 36)

c[i],(⌽↑⌽∘'TWL'¨⍳3)[⍞⍳⍨c←'rps';i←?3]

Вывод 'T', 'W' и 'L' для ничьей, победы и поражения.

Образец прогона:

      c[i],(⌽↑⌽∘'TWL'¨⍳3)[⍞⍳⍨c←'rps';i←?3]
p    
rW

(Пользователь печатает «p» для бумаги. Компьютер выбирает «r» (рок), пользователь выигрывает)

Объяснение:

• ⌽↑⌽∘'TWL'¨⍳3: генерирует следующую матрицу:

TLW
WTL
LWT

• ⍞⍳⍨c←'rps': установите cв строку 'rps', прочитайте ввод пользователя и получите индекс ввода пользователя в строке (это будет значение от 1 до 3). Этот индекс используется в качестве координаты Y в матрице.
• i←?3: получить случайное число от 1 до 3 и сохранить его i, это выбор компьютера. Это используется как координата X в матрице.
• c[i]: использовать iв качестве индекса c, отображая выбор компьютера как «r», «p» или «s».

ferNANDo 1184 байта (259 в гольфе)

Переводчик, написанный на Python, можно найти внизу связанной страницы.

ferNANDo - это эзотерический язык, который поддерживает только один тип переменной - логическое значение и только одну операцию - NAND. Как вы можете себе представить, это может привести к довольно длинной логике для выполнения, казалось бы, простых задач. Он поддерживает чтение из stdin (по одному байту за раз), запись в stdout (также по одному байту за раз), условные циклы, а также случайный логический генератор.

Там нет ключевых слов вообще; все переменное. Функция оператора определяется исключительно количеством переменных, которые в нем содержатся. Там также нет комментариев, поэтому я сделал все возможное, чтобы код сам комментировал. Последние четыре строки могут быть немного запутанным, но это, вероятно , достаточно сказать , что он печатает Win!, Loseили в Drawзависимости от результата.

not sure, but right now i'm guessing you're_not_paper you're_scissors
you're_paper not you're_not_paper
you're_not_scissors not you're_scissors
you're_rock you're_not_paper you're_not_scissors
you're_rock you're_rock

o_shi-
i'm_not_paper right ?
i'm_scissors right ?
i'm_paper not i'm_not_paper
i'm_not_scissors not i'm_scissors
o_shi- i'm_paper i'm_scissors
o_shi- o_shi-
o_shi-
i'm_rock i'm_not_paper i'm_not_scissors
i'm_rock i'm_rock

print right now but only if i'm_not_paper i'm_scissors
print a newline here, not more, not less

i_win_if i'm_scissors you're_paper
or_if i'm_rock you're_scissors
or_even_if i'm_paper you're_rock

i_win i_win_if or_if
i_win i_win
i_win or_even_if

i_lose_if i'm_paper you're_scissors
or_if i'm_scissors you're_rock
or_even_if i'm_rock you're_paper

i_lose i_lose_if or_if
i_lose i_lose
i_lose or_even_if

i_don't_win not i_win
i_don't_lose not i_lose
we_tie i_don't_win i_don't_lose
we_tie we_tie
we_don't_tie not we_tie

print now if i_win i_lose not i_win i_win
print but not we_tie we_don't_tie i_lose i_don't_win we_don't_tie
print right now i_lose i_win i_win we_don't_tie i_don't_win
print i_don't_win but we_tie or i_don't_win we_tie now

Сценарий может быть запущен в интерактивном режиме, набрав ваш ход, а затем Enter.

Пример использования (при условии, что вы назвали переводчика nand.py):

$ python nand.py rps.nand
p
s
Win!

$ python nand.py rps.nand
r
r
Draw

$ python nand.py rps.nand
s
p
Lose

Редактировать: просто чтобы доказать, что ferNANDo может конкурировать с Java, вот «версия для гольфа» с 259 байтами . Логика заметно отличается; он проверяет not winи not tie, что сохраняет несколько ворот NAND (потому что тогда мне нужны только notверсии ходов игрока, и потому что они not loseне требуются для вывода). Не так интересно читать, хотя.

1 _ _ _ _ _ _ A b
B 1 b
C A B
o
P 1 ?
s 1 ?
p 1 P
S 1 s
o p s
o o
o
r P S
r r
0 1 1 1 0 0 P s
0 0 0 0 1 0 1 0
t s A
u r B
v p C
W t u
W W
W v
t p A
u s B
v r C
D t u
D D
D v
w 1 W
d 1 D
l W D
l l
0 1 0 w l 1 w w
0 1 1 d D l W D
0 1 1 l w w D W
0 W 1 d 0 W d 1

Python 3.x: 74 символа

import time
A,f="psr",time.gmtime()[5]%3
print(A[(A.find(input())+f)%3],f)

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

Before Machine Proceeds it determines the outcome of the game and based 
on the outcome, it determines the choice which would result in the outcome
viz Human's choice


\     Outcome
 \    0  1  2
  \_____________
H  | 
U 0|  0  1  2
M 1|  1  2  0
A 2|  2  0  1
N  |

Where Choices are represented as 
0 --> Paper
1 --> Scissor
2 --> Rock

Outcome (From Computer's Perspective)
0 --> Draw
1 --> Win
2 --> Fail

Given the sequence of choices as a string
"psr"
So its easy to see, if computer needs to win, it needs to choose the character
next to what human chooses. 
If computer needs to loose, it needs to choose the previous character to what
human chooses


MACHINE's|      CHOICES    |  Formulation
FATE     |-----------------|  For Machine's
         |  P     S      R |  Choice
---------|-----------------|-----------------------------
WIN(1)   |        H ---> M | (CHOICE+1) % 3 = (CHOICE+WIN)%3 
---------|-----------------|-----------------------------
LOSS(2)  |  M     H -----\ | (CHOICE+2)%3   = (CHOICE+LOSS)%3 
         |  ^            | |
         |  |____________| |
---------|-----------------|------------------------------       
DRAW(0)  |        H        | (CHOICE+0)%3   = (CHOICE+DRAW)%3
         |        M        |  
---------|-----------------|         

Combining all the above we have

MACHINE's CHOICE = (HUMAN CHOICE + MACHINE's FATE) % 3

Исходя из судьбы, он определяет, какой выбор должен быть основан на формуле

result = (User_choice + machines_fate) % no_of_choices

machine_choice = "psr"[result]

Версия без гольфа

import time
choices = "psr"
#time.gmtime() returns the time structure in gmt
#time.gmtime()[5] is the current second tick
fate = time.gmtime()[5]%3
user_choice = input()
result = (choices.find(user_choice)+fate)%len(choices)
machine_choice = choices[result]
print(machine_choice, fate)

Пробный прогон

D:\temp\rivalry>rps.py
r
r 0

D:\temp\rivalry>rps.py
r
p 1

D:\temp\rivalry>rps.py
p
r 2

D:\temp\rivalry>rps.py
p
r 2

D:\temp\rivalry>rps.py
p
s 1

D:\temp\rivalry>rps.py
p
s 1

D:\temp\rivalry>rps.py
p
p 0

Луа, 87

c,n=os.time()%3+1,'rps'print(n:sub(c,c),({'Draw','Win','Defeat'})[(n:find(...)-c)%3+1])

Использование:

$ lua rps.lua p
s   Defeat

Ungolfed:

names = 'rps'
comp_idx = os.time()%3 + 1                -- 1, 2 or 3 (depends on timer)
comp_move = names:sub(comp_idx, comp_idx) -- 'r', 'p' or 's'
user_move = ...                           -- input parameter: 'r', 'p' or 's'
user_idx = names:find(user_move)          -- 1, 2 or 3
delta_idx = (user_idx - comp_idx) % 3     -- 0, 1 or 2
all_results = {'Draw', 'Win', 'Defeat'}   -- [1]=='Draw', [2]=='Win', [3]=='Defeat'
game_result = all_results[delta_idx + 1]
print(comp_move, game_result)

GolfScript 62

Альтернативное решение GolfScript, гораздо более скучное, чем у Говарда :).

Программа выбирает случайный ход и отображает результат с точки зрения пользователя.

Код

'rssppr'.[6rand=]''+:§@+..&,({?)§\'Lose''Win'if}{;;§'Draw'}if`

Пробный прогон

> эхо с | ruby golfscript.rb rps.gs

г «потерять»

Онлайн тест

Вы можете запустить программу и поэкспериментировать с различными входными данными здесь: http://golfscript.apphb.com/?c=OydzJwoKJ3Jzc3BwcicuWzZyYW5kPV0nJys6wqdAKy4uJiwoez8pwqdcJ0xvc2UnJ1dpbidpZn3PxP3P3PF

Обратите внимание, однако, что параметр (перемещение пользователя), который обычно передается в командной строке, теперь добавляется в стек в самом коде (нет способа предоставить «реальные» параметры командной строки в этом онлайн-инструменте).

Версия "Ungolfed"

Я не имею ни малейшего представления о том, что означает ungolfed, когда дело доходит до GolfScript, поэтому я попытался добавить комментарии. Надеюсь, это прояснит работу кода и сделает его более читабельным:

# initially, the input (user's move) is on the stack

'rssppr'                # push the string 'rsspr' on the stack...
.                       # ...twice.

[
    6rand               # get a pseudo-random integer in the [0-5] range
    =                   # use the random index to get 
                        # a letter from the string above

]''+                    # workaroud to get the actual letter instead of the
                        # ASCII code

:§                      # assign the randomly chosen letter (computer's move)
                        # to a nice variable called "§"

@                       # rotates last 3 elements on the stack, bringing
                        # the user input in the uppermost position
                        # So, now we have: "rssppr" <computer_move> <user_move>
                        # on the stack

+                       # concatenate the two moves, so now we have a string
                        # that contains both (ex: "rs")

..                      # copy the move string twice
&                       # do a setwise AND to get the DISTINCT elements
,(                      # get the length of the resulting string and subtract 1
                        # (now we have 0 if the letters were equal and non-zero otherwise)

{                       # beginning of block to execute when the moves are different:

                        # now we have on the stack two strings:
                        #     - the string 'rssppr'
                        #     - the string containing the moves (ex: 'rs')

    ?                   # find the second string inside the first one,
                        # and get the index at which it occurs
                        # (or -1 if it does not)

    )                   # increment that number (we now get 0 if no occurrence, 1 otherwise)

    §                   # recall the § variable (so we display the computermove)
    \                   # rotate the uppermost two stack entries

    'Lose''Win'if       # if the move pair is found in the 'rssppr' string, 
                        # then print 'Lose', otherwise print 'Win'
}

{                       # beginning of block to execute when the moves are identical:

    ;;                  # discard the latest two stack items (not needed in this case)
    §                   # display computer's move
    'Draw'              # display the text 'Draw'
}
if                      # if computer's and user's moves were NOT equal, 
                        # execute the first block.
                        # if they were, execute the second block

`                       # put the last word in quotes to separate it from computer's move

C 92 86 символов

main(y){
    srand(time(0));
    y="rps"[rand()%3];
    printf("%c%c\n",y,"LWWTLLW"[getchar()-y+3]);
}

Печатает выбор компьютера и результат с точки зрения пользователя - W = вы выиграли, L = вы проиграли, T = ничья.
Простая формула x-y, учитывая значения ASCII выбора, дает 0 при ничьей (очевидно) и уникальное значение в каждом другом случае.

Питон 2 ( 86 84 80 78), Python 3 - 76 символов

0 - ничья, 1 - поражение, 2 - победа

from random import*
a=raw_input()
b=choice('psr')
print(a!=b)+(b+a in'rpsr'),b

from random import*
a=input()
b=choice('psr')
print((a!=b)+(b+a in'rpsr'),b)

Ungolfed

from random import*
moves = 'psr'
inp   = raw_input()
comp  = choice(moves)
match = comp+inp
is_not_tie = inp!=comp
wins = 'r' + moves         #rpsr; rock beats scissors, scissors beats paper, paper beats rock
print is_not_tie + (match in wins), comp

Как запустить: python file_name_here.py

Задачи:
компьютер AI: 35 символов

Сначала попробуйте без рассмотрения других.

гольф: 107 85 байт

i=prompt(),c="rps"[new Date%3],w={r:"s",p:"r",s:"p"};alert(c+(i==w[c]?2:w[i]==c?1:3))

вывод [выбор NPC] [1: победа, 2: проигрыш, 3: ничья]

ungolfed:

var input = prompt(),
    choices = ["r","p","s"],
    computer_choice = choices[Math.floor(Math.random() * 3)],
    outcomes = {'r':'s','p':'r','s':'p'},
    winner;

    if( input == outcomes[computer_choice] ) {
        winner = 'NPC';
    } else if ( computer_choice == outcomes[input] ) {
        winner = 'You';
    } else {
        winner = 'No one, it was a Tie!';
    }

    alert('Computer chose: ' + computer_choice + '\n' +
          'The winner is: ' + winner);

PowerShell: 144 133 117 111 92 73

Отличия от оригинала:

• Полностью переписал скрипт после просмотра четное или нечетное решение Данко Дурбика для трех игроков .
• Изменено $ s на одну строку вместо символьного массива.
• Использовал IndexOf в качестве прямого метода для $ s, вместо того, чтобы указывать класс .NET и метод.
• Удалены лишние %3с.

В общем, чуть ли не разрезать длину пополам от моего первоначального ответа!

Гольф-код:

$p=($s='rps').IndexOf((read-host));$s[($c=Random 3)];"TWLLTWWLT"[$p+$c*3]

Можно запустить прямо с консоли.

Ungolfed, с комментариями:

# Variable $p will store the player's selection as a ternary digit by finding its position in a string containing the possible choices.
$p=(
    # Possible choices will be stored in a variable, $s, for later reuse.
    $s='rps'
# Get the position of the player's choice from $s.
).IndexOf((read-host));

# Express the computer's choice by outputting the appropriate character from $s.
$s[(
    # Computer's choice will be stored as a ternary digit in $c.
    $c=Random 3
)];

# Outcome for the player will be chosen from a string of possible outcomes by looking up the decimal repesentation of a two-digit ternary number.
# The threes digit is represented by $c, ones digit by $p.
"TWLLTWWLT"[$p+$c*3]

# Variable cleanup - do not include in golfed code.
rv p,s,c

Некоторые примеры запускаются на консоли:

JAVA 259 :(

class c {public static void main(String[]a){char y=a[0].charAt(0);char m="rps".charAt(new java.util.Random().nextInt(3));if(y==m)a[0]="T";else if((y=='r'&& m=='s')||(y=='s'&& m=='p')||(y=='p'&& m=='r'))a[0]="1";else a[0]="0";System.out.println(m+":"+a[0]);}}

Весьма негольфированный код:

class c {
    public static void main(String[] a) {
        char y = a[0].charAt(0);
        char m = "rps".charAt(new java.util.Random().nextInt(3));
        if (y == m) {
            a[0] = "T";
        } else if ((y == 'r' && m == 's') || (y == 's' && m == 'p') || (y == 'p' && m == 'r')) {
            a[0] = "1";
        } else {
            a[0] = "0";
        }
        System.out.println(m + ":" + a[0]);
    }
}

Образцы прогонов:

C:> Java Cr

S: 1

C:> Java Cp

р: Т

C:> Java CS

с: T

Befunge: 107 символов

~v@,"w"<   <   <  <
v?v3.14159265@,"l"<
"""358979323846>3-|
rps26433832>:1+|
"""7950>:2+|
>>>:,-:|
28@,"t"<

Немного неуклюжий Это сокращается, вопрос в том, насколько.

JavaScript (87)

Golfed:

o='LDW'[2*((a=prompt())+(b='prs'[new Date%3])!='ps'&a<b|a+b=='sp')+ +(a==b)];alert(b+o)

Ungolfed:

var player = prompt(), 
    computer = 'prs'[new Date%3], // Date mod 3 "pseudo-random"
    outcome = 'LDW'[2*(player+computer != 'ps' 
                    & player < computer 
                    | player + computer == 'sp') // convert boolean W/L outcome to int (0,2)
              +
              +(player == computer)]; // convert D outcome to int (0,1)
alert(computer + outcome);

Вы можете просто вставить код в консоль JavaScript вашего браузера, чтобы запустить его.

Если мне разрешено распечатать результат перед печатью компьютера (83) :

alert('LDW'[2*((a=prompt())+(b='prs'[new Date%3])!='ps'&a<b|a+b=='sp')+ +(a==b)]+b)

К, 67

{-1'f:x,*1?"rps";$[f in b:("pr";"rs";"sp");"W";f in|:'b;"L";"D"]}

Печатает W, L, D для победы / поражения / ничьей.

Ungolfed:

rps:{[x]
    res:x,*1?"rps";        // join user input to random selection of r,p,s
    -1'f;                  // print the user input and the program selection to stdout
    wins:("pr";"rs";"sp"); // the universe of winning combinations
    losses:|:'wins;        // reverse each win to the get losses

    $[f in wins;    
        "win";
    f in losses;
        "lose";
    "draw"]
    }

Или в Q, который более читабелен:

rps:{[x]
    res:x,rand["rps"];        // join user input to random selection of r,p,s
    -1 each f;                // print the user input and the program selection to stdout
    wins:("pr";"rs";"sp");    // the universe of winning combinations
    losses:reverse each wins; // reverse each win to the get losses

    $[f in wins;    
        "win";
    f in losses;
        "lose";
    "draw"]
    }

Пробный прогон:

k){-1'f:x,*1?"rps";$[f in b:("pr";"rs";"sp");"W";f in|:'b;"L";"D"]}"r"
r
s
"W"
k){-1'f:x,*1?"rps";$[f in b:("pr";"rs";"sp");"W";f in|:'b;"L";"D"]}"s"
s
s
"D"
k){-1'f:x,*1?"rps";$[f in b:("pr";"rs";"sp");"W";f in|:'b;"L";"D"]}"p"
p
s
"L"

Javascript, 117 знаков

Вот управляемый данными подход к проблеме. Вероятно, это можно оптимизировать, генерируя данные выигрыша / проигрыша / розыгрыша, а не отображая их вручную, но это только начало :)

Golfed:

alert((r=[{v:"r",r:d="D",p:w="W",s:l="L"},{v:"p",r:l,p:d,s:w},{v:"s",r:w,p:l,s:d}][Math.random()*3|0]).v+r[prompt()])

Ungolfed:

//Output the result to the user
alert(
    (
        //Store the random computer outcome data
        randomRPSData =
            //Create the data for if the computer chooses r, p, or s
            [
                {
                    value: "r",
                    r: (d = "Draw"),
                    p: (w = "Win"),
                    s: (l = "Lose")},
                {
                    value: "p",
                    r: l,
                    p: d,
                    s: w},
                {
                    value: "s",
                    r: w,
                    p: l,
                    s: d}
            ]
            //Have the computer pick a random variable
            [Math.random() * 3 | 0]

    //Output the value the computer chose
    ).value

    //Output whether the user won or not
    + r[prompt()]
);

Наконец, вот скрипка с обоими.

Javascript: 256

golfed:

i=prompt(),a=['p','r','s'];a=a[Math.floor(Math.random()*(3-1+1))+1];if(i==a){alert('d');}else if(i=='p'){if(a=='s'){alert('l');}else{alert('w');}}else if(i=='r'){if(a=='s'){alert('w');}else{alert('l');}}else if(i=='s'){if(a=='r'){alert('l');}else{alert('w')}}

ungolfed:

i=prompt(),a=['p','r','s'];
a=a[Math.floor(Math.random()*(3-1+1))+1];
if(i==a){
    alert('d');
}
else if(i=='p'){
    if(a=='s'){
        alert('l');
    }else{alert('w');}
}else if(i=='r'){
    if(a=='s'){
        alert('w');
    }else{alert('l');}
}else if(i=='s'){
    if(a=='r'){
        alert('l');
    }else{alert('w')}
} 

Clojure:

(def r 0) (def s 1) (def p 2)
(def object-name #(get {'p "Paper", 's "Scissors", 'r "Rock"} %))
(def result-name #(get {\d "Draw", \w "Win", \l "Lose"} %))
(defn computer-choice [] (nth ['r 's 'p] (int (rand 3))))
(defn game [a b] (get "dwlldwwld" (+ (* 3 a) b) ))
(defn print-game [user comp result] (print (format
  "User: %s\nComputer: %s\nResult: %s\n" 
  (object-name user) (object-name comp) (result-name result))))
(println "Enter 'p', 's' or 'r' and press return")
(let [comp (computer-choice),  user (read)]  (print-game user comp (game (eval user) (eval comp))))

Мини-версия (129 кодовых символов):

java -jar clojure.jar -e \
"(def r 0)(def s 1)(def p 2)(let[u(read),c(nth['r 's 'p](int(rand 3)))](print c)(print (get \"dwlldwwld\"(+(* 3(eval u))(eval c)))))"

Ява (387) первый код гольф!

import java.util.HashMap;public class _ {public static void main(String i[]){HashMap l = new HashMap(){{put('r',0);put('p',1);put('s',2);put(0,'T');put(1,'L');put(2,'W');}};char u =i[0].charAt(0);char c ="rps".charAt((int)(Math.random()*3)%3);int[][] m =new int[][]{{0,1,2},{2,0,1},{1,2,0}};System.out.println("U"+u+"C"+c+"R"+(Character)l.get(m[(Integer)l.get(u)][(Integer)l.get(c)]));}}

Ungolfed

import java.util.HashMap;
public class _ {
    public static void main(String[] input) {
       input = new String[] {"s"};
       HashMap lookup = new HashMap(){{
           put('r', 0);
           put('p', 1);
           put('s', 2);
           put(0, 'T');
           put(1, 'L');
           put(2, 'W');
       }};
       char user = input[0].charAt(0);
       char computer = new char[] {'r', 'p', 's'}[(int)(Math.random()*3)%3];
       int[][] matrix = new int[][] {{0,1,2}, {2,0,1}, {1,2,0}};

       Integer userChoice = (Integer) lookup.get(user);
       Integer computerChoice = (Integer) lookup.get(computer);
       Character result = (Character) lookup.get(matrix[userChoice][computerChoice]);

       System.out.println("u:" + user + ",c:" + computer + ",r:" + result);
    }
    /*
     t = 0, l = 1, w = 2
     *
        +---------------+
        | * | r | p | s |
        +---------------+
        | r | 0 | 1 | 2 |
        +---------------+
        | p | 2 | 0 | 1 |
        +---------------+
        | s | 1 | 2 | 0 |
        +---------------+
     */
}

Гольф (расстояние / отступ)

import java.util.HashMap;
public class _ {
public static void main(String i[]) {
    HashMap l = new HashMap(){{
        put('r',0);put('p',1);put('s',2);put(0,'T');put(1,'L');put(2,'W');
    }};

    char u =i[0].charAt(0);char c = "rps".charAt((int)(Math.random()*3)%3);
    int[][] m =new int[][]{{0,1,2},{2,0,1},{1,2,0}};

    System.out.println("U"+u+"C"+c+"R:"+(Character)l.get(m[(Integer)l.get(u)][(Integer)l.get(c)]));
}}

_{Не самый короткий код, но моя первая попытка}

Go (169)

Гольф:

package main
import("fmt";"os")
func main(){v:=map[uint8]int{114:0,112:1,115:2}
u:=os.Args[1][0]
c:="rps"[os.Getpid()%3]
fmt.Printf("%c\n%c\n",c,"TWL"[(3+v[c]-v[u])%3])}

Ungolfed (в формате go fmt):

package main

import (
    "fmt"
    "os"
)

func main() {
    v := map[uint8]int{114: 0, 112: 1, 115: 2}
    u := os.Args[1][0]
    c := "rps"[os.Getpid()%3]
    fmt.Printf("%c\n%c\n", c, "TWL"[(3+v[c]-v[u])%3])
}

Бег :

иди беги main.go p

s

W

Пиф , 23

J"rps"K+wOJK%-XJ'KXJtK3

Вывод в виде:

Tie: 0 Win: 1 Loss: 2

Объяснение:

J"rps"             J="rps"
K+wOJ              K=input()+random_choice(J)
K                  print K
  XJ'K             index of K[0] in J
      XJtK         index of K[1] in J
 -XJ'KXJtK         difference of above indexes
%-XJ'KXJtK3        above difference mod 3

Запустите следующим образом:

$ cat rps
J"rps"K+wOJK%-XJ'KXJtK3
s
$ cat rps | python3 pyth.py
< Extraneous debug output removed>
sp
1

Только для еще 4 символов мы можем использовать T для ничьей, W для победы и L для проигрыша:

J"rps"K+wOJKr@"TWL"-XJ'KXJtK

Все одинаково до разницы индексов, и в этот момент мы используем разность в качестве индекса в строке "TWL".

Примечание. Несмотря на то, что я разработал этот язык после публикации заявки, я не видел ее до сегодняшнего дня. Задача не повлияла ни на один аспект языка.

Groovy, 89

v='rps'
r=new Random().nextInt(3)
print"${v[r]}${'TLW'[((r-v.indexOf(this.args[0]))%3)]}"

Принимает выбор пользователя в качестве аргумента. Пример:

groovy rps.groovy p
sL

C # & LinqPad 133

golfed:

char i,c,r;i=Console.ReadLine()[0];var a="prsp";c="prs"[new Random().Next(3)];r=i==c?'T':a.Contains(""+i+c)?'W':'L';(c+">"+r).Dump();

ungolfed:

        char i, c, r; // i for input / c for choosen by computer / r for result
        i = Console.ReadLine()[0]; //getting input in LinqPad
        var a = "prsp"; 
        c = "prs"[new Random().Next(3)]; // Computer choose a random string
        r = i == c ? 'T' : a.Contains("" + i + c) ? 'W' : 'L'; (c + ">" + r).Dump(); //check for win - dump for output in LinqPad

Пример вывода (входные данные были s): r> L // Компьютер выбирает рок (r) -> поэтому мы проиграли

JavaScript (79)

Натыкаясь на старый, но здесь мы идем ...

С дополнительным бонусом вы можете использовать любую понравившуюся вам скалу - пегнатит, пироксенит, скорию, совит, кимберлит, тронджемит, туф или любую другую. Единственным ограничением является то, что вы не можете использовать pили s ;-)

Входные данные:

r = rock      (Or , ...)
p = paper
s = scissors

Выход:

[computers choice][0=Loss, 1=Win, 2=Draw]

Пример:

User  Computer  Result
r     r         r2
r     p         p0
r     s         s1

Гольф-код:

u=~~{p:1,s:2}[prompt()],c=new Date%3;alert('rps'[c]+(u==c?2:!u&c>1|u&!c|u>1&c))

Основные используемые приемы:

1. u = ~~{}[prompt()]

       Использование объекта {}и получение значения с помощью пользовательского ввода из prompt(). Все идет нормально. Тогда вместо того, чтобы иметь его, r : 0мы можем принудительно преобразовать его 0с помощью ~~оператора NOT. Он часто используется для номеров этажей, но также имеет (преимущество) в том, что не возвращает, NaNкогда другие операторы хотели бы, например:+{a:1, b:2}['c'] .

2. c = new Date%3

       С датой часто обманывают, например, используя +new Dateдля непосредственного преобразования ее в метку времени, иначе можно получить строковое представление. Здесь, используя мод, можно достичь того же эффекта.

3. 'rps'[c]

       Индексированный доступ к строке, предоставляющий компьютерам выбор 0 = r, 1 = pили 2 = s.

4. (u==c ? 2 : !u&c>1 | u&!c | u>1&c )

   IF  u == c
       Draw                    (aka 2)
   ELSE IF !u&c>1|u&!c|u>1&c 
       Win                     (aka 1)
   ELSE
       Loss                    (aka 0)
   ENDIF


...

Код ungolfed может быть примерно таким:

function rock_paper_scissors() {
    var choices = {
            r : 0,
            p : 1,
            s : 2,
        },
        tr_table = ['Rock','Paper','Scissors'],
        user, pc, result
    ;

    function get_input() {
        var input = prompt("Enter your choice `r', `p' or `s':")
                    .toLowerCase();

        if (!/^[rps]/.test(input)) {
            console.warn("Bad input. Please choose `r', `p' or `s'.");
            // return get_input();
            return null;
        }
        return input[0];
    }
    function report(c1, c2) {
        if (c1 === pc) {
            return 'Draw';
        } else if (
            (c1 === 0 && c2  >  1) ||
            (c2 === 0 && c1 === 1) ||
            (c1  >  1 && c2  >  0)
        ) {
            return 'Win';
        } else {
            return 'Loss';
        }
    }

    if ((user = get_input())) {
        user = choices[user];
        pc = Math.floor(Math.random() * 3);
        result  = 
            'Computers choice: ' + tr_table[pc] + ', ' +
            'Your choice: ' + tr_table[user] + ', ' +
            'Result=' +  report(user, pc);
        console.log(result);
    }
    return result;
}

rock_paper_scissors();

Гольфскрипт - 29

Это актуальный ответ на этот раз (глядя на вас n"Draw": P).

'rps'.@\?3rand.@- 3%@@[=]''+\

Ungolfed:

'rps'3rand[=]''+.2$={\;'
T'}{.@'rspr'.@?@@(;\?='
L''
W'if=}if

Вы можете запустить его ruby golfscript.rb MyCode.txt, где MyCode.txtнаходится код программы.

Пробные прогоны (все с вводом «r», но все работает) (ничья 0, победа 2, проигрыш 1):

ruby golfscript.rb MyCode.txt
r0
ruby golfscript.rb MyCode.txt
p2
ruby golfscript.rb MyCode.txt
s1

Если вам нужно объяснение какой-либо версии и / или вы видите потенциальное улучшение, скажите мне.

Javascript, 65 71 70

Без выбора компьютера: 65

alert('-+0+0+0'['rppssrr'.indexOf('rps'[new Date%3]+prompt())+1])

Просто чтобы проверить это решение правильно:

for(x in {r:0,p:0,s:0})
  for(y in {r:0,p:0,s:0})
    console.log("%s %s %s", x, y, '-+0+0+0'['rppssrr'.indexOf(x+y)+1])

С выходом выбора компьютера: 71

alert((c='rps'[new Date%3])+'-+0+0+0'['rppssrr'.indexOf(c+prompt())+1])

70

alert((g='rps'[new Date%3]+prompt())+-('srps'.match(g)?-1:g[0]!=g[1]))

и тест:

for(x in {r:0,p:0,s:0})
  for(y in {r:0,p:0,s:0})
    console.log((g=x+y)+-('srps'.match(g)?-1:g[0]!=g[1]))