实施经典的剪刀石头布。

条件：

• 用户将输入“ r”，“ p”或“ s”
• 程序将输出“ r”，“ p”或“ s”以及结果
• 程序选择（“ r”，“ p”或“ s”）必须是伪随机的（我在看你霍华德）
• 结果可以用任何可打印的字符表示，对于用户输入的内容（用户赢，输或平局），应始终存在三个可能的结果。
• 如果用户不输入任何内容，或者与“ r”，“ p”或“ s”不同的内容不重要，将会发生什么。

你需要：

• 提供打高尔夫球的代码。
• 取消编码
• 您如何调用程序
• 样品运行

如果平局显示投票最多的答案，我将选择字符较少的答案。

打高尔夫好运，可能永远都对你有利。

我将用Java发布自己的答案。

对于那些住在山下的人：

r =岩石

p =纸

s =剪刀

石头：胜于剪刀，不胜枚于纸，不胜枚举。

纸：胜于摇滚，用剪刀输，用纸扎。

剪刀：胜于纸张，不胜枚举，不胜枚举。

当前职位：

• 联合国：用户名
• PL：编程语言
• CC：字符数
• 紫外线：得票最多

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

我无法选择Howards答案，因为这是一次（成功）弯曲规则的尝试，但是我更改了规则以使其更加明确。

无法选择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

用户选择岩石，程序选择纸张：丢失

LOLCODE，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!

高尔夫脚本

n"Draw"

上面的代码实现了所需的功能。此外，它还可以确保玩家永远不会因为计算机策略的不公平而感到生气。

非高尔夫版本

n"Draw"

如何调用程序

必须在STD​​IN上提供输入（单个字符“ r”，“ p”，“ s”），并可能以换行符终止。

样品运行

> 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 == 0，则rand返回0.0到1.0之间的伪随机浮点数，包括0.0到1.0。”
• String.index（substring [，offset]）→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。$%（格式页号）用于存储计算机的移动，因为它可能仅包含一个整数值，从而节省了int类型转换。

取消高尔夫：

# 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

杀伤人员地雷（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
轻载

• ⍞⍳⍨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个字节的“ golfed”版本。逻辑明显不同；它检查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)

高尔夫脚本62

一个替代的GolfScript解决方案，比霍华德的 :) 更无聊。

该程序随机选择一个动作并从用户角度显示结果。

代码

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

样品运行

> echo s | 红宝石golfscript.rb rps.gs

r“丢失”

在线测试

您可以在此处运行该程序并尝试使用不同的输入：http : //golfscript.apphb.com/?c=OydzJwoKJ3Jzc3BwcicuWzZyYW5kPV0nJys6wqdAKy4uJiwoez8pwqdcJ0xvc2EJ1dpbidpZn17OzvCpyD

但是请注意，现在通常在命令行中传递的参数（用户移动）现在已添加到代码本身的堆栈中（此在线工具中无法提供“真实的”命令行参数）。

“ Ungolfed”版本

我不知道在谈到GolfScript时ungolf意味着什么，所以我尝试添加评论。希望这将阐明代码的工作方式，并使代码更具可读性：

# 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 =平手。给定选项的ASCII值
的简单公式x-y在绘制时给出0（很明显），而在其他情况下则给出唯一值。

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

不打高尔夫球

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-choice] [1：win，2：loss，3：tie]

松散：

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

与原始版本的不同：

• 在看到Danko Durbic的三人偶数或奇数解决方案后，完全重写了脚本。
• 将$ s更改为单个字符串，而不是字符数组。
• 使用IndexOf作为$ s上的直接方法，而不是拼出.NET类和方法。
• 删除了多余%3的。

总而言之，我的原始答案几乎缩短了一半！

高尔夫代码：

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

K，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])}

取消高尔夫（按格式化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

输出形式为：

并列：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"。

注意：虽然我在挑战发布后确实开发了这种语言，但直到今天我才看到挑战。挑战没有影响语言的任何方面。

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

打高尔夫球：

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我们可以不用NOT 强制0使用~~NOT运算符将其转换为。它经常被用来楼层号，而且还具有（优势）没有返回的NaN时候其他运营商一定会象例如：+{a:1, b:2}['c']。

2. c = new Date%3

       日期经常被欺骗，例如使用+new Date直接将其转换为时间戳，否则将获得字符串表示形式。在这里，通过使用mod 1可以达到相同的效果。

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

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