Implementa le classiche forbici di carta rock.

condizioni:

• l'utente inserirà 'r', 'p' o 's'
• il programma produrrà 'r', 'p' o 's' e il risultato
• la scelta del programma ('r', 'p' o 's') deve essere pseudo casuale ( ti sto guardando Howard )
• il risultato può essere rappresentato con qualsiasi carattere stampabile, dovrebbero esserci sempre tre possibili risultati per ciò che l'utente ha inserito (l'utente vince, perde o è in pareggio).
• cosa succede se l'utente non inserisce nulla o qualcosa di diverso che "r", "p" o "s" non dovrebbe essere importante.

Devi:

• Fornire il codice golf.
• Il codice ungolfed
• Come invochi il programma
• Una corsa di esempio

Sceglierò la risposta con meno caratteri, se un pareggio presenterà la risposta più votata verrà scelta.

Buon golf e la fortuna può essere sempre a tuo favore.

Pubblicherò una risposta da solo, in Java.

Per quelli che vivono in una montagna sotto una roccia:

r = rock

p = carta

s = forbici

rock: vince con le forbici, perde con la carta, una cravatta con la roccia.

carta: vince al rock, perde con le forbici, una cravatta con la carta.

forbici: vince sulla carta, perde con la roccia, una cravatta con le forbici.

Posizioni attuali:

• ONU: nome utente
• PL: Linguaggio di programmazione
• CC: Conteggio personaggi
• UV: voti positivi

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

Non riesco a selezionare la risposta di Howards, dal momento che è stato un tentativo (riuscito) di piegare le regole, ma le cambio, per renderle più esplicite.

la risposta del primo 27 caratteri non può essere selezionata perché non è pseudo casuale di per sé

primo -p risposta, vado con "-p verrebbe contato come 3 byte: uno per il -, uno per la p e un altro lo spazio bianco necessario."

Grazie a tutti coloro che hanno risposto, spero che tu ti sia divertito!

NOTA: proverò a modificarlo ogni due settimane, per adattare la tabella e cambiare la mia risposta selezionata se qualcuno batte quella corrente, quindi se sei appena arrivato, pubblica la tua risposta se vuoi!

APL, 31

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

x←'rps'Assegna stringa 'rps'ax

(?3)⌷ Scegli un numero intero casuale 1 ~ 3, scegli quell'indice di x

⍞, Prepara l'input dell'utente alla scelta della macchina

⎕← Output stringa risultante

x⍳ Converti in matrice numerica per indice di In x

-/ Differenza dei due numeri

1+|3 Modulo 3 e più 1

'TWL'[...] indicizzazione da 'TWL'

Campione

r
rp
L

L'utente sceglie il rock, il programma sceglie il paper: Lose

LOLCODE, 1397

Nota: l' ho presentato prima di notare che il requisito vincente era cambiato dalla popolarità con il golf tie-break al golf con il tie-break di popolarità.

Non c'è davvero alcuna sintassi rigorosa, ma sono sicuro che questo sia accettabile.

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 questo dovesse essere eseguito con successo RockPaperScissors.LOL, ecco alcuni possibili esiti casuali:

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

GolfScript

n"Draw"

Il codice sopra implementa la funzionalità richiesta. Inoltre, garantisce che il giocatore non rimarrà mai arrabbiato a causa di una (percepita) ingiustizia della strategia del computer.

Versione Ungolfed

n"Draw"

Come invocare il programma

L'input (un singolo carattere di 'r', 'p', 's') deve essere fornito su STDIN, eventualmente terminato con newline.

Una corsa di esempio

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

Spiegazione del codice

Per tutti coloro che non hanno familiarità con GolfScript, aggiungerò una spiegazione dettagliata di come funziona questo codice. Il codice esiste essenzialmente di tre parti.

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

Gli appunti

Dato che non si tratta di code-golf ma di contest di popolarità, non ho scelto la versione più breve. Forse in caso di pareggio un codice più corto eliminerà la mia soluzione. Tuttavia, per coloro che sono interessati al golf, vengono fornite le seguenti possibilità:

• Gestire solo l'input corretto e forzare l'utente a fornire una nuova riga. Ciò salverà un personaggio.
• Le regole hanno una piccola insufficienza che consente di salvare un altro personaggio piegando le regole. Il risultato può sempre essere stampato come "Win" - non è stato specificato che deve essere stampato il risultato corretto. Ma nota che i giocatori si arrabbieranno presto se scegli di implementare un programma di imbroglio.
• Il formato di output non è ben specificato. Possiamo scegliere 0come output per disegnare. Pertanto, il programma valido più breve è il codice a carattere singolo 0.

