클래식 가위 바위 보를 구현하십시오.

정황:

• 사용자는 'r', 'p'또는 's'를 입력합니다
• 프로그램은 'r', 'p'또는 's'와 결과를 출력합니다
• 프로그램 선택 ( 'r', 'p'또는 's')은 의사 랜덤이어야 합니다 (하워드를보고 있습니다 )
• 결과는 인쇄 가능한 문자로 표현 될 수 있습니다. 사용자가 입력 한 내용에 대해 항상 3 가지 가능한 결과가 있어야합니다 (사용자가이기거나 잃거나 넥타이 인 경우).
• 사용자가 아무것도 입력하지 않거나 'r', 'p'또는 's'와 다른 것이 중요하지 않은 경우에 발생합니다.

다음을 수행해야합니다.

• 골프 코드를 제공하십시오.
• ungolfed 코드
• 프로그램을 어떻게 호출합니까
• 샘플 런

넥타이가 가장 많으면 가장 많이 투표 된 답변이 선택 될 경우 더 적은 문자로 답변을 선택하겠습니다.

좋은 골프와 행운을 빕니다.

Java로 답변을 게시 할 것입니다.

바위 아래 산에 사는 사람들에게는 :

r = 바위

p = 종이

s = 가위

바위 : 가위로 이기고 종이로 잃고 바위로 묶습니다.

종이 : 바위에 이기고 가위로 잃어 버리고 종이로 묶습니다.

가위 : 종이로 이기고, 바위로 잃고, 가위로 묶습니다.

현재 위치 :

• 유엔 : 사용자 이름
• PL : 프로그래밍 언어
• CC : 문자 수
• UV : 투표

╔══════════════════╦════════════╦══════╦════╗
║        UN        ║     PL     ║  CC  ║ UV ║
╠══════════════════╬════════════╬══════╬════╣
║ Howard           ║ GolfScript ║    6 ║ 15 ║
║ primo            ║ Perl       ║   27 ║  7 ║
║ TwiNight         ║ APL        ║   31 ║  4 ║
║ primo            ║ Perl       ║   33 ║  7 ║
║ marinus          ║ APL        ║   36 ║  5 ║
║ primo            ║ Perl       ║   38 ║  7 ║
║ primo            ║ Perl       ║   48 ║  7 ║
║ manatwork        ║ Ruby       ║   54 ║ 13 ║
║ w0lf             ║ GolfScript ║   62 ║  4 ║
║ tmartin          ║ K          ║   67 ║  2 ║
║ Abhijit          ║ Python 3   ║   74 ║  5 ║
║ beary605         ║ Python 3   ║   76 ║  4 ║
║ rlemon           ║ javascript ║   85 ║  4 ║
║ ugoren           ║ C          ║   86 ║  3 ║
║ Egor Skriptunoff ║ LUA        ║   87 ║  4 ║
║ Shmiddty         ║ javascript ║   87 ║  3 ║
║ Fors             ║ Befunge    ║  107 ║  3 ║
║ Briguy37         ║ javascript ║  117 ║  2 ║
║ Vi.              ║ Clojure    ║  129 ║  1 ║
║ Henrik           ║ C#         ║  167 ║  4 ║
║ dystroy          ║ Go         ║  169 ║  1 ║
║ Praveen          ║ javascript ║  250 ║  0 ║
║ ryan             ║ javascript ║  256 ║  1 ║
║ primo            ║ ferNANDo   ║  259 ║  5 ║
║ anakata          ║ Java       ║  259 ║  1 ║
║ epoch            ║ Java       ║  387 ║  1 ║
║ jdstankosky      ║ LOLCODE    ║ 1397 ║ 15 ║
╚══════════════════╩════════════╩══════╩════╝

규칙을 구부리려는 시도가 성공했기 때문에 Howards 답변을 선택할 수는 없지만 규칙을 명시 적으로 변경하기 위해 변경했습니다.

primo 27 문자 답변은 의사 난수 자체가 아니므로 선택할 수 없습니다.

primo -p 답변, "-p는 3 바이트로 계산됩니다. 하나는-, 하나는 p, 다른 하나는 필요한 공백으로 계산됩니다."

답변 해 주신 모든 분들께 감사 드리며 즐거운 시간을 보내시기 바랍니다.

참고 : 격주로 편집하고 테이블을 조정하고 누군가가 현재 답변을 이길 경우 선택한 답변을 변경하려고하므로 방금 도착한 경우 원하는 경우 답변을 게시하십시오!

APL, 31

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

x←'rps'지정 문자열 'rps'에x

(?3)⌷ 임의의 정수 1 ~ 3을 선택하고 x

⍞, 기계 선택에 사용자 입력을 추가

⎕← 결과 문자열

x⍳ 에서 indexOf로 숫자 형 배열로 변환 x

-/ 두 숫자의 차이

1+|3 계수 3과 1

'TWL'[...] 에서 색인 생성 'TWL'

견본

r
rp
L

사용자는 바위를 선택하고, 프로그램은 종이를 선택합니다.

롤 코드, 1397

참고 : 우승 요건이 골프 타이 브레이크 인기에서 인기 타이 브레이크가있는 골프로 바뀌는 것을 발견하기 전에 이것을 제출했습니다.

실제로 엄격한 구문은 없지만 이것이 수용 가능하다고 확신합니다.

