Implemente a tesoura de papel de pedra clássica.

Condições:

• o usuário inserirá 'r', 'p' ou 's'
• programa produzirá 'r', 'p' ou 's' e o resultado
• a escolha do programa ('r', 'p' ou 's') deve ser pseudo-aleatória ( estou olhando para você Howard )
• Como o resultado pode ser representado com qualquer caractere imprimível, sempre deve haver três resultados possíveis para o que o usuário inseriu (o usuário ganha, perde ou empata).
• o que acontece se o usuário não inserir nada, ou algo diferente de 'r', 'p' ou 's' não seja importante.

Você precisa:

• Forneça o código do golfe.
• O código não destruído
• Como você invoca o programa
• Uma amostra de execução

Vou escolher a resposta com menos caracteres, se um empate apresentar a resposta mais votada será escolhida.

Bom golfe e sorte pode estar sempre a seu favor.

Vou postar uma resposta em Java.

Para aqueles que vivem em uma montanha debaixo de uma rocha:

r = rock

p = papel

s = tesoura

pedra: ganha em tesoura, perde com papel, um empate com pedra.

papel: ganha a pedra, perde com tesoura, um empate com papel.

tesoura: ganha no papel, perde com pedra, um empate com tesoura.

Posições Atuais:

• UN: nome de usuário
• PL: Linguagem de Programação
• CC: contagem de caracteres
• UV: até votos

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

Não consigo selecionar a resposta de Howards, pois foi uma tentativa (bem-sucedida) de dobrar as regras, mas eu as altero para torná-las mais explícitas.

A resposta primo de 27 caracteres não pode ser selecionada porque não é pseudo-aleatória em si

resposta primo -p, vou usar "-p será contado como 3 bytes: um para o -, um para o pe mais um espaço em branco necessário".

Obrigado a todos que responderam, espero que você tenha se divertido!

OBSERVAÇÃO: tentarei editar isso a cada duas semanas, para ajustar a tabela e alterar minha resposta selecionada se alguém superar a atual, então, se você acabou de chegar aqui, poste sua resposta, se quiser!

APL, 31

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

x←'rps'Atribuir string 'rps'ax

(?3)⌷ Escolha um número inteiro aleatório 1 ~ 3, escolha esse índice de x

⍞, Anexar entrada do usuário à escolha da máquina

⎕← String resultante de saída

x⍳ Converta em matriz numérica por indexOf em x

-/ Diferença dos dois números

1+|3 Módulo 3 e mais 1

'TWL'[...] indexação de 'TWL'

Amostra

r
rp
L

Usuário escolhe rock, programa escolhe papel: Perca

LOLCODE, 1397

Nota: enviei isso antes de perceber que o requisito vencedor foi alterado de popularidade com tie-break de golfe para golfe com tie-break de popularidade.

Não há realmente nenhuma sintaxe estrita, mas tenho certeza de que isso é aceitável.

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

Se isso fosse executado com sucesso como RockPaperScissors.LOL , aqui estão alguns possíveis resultados aleatórios:

• Entrada: Rock- Saída:I GUESSED SCIZZORS U WONNED
• Entrada: Paper- Saída:I GUESSED PAPER NOWAI TIED
• Entrada: Scissors- Saída:I GUESSED ROCK LOL U LOZED
• Entrada: Tuna- Saída:WHAT U SAYZ? YOU BURNTED MAH TREAT!

GolfScript

n"Draw"

O código acima implementa a funcionalidade necessária. Além disso, garante que o jogador nunca fique com raiva por causa de uma injustiça (percebida) da estratégia do computador.

Versão ungolfed

n"Draw"

Como invocar o programa

A entrada (um único caractere de 'r', 'p', 's') deve ser fornecida no STDIN, possivelmente finalizada com nova linha.

Uma amostra de execução

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

Explicação do código

Para todos aqueles que não estão familiarizados com o GolfScript, adicionarei uma explicação detalhada de como esse código funciona. O código existe essencialmente de três partes.

### 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.

Notas

Como este não é um código de golfe, mas um concurso de popularidade, não escolhi a versão mais curta. Talvez em caso de empate, um código mais curto elimine minha solução. No entanto, para os interessados ​​em jogar golfe, são dadas as seguintes possibilidades:

• Lide apenas com a entrada adequada e force o usuário a fornecer uma nova linha. Isso salvará um caractere.
• As regras têm uma pequena insuficiência que permite salvar outro personagem dobrando as regras. O resultado sempre pode ser impresso como "Win" - não foi especificado que o resultado correto deve ser impresso. Mas observe que os jogadores logo ficarão com raiva se você optar por implementar um programa de trapaça.
• O formato de saída não está bem especificado. Podemos escolher 0como saída para empate. Portanto, o menor programa válido é o código de um caractere 0.

Ruby: 61 54 caracteres

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

De alguma forma, explicou:

Todo o problema é reduzido ao cálculo dos seguintes resultados:

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

Onde os números significam:

• escolha: 0 pedra, 1 papel, 2 tesouras
• resultado: 0 empate, 1 vitória, 2 derrotas

Para isso, usei a fórmula: machine_choice - human_choice. Ocasionalmente, isso resulta em valor negativo, mas como é usado apenas como índice e o índice negativo é contado para trás, o elemento de matriz correto será escolhido.

# ┌── 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

Métodos usados ​​(outros, então Fixnumos óbvios):

• Kernel.p (obj) → obj - “Para cada objeto, escreve diretamente obj . inspectseguido por uma nova linha na saída padrão do programa. ”
• Kernel.rand (max = 0) → número - "Se chamado sem argumento, ou se max.to_i.abs == 0, rand retorna um número de ponto flutuante pseudo-aleatório entre 0,0 e 1,0, incluindo 0,0 e excluindo 1,0".
• String.index (substring [, offset]) → fixnum ou nil - "Retorna o índice da primeira ocorrência da substring ou padrão especificado (regexp) em 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]

Exemplo de execução:

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

Minha primeira tentativa no golfe.

Golfe

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

Sem golfe

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

Execução de amostra O aplicativo requer entradas de caracteres únicas como argumento 1 para o aplicativo r, sou p.

cmd > app.exe r

Todos os resultados possíveis

• cmd > app.exe rdá saída r T(rock, tie)
• cmd > app.exe rproduz saída p L(papel, perdido)
• cmd > app.exe rdá saída s W(tesoura, vitória)
• cmd > app.exe pdá saída r W(rock, vitória)
• cmd > app.exe pdá saída p T(papel, gravata)
• cmd > app.exe pdá saída s L(tesoura, perdida)
• cmd > app.exe s dá saída r L (rocha, perdida)
• cmd > app.exe s dá saída p W (papel, vitória)
• cmd > app.exe sdá saída s T(tesoura, gravata)

Perl 48 bytes

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

O script imprime o resultado da perspectiva do computador; por exemplo, se o jogador escolhe re o computador escolhe s, o resultado é Lose. $%(formatar número da página) é usado para armazenar a movimentação do computador, pois pode conter apenas um valor inteiro, o que salva uma conversão 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];

Uso da amostra:

$ echo p | perl rps.pl
s
Win

$ echo r | perl rps.pl
r
Draw

$ echo s | perl rps.pl
p
Lose

O script também pode ser executado interativamente, digitando sua movimentação seguida por Enter:

$ perl rps.pl
r
s
Lose

Alongamento de Regras

Perl 35 +3 bytes

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

Requer a -popção de linha de comando (contada como 3 bytes). Cada um dos resultados Win, Losee Drawforam mapeados para W, L,D . A nova linha entre a escolha do computador e o resultado foi excluída.

Uso da amostra:

$ echo r | perl -p rps.pl
sL

Perl 30 +3 bytes

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

Mais uma vez requer -p. Aqui Win, Losee Drawforam mapeados para 2, 1e 0respectivamente. Isso ainda é tecnicamente compatível, pois são caracteres imprimíveis.

Uso da amostra:

$ echo r | perl -p rps.pl
s1

Perl 24 +3 bytes

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

Requer -p, WLD mapeado para 2, 1, 0como antes. Cada um ^Tdeve ser substituído por um caractere ascii literal 20. Este é reconhecidamente um pouco exagerado;$^Tretorna o número de segundos desde a época em que o script foi iniciado. Todos os resultados são possíveis, mas não se qualificam como pseudo-aleatórios.

Uso da amostra:

$ echo r | perl -p rps.pl
s1

APL ( 38 36)

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

Saídas 'T', 'W' e 'L' para empate, vitória e derrota.