Rubino: 61 54 caratteri

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

In qualche modo spiegato:

L'intero problema si riduce al calcolo dei seguenti risultati:

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

Dove significano i numeri:

• scelta: 0 rock, 1 paper, 2 scissor
• risultato: 0 pareggio, 1 vittoria, 2 sconfitte

Per questo ho usato la formula: machine_choice - human_choice. Questo a volte risulta un valore negativo, ma poiché viene utilizzato solo come indice e l'indice negativo viene contato all'indietro, sceglierà l'array corretto.

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

Metodi usati (altri poi Fixnumquelli ovvi):

• Kernel.p (obj) → obj - “Per ogni oggetto, scrive direttamente obj . inspectseguito da una nuova riga per l'output standard del programma. "
• Kernel.rand (max = 0) → numero - "Se chiamato senza argomento, o se max.to_i.abs == 0, rand restituisce un numero in virgola mobile pseudo-casuale compreso tra 0,0 e 1,0, incluso 0,0 ed escluso 1,0".
• String.index (substring [, offset]) → fixnum o nil - "Restituisce l'indice della prima occorrenza della sottostringa o modello (regexp) in 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]

Esecuzione di esempio:

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

Il mio primo tentativo di giocare a 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"));}}

Un-golfed

using System;

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

Esempio Run L'applicazione richiede ingressi char singoli come argomento 1 per l'applicazione, sia r, so p.

cmd > app.exe r

Tutti i possibili risultati

• cmd > app.exe rdà output r T(rock, tie)
• cmd > app.exe rdà output p L(carta, perso)
• cmd > app.exe rdà output s W(forbici, vinci)
• cmd > app.exe pdà output r W(rock, win)
• cmd > app.exe pdà output p T(carta, cravatta)
• cmd > app.exe pdà uscita s L(forbici, perse)
• cmd > app.exe sdà output r L(rock, perso)
• cmd > app.exe sdà output p W(carta, vinci)
• cmd > app.exe sdà uscita s T(forbici, cravatta)

Perl 48 byte

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

Lo script stampa il risultato dalla prospettiva del computer, ad esempio se il giocatore sceglie re il computer sceglie s, il risultato è Lose. $%(formato numero pagina) viene utilizzato per memorizzare lo spostamento del computer, poiché può contenere solo un valore intero, che consente di salvare un cast 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];

Esempio di utilizzo:

$ echo p | perl rps.pl
s
Win

$ echo r | perl rps.pl
r
Draw

$ echo s | perl rps.pl
p
Lose

Lo script può anche essere eseguito in modo interattivo, digitando la tua mossa seguita da Enter:

$ perl rps.pl
r
s
Lose

Allungamento delle regole

Perl 35 +3 byte

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

Richiede l'opzione della -priga di comando (conteggiata come 3 byte). Ciascuno dei risultati Win, Losee Drawsono stati mappati W, L,D . La nuova linea tra la scelta del computer e il risultato è stata esclusa.

Esempio di utilizzo:

$ echo r | perl -p rps.pl
sL

Perl 30 +3 byte

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

Ancora una volta richiede -p. Qui Win, Losee Drawsono stati mappati 2, 1e 0rispettivamente. Questo è ancora tecnicamente conforme, in quanto sono personaggi stampabili.

Esempio di utilizzo:

$ echo r | perl -p rps.pl
s1

Perl 24 +3 byte

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

Richiede -p, WLD mappato 2, 1, 0come prima. Ognuno ^Tdovrebbe essere sostituito con un carattere letterale ASCII 20. Questo è certamente un po 'allungato;$^Trestituisce il numero di secondi dall'epoca in cui è stato avviato lo script. Tutti i risultati sono possibili, ma non si qualificano come pseudo-casuali.

Esempio di utilizzo:

$ echo r | perl -p rps.pl
s1

APL ( 38 36)

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

Emette "T", "W" e "L" per pareggio, vittoria e sconfitta.

Esecuzione di esempio:

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

(L'utente digita 'p' per la carta. Il computer sceglie 'r' (rock), l'utente vince)

Spiegazione:

• ⌽↑⌽∘'TWL'¨⍳3: genera la seguente matrice:

TLW
WTL
LWT

• ⍞⍳⍨c←'rps': impostare csulla stringa 'rps', leggere l'input dell'utente e ottenere l'indice dell'input dell'utente nella stringa (questo sarà un valore compreso tra 1 e 3). Questo indice viene utilizzato come coordinata Y nella matrice.
• i←?3: ottieni un numero casuale da 1 a 3 e memorizzalo in i, questa è la scelta del computer. Questo è usato come coordinata X nella matrice.
• c[i]: usa icome indice in c, mostrando la scelta del computer come 'r', 'p' o 's'.

ferNANDo 1184 (259 golf) byte

Un interprete scritto in Python si trova in fondo alla pagina collegata.

ferNANDo è un linguaggio esoterico che supporta solo un tipo di variabile, booleano e una sola operazione, NAND. Come puoi immaginare, questo può portare a una logica abbastanza lunga per svolgere compiti apparentemente semplici. Supporta la lettura da stdin (un byte alla volta), la scrittura su stdout (anche un byte alla volta), i loop condizionali e anche un generatore booleano casuale.

Non ci sono parole chiave di sorta; tutto è una variabile. La funzione di un'istruzione è determinata esclusivamente dal numero di variabili che contiene. Inoltre non ci sono commenti, quindi ho fatto del mio meglio per rendere il codice auto-commentante. Le ultime quattro righe potrebbero essere un po 'di confusione, ma sarà probabilmente basti dire che la stampa Win!, Loseoppure Drawa seconda del risultato.

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

Lo script può essere eseguito in modo interattivo, digitando la tua mossa seguita da Enter.

Esempio di utilizzo (supponendo che tu abbia chiamato l'interprete 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

Modifica: solo per dimostrare che ferNANDo può competere con Java, ecco una versione "giocata a golf" a 259 byte . La logica è visivamente diversa; controlla not wine not tie, il che salva alcune porte NAND (perché allora ho solo bisogno delle notversioni delle mosse del giocatore, e perché not losenon era necessario per l'output). Non altrettanto interessante da leggere, però.

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 personaggi

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

Come funziona

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

In base al destino, determina quale dovrebbe essere la scelta in base alla formula

result = (User_choice + machines_fate) % no_of_choices

machine_choice = "psr"[result]

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

Esecuzione del campione

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

Una soluzione GolfScript alternativa, molto più noiosa di Howard :).

Il programma sceglie una mossa in modo casuale e visualizza il risultato dal punto di vista dell'utente.

Il codice

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

Esecuzione del campione

> echo s | ruby golfscript.rb rps.gs

r "Lose"

Test online

È possibile eseguire il programma e sperimentare diversi input qui: http://golfscript.apphb.com/?c=OydzJwoKJ3Jzc3BwcicuWzZyYW5kPV0nJys6wqdAKy4uJiwoez8pwqdcJ0xvc2UnJ1dpbidpZn17Ozv

Si noti, tuttavia, che il parametro (spostamento dell'utente) che di solito viene passato nella riga di comando viene ora aggiunto allo stack nel codice stesso (non è possibile fornire parametri "reali" della riga di comando in questo strumento online).

Versione "Ungolfed"

Non ho idea di cosa significhi ungolf quando si tratta di GolfScript, quindi ho cercato di aggiungere commenti. Spero che ciò chiarisca come funziona il codice e lo renda un po 'più leggibile:

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

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

Stampa la scelta del computer e il risultato dal punto di vista dell'utente: W = vinci, L = perdi, T = pareggio.
La formula semplice x-y, dati i valori ASCII delle scelte, dà 0 in pareggio (ovviamente) e un valore univoco l'uno nell'altro caso.

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

0 - pareggio, 1 - perdita, 2 - vittoria

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

Come eseguire: python file_name_here.py

Problemi:
Computer AI: 35 caratteri

Prima prova senza rivedere gli altri.

golfed: 107 85 byte

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

l'output è [npc-choice] [1: win, 2: loss, 3: tie]

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

Modifiche rispetto all'originale:

• Ho riscritto completamente la sceneggiatura dopo aver visto la soluzione pari o dispari a tre giocatori di Danko Durbic .
• Modificato $ s in una singola stringa anziché in una matrice di caratteri.
• Utilizzato IndexOf come metodo diretto su $ s, invece di precisare la classe e il metodo .NET.
• Rimossi ridondanti %3.

Tutto sommato, ho quasi tagliato la lunghezza della metà dalla mia risposta originale!

Codice golfizzato:

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

Può essere eseguito direttamente dalla console.

Ungolfed, con commenti:

# 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

Alcuni esempi vengono eseguiti sulla 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]);}}

