Implementa las tijeras clásicas de papel piedra

Condiciones:

• el usuario ingresará 'r', 'p' o 's'
• el programa generará 'r', 'p' o 's' y el resultado
• la elección del programa ('r', 'p' o 's') tiene que ser pseudoaleatoria ( te estoy mirando Howard )
• El resultado se puede representar con cualquier carácter imprimible, siempre debe haber tres resultados posibles para lo que el usuario ha ingresado (el usuario gana, pierde o es un empate).
• qué sucede si el usuario no ingresa nada, o algo diferente que 'r', 'p' o 's' no deberían ser importantes.

Necesitas:

• Proporcione el código de golf.
• El código no golfista
• ¿Cómo invocas el programa?
• Una muestra de ejecución

Elegiré la respuesta con menos caracteres, si se elige un empate, se elegirá la respuesta más votada.

Buen golf y que la suerte esté siempre a tu favor.

Publicaré una respuesta yo mismo, en Java.

Para los que viven en una montaña debajo de una roca:

r = roca

p = papel

s = tijeras

piedra: gana con tijeras, pierde con papel, un empate con piedra.

papel: gana con piedra, pierde con tijeras, un empate con papel.

tijeras: gana con papel, pierde con piedra, un empate con tijeras.

Posiciones actuales:

• ONU: nombre de usuario
• PL: lenguaje de programación
• CC: recuento de caracteres
• UV: hasta 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 ║
╚══════════════════╩════════════╩══════╩════╝

No puedo seleccionar la respuesta de Howards, ya que fue un intento (exitoso) de doblar las reglas, pero las cambio para hacerlas más explícitas.

La respuesta de 27 caracteres primos no se puede seleccionar porque no es pseudoaleatoria per se

primo -p respuesta, voy a ir con "-p se contaría como 3 bytes: uno para el -, uno para el p, y uno más el espacio en blanco necesario".

Gracias a todos los que respondieron, ¡espero que lo hayan pasado bien!

NOTA: Intentaré editar esto cada dos semanas, ajustar la tabla y cambiar mi respuesta seleccionada si alguien supera la actual, así que si acabas de llegar, ¡publica tu respuesta si quieres!

APL, 31

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

x←'rps'Asignar cadena 'rps'ax

(?3)⌷ Elija un entero aleatorio 1 ~ 3, elija ese índice de x

⍞, Anteponer la entrada del usuario a la elección de la máquina

⎕← Cadena resultante de salida

x⍳ Convertir a matriz numérica por indexOf en x

-/ Diferencia de los dos números

1+|3 Módulo 3 y más 1

'TWL'[...] indexación desde 'TWL'

Muestra

r
rp
L

El usuario elige roca, el programa elige papel: perder

LOLCODE, 1397

Nota: envié esto antes de notar que el requisito ganador cambió de popularidad con el tie-break de golf a golf con el tie-break de popularidad.

Realmente no hay ninguna sintaxis estricta, pero estoy seguro de que esto es aceptable.

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

Si esto se ejecutara con éxito como RockPaperScissors.LOL , esto es lo que podrían ser algunos posibles resultados aleatorios:

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

GolfScript

n"Draw"

El código anterior implementa la funcionalidad requerida. Además, asegura que el jugador nunca se enfadará debido a una injusticia (percibida) de la estrategia de la computadora.

Versión sin golf

n"Draw"

Cómo invocar el programa

La entrada (un solo carácter de 'r', 'p', 's') debe proporcionarse en STDIN, posiblemente terminado con nueva línea.

Una muestra de ejecución

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

Explicación del código.

Para todos aquellos que no estén familiarizados con GolfScript, agregaré una explicación detallada de cómo funciona este código. El código existe esencialmente de tres 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 no es un código de golf sino un concurso de popularidad, no elegí la versión más corta. Tal vez en caso de empate, un código más corto eliminará mi solución. Sin embargo, para aquellos interesados ​​en el golf, se ofrecen las siguientes posibilidades:

• Trate solo con la entrada adecuada y obligue al usuario a proporcionar una nueva línea. Esto salvará un personaje.
• Las reglas tienen una pequeña insuficiencia que permite salvar a otro personaje doblando las reglas. El resultado siempre se puede imprimir como "Win"; no se especificó que se deba imprimir el resultado correcto. Pero tenga en cuenta que los jugadores pronto se enojarán si elige implementar un programa de trampa.
• El formato de salida no está bien especificado. Podemos elegir 0como salida para dibujar. Por lo tanto, el programa válido más corto es el código de un solo carácter 0.

Ruby: 61 54 caracteres

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

De alguna manera explicado:

Todo el problema se reduce a calcular los siguientes resultados:

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

Donde los números significan:

• elección: 0 piedra, 1 papel, 2 tijera
• resultado: 0 empate, 1 victoria, 2 pérdidas

Para esto utilicé la fórmula: machine_choice - human_choice. Esto ocasionalmente da como resultado un valor negativo, pero como solo se usa como índice y el índice negativo se cuenta hacia atrás, elegirá el elemento de matriz correcto.

# ┌── 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 utilizados (otros que Fixnumson obvios):

• Kernel.p (obj) → obj - “Para cada objeto, escribe directamente obj . inspectseguido de una nueva línea a la salida estándar del programa ".
• Kernel.rand (max = 0) → número - "Si se llama sin argumento, o si max.to_i.abs == 0, rand devuelve un número de punto flotante pseudoaleatorio entre 0.0 y 1.0, que incluye 0.0 y excluye 1.0".
• String.index (substring [, offset]) → fixnum or nil : "Devuelve el índice de la primera aparición de la subcadena o patrón (regexp) en str ".

Sin golf:

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]

Ejecución de muestra:

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)

Mi primer intento en el golf.

Golfed

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

Sin golf

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

Muestra Run La aplicación requiere entradas de char individuales como argumento 1 a la aplicación, ya sea r, so p.

cmd > app.exe r

Todos los resultados posibles

• cmd > app.exe rda salida r T(rock, tie)
• cmd > app.exe rda salida p L(papel, perdido)
• cmd > app.exe rda salida s W(tijeras, gana)
• cmd > app.exe pda salida r W(rock, win)
• cmd > app.exe pda salida p T(papel, corbata)
• cmd > app.exe pda salida s L(tijeras, perdido)
• cmd > app.exe sda salida r L(roca, perdida)
• cmd > app.exe sda salida p W(papel, ganar)
• cmd > app.exe sda salida s T(tijeras, corbata)

Perl 48 bytes

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

El guión imprime el resultado desde la perspectiva de la computadora, por ejemplo, si el jugador elige ry la computadora elige s, el resultado es Lose. $%(formato de número de página) se utiliza para almacenar el movimiento de la computadora, ya que solo puede contener un valor entero, lo que guarda un int int.

Sin golf:

# 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 de la muestra:

$ echo p | perl rps.pl
s
Win

$ echo r | perl rps.pl
r
Draw

$ echo s | perl rps.pl
p
Lose

El script también se puede ejecutar de forma interactiva, escribiendo su movimiento seguido de Enter:

$ perl rps.pl
r
s
Lose

Estiramiento de regla

Perl 35 +3 bytes

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

Requiere el -pcambio de línea de comando (contado como 3 bytes). Cada uno de los resultados Win, Losey Drawse han mapeado en W, L, D. Se ha excluido la nueva línea entre la elección de la computadora y el resultado.

Uso de la muestra:

$ echo r | perl -p rps.pl
sL

Perl 30 +3 bytes

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

Una vez más requiere -p. Aquí Win, Losey Drawse han asignado a 2, 1y 0respectivamente. Esto sigue siendo técnicamente compatible, ya que son caracteres imprimibles.

Uso de la muestra:

$ echo r | perl -p rps.pl
s1

Perl 24 +3 bytes

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

Requiere -p, WLD asigna a 2, 1, 0como antes. Cada uno ^Tdebe ser reemplazado por un carácter literal ascii 20. Este es ciertamente un poco exagerado; $^Tdevuelve el número de segundos desde la época en que se inició el script. Todos los resultados son posibles, pero no califican como pseudoaleatorios.

Uso de la muestra:

$ echo r | perl -p rps.pl
s1

APL ( 38 36)

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

Salidas 'T', 'W' y 'L' para empate, ganar y perder.

Ejecución de muestra:

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

(El usuario escribe 'p' para papel. La computadora elige 'r' (rock), el usuario gana)