HAI
    I HAS A CRAZY, LUCKY, CHALLENGE, TREAT
    I HAS YUMMY ITZ "LOL U LOZED"
    I HAS MEH ITZ "NOWAI TIED"
    I HAS GROSS ITZ "OMG U WONNED"
    I HAS BURNT ITZ "LAME"
    GIMMEH CHALLENGE
    BTW I HOPE I R TEH WINZ
    LOL CRAZY IZ BETWEEN 1 AN 3
    I HAS A SUPA ITZ A BUKKIT
    LOL SUPA'Z 1 R "ROCK"
    LOL SUPA'Z 2 R "PAPER"
    LOL SUPA'Z 3 R "SCIZZORS"
    LOL LUCKY R SUPA'Z CRAZY
    GOT CHALLENGE, WTF?
        OMG "Rock"
            GOT LUCKY, WTF?
                OMG ROCK, LOL TREAT R MEH, GTFO
                OMG PAPER, LOL TREAT R YUMMY, GTFO
                OMG SCIZZORS, LOL TREAT R GROSS, GTFO
            OIC
        OMG "Paper"
            GOT LUCKY, WTF?
                OMG ROCK, LOL TREAT R GROSS, GTFO
                OMG PAPER, LOL TREAT R MEH, GTFO
                OMG SCIZZORS, LOL TREAT R YUMMY, GTFO
            OIC
        OMG "Scissors"
            GOT LUCKY, WTF?
                OMG ROCK, LOL TREAT R YUMMY, GTFO
                OMG PAPER, LOL TREAT R GROSS, GTFO
                OMG SCIZZORS, LOL TREAT R MEH, GTFO
            OIC
        OMGWTF
            VISIBLE "WHAT U SAYZ?", LOL TREAT R BURNT
            GTFO
    OIC
        BOTH SAEM TREAT AN BURNT, O RLY?
            YARLY
                VISIBLE "YOU BURNTED MAH TREAT!"
            NOWAI
                VISIBLE SMOOSH "I GUESSED " AN LUCKY
                VISIBLE TREAT
        KTHX
KTHXBAI

이것이로 성공적으로 실행 되었다면 RockPaperScissors.LOL, 가능한 임의의 결과는 다음과 같습니다.

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

GolfScript

n"Draw"

위의 코드는 필요한 기능을 구현합니다. 또한 컴퓨터 전략의 불공평성으로 인해 플레이어가 화를 내지 않을 수 있습니다.

언 골프 버전

n"Draw"

프로그램을 호출하는 방법

입력 ( 'r', 'p', 's'의 단일 문자)은 STDIN에 제공해야하며 개행으로 끝날 수 있습니다.

샘플 런

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

코드 설명

GolfScript에 익숙하지 않은 모든 사람들을 위해이 코드의 작동 방식에 대한 자세한 설명을 추가하겠습니다. 코드는 본질적으로 세 부분으로 구성됩니다.

### Computer's strategy ###
# The strategy used to play r/p/s. 
# The computer is so fast, it can really guess in an instance 
# what the player has played. Since the computer should 
# not play unfair, the best strategy is to always go for a 
# draw and choose the same move.
        # on the stack is player's move
        # choose to play the same -> now the computer's move is on the stack

### Fiddle with input ###
# The input may of may not be delimited by newline.
# In order to make the output readable, we'll give
# a newline here.
n       # Push a newline onto the stack

### Give the result ###
# We can skip a complicated calculation of the result
# since we chose to play draw anyways.
"Draw"  # Push the result onto the stack

# Output is printed automatically when GolfScript code terminates.

노트

이것은 코드 골프가 아니라 인기 콘테스트이므로 가장 짧은 버전을 선택하지 않았습니다. 아마 넥타이의 경우 코드가 짧을수록 솔루션이 녹아웃됩니다. 그럼에도 불구하고 골프에 관심이있는 사람들에게는 다음과 같은 가능성이 있습니다.

• 적절한 입력 만 처리하고 사용자가 줄 바꿈을 제공하도록합니다. 이것은 하나의 문자를 저장합니다.
• 이 규칙에는 규칙이 구부러져 다른 캐릭터를 구할 수있는 부족한 부분이 있습니다. 결과는 항상 "Win"으로 인쇄 될 수 있습니다. 정확한 결과를 인쇄하도록 지정되지 않았습니다. 그러나 부정 행위 프로그램을 구현하기로 선택하면 플레이어는 곧 화를 낼 것입니다.
• 출력 형식이 잘못 지정되었습니다. 0추첨 출력으로 선택할 수 있습니다 . 따라서 가장 짧은 유효한 프로그램은 단일 문자 코드 0입니다.

루비 : 61 54 자

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

어떻게 든 설명 :

전체 문제는 다음 결과를 계산하기 위해 줄어 듭니다.

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

숫자가 의미하는 곳 :

• 선택 : 0 바위, 1 종이, 2 가위
• 결과 : 0 추첨, 1 승, 2 패

이를 위해 machine_choice-human_choice 공식을 사용했습니다. 때때로 마이너스 값이 발생하지만 인덱스로만 사용되고 네거티브 인덱스는 역으로 계산되므로 올바른 배열 요소를 선택합니다.

# ┌── choosable object type
# │           ┌── machine's choice numeric code
# │           │                  ┌── result type
# │           │                  │                   ┌── human's choice
# │           │          ┌───────┴───────┐           │
  o="rps";p o[c=rand(3)],%w{Draw Win Lose}[c.-o.index$_]
#           └─────┬────┘                   └─────┬────┘  
#                 └── machine's choice letter    │
#                                                └── result numeric code

사용 된 방법 (다른 방법은 Fixnum명백한 방법) :