Codice altamente non golfato:

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

Esecuzioni campione:

C:> java cr

S: 1

C:> java cp

p: T

C:> java cs

s: T

Befunge: 107 personaggi

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

Leggermente goffo. È restringibile, la domanda è di quanto.

JavaScript (87)

golfed:

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

Ungolfed:

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

Puoi semplicemente incollare il codice nella console javascript del tuo browser per eseguirlo.

Se sono autorizzato a stampare il risultato prima di stampare la selezione del computer (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"]}

Stampa W, L, D per vincere / perdere / pareggiare.

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

O in Q, che è più leggibile:

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

Esempio di esecuzione:

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 caratteri

Ecco un approccio basato sui dati al problema. Questo può probabilmente essere ottimizzato generando i dati di vincita / perdita / pareggio invece di mapparli manualmente, ma è un inizio :)

golfed:

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

Ungolfed:

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

    //Output the value the computer chose
    ).value

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

Infine, ecco un violino con entrambi.

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

Versione mini (129 caratteri di codice):

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

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

Golfed (spaziatura / rientro)

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

_{Non il codice più breve, ma il mio primo tentativo}

Go (169)

Golfato:

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 (come formattato da 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])
}

Correre :

vai a main.go p

S

W

Pyth , 23

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

L'output è nella forma:

Cravatta: 0 Vittoria: 1 Perdita: 2

Spiegazione:

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

Esegui come segue:

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

Solo per altri 4 personaggi, possiamo usare T per pareggio, W per vittoria e L per perdita:

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

Tutto è uguale fino alla differenza degli indici, a quel punto usiamo la differenza come indice nella stringa "TWL".

Nota: mentre sviluppavo questa lingua dopo che la sfida era stata pubblicata, non l'avevo vista fino ad oggi. La sfida non ha influenzato nessun aspetto della lingua.

Groovy, 89

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

Prende la scelta dell'utente come argomento. Esempio:

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

output di esempio (input was s): r> L // Il computer sceglie rock (r) -> quindi abbiamo perso

JavaScript (79)

Incontrare un vecchio, ma qui andiamo ...

Con l'ulteriore vantaggio di poter usare qualsiasi roccia che ti piaccia pegnatite, pirossenite, scoria, sovite, kimberlite, trondjemite, tufo o qualsiasi altra. L'unica limitazione è che non puoi usare po s ;-)

Ingresso:

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

Produzione:

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

Esempio:

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

Codice golfizzato:

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

I principali trucchi utilizzati sono:

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

       Utilizzo dell'oggetto {}e recupero del valore mediante l'input dell'utente da prompt(). Fin qui tutto bene. Quindi invece di averlo r : 0possiamo forzare la conversione in 0utilizzando l' ~~operatore NOT. E 'spesso usato per numeri dei piani, ma ha anche la (vantaggio) di non tornare NaNquando altri operatori sarebbe, come ad esempio: +{a:1, b:2}['c'].

2. c = new Date%3

       La data viene spesso ingannata dall'uso, +new Datead esempio, per convertirla direttamente in data / ora, altrimenti si otterrebbe una rappresentazione di stringa. Qui usando mod one ottieni lo stesso effetto.

3. 'rps'[c]

       Accesso indicizzato su stringa che consente ai computer di scegliere 0 = r, 1 = poppure 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


...

Il codice ungolfed può essere qualcosa del genere:

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

Questa volta questa è una vera risposta (guardandoti n"Draw": P).

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

Ungolfed:

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

Puoi eseguirlo con ruby golfscript.rb MyCode.txt, dov'è MyCode.txtil codice del programma.

Esecuzioni campione (tutte con input "r", ma funziona con tutto) (il pareggio è 0, la vittoria è 2, la perdita è 1):

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

Se vuoi una spiegazione di entrambe le versioni e / o vedi un potenziale miglioramento, dimmelo.

Javascript, 65 71 70

Senza uscita scelta dal computer: 65

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

Solo per testare quella soluzione è corretta:

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 uscita a scelta computer: 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 il test:

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