Explicación:

• ⌽↑⌽∘'TWL'¨⍳3: genera la siguiente matriz:

TLW
WTL
LWT

• ⍞⍳⍨c←'rps': establecer cen la cadena 'rps', leer la entrada del usuario y obtener el índice de la entrada del usuario en la cadena (este será un valor de 1 a 3). Este índice se usa como la coordenada Y en la matriz.
• i←?3: obtenga un número aleatorio del 1 al 3 y guárdelo i, esta es la elección de la computadora. Esto se usa como la coordenada X en la matriz.
• c[i]: se utiliza icomo índice en c, mostrando la elección de la computadora como 'r', 'p' o 's'.

ferNANDo 1184 (259 golf) bytes

Un intérprete escrito en Python se puede encontrar en la parte inferior de la página vinculada.

ferNANDo es un lenguaje esotérico que admite solo un tipo de variable, booleano, y solo una operación, NAND. Como puede imaginar, esto puede llevar a una lógica bastante larga para realizar tareas aparentemente simples. Tiene soporte para leer desde stdin (un byte a la vez), escribir en stdout (también un byte a la vez), bucles condicionales y también un generador booleano aleatorio.

No hay palabras clave de ningún tipo; Todo es una variable. La función de una declaración está determinada únicamente por el número de variables que contiene. Tampoco hay comentarios, así que hice todo lo posible para que el código se auto comentara. Las últimas cuatro líneas podrían ser un poco confuso, pero probablemente será suficiente decir que se imprime Win!, Loseo Drawdependiendo del 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

El script se puede ejecutar de forma interactiva, escribiendo su movimiento seguido de Enter.

Ejemplo de uso (suponiendo que haya nombrado al 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

Editar: solo para demostrar que ferNANDo puede competir con Java, aquí hay una versión 'golfizada' de 259 bytes . La lógica es visiblemente diferente; comprueba not winy not tie, lo que ahorra algunas puertas NAND (porque entonces solo necesito las notversiones de los movimientos del jugador, y porque not loseno era necesario para la salida). Sin embargo, no es tan interesante de leer.

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)

Cómo 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

Basado en el destino, determina qué elección debería basarse en la fórmula

result = (User_choice + machines_fate) % no_of_choices

machine_choice = "psr"[result]

Versión sin golf

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)

Ejecución de la muestra

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

Sin golf:

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

Una solución alternativa de GolfScript, mucho más aburrida que la de Howard :).

El programa elige un movimiento al azar y muestra el resultado desde la perspectiva del usuario.

El código

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

Ejecución de la muestra

> echo s | ruby golfscript.rb rps.gs

r "Perder"

Prueba en línea

Puede ejecutar el programa y experimentar con diferentes entradas aquí: http://golfscript.apphb.com/?c=OydzJwoKJ3Jzc3BwcicuWzZyYW5kPV0nJys6wqdAKy4uJiwoez8pwqdcJ0xvc2UnJ1dpbidpZn17Ozv3py31cmcm3

Sin embargo, tenga en cuenta que el parámetro (movimiento del usuario) que generalmente se pasa en la línea de comando ahora se agrega a la pila en el código mismo (no hay forma de proporcionar parámetros de línea de comando "reales" en esta herramienta en línea).

Versión "no golfista"

No tengo ni idea de lo que significa sin golf cuando se trata de GolfScript, así que intenté agregar comentarios. Esperemos que eso aclare cómo funciona el código y lo haga un poco más legible:

# 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 la elección de la computadora y el resultado desde el punto de vista del usuario: W = ganas, L = pierdes, T = empate.
La fórmula simple x-y, dados los valores ASCII de las opciones, da 0 en el sorteo (obviamente) y un valor único en cada caso.

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

0 - empate, 1 - perder, 2 - ganar

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)

Sin golf

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 correr: python file_name_here.py

Problemas:
computadora AI: 35 caracteres

Primero intente sin revisar a los demás.

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

la salida es [npc-choice] [1: victoria, 2: pérdida, 3: empate]

sin golf:

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

Cambios del original:

• Reescribió completamente el guión después de ver la solución par o impar de tres jugadores de Danko Durbic .
• Cambió $ s a una sola cadena en lugar de una matriz de caracteres.
• Se utilizó IndexOf como método directo en $ s, en lugar de detallar la clase y el método .NET.
• Eliminado redundante %3s.

En total, ¡casi reduzco la longitud a la mitad de mi respuesta original!

Código de golf:

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

Se puede ejecutar directamente desde la consola.

Sin golf, con comentarios:

# 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

Algunos ejemplos se ejecutan en la consola:

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 no protegido:

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

Ejecuciones de muestra:

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

Ligeramente torpe. Es encogible, la pregunta es por cuánto.

JavaScript (87)

Golfizado:

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

Sin golf:

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

Simplemente puede pegar el código en la consola de JavaScript de su navegador para ejecutarlo.

Si se me permite imprimir el resultado antes de imprimir la selección de la computadora (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 ganar / perder / empatar.

Sin golf:

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

O en Q, que es más legible:

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

Ejecución de muestra:

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

Aquí hay un enfoque del problema basado en datos. Esto probablemente se puede optimizar generando los datos de ganar / perder / dibujar en lugar de asignarlos manualmente, pero es un comienzo :)

Golfizado:

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

Sin golf:

//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, aquí hay un violín con ambos.

Javascript: 256

golfizado:

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

sin golf:

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 versión (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) primer código de golf!

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

Sin golf

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

Golfizado (espaciado / sangría)

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

_{No es el código más corto, pero mi primer intento}

Ir (169)

Golfizado:

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

Sin golf (formateado 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])
}

Correr :

ir a ejecutar main.go p

s

W

Pyth , 23

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

La salida tiene la forma:

Empate: 0 Victoria: 1 Pérdida: 2

Explicación:

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

Ejecute de la siguiente manera:

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

Para solo 4 personajes más, podemos usar T para empatar, W para ganar y L para perder:

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

Todo es igual hasta la diferencia de índices, en cuyo punto usamos la diferencia como índice en la cadena "TWL".

Nota: si bien desarrollé este lenguaje después de que se publicó el desafío, no lo había visto hasta hoy. El desafío no influyó en ningún aspecto del lenguaje.

Groovy, 89

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

Toma la elección del usuario como argumento. Ejemplo:

groovy rps.groovy p
sL

C # y LinqPad 133

golfizado:

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

sin golf:

        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

salida de muestra (la entrada era s): r> L // La computadora elige rock (r) -> así que perdimos

JavaScript (79)

Chocando con uno viejo, pero aquí vamos ...

Con la ventaja adicional de que puedes usar cualquier roca que te guste pegnatita, piroxenita, escoria, sovita, kimberlita, trondjemita, toba o cualquier otra. La única limitación es que no puedes usar po s ;-)

Entrada:

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

Salida:

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

Ejemplo:

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

Código de golf:

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

Los principales trucos utilizados son:

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

       Uso de objetos {}y recuperación de valor por entrada del usuario de prompt(). Hasta aquí todo bien. Luego, en lugar de tenerlo r : 0, podemos forzarlo a convertirse 0mediante el uso del ~~operador NOT. Se utiliza con frecuencia para números de los pisos, pero también tiene la (ventaja) de no volver NaNcuando otros operadores haría, como por ejemplo: +{a:1, b:2}['c'].

2. c = new Date%3

       La fecha se engaña con frecuencia mediante, por ejemplo, el uso +new Datepara convertirla en marca de tiempo directamente, de lo contrario se obtendría una representación de cadena. Aquí al usar mod uno logra el mismo efecto.

3. 'rps'[c]

       Acceso indexado en cadena que permite a las computadoras elegir 0 = r, 1 = po 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


...

El código no protegido puede ser algo como esto:

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 es una respuesta real esta vez (mirándote,: n"Draw"P).

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

Sin golf:

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

Puede ejecutarlo ruby golfscript.rb MyCode.txt, donde MyCode.txtestá el código del programa.

Ejecuciones de muestra (todas con entrada "r", pero funciona con todo) (el empate es 0, la ganancia es 2, la pérdida es 1):

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

Si desea una explicación de cualquiera de las versiones y / o ve una mejora potencial, dígame.

Javascript, 65 71 70

Sin salida de elección de computadora: 65

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

Solo para probar que la solución es correcta:

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

Con salida de elección de computadora: 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]))

y la prueba:

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