• Kernel.p (obj) → obj –“각 객체마다 obj를 직접 씁니다 . inspect그 다음에 프로그램의 표준 출력에 개행 문자를 붙였습니다.”
• Kernel.rand (max = 0) → number – "인수없이 호출하거나이면 max.to_i.abs == 0rand는 0.0과 1.0을 포함하여 0.0과 1.0 사이의 의사 난수 부동 소수점 숫자를 반환합니다."
• String.index (substring [, offset]) → fixnum 또는 nil – " str 에서 주어진 부분 문자열 또는 패턴 (regexp) 이 처음 나타나는 색인을 반환합니다 ."

언 골프 드 :

object_type = "rps";
result_type = %w{Draw Win Lose}

machine_choice = rand(3)
human_choice = $_

p object_type[machine_choice]

result_code = machine_choice - object_type.index(human_choice)
p result_type[result_code]

샘플 실행 :

bash-4.2$ ruby -nle 'o="rps";p o[c=rand(3)],%w{Draw Win Lose}[c.-o.index$_]'
r
"p"
"Win"
p
"p"
"Draw"
s
"p"
"Lose"

C # (167 자)

내 첫 골프 시도.

골프

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

언 골프

using System;

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

샘플 실행 앱은 r, s또는에 인수 1로 단일 문자 입력이 필요합니다 p.

cmd > app.exe r

가능한 모든 결과

• cmd > app.exe r출력 r T(바위, 넥타이)
• cmd > app.exe r출력 p L(종이, 분실)
• cmd > app.exe r출력 s W(가위, 승리)
• cmd > app.exe p출력을 준다 r W(락, 승리)
• cmd > app.exe p출력 p T(종이, 넥타이)
• cmd > app.exe p출력 s L(가위, 손실)
• cmd > app.exe s출력을 제공합니다 r L(락, 손실)
• cmd > app.exe s출력 p W(종이, 승리)
• cmd > app.exe s출력 s T(가위, 넥타이)

펄 48 바이트

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

스크립트는 컴퓨터의 관점에서 결과를 인쇄합니다. 예를 들어 플레이어가 선택 r하고 컴퓨터가을 선택한 s경우 결과는 Lose입니다. $%(포맷 페이지 번호)는 정수 값만 포함하여 int 캐스트를 저장하기 때문에 컴퓨터의 이동을 저장하는 데 사용됩니다.

언 골프 드 :

# choose a random move index 0, 1, or 2
$cindex = int(rand 3);
# convert this index to a move
# 0 => r, 1 => s, 2 => p
$cmove = "$cindex" ^ B;

# read the player's move
$pmove = <>;
# convert this move to its index
$pindex = $pmove ^ B;

# print computer's move
print $cmove, $/;
# compare indices, and output result
@result = (Draw, Lose, Win);
print $result[$cindex - $pindex];

샘플 사용법 :

$ echo p | perl rps.pl
s
Win

$ echo r | perl rps.pl
r
Draw

$ echo s | perl rps.pl
p
Lose

이동과 다음을 입력하여 스크립트를 대화식으로 실행할 수도 있습니다 Enter.

$ perl rps.pl
r
s
Lose

규칙 스트레칭

펄 35 +3 바이트

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

-p명령 행 스위치가 필요합니다 (3 바이트로 계산). 성과의 각 Win, Lose및 Draw에 매핑 된 W, L, D. 컴퓨터 선택과 결과 사이의 줄 바꿈이 제외되었습니다.

샘플 사용법 :

$ echo r | perl -p rps.pl
sL

펄 30 +3 바이트

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

다시 한번 필요합니다 -p. 여기에 Win, Lose그리고 Draw에 매핑 된 2, 1그리고 0각각. 인쇄 가능한 문자이므로 여전히 기술적으로 호환됩니다.

샘플 사용법 :

$ echo r | perl -p rps.pl
s1

펄 24 +3 바이트

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

필요 -p, WLD는 매핑 2, 1, 0이전. 각각 ^T은 문자 그대로의 ASCII 문자 20으로 대체되어야합니다. 이것은 약간의 스트레칭입니다. $^T스크립트가 시작된 시점부터 에포크 이후의 시간 (초)을 반환합니다. 모든 결과가 가능하지만 의사 난수로 간주되지는 않습니다.

샘플 사용법 :

$ echo r | perl -p rps.pl
s1

APL ( 38 36)

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

동점, 승리 및 패배에 대한 'T', 'W'및 'L'을 출력합니다.

샘플 실행 :

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

(종이의 경우 사용자 유형 'p'. 컴퓨터가 'r'(락)을 선택하면 사용자가 이깁니다)

설명:

• ⌽↑⌽∘'TWL'¨⍳3: 다음 행렬을 생성합니다.

TLW
WTL
LWT

• ⍞⍳⍨c←'rps': cstring으로 설정 하고 'rps'사용자 입력을 읽고 문자열 에서 사용자 입력 색인을 가져옵니다 (1에서 3 사이의 값이 됨). 이 인덱스는 행렬의 Y 좌표로 사용됩니다.
• i←?3: 1에서 3 사이의 임의의 숫자를 가져 와서 저장하십시오 i. 이것이 컴퓨터의 선택입니다. 행렬에 대한 X 좌표로 사용됩니다.
• c[i]: i의 색인으로 사용 c하여 컴퓨터의 선택을 'r', 'p'또는 's'로 표시합니다.

ferNANDo 1184 (259 골프) 바이트

파이썬으로 작성된 인터프리터는 링크 된 페이지의 맨 아래에 있습니다.