Exemplo de execução:

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

(O usuário digita 'p' para papel. O computador escolhe 'r' (rock), o usuário vence)

Explicação:

• ⌽↑⌽∘'TWL'¨⍳3: gera a seguinte matriz:

TLW
WTL
LWT

• ⍞⍳⍨c←'rps': defina ca string 'rps', leia a entrada do usuário e obtenha o índice da entrada do usuário na string (este será um valor de 1 a 3). Este índice é usado como coordenada Y na matriz.
• i←?3: obtenha um número aleatório de 1 a 3 e armazene-o i, essa é a escolha do computador. Isso é usado como a coordenada X na matriz.
• c[i]: use icomo um índice para c, exibindo a opção do computador como 'r', 'p' ou 's'.

ferNANDo 1184 (259 golfed) bytes

Um intérprete escrito em Python pode ser encontrado na parte inferior da página vinculada.

ferNANDo é uma linguagem esotérica que suporta apenas um tipo de variável, booleano e apenas uma operação, NAND. Como você pode imaginar, isso pode levar a uma lógica bastante longa para realizar tarefas aparentemente simples. Ele suporta leitura de stdin (um byte de cada vez), gravação para stdout (também um byte de cada vez), loops condicionais e também um gerador booleano aleatório.

Não há palavras-chave; tudo é uma variável. A função de uma instrução é determinada apenas pelo número de variáveis ​​que ela contém. Também não há comentários, então eu fiz o meu melhor para tornar o código com comentários próprios. As últimas quatro linhas pode ser um pouco confuso, mas provavelmente será suficiente para dizer que ele imprime Win!, Loseou Drawdependendo do resultado.

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

O script pode ser executado interativamente, digitando sua movimentação seguida de Enter .

Exemplo de uso (assumindo que você nomeou o intérprete 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

Edit: Apenas para provar que o ferNANDo pode competir com Java, aqui está uma versão 'golfada' com 259 bytes . A lógica é visivelmente diferente; ele verifica not wine not tie, o que salva alguns portões NAND (porque então eu só preciso das notversões dos movimentos do jogador e porque not losenão era necessário para a saída). Não é tão interessante de ler, no entanto.

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 caracteres

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

Como funciona

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

Com base no destino, determina qual deve ser sua escolha com base na fórmula

result = (User_choice + machines_fate) % no_of_choices

machine_choice = "psr"[result]

Versão sem golfe

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)

Amostra de execução

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

Lua, 87

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

Uso:

$ 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

Uma solução alternativa do GolfScript, muito mais chata do que a de Howard :).

O programa escolhe um movimento aleatoriamente e exibe o resultado da perspectiva do usuário.

O código

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

Amostra de execução

> eco s | ruby golfscript.rb rps.gs

r "Perder"

Teste online

Você pode executar o programa e experimentar diferentes entradas aqui: http://golfscript.apphb.com/?c=OydzJwoKJ3Jzc3BwcicuWzZyYW5kPV0nJys6wqdAKy4uJiwoez8pwqdcJ0xvc2UnJ1dpbidpZd17Ocmv3D

Observe, no entanto, que o parâmetro (movimentação do usuário) que normalmente é passado na linha de comando agora é adicionado à pilha no próprio código (não há como fornecer parâmetros de linha de comando "reais" nesta ferramenta online).

Versão "Ungolfed"

Eu não tenho nenhuma idéia do que significa não destruído quando se trata de GolfScript, então tentei adicionar comentários. Esperamos que isso esclareça como o código funciona e o torne um pouco mais legível:

# 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 caracteres

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

Imprime a escolha do computador e o resultado do ponto de vista do usuário - W = você ganha, L = você perde, T = empate.
A fórmula simples x-y, dados os valores ASCII das opções, fornece 0 no empate (obviamente) e um valor único nos outros casos.

Python 2 ( 86 84 80 78), Python 3-76 caracteres

0 - empate, 1 - derrota, 2 - vitória

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

Como executar: python file_name_here.py

Problemas:
AI do computador: 35 caracteres

Primeiro tente sem revisar os outros.

golfe: 107 85 bytes

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

a saída é [npc-choice] [1: vitória, 2: perda, 3: empate]

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

Alterações do original:

• Reescreveu completamente o script depois de ver Reescreveu solução par ou ímpar para três jogadores de Danko Durbic .
• Alterou $ s para uma única sequência em vez de uma matriz de caracteres.
• Utilizou IndexOf como um método direto em $ s, em vez de especificar a classe e o método .NET.
• Removidos %3s redundantes .

Ao todo, quase cortamos o comprimento pela metade da minha resposta original!

Código de golfe:

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

Pode ser executado diretamente do console.

Ungolfed, com comentários:

# 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

Algumas amostras são executadas no console:

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

Código altamente não destruído:

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

Amostras de execuções:

C:> java cr

s: 1

C:> java cp

p: T

C:> Java cs

s: T

Befunge: 107 caracteres

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

Ligeiramente desajeitado. É encolhível, a questão é quanto.

JavaScript (87)

Golfe:

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

Você pode simplesmente colar o código no console javascript do seu navegador para executá-lo.

Se eu puder imprimir o resultado antes de imprimir a seleção do computador (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"]}

Imprime W, L, D para ganhar / perder / empatar.

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"]
    }

Ou em Q, que é mais legível:

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"]
    }

Exemplo de execução:

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 caracteres

Aqui está uma abordagem orientada a dados para o problema. Provavelmente, isso pode ser otimizado gerando os dados de vitória / perda / empate em vez de mapear manualmente, mas é um começo :)

Golfe:

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

Finalmente, aqui está uma mexida com ambos.

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

Mini versão (129 caracteres de código):

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) primeiro código de golfe!

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 |
        +---------------+
     */
}

Golfe (espaçamento / recuo)

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

_{Não é o código mais curto, mas minha primeira tentativa}

Go (169)

Golfe:

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 (como formatado por 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])
}

Corre :

vá executar main.go p

s

W

Pyth , 23

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

A saída está no formato:

Empate: 0 Vitória: 1 Perda: 2

Explicação:

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

Execute da seguinte maneira:

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

Para apenas mais 4 personagens, podemos usar T para empate, W para vitória e L para derrota:

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

Tudo é o mesmo até a diferença de índices; nesse ponto, usamos a diferença como índice na string "TWL".

Nota: embora eu tenha desenvolvido esse idioma depois que o desafio foi publicado, eu não o havia visto até hoje. O desafio não influenciou nenhum aspecto do idioma.

Groovy, 89

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

Toma a escolha do usuário como argumento. Exemplo:

groovy rps.groovy p
sL

C # e 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

saída de amostra (a entrada era): r> L // O computador escolhe rock (r) -> então perdemos

JavaScript (79)

Colidindo com um antigo, mas aqui vamos nós ...

Com o bônus adicional de que você pode usar qualquer pedra que você gosta de pegnatita, piroxenita, escória, sovita, kimberlita, trondjemita, tufo ou qualquer outra. A única limitação é que você não pode usar pou s ;-)

Entrada:

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

Saída:

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

Exemplo:

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

Código de golfe:

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

Os principais truques usados ​​são:

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

       Usando objeto {}e recuperando valor pela entrada do usuário de prompt(). Por enquanto, tudo bem. Então, em vez de ter r : 0, podemos forçar a conversão 0, usando o ~~operador NOT. É freqüentemente usado para andar números, mas também tem o (vantagem) de não voltar NaNquando outros operadores, como por exemplo: +{a:1, b:2}['c'].

2. c = new Date%3

       A data é frequentemente enganada, por exemplo, usando-a +new Datepara convertê-la em carimbo de data / hora diretamente, caso contrário, seria possível obter uma representação de string. Aqui, usando o mod one, obtém o mesmo efeito.

3. 'rps'[c]

       Acesso indexado na corda dando computadores escolha 0 = r, 1 = pou 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


...

O código não destruído pode ser algo como isto:

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

Esta é uma resposta real desta vez (olhando para você n"Draw": P).

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

Ungolfed:

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

Você pode executá-lo com ruby golfscript.rb MyCode.txt, onde MyCode.txtestá o código do programa.

Amostras são executadas (todas com entrada "r", mas funcionam com tudo) (empate é 0, vitória é 2, perda é 1):

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

Se você quiser uma explicação sobre a versão e / ou ver uma melhoria em potencial, me diga.

Javascript, 65 71 70

Sem saída de escolha do computador: 65

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

Apenas para testar se a solução está correta:

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

Com saída de escolha do computador: 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]))

e o teste:

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