Реалізуйте класичні ножиці з паперової папери.

Умови:

• користувач введе 'r', 'p' або 's'
• програма виведе 'r', 'p' або 's' і результат
• вибір програми ('r', 'p' або 's') повинен бути псевдо випадковим ( я дивлюся на вас Говард )
• Результат може бути представлений будь-яким символом для друку, завжди має бути три можливі результати для того, що користувач має вклад (користувач виграє, програє або зрівняється).
• що станеться, якщо користувач нічого не вводить, або щось інше, що 'r', 'p' або 's' не має значення.

Тобі потрібно:

• Надайте код для гольфу.
• Невикористаний код
• Як викликати програму
• Вибірка зразка

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

Хороший гольф і удача коли-небудь на вашу користь.

Я буду розміщувати відповідь на самому собі, на Java.

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

r = скеля

p = папір

s = ножиці

рок: виграє до ножиць, програє з папером, краватка зі скелею.

папір: виграє до гойдання, програє ножицями, краватка з папером.

ножиці: виграє на папері, програє з каменем, краватка ножицями.

Поточні позиції:

• ООН: Ім'я користувача
• PL: Мова програмування
• СК: кількість символів
• УФ: Підвищення голосів

╔══════════════════╦════════════╦══════╦════╗
║        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 ║
╚══════════════════╩════════════╩══════╩════╝

Я не можу вибрати відповідь Говарда, оскільки це була (успішна) спроба згинати правила, але я змінюю їх, щоб зробити їх явнішими.

відповідь символу primo 27 не може бути обрана, оскільки сама по собі не є псевдо випадковою

відповідь 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

Користувач вибирає рок, програма вибирає папір: програш

ЛОЛКОД, 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.

Ruby: 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) → число - "Якщо викликається без аргументу, або якщо max.to_i.abs == 0rand повертає псевдовипадкове число з плаваючою точкою між 0,0 і 1,0, включаючи 0,0 і без 1,0".
• String.index (substring [, зсув]) → fixnum або nil - "Повертає індекс першого появи даної підрядки або шаблону (regexp) у str ."

Безголівки:

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 символів)

Моя сама перша спроба в гольфі.

Гольф

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

Без гольфу

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. $%(номер сторінки формату) використовується для зберігання ходу комп'ютера, оскільки він може містити лише ціле значення, яке зберігає цілий склад.

Безголівки:

# 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

Безголівки:

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`

Вибірка зразка

> echo s | ruby golfscript.rb rps.gs

r "програш"

Інтернет-тест

Ви можете запустити програму і експериментувати з різними входами тут: http://golfscript.apphb.com/?c=OydzJwoKJ3Jzc3BwcicuWzZyYW5kPV0nJys6wqdAKy4uJiwoez8pwqdcJ0xvc2UnJ1dpbidpZn17OzvCpydEcmF3J31pZmA%3D

Однак зауважте, що параметр (переміщення користувача), який зазвичай передається в командному рядку, тепер додається до стеку в самому коді (у цьому інтернет-інструменті немає можливості надати "реальні" параметри командного рядка).

"Негольова" версія

Я навіть не маю уявлення, що означає neololfed, коли мова йде про 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), Пітон 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)

Безумовно

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: нічия]

неозорений:

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 класу та методу.
• Видалено зайві %3s.

Все сказане, майже скоротити довжину навпіл від моєї оригінальної відповіді!

Код для гольфу:

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

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

Безголовка, з коментарями:

# 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

s: T

Befunge: 107 символів

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

Трохи незграбний. Це скорочується, питання в тому, на скільки.

JavaScript (87)

Гольф:

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

Безголівки:

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 для виграшу / програшу / нічиї.

Безголівки:

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 символів

Ось керований даними підхід до проблеми. Можливо, це можна оптимізувати, генеруючи дані виграш / програш / нічия замість відображення їх вручну, але це початок :)

Гольф:

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

Безголівки:

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

гольф:

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

неозорений:

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

JAVA (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)]));}}

Безумовно

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

_{Не найкоротший код, але моя перша спроба}

Перейти (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 стор

с

W

Піта , 23

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

Вихід у формі:

Краватка: 0 Перемога: 1 Втрата: 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".

Примітка. Хоча я розробляв цю мову після публікації виклику, я не бачив цього виклику до сьогодні. Виклик не вплинув на жоден аспект мови.

Гровий, 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

гольф:

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();

неозорений:

        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 // Комп'ютер вибирає rock (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для перетворення безпосередньо її в часову марку, інакше можна отримати строкове подання. Тут, використовуючи mod, можна досягти такого ж ефекту.

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


...

Невикольований код може бути приблизно таким:

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%@@[=]''+\

Безголівки:

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