ferNANDo는 하나의 변수 유형 (부울)과 하나의 연산 (NAND) 만 지원하는 난해한 언어입니다. 당신이 상상할 수 있듯이, 이것은 겉보기에 간단한 작업을 수행하기 위해 상당히 긴 논리를 초래할 수 있습니다. stdin에서 읽기 (한 번에 한 바이트), stdout에 쓰기 (한 번에 한 바이트), 조건부 루프 및 임의의 부울 생성기를 지원합니다.

키워드는 없습니다. 모든 것이 변수입니다. 명령문의 기능은 포함 된 변수의 수에 의해서만 결정됩니다. 의견도 없으므로 코드 자체 주석 처리를 위해 최선을 다했습니다. 마지막 네 줄은 약간 혼동 될 수도 있지만 그것은 아마 인쇄 말을 충분 Win!, Lose또는 Draw결과에 따라.

not sure, but right now i'm guessing you're_not_paper you're_scissors
you're_paper not you're_not_paper
you're_not_scissors not you're_scissors
you're_rock you're_not_paper you're_not_scissors
you're_rock you're_rock

o_shi-
i'm_not_paper right ?
i'm_scissors right ?
i'm_paper not i'm_not_paper
i'm_not_scissors not i'm_scissors
o_shi- i'm_paper i'm_scissors
o_shi- o_shi-
o_shi-
i'm_rock i'm_not_paper i'm_not_scissors
i'm_rock i'm_rock

print right now but only if i'm_not_paper i'm_scissors
print a newline here, not more, not less

i_win_if i'm_scissors you're_paper
or_if i'm_rock you're_scissors
or_even_if i'm_paper you're_rock

i_win i_win_if or_if
i_win i_win
i_win or_even_if

i_lose_if i'm_paper you're_scissors
or_if i'm_scissors you're_rock
or_even_if i'm_rock you're_paper

i_lose i_lose_if or_if
i_lose i_lose
i_lose or_even_if

i_don't_win not i_win
i_don't_lose not i_lose
we_tie i_don't_win i_don't_lose
we_tie we_tie
we_don't_tie not we_tie

print now if i_win i_lose not i_win i_win
print but not we_tie we_don't_tie i_lose i_don't_win we_don't_tie
print right now i_lose i_win i_win we_don't_tie i_don't_win
print i_don't_win but we_tie or i_don't_win we_tie now

이동 다음에을 입력하여 스크립트를 대화식으로 실행할 수 있습니다 Enter.

샘플 사용법 (인터프리터라고 가정 nand.py) :

$ python nand.py rps.nand
p
s
Win!

$ python nand.py rps.nand
r
r
Draw

$ python nand.py rps.nand
s
p
Lose

편집 : ferNANDo가 Java와 경쟁 할 수 있음을 증명하기 위해 259 바이트 의 '골프'버전이 있습니다. 논리는 눈에 띄게 다릅니다. 그것을 확인 not win하고 not tie(나는 만 필요하기 때문에 몇 NAND 게이트를 저장, not플레이어의 움직임의 버전을하고 있기 때문에이 not lose출력에 필요한되지 않았다). 그러나 읽기만큼 흥미롭지는 않습니다.

1 _ _ _ _ _ _ A b
B 1 b
C A B
o
P 1 ?
s 1 ?
p 1 P
S 1 s
o p s
o o
o
r P S
r r
0 1 1 1 0 0 P s
0 0 0 0 1 0 1 0
t s A
u r B
v p C
W t u
W W
W v
t p A
u s B
v r C
D t u
D D
D v
w 1 W
d 1 D
l W D
l l
0 1 0 w l 1 w w
0 1 1 d D l W D
0 1 1 l w w D W
0 W 1 d 0 W d 1

Python 3.x : 74 자

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

작동 원리

Before Machine Proceeds it determines the outcome of the game and based 
on the outcome, it determines the choice which would result in the outcome
viz Human's choice


\     Outcome
 \    0  1  2
  \_____________
H  | 
U 0|  0  1  2
M 1|  1  2  0
A 2|  2  0  1
N  |

Where Choices are represented as 
0 --> Paper
1 --> Scissor
2 --> Rock

Outcome (From Computer's Perspective)
0 --> Draw
1 --> Win
2 --> Fail

Given the sequence of choices as a string
"psr"
So its easy to see, if computer needs to win, it needs to choose the character
next to what human chooses. 
If computer needs to loose, it needs to choose the previous character to what
human chooses


MACHINE's|      CHOICES    |  Formulation
FATE     |-----------------|  For Machine's
         |  P     S      R |  Choice
---------|-----------------|-----------------------------
WIN(1)   |        H ---> M | (CHOICE+1) % 3 = (CHOICE+WIN)%3 
---------|-----------------|-----------------------------
LOSS(2)  |  M     H -----\ | (CHOICE+2)%3   = (CHOICE+LOSS)%3 
         |  ^            | |
         |  |____________| |
---------|-----------------|------------------------------       
DRAW(0)  |        H        | (CHOICE+0)%3   = (CHOICE+DRAW)%3
         |        M        |  
---------|-----------------|         

Combining all the above we have

MACHINE's CHOICE = (HUMAN CHOICE + MACHINE's FATE) % 3

운명에 따라 선택에 따라 수식을 선택해야합니다.

result = (User_choice + machines_fate) % no_of_choices

machine_choice = "psr"[result]

골프 용 버전

import time
choices = "psr"
#time.gmtime() returns the time structure in gmt
#time.gmtime()[5] is the current second tick
fate = time.gmtime()[5]%3
user_choice = input()
result = (choices.find(user_choice)+fate)%len(choices)
machine_choice = choices[result]
print(machine_choice, fate)

샘플 런

D:\temp\rivalry>rps.py
r
r 0

D:\temp\rivalry>rps.py
r
p 1

D:\temp\rivalry>rps.py
p
r 2

D:\temp\rivalry>rps.py
p
r 2

D:\temp\rivalry>rps.py
p
s 1

D:\temp\rivalry>rps.py
p
s 1

D:\temp\rivalry>rps.py
p
p 0

루아, 87

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

용법:

$ lua rps.lua p
s   Defeat

언 골프 드 :

names = 'rps'
comp_idx = os.time()%3 + 1                -- 1, 2 or 3 (depends on timer)
comp_move = names:sub(comp_idx, comp_idx) -- 'r', 'p' or 's'
user_move = ...                           -- input parameter: 'r', 'p' or 's'
user_idx = names:find(user_move)          -- 1, 2 or 3
delta_idx = (user_idx - comp_idx) % 3     -- 0, 1 or 2
all_results = {'Draw', 'Win', 'Defeat'}   -- [1]=='Draw', [2]=='Win', [3]=='Defeat'
game_result = all_results[delta_idx + 1]
print(comp_move, game_result)

GolfScript 62

Howard의 것보다 훨씬 지루한 대체 GolfScript 솔루션 :).

프로그램은 무작위로 이동을 선택하고 사용자의 관점에서 결과를 표시합니다.

코드

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

샘플 런

> 에코 s | 루비 golfscript.rb rps.gs

r "로즈"

온라인 테스트

: 현재 다른 입력을 가진 프로그램 및 실험을 실행할 수 있습니다 http://golfscript.apphb.com/?c=OydzJwoKJ3Jzc3BwcicuWzZyYW5kPV0nJys6wqdAKy4uJiwoez8pwqdcJ0xvc2UnJ1dpbidpZn17OzvCpydEcmF3J31pZmA%3D

그러나 일반적으로 명령 행에 전달되는 매개 변수 (사용자 이동)는 이제 코드 자체의 스택에 추가됩니다 (이 온라인 도구에서 "실제"명령 행 매개 변수를 제공 할 방법은 없습니다).

"Ungolfed"버전

GolfScript와 관련하여 ungolfed가 무엇을 의미 하는지 전혀 모르므로 의견을 추가하려고했습니다. 코드가 작동하는 방식을 명확히하고 좀 더 읽기 쉽게하기를 바랍니다.

# initially, the input (user's move) is on the stack

'rssppr'                # push the string 'rsspr' on the stack...
.                       # ...twice.

[
    6rand               # get a pseudo-random integer in the [0-5] range
    =                   # use the random index to get 
                        # a letter from the string above

]''+                    # workaroud to get the actual letter instead of the
                        # ASCII code

:§                      # assign the randomly chosen letter (computer's move)
                        # to a nice variable called "§"

@                       # rotates last 3 elements on the stack, bringing
                        # the user input in the uppermost position
                        # So, now we have: "rssppr" <computer_move> <user_move>
                        # on the stack

+                       # concatenate the two moves, so now we have a string
                        # that contains both (ex: "rs")

..                      # copy the move string twice
&                       # do a setwise AND to get the DISTINCT elements
,(                      # get the length of the resulting string and subtract 1
                        # (now we have 0 if the letters were equal and non-zero otherwise)

{                       # beginning of block to execute when the moves are different:

                        # now we have on the stack two strings:
                        #     - the string 'rssppr'
                        #     - the string containing the moves (ex: 'rs')

    ?                   # find the second string inside the first one,
                        # and get the index at which it occurs
                        # (or -1 if it does not)

    )                   # increment that number (we now get 0 if no occurrence, 1 otherwise)

    §                   # recall the § variable (so we display the computermove)
    \                   # rotate the uppermost two stack entries

    'Lose''Win'if       # if the move pair is found in the 'rssppr' string, 
                        # then print 'Lose', otherwise print 'Win'
}

{                       # beginning of block to execute when the moves are identical:

    ;;                  # discard the latest two stack items (not needed in this case)
    §                   # display computer's move
    'Draw'              # display the text 'Draw'
}
if                      # if computer's and user's moves were NOT equal, 
                        # execute the first block.
                        # if they were, execute the second block

`                       # put the last word in quotes to separate it from computer's move

C, 92 86 자

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

컴퓨터의 선택과 사용자 관점의 결과를 인쇄합니다-W = 승리, L = 패배, T = 넥타이. 선택의 ASCII 값이 주어지면
간단한 공식 x-y은 그릴 때 0 (분명히)과 서로 다른 경우 고유 값을 제공합니다.

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

0-타이, 1-패배, 2-승리

from random import*
a=raw_input()
b=choice('psr')
print(a!=b)+(b+a in'rpsr'),b

from random import*
a=input()
b=choice('psr')
print((a!=b)+(b+a in'rpsr'),b)

언 골프

from random import*
moves = 'psr'
inp   = raw_input()
comp  = choice(moves)
match = comp+inp
is_not_tie = inp!=comp
wins = 'r' + moves         #rpsr; rock beats scissors, scissors beats paper, paper beats rock
print is_not_tie + (match in wins), comp

실행하는 방법 : python file_name_here.py

문제 :
컴퓨터 AI : 35 자

먼저 다른 사람을 검토하지 않고 시도하십시오.

골프 : 107 85 바이트

i=prompt(),c="rps"[new Date%3],w={r:"s",p:"r",s:"p"};alert(c+(i==w[c]?2:w[i]==c?1:3))

출력은 [npc-choice] [1 : win, 2 : loss, 3 : tie]입니다.

언 골프 :

var input = prompt(),
    choices = ["r","p","s"],
    computer_choice = choices[Math.floor(Math.random() * 3)],
    outcomes = {'r':'s','p':'r','s':'p'},
    winner;

    if( input == outcomes[computer_choice] ) {
        winner = 'NPC';
    } else if ( computer_choice == outcomes[input] ) {
        winner = 'You';
    } else {
        winner = 'No one, it was a Tie!';
    }

    alert('Computer chose: ' + computer_choice + '\n' +
          'The winner is: ' + winner);

PowerShell을 : 144 133 117 111 92 73

원본에서 변경 :

• Danko Durbic의 3 인 짝수 또는 홀수 솔루션 을 본 후 스크립트를 완전히 다시 작성했습니다 .
• 문자 배열 대신 $ s를 단일 문자열로 변경했습니다.
• .NET 클래스 및 메소드를 철자하는 대신 IndexOf를 $ s의 직접적인 메소드로 사용했습니다.
• 중복을 제거했습니다 %3.

모두들, 원래 대답에서 길이를 거의 절반으로 줄였습니다!

골프 코드 :

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

콘솔에서 바로 실행할 수 있습니다.

코멘트가없는 언 골프 드 :

# Variable $p will store the player's selection as a ternary digit by finding its position in a string containing the possible choices.
$p=(
    # Possible choices will be stored in a variable, $s, for later reuse.
    $s='rps'
# Get the position of the player's choice from $s.
).IndexOf((read-host));

# Express the computer's choice by outputting the appropriate character from $s.
$s[(
    # Computer's choice will be stored as a ternary digit in $c.
    $c=Random 3
)];

# Outcome for the player will be chosen from a string of possible outcomes by looking up the decimal repesentation of a two-digit ternary number.
# The threes digit is represented by $c, ones digit by $p.
"TWLLTWWLT"[$p+$c*3]

# Variable cleanup - do not include in golfed code.
rv p,s,c

일부 샘플은 콘솔에서 실행됩니다.

자바 259 :(

class c {public static void main(String[]a){char y=a[0].charAt(0);char m="rps".charAt(new java.util.Random().nextInt(3));if(y==m)a[0]="T";else if((y=='r'&& m=='s')||(y=='s'&& m=='p')||(y=='p'&& m=='r'))a[0]="1";else a[0]="0";System.out.println(m+":"+a[0]);}}

고도로 코드화되지 않은 코드 :

class c {
    public static void main(String[] a) {
        char y = a[0].charAt(0);
        char m = "rps".charAt(new java.util.Random().nextInt(3));
        if (y == m) {
            a[0] = "T";
        } else if ((y == 'r' && m == 's') || (y == 's' && m == 'p') || (y == 'p' && m == 'r')) {
            a[0] = "1";
        } else {
            a[0] = "0";
        }
        System.out.println(m + ":" + a[0]);
    }
}

샘플 실행 :

C :> 자바 cr

s : 1

C :> 자바 CP

p : T

C :> 자바 CS

성

용서 : 107 자

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

약간 시끄럽다. 그것은 축소 가능하며 문제는 얼마입니다.

자바 스크립트 (87)

골프 :

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

언 골프 드 :

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

브라우저의 자바 스크립트 콘솔에 코드를 붙여 넣어 실행할 수 있습니다.

컴퓨터 선택 (83)을 인쇄하기 전에 결과를 인쇄 할 수있는 경우 :

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

K, 67

{-1'f:x,*1?"rps";$[f in b:("pr";"rs";"sp");"W";f in|:'b;"L";"D"]}

승 / 패 / 무승부를 위해 W, L, D를 인쇄합니다.

언 골프 드 :

rps:{[x]
    res:x,*1?"rps";        // join user input to random selection of r,p,s
    -1'f;                  // print the user input and the program selection to stdout
    wins:("pr";"rs";"sp"); // the universe of winning combinations
    losses:|:'wins;        // reverse each win to the get losses

    $[f in wins;    
        "win";
    f in losses;
        "lose";
    "draw"]
    }

또는 Q에서 더 읽기 쉽습니다.

rps:{[x]
    res:x,rand["rps"];        // join user input to random selection of r,p,s
    -1 each f;                // print the user input and the program selection to stdout
    wins:("pr";"rs";"sp");    // the universe of winning combinations
    losses:reverse each wins; // reverse each win to the get losses

    $[f in wins;    
        "win";
    f in losses;
        "lose";
    "draw"]
    }

샘플 실행 :

k){-1'f:x,*1?"rps";$[f in b:("pr";"rs";"sp");"W";f in|:'b;"L";"D"]}"r"
r
s
"W"
k){-1'f:x,*1?"rps";$[f in b:("pr";"rs";"sp");"W";f in|:'b;"L";"D"]}"s"
s
s
"D"
k){-1'f:x,*1?"rps";$[f in b:("pr";"rs";"sp");"W";f in|:'b;"L";"D"]}"p"
p
s
"L"

자바 스크립트, 117 자

다음은 문제에 대한 데이터 중심 접근 방식입니다. 수동으로 매핑하는 대신 win / lose / draw 데이터를 생성하여 최적화 할 수는 있지만 시작입니다. :)

골프 :

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

언 골프 드 :

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

    //Output the value the computer chose
    ).value

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

마지막으로 여기 에 둘 다 있는 바이올린 이 있습니다.

자바 스크립트 : 256

골프 :

i=prompt(),a=['p','r','s'];a=a[Math.floor(Math.random()*(3-1+1))+1];if(i==a){alert('d');}else if(i=='p'){if(a=='s'){alert('l');}else{alert('w');}}else if(i=='r'){if(a=='s'){alert('w');}else{alert('l');}}else if(i=='s'){if(a=='r'){alert('l');}else{alert('w')}}

언 골프 :

i=prompt(),a=['p','r','s'];
a=a[Math.floor(Math.random()*(3-1+1))+1];
if(i==a){
    alert('d');
}
else if(i=='p'){
    if(a=='s'){
        alert('l');
    }else{alert('w');}
}else if(i=='r'){
    if(a=='s'){
        alert('w');
    }else{alert('l');}
}else if(i=='s'){
    if(a=='r'){
        alert('l');
    }else{alert('w')}
} 

클로저 :

(def r 0) (def s 1) (def p 2)
(def object-name #(get {'p "Paper", 's "Scissors", 'r "Rock"} %))
(def result-name #(get {\d "Draw", \w "Win", \l "Lose"} %))
(defn computer-choice [] (nth ['r 's 'p] (int (rand 3))))
(defn game [a b] (get "dwlldwwld" (+ (* 3 a) b) ))
(defn print-game [user comp result] (print (format
  "User: %s\nComputer: %s\nResult: %s\n" 
  (object-name user) (object-name comp) (result-name result))))
(println "Enter 'p', 's' or 'r' and press return")
(let [comp (computer-choice),  user (read)]  (print-game user comp (game (eval user) (eval comp))))

미니 버전 (129 코드 문자) :

java -jar clojure.jar -e \
"(def r 0)(def s 1)(def p 2)(let[u(read),c(nth['r 's 'p](int(rand 3)))](print c)(print (get \"dwlldwwld\"(+(* 3(eval u))(eval c)))))"

JAVA (387) 퍼스트 코드 골프!

import java.util.HashMap;public class _ {public static void main(String i[]){HashMap l = new HashMap(){{put('r',0);put('p',1);put('s',2);put(0,'T');put(1,'L');put(2,'W');}};char u =i[0].charAt(0);char c ="rps".charAt((int)(Math.random()*3)%3);int[][] m =new int[][]{{0,1,2},{2,0,1},{1,2,0}};System.out.println("U"+u+"C"+c+"R"+(Character)l.get(m[(Integer)l.get(u)][(Integer)l.get(c)]));}}

언 골프

import java.util.HashMap;
public class _ {
    public static void main(String[] input) {
       input = new String[] {"s"};
       HashMap lookup = new HashMap(){{
           put('r', 0);
           put('p', 1);
           put('s', 2);
           put(0, 'T');
           put(1, 'L');
           put(2, 'W');
       }};
       char user = input[0].charAt(0);
       char computer = new char[] {'r', 'p', 's'}[(int)(Math.random()*3)%3];
       int[][] matrix = new int[][] {{0,1,2}, {2,0,1}, {1,2,0}};

       Integer userChoice = (Integer) lookup.get(user);
       Integer computerChoice = (Integer) lookup.get(computer);
       Character result = (Character) lookup.get(matrix[userChoice][computerChoice]);

       System.out.println("u:" + user + ",c:" + computer + ",r:" + result);
    }
    /*
     t = 0, l = 1, w = 2
     *
        +---------------+
        | * | r | p | s |
        +---------------+
        | r | 0 | 1 | 2 |
        +---------------+
        | p | 2 | 0 | 1 |
        +---------------+
        | s | 1 | 2 | 0 |
        +---------------+
     */
}

골프 (간격 / 인덴 테이션)

import java.util.HashMap;
public class _ {
public static void main(String i[]) {
    HashMap l = new HashMap(){{
        put('r',0);put('p',1);put('s',2);put(0,'T');put(1,'L');put(2,'W');
    }};

    char u =i[0].charAt(0);char c = "rps".charAt((int)(Math.random()*3)%3);
    int[][] m =new int[][]{{0,1,2},{2,0,1},{1,2,0}};

    System.out.println("U"+u+"C"+c+"R:"+(Character)l.get(m[(Integer)l.get(u)][(Integer)l.get(c)]));
}}

_{가장 짧은 코드는 아니지만 첫 번째 시도}

이동 (169)

골프 :

package main
import("fmt";"os")
func main(){v:=map[uint8]int{114:0,112:1,115:2}
u:=os.Args[1][0]
c:="rps"[os.Getpid()%3]
fmt.Printf("%c\n%c\n",c,"TWL"[(3+v[c]-v[u])%3])}

ungolfed (로 형식화 됨) go fmt ) :

package main

import (
    "fmt"
    "os"
)

func main() {
    v := map[uint8]int{114: 0, 112: 1, 115: 2}
    u := os.Args[1][0]
    c := "rps"[os.Getpid()%3]
    fmt.Printf("%c\n%c\n", c, "TWL"[(3+v[c]-v[u])%3])
}

운영 :

실행 main.go p

에스

여

피 이스 , 23

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

출력 형식은 다음과 같습니다.

동점 : 0 승리 : 1 손실 : 2

설명:

J"rps"             J="rps"
K+wOJ              K=input()+random_choice(J)
K                  print K
  XJ'K             index of K[0] in J
      XJtK         index of K[1] in J
 -XJ'KXJtK         difference of above indexes
%-XJ'KXJtK3        above difference mod 3

다음과 같이 실행하십시오.

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

캐릭터가 4 명 이상인 경우 넥타이에는 T, 승리에는 W, 손실에는 L을 사용할 수 있습니다.

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

인덱스 차이가 나올 때까지 모든 것이 동일합니다.이 시점에서 차이를 문자열의 인덱스로 사용합니다 "TWL".

참고 : 챌린지가 게시 된 후이 언어를 개발했지만 오늘까지는 챌린지를 보지 못했습니다. 도전은 언어의 어떤 측면에도 영향을 미치지 않았습니다.

그루비, 89

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

사용자 선택을 인수로 사용합니다. 예:

groovy rps.groovy p
sL

C # 및 LinqPad 133

골프 :

char i,c,r;i=Console.ReadLine()[0];var a="prsp";c="prs"[new Random().Next(3)];r=i==c?'T':a.Contains(""+i+c)?'W':'L';(c+">"+r).Dump();

언 골프 :

        char i, c, r; // i for input / c for choosen by computer / r for result
        i = Console.ReadLine()[0]; //getting input in LinqPad
        var a = "prsp"; 
        c = "prs"[new Random().Next(3)]; // Computer choose a random string
        r = i == c ? 'T' : a.Contains("" + i + c) ? 'W' : 'L'; (c + ">" + r).Dump(); //check for win - dump for output in LinqPad

샘플 출력 (입력은 s였습니다) : r> L // 컴퓨터는 rock (r)을 선택합니다-> 그래서 우리는졌습니다

자바 스크립트 (79)

오래된 것을 범프하지만 여기에 우리는 간다 ...

pegnatite, pyroxenite, scoria, sovite, kimberlite, trondjemite, tuff 또는 기타를 좋아하는 모든 바위를 사용할 수있는 보너스가 추가되었습니다. 유일한 제한은 p또는 ;-)를 사용할 수 없다는 것s

입력:

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

산출:

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

예:

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

골프 코드 :

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

사용되는 주요 요령은 다음과 같습니다.

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

       개체를 사용 {}하고, 사용자로부터의 입력에 의해 값을 검색 prompt(). 여태까지는 그런대로 잘됐다. 그런 다음 NOT 연산자 를 사용하여 r : 0강제로 변환 할 수 있습니다 . 그것은 바닥 번호에 자주 사용되지만 , 예를 들어 다음과 같이 다른 연산자가 원할 때 반환하지 않는 이점도 있습니다.0~~NaN+{a:1, b:2}['c']

2. c = new Date%3

       예를 들어 날짜 +new Date를 타임 스탬프로 직접 변환하는 데 사용 하면 날짜가 자주 사용 됩니다. 그렇지 않으면 문자열 표현이 나타납니다. 여기서 mod one 을 사용 하면 동일한 효과를 얻을 수 있습니다.

3. 'rps'[c]

       문자열은 컴퓨터의 선택을 제공에 인덱스 액세스 0 = r, 1 = p또는 2 = s.

4. (u==c ? 2 : !u&c>1 | u&!c | u>1&c )

   IF  u == c
       Draw                    (aka 2)
   ELSE IF !u&c>1|u&!c|u>1&c 
       Win                     (aka 1)
   ELSE
       Loss                    (aka 0)
   ENDIF


...

ungolfed 코드는 다음과 같습니다.

function rock_paper_scissors() {
    var choices = {
            r : 0,
            p : 1,
            s : 2,
        },
        tr_table = ['Rock','Paper','Scissors'],
        user, pc, result
    ;

    function get_input() {
        var input = prompt("Enter your choice `r', `p' or `s':")
                    .toLowerCase();

        if (!/^[rps]/.test(input)) {
            console.warn("Bad input. Please choose `r', `p' or `s'.");
            // return get_input();
            return null;
        }
        return input[0];
    }
    function report(c1, c2) {
        if (c1 === pc) {
            return 'Draw';
        } else if (
            (c1 === 0 && c2  >  1) ||
            (c2 === 0 && c1 === 1) ||
            (c1  >  1 && c2  >  0)
        ) {
            return 'Win';
        } else {
            return 'Loss';
        }
    }

    if ((user = get_input())) {
        user = choices[user];
        pc = Math.floor(Math.random() * 3);
        result  = 
            'Computers choice: ' + tr_table[pc] + ', ' +
            'Your choice: ' + tr_table[user] + ', ' +
            'Result=' +  report(user, pc);
        console.log(result);
    }
    return result;
}

rock_paper_scissors();

골프 스크립트-29

이것은 이번에 실제 답변입니다 (당신을보고 n"Draw": P).

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

언 골프 드 :

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

프로그램 코드가있는 ruby golfscript.rb MyCode.txt곳에서 실행할 수 있습니다 MyCode.txt.

샘플 실행 (모두 입력 "r"을 사용하지만 모든 것이 작동 함) (tie는 0, win은 2, loss는 1) :

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

버전에 대한 설명을 원하거나 개선이 필요한 경우 알려주십시오.

자바 스크립트, 65 71 70

컴퓨터 선택 출력이없는 경우 : 65

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

해당 솔루션이 올바른지 테스트하십시오.

for(x in {r:0,p:0,s:0})
  for(y in {r:0,p:0,s:0})
    console.log("%s %s %s", x, y, '-+0+0+0'['rppssrr'.indexOf(x+y)+1])

컴퓨터 선택 출력 : 71

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

70

alert((g='rps'[new Date%3]+prompt())+-('srps'.match(g)?-1:g[0]!=g[1]))

그리고 테스트 :

for(x in {r:0,p:0,s:0})
  for(y in {r:0,p:0,s:0})
    console.log((g=x+y)+-('srps'.match(g)?-1:g[0]!=g[1]))