"Rock", "Paper"또는 "Scissors"의 두 개의 문자열 입력이 주어지면 RPS 라운드 의 결과를 결정합니다 . 첫 번째 플레이어가 이기면 1을, 두 번째 플레이어가 이기면 -1을, 넥타이를 0으로 출력하십시오.

Rock Rock -> 0
Rock Paper -> -1
Rock Scissors -> 1
Paper Rock -> 1
Paper Paper -> 0
Paper Scissors -> -1
Scissors Rock -> -1
Scissors Paper -> 1
Scissors Scissors -> 0

정확한 문자열 "Rock", "Paper"및 "Scissors"를 입력으로 사용해야합니다. 첫 번째 플레이어의 선택이 (일관되게) 첫 번째인지 두 번째인지를 선택할 수 있습니다. 또는 단일 문자 또는 빈 구분 기호를 사용하여 단일 입력으로 사용할 수도 있습니다. 입력은 입력 형식에서 세 가지 선택 중 9 가지 가능한 페어링 중 하나를 보장합니다.

출력은 숫자 1, 0 또는 -1 또는 문자열 표현이어야합니다. 수레는 괜찮습니다. 그래서입니다 +1, +0,하고 -0.

관련 : RPS 게임을 코딩

리더 보드 :

var QUESTION_ID=106496,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/106496/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

그루비, 67 56 50 바이트

{a,b->Math.sin(1.3*((int)b[0]-(int)a[0])).round()}

온라인으로 사용해보십시오!

바위, 종이, 가위 게임은 꽤 멋진 특성을 가지고 있습니다.
주어진 문자열 a와 b는 각각의 첫 글자를 취합니다. 결과는 다음 중 두 가지입니다.R,P,S

가능한 값의 전체 목록은 다음과 같습니다 (두 가지 선택 사항이 결합 된 경우).

XX=ASCII=Y=Wanted output
RR=82-82=0=0
PP=80-80=0=0
SS=83-83=0=0
RS=82-83=-1=1
RP=82-80=2=-1
PS=80-83=-3=-1
PR=80-82=-2=1
SR=83-82=1=-1
SP=83-80=3=1

목록을 다음으로 재구성 :

-3->-1
-2->1
-1->1
0->0
1->-1
2->-1
3->1

역 정현파로 보이는 시퀀스를 제공하며, 실제로이 공식을 대략적으로 표현할 수 있습니다.

-sin((4*a[0]-b[0])/PI).roundNearest() = sin(1.3*(b[0]-a[0])).roundNearest()

4 / pi의 1.3으로의 단순화는 @flawr에서 먼저 제안한 다음 @titus 에서 6 바이트의 총 절감 을 테스트했습니다 .

그루비의 이중 반올림 속성을 사용하면 가위 바위 보에 대한 올바른 출력이 생성됩니다.

05AB1E , 10 바이트 (비경쟁)

Ç¥13T/*.½ò

온라인으로 사용해보십시오!

2017 년 10 월 26 일 추가 된 새로운 명령을 사용하여 05AB1E로 포팅 된 동일한 답변입니다.

C, 50 35 바이트

#define f(i)*(short*)(i+7)%51%4%3-1

f구분 기호없이 두 플레이어를 모두 포함하는 문자열로 전화 하면 첫 번째 승리 여부를 반환합니다.

설명:

9 개의 가능한 문자열을 보면 7 열과 8 열의 문자 쌍이 고유하다는 것이 밝혀졌습니다.

       vv
RockPaper
PaperScissors
ScissorsRock
RockRock         // Sneakily taking advantage of the terminating zero
PaperPaper
ScissorsScissors
RockScissors
PaperRock
ScissorsPaper
       ^^

short*이러한 문자 쌍 을 검색하여 숫자로 해석 하기 위해 오프셋과 야만적 캐스트를 수행합니다.

29285
29545
21107
107
25968
21363
29555
27491
20595

그런 다음 찾을 수 무차별의 문제라고 51하고 4이러한 숫자를 감소 연속적으로 적용된 나머지를 :

3 0 0 1 1 1 2 2 2

그것은 마지막에 또 다른 나머지를 압수하고 결과를 상쇄하기에 완벽합니다.

콜리 루에서 생방송보기

MATLAB / 옥타브 , 63 54 52 바이트

첫 문자의 ASCII 코드 Rock,Paper,Scissors는 R=82,P=80,S=83입니다. 우리가 빼면 79우리는 편리하게 얻을 수 3,1,4있으며, 이제 우리는 행렬 인덱스로 사용할 것입니다. 여기서 4x4 행렬이 하드 코딩되어 있습니다. 여기서- i,j번째 항목은 바로 전에 값을 연결하면 결과에 해당합니다.

     1   2   3   4
  +---------------
1 |  0   0   1  -1
2 |  0   0   0   0
3 | -1   0   0   1
4 |  1   0  -1   0

A(5,5)=0;A(4:7:18)=1;A=A-A';@(x,y)A(x(1)-79,y(1)-79)

온라인으로 사용해보십시오!

순수한 배쉬, 31

@Dennis 의 공식 대여 :

a=$1$1$2
echo $[(${#a}^67)%3-1]

온라인으로 사용해보십시오 .

이전 답변 :

퓨어 배쉬, 43 35

echo $[(7+(${#2}^3)-(${#1}^3))%3-1]

• 각 인수의 문자열 길이를 가져옵니다 ( 4, 5, 8각각 록, 종이, 가위)

• 3 각 얻었다 XOR 7, 6, 11(여기서 3 개조주고 촬영시 1, 0, 2)

• 그런 다음 원하는 결과를 얻기 위해 mod 3을 빼고 바이올린을칩니다.

온라인으로 사용해보십시오 .

파이썬 , 40 30 바이트

lambda x,y:(len(2*x+y)^67)%3-1

온라인으로 사용해보십시오!

배경

함수 템플릿으로 시작했습니다

lambda x,y:(len(a*x+b*y)^c)%d-e

다음 프로그램을 사용하여 적절한 매개 변수에 대한 무차별 검색을 실행 한 다음 최소 길이 구현으로 선택했습니다.

RPS = 'Rock Paper Scissors'.split()
g = lambda x,y:2-(94>>len(6*x+y)%7)%4
r = range(1,10)
R = range(100)

def f(a, b, c, d, e):
    h = lambda x,y:(len(a*x+b*y)^c)%d-e
    return all(g(x, y) == h(x, y) for x in RPS for y in RPS)

[
    print('%2d ' * 5 % (a, b, c, d, e))
    for e in r
    for d in r
    for c in R
    for b in r
    for a in r
    if f(a, b, c, d, e)
]

온라인으로 사용해보십시오!

수학, 32 바이트

Mod[{1,-1}.(Length/@#-3)!,3,-1]&

이름없는 함수와 같은 문자 목록을 순서대로 가져 와서 {{"R","o","c","k"},{"P","a","p","e","r"}}반환 -1|0|1합니다.

나는 코드가 세 개의 입력 단어뿐만 아니라 너무 긴 함수 이름을 피하기를 원했다 ToCharacterCode. 그래서 나는 4,5,8입력 단어 의 길이 를 대신 사용하여 모듈러스 3이라는 뚜렷한 답변을주는 길이의 짧은 함수를 찾았습니다 (2로 정수 나누기는 수학적으로 유망하지만 Mathematica에서는 그 함수의 이름이 너무 깁니다).

그것은 밝혀 그 (길이 - 3)의 계승 복용에 대한 답변 제공 1,2,120되며, 1,-1,03. 그 다음 우리가 계산 모듈로를, 모듈 3, 내적 통해 두 값의 차이 ( {1,-1}.{x,y} = x-y좋은 방법이며,시 두 값이 목록에 있습니다).

루비, 36 35 30 바이트

a=->a,b{(a+b)[12]?a<=>b:b<=>a}

ideone.com에서 사용해보십시오

테스트 출력 :

a=->a,b{(a+b)[12]?a<=>b:b<=>a}

puts a.call("Rock", "Rock")
puts a.call("Rock", "Paper")
puts a.call("Rock", "Scissors")
puts a.call("Paper", "Rock")
puts a.call("Paper", "Paper")
puts a.call("Paper", "Scissors")
puts a.call("Scissors", "Rock")
puts a.call("Scissors", "Paper")
puts a.call("Scissors", "Scissors")

0
-1
1
1
0
-1
-1
1
0

9 개의 올바른 결과 중 7 개가 우주선 연산자를 사용하여 사전 비교를 수행하여 생성된다는 사실을 이용합니다 <=>. 는 (a+b)[12]입력이있는 경우 바로 비교에 대한 입력을 반전 Paper하고 Scissors(도 Scissors Scissors-하지만 그건 0어느 쪽이든 라운드).

캐릭터를 구해준 Horváth Dávid와 5를 구해 준 GB에게 감사합니다.

파이썬 , 39 36 34 33 바이트

lambda x,y:2-(94>>len(6*x+y)%7)%4

온라인으로 사용해보십시오!

작동 원리

x 의 6 개 사본 길이 와 y modulo 7 의 1 개 사본 길이의 몇 가지 값을 살펴 보겠습니다 .

                                l(x,y) =:
x        y        len(x) len(y) len(6*x+y)%7
--------------------------------------------
Rock     Rock          4      4            0
Rock     Paper         4      5            1
Rock     Scissors      4      8            4
Paper    Rock          5      4            6
Paper    Paper         5      5            0
Paper    Scissors      5      8            3
Scissors Rock          8      4            3
Scissors Paper         8      5            4
Scissors Scissors      8      8            0

결과를 {0, 1, 2, 3} 세트에 맵핑 하여 결과 ( {-1, 0, 1} )를 인코딩 할 수 있습니다 . 예를 들어, 매핑 t ↦ 2-t 는 이것을 달성하며 그 자체는 역이다.

의는의 결과를 나타내는합시다 X 와 Y를 하여 오 (X, Y) . 그때:

x        y        l(x,y) o(x,y) 2-o(x,y) (2-o(x,y))<<l(x,y)
-----------------------------------------------------------
Rock     Rock          0      0        2                10₂
Rock     Paper         1     -1        3               110₂
Rock     Scissors      4      1        1            010000₂
Paper    Rock          6      1        1          01000000₂
Paper    Paper         0      0        2                10₂
Paper    Scissors      3     -1        3             11000₂
Scissors Rock          3     -1        3             11000₂
Scissors Paper         4      1        1            010000₂
Scissors Scissors      0      0        2                10₂

다행히, 마지막 컬럼의 비트 모두가 서로 일치, 그래서 우리는 또는 그들을 하나의 정수 형성 할 수 없음을 하고 검색 O (X, Y) 로 2 - ((N»O (X, Y)) % 4) . n 값 은 94 입니다.

망막 , 35 31 바이트

G`k P|r S|s R
*\)`.+
-
D`\w+
 .

온라인으로 사용해보십시오!

설명

이것은 두 단계로 작동합니다. 먼저 관련 입력에 대한 빼기 기호를 인쇄합니다. 그런 다음 0관계 및 1기타 를 인쇄합니다 .

G`k P|r S|s R
*\)`.+
-

이것은 두 단계입니다. 은 )함께 두 번째 단계의 그룹화에서,는 *그 건조를 실행한다 (이들이 처리 된 후, 입력 된 문자열이 복원되는 것을 의미하지만, 그 결과를 인쇄한다)와 \후행 바꿈 인쇄를 억제한다. -해당 되는 경우 두 단계가 함께 인쇄 됩니다.

첫 번째 스테이지는 인 G이 하나 포함되어있는 경우에만 광고 유지 담당자 단계 k P, r S또는 s R. 이것은 우리가 출력해야하는 경우에 해당합니다 -1. 이러한 경우 중 하나가 아닌 경우 입력이 빈 문자열로 바뀝니다.

두 번째 단계는 .+(전체 문자열이지만 하나 이상의 문자가 포함 된 경우에만)를로 바꿉니다 -. 따라서이 -세 가지 경우에 대해 a 를 인쇄하고 그렇지 않은 경우 아무것도 인쇄 하지 않습니다.

D`\w+
 .

이것은 두 단계 더 있습니다. 첫 번째 단계는 D중복 제거입니다. 단어를 일치시키고 중복을 제거합니다. 입력이 타이 인 경우에만 두 번째 단어가 삭제됩니다.

두 번째 단계는의 일치 횟수를 계산합니다 .. 공백은 그 뒤에 문자가옵니다. 입력이 동점이고 두 번째 단어가 제거 된 경우 결과는 0입니다. 그렇지 않으면 두 번째 단어가 그대로 있고 일치하는 단어가 있으므로 1대신 인쇄 됩니다.

05AB1E , 18 17 15 10 9 바이트

Digital Trauma의 입력 길이 트릭으로 6 바이트 저장

€g3^Æ>3%<

다음과 같이 입력을받습니다. [SecondPlayersChoice,FirstPlayersChoice]

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 검증

대체 9 바이트 솔루션 : íø¬ÇÆ>3%<

설명

€g          # length of each in input
  3^        # xor 3
    Æ       # reduce by subtraction
     >      # increment
      3%    # modulus 3
        <   # decrement

이전 15 바이트 솔루션

A-D{„PSÊiR}Ç`.S

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 검증

설명

 A-               # remove the lowercase alphabet from the input (leaves a 2 char string)
   D{             # sort a copy of the leftover
     „PSÊ         # check if the copy isn't "PS" (our special case)
         iR}      # if true, reverse the string to get the correct sign
            Ç`    # convert the two letters to their character codes
              .S  # compare their values

젤리 , 8 바이트

L€Iµ-*×Ṡ

온라인으로 사용해보십시오! (테스트 스위트, 명확성을 위해 정수로 캐스트)

작동 원리

L€Iµ-*×Ṡ  Main link. Argument: A (string array)

L€        Take the length of each string.
  I       Increments; compute the forward difference of the length.
   µ      Begin a new chain with the difference d as argument.
    -*    Compute (-1)**d.
      ×Ṡ  Multiply the result with the sign of d.

파이썬 2 , 46 40 바이트

lambda x,y:+(x!=y,-1)[x[0]+y[0]in'RPSR']

온라인으로 사용해보십시오!

@Dennis에게 온라인 테스트 코드를 빌려주고 6 바이트를 절약 해 준 것에 감사드립니다.

편집하다

@ hashcode55-당신이 묘사 한대로. (x! = y, -1)은 두 개의 요소 시퀀스이며 [x [0] + y [0] in'RPSR ']은 어떤 요소를 취할지 계산합니다. x의 첫 번째 문자 + y의 첫 번째 문자가 문자 목록에 있으면 True 또는 1로 평가되므로 (x! = y, -1) [1]이 반환됩니다. 그렇지 않으면 (x! = y, -1) [0]입니다. 여기가 조금 까다로워집니다. 첫 번째 요소는 사실상 다른 요소입니다. x! = y 인 경우 첫 번째 요소는 True이고 그렇지 않으면 False가됩니다. 따라서 'RPSR'에서 x [0] + y [0]이 false이면 x == y에 따라 True 또는 False가 반환됩니다. +는 조금 비꼬고 @Dennis에게 다시 한 번 감사드립니다. x! = y는 리터럴 True 또는 False를 반환합니다. 1 또는 0이 필요합니다. 여전히 +를 사용하여이 변환을 수행하는 방법을 모르겠습니다. True / False에서 수학 연산자를 사용하면 정수로 표시되도록 강요한다고 가정 할 수 있습니다. 분명히 -1 앞의 +는 여전히 -1을 반환합니다.

도움이 되었기를 바랍니다!

자바 스크립트 (ES6), 46 38 바이트

(a,b)=>(4+!b[4]+!b[5]-!a[4]-!a[5])%3-1

가위 바위 기가 주기적이라는 사실을 이용합니다. JavaScript에는 우주선이나 균형 잡힌 3 항 연산자가 없습니다 (a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3. 그렇지 않으면 대답은입니다 .

편집 : @WashingtonGuedes 덕분에 8 바이트가 절약되었습니다.

MATL , 14 13 바이트

TTt_0vic1Z)d)

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

첫 번째 문자열의 초기 문자의 ASCII 코드가 두 번째 문자열의 ASCII 문자에서 빼면 아래 D 열의 값을 얻습니다 . 모듈로 5를 취하면 값 M이 됩니다. 괄호 안의 최종 값은 원하는 결과 R 입니다.

                        D        M     R
                       ---      ---   ---
Rock Rock          ->   0   ->   0   ( 0) 
Rock Paper         ->  −2   ->   3   (−1)
Rock Scissors      ->   1   ->   1   ( 1)
Paper Rock         ->   2   ->   2   ( 1)
Paper Paper        ->   0   ->   0   ( 0)
Paper Scissors     ->   3   ->   3   (−1)
Scissors Rock      ->  −1   ->   4   (−1)
Scissors Paper     ->  −3   ->   2   ( 1)
Scissors Scissors  ->   0   ->   0   ( 0)

따라서 D 를 계산 한 다음 M을 계산 하면 R 을 얻기 위해 0에 0 만 매핑하면됩니다. 1 및 2 내지 1; 3 및 4 내지 -1. 이것은 0, 1 또는 -1과 같은 5 개의 항목 배열로 색인화하여 수행 할 수 있습니다. MATL의 인덱싱은 1 기반이며 모듈 식이므로 배열은 [1, 1, −1, −1, 0]첫 번째 항목에 인덱스 1이 있고 마지막 항목에 인덱스 5가 있거나 동등하게 0 이어야합니다 . 마지막으로 모듈러스 5 연산은 모듈 식 인덱싱에 의해 암시 적으로 수행되기 때문에 운 좋게 피할 수 있습니다.

TT     % Push [1 1]
t_     % Duplicate, negate: pushes [−1 −1]
0      % Push 0
v      % Concatenate vertically into the 5×1 array [1; 1; −1; −1; 0]
i      % Input cell array of strings
c      % Convert to 2D char array, right-padding with zeros if necessary
1Z)    % Take the first column. Gives a 2×1 array of the initial letters
d      % Difference
)      % Index into array. Implicit display

CJam , 12 바이트

0XXWW]rcrc-=

두 입력은 공백으로 구분됩니다. 챌린지 텍스트의 순서와 반대로 순서가 바뀝니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

내 MATL 답변의 번역 . 이것은 c문자열에 적용된 CJam (char로 변환)에서 첫 문자를 취 한다는 사실을 이용합니다 . 또한 CJam의 인덱싱이 0 기반이기 때문에 매핑의 배열이 다릅니다.

0XXWW    e# Push 0, 1, 1, -1, -1
]        e# Pack into an array
rc       e# Read whitespace-separated token as a string, and take its first char
rc       e# Again
-        e# Subtract code points of characters
=        e# Index into array. Implicitly display

CJam, 15 14 12 바이트

rW=rW=-J+3%(

각 문자열의 마지막 문자의 ASCII 코드를 가져 와서 다음을 반환합니다.

(a1 - a2 + 19) % 3 - 1

여기에서 테스트 하십시오 !

파이썬 3, 54 바이트

lambda o,t:(o!=t)*[-1,1]['RPS'['PS'.find(t[0])]!=o[0]]

온라인으로 사용해보십시오!

자바 7, 82 바이트

int c(String...a){int x=(a[0].charAt(1)-a[1].charAt(1))%5/2;return x%2==x?x:x/-2;}

언 골프 드 :

int c(String... a){
   int x = (a[0].charAt(1) - a[1].charAt(1)) % 5 / 2;
   return x%2 == x
           ? x
           : x / -2;
}

설명:

• 두 번째 편지는 o, a그리고 c는 ASCII 십진수로 111, 97와 99.
• 테스트 사례에서 서로 빼면 다음과 같은 결과가 나타납니다.
  • 0 (락, 락)
  • 14 (바위, 종이)
  • 12 (종이, 가위)
  • -14 (종이, 바위)
  • 0 (용지, 종이)
  • -2 (종이, 가위)
  • -2 (가위, 바위)
  • 2 (가위, 종이)
  • 0 (가위, 가위)
• 우리는 각각의 모듈 (5)를 가지고가는 경우에, 우리는 수 4, 2, -4, -2, -2, 2.
• x테스트 케이스의 경우 2 로 나눈 값 은 다음과 같습니다.
  • x = 0 (락, 락)
  • x = 2 (바위, 용지)
  • x = 1 (용지, 가위)
  • x = -2 (종이, 바위)
  • x = 0 (용지, 용지)
  • x = -1 (용지, 가위)
  • x = -1 (가위, 바위)
  • x = 1 (가위, 용지)
  • x = 0 (가위, 가위)
• 만 2하고 -2정확하고 있었어야 -1하고 1대신. 따라서 x%2 != x(위 1또는 아래의 모든 것 -1) -2이 두 '가장자리'를 수정하기 위해 나눕니다 .

테스트 코드 :

여기에서 시도하십시오.

class M{
  static int c(String...a){int x=(a[0].charAt(1)-a[1].charAt(1))%5/2;return x%2==x?x:x/-2;}

  public static void main(String[] a){
    String R = "Rock",
           P = "Paper",
           S = "Scissors";
    System.out.println(c(R, R)); // 0
    System.out.println(c(R, P)); // -1
    System.out.println(c(R, S)); // 1
    System.out.println(c(P, R)); // 1
    System.out.println(c(P, P)); // 0
    System.out.println(c(P, S)); // -1
    System.out.println(c(S, R)); // -1
    System.out.println(c(S, P)); // 1
    System.out.println(c(S, S)); // 0
  }
}

산출:

0
-1
1
1
0
-1
-1
1
0

dc, 18

1?Z9+2/rZ1+2/-3%-p

온라인으로 사용해보십시오 .

두 개의 인수는 한 줄에서 STDIN으로 전달됩니다 (공백으로 구분). 인수는 문자열을 좋아 [ ]하는 방식이므로 대괄호 안에 들어 dc있습니다.

dc문자열 처리 가 매우 제한적이지만 Z명령을 사용하여 문자열 길이를 얻는 것입니다. 운 좋게도 "Rock", "Paper"및 "Scissors"와 구별되며 상당히 간단하게 산술적으로 할 수 있습니다. 원하는 결과를 제공하기 위해 조작.

PHP, 34 바이트

<?=md5("BMn$argv[1]$argv[2]")%3-1;

피스, 16

t%+7h.+mx3ldQ3

아마 더 짧을 수 있습니다.

        x3ld      # lambda to get string length then XOR with 3
       m    Q     # map over the input (array of 2 strings)
     .+           # difference of the two results
    h             # flatten one-element array
  +7              # add 7
 %           3    # mod 3
t                 # subtract 1 and implicit print

온라인 .

C #, 85 84 바이트

TheLethalCoder 덕분에 1 바이트 절약

a=>b=>a==b?0:(a[0]=='R'&b[0]=='S')|(a[0]=='P'&b[0]=='R')|(a[0]=='S'&b[0]=='P')?1:-1;

두 개의 문자열을 입력으로 받아서 정수를 출력합니다. 두 현이 같은 경우 동점이 있으며, 그렇지 않으면 어떤 선수가 이길 지 결정하기 위해 현의 첫 번째 캐릭터를 확인합니다.

자바 스크립트, 37 , 32 , 31 바이트

a=>b=>a==b?0:!(a+b)[12]^a>b||-1

a가 b와 같으면 0을 출력합니다.

그렇지 않으면, b보다 큰 길이를 비교하여 길이가 12보다 크지 않은지 (가위 및 용지 비교) 확인한 결과를 x.
이것이 1을 리턴하면 리턴하십시오.

0을 리턴하면 OR 연산자를 사용하여 -1로 바꾸십시오.

배치, 116 바이트

@if %1==%2 echo 0&exit/b
@for %%a in (RockScissors PaperRock ScissorsPaper)do @if %%a==%1%2 echo 1&exit/b
@echo -1

펄, 33 바이트

32 바이트의 코드 + -p플래그

$_=/(.+) \1/?0:-/k P|r S|s R/||1

그것을 실행하려면 :

perl -pe '$_=/(.+) \1/?0:-/k P|r S|s R/||1' <<< "Rock Paper"

Martin Ender 's Retina answer 의 정규식을 사용하여 3 바이트를 절약했습니다 . (이전 정규 표현식은 /R.*P|P.*S|S.*R/)

설명:

먼저 /(.+) \1/입력에 동일한 단어가 두 배 포함되어 있는지 확인합니다. 그렇다면 결과는 0입니다. 그렇지 않으면 /k P|r S|s R/답변이 인 경우를 처리합니다 -1. 이 마지막 정규식이 거짓이면 -/k P|r S|s R/거짓입니다. 그래서 우리는를 반환 1합니다.

젤리 , 9 바이트

L€^3Iæ%1.

이것은 @ DigitalTrauma 's Bash answer의 알고리즘을 사용합니다 .

온라인으로 사용해보십시오!

작동 원리

L€^3Iæ%1.  Main link. Argument: A (string array)

L€         Take the length of each string.
  ^3       XOR the lengths bitwise with 3.
    I      Increments; compute the forward difference of both results.
     æ%1.  Balanced modulo 1.5; map the results into the interval (-1.5, 1.5].

Japt , 19 바이트

-Ms(4*(Uc -Vc)/MP¹r

여기 사용해보십시오!

_{carusocomputing의 솔루션에서 영감을 얻음}

이전 53 바이트 솔루션

W=Ug c X=Vg c W¥X?0:W¥82©X¥83?1:W¥80©X¥82?1:W¥83©X¥80?1:J

온라인으로 사용해보십시오!

_{다시 한번 감사드립니다. ETHproductions!}

PHP, 55 53 바이트

<?=(3-(ord($argv[2])%6%4-ord($argv[1])%6%4+3)%3*2)%3;

• 첫 번째 문자의 ASCII 값을 가져옵니다 (명령 줄 인수에서) : 82,80,83
• % 6 : 4,2,5
• % 4 : 0,2,1
• 차이 (ba) :
  • PS : 1-2, SR : 2-0, RP : 2-0-> -1 또는 2; + 3, % 3-> 2
  • SP : 2-1, RS : 0-2, PR : 0-2-> -2 또는 1; + 3, % 3-> 1
  • RR, PP, SS : 0; + 3, % 3 : 0
• (3-2 * x) : -1,1,3
• % 3 : -1,1,0

사인 버전, 49 46 바이트

<?=2*sin(1.3*(ord($argv[2])-ord($argv[1])))|0;

carusocomputing의 답변 의 골프 포트 :

@ user59178에 의해 3 바이트 절약

펄, 25 바이트

$_=/kS|rR|sP/-/kP|rS|sR/

-p옵션으로 24 바이트 +1 바이트를 코딩하십시오.

입력은 구분 기호없이 stdin에 있어야합니다. 예 :

echo PaperRock | perl -pe'$_=/kS|rR|sP/-/kP|rS|sR/'

첫 번째 정규 표현식은 첫 번째 플레이어 승리를 검색하고 두 번째는 그의 손실을 검색합니다. 차이가 인쇄됩니다.

스칼라, 148 바이트

object R extends App{val t=Seq('R','P','S')
val(a,b)=(args(0)(0),args(1)(0))
print(if(a==b)0 else if(t.indexOf(a)%3==(t.indexOf(b)-1)%3)-1 else 1)}

고맙게도, 세미콜론은 같은 줄에서 여러 명령을 분리해야하므로 스칼라는 형식화 가능한 골프 코드를 사용하는 것이 좋습니다!

이 골프 시도에서 나는 당신이 교체 할 수 있다는 것을 배웠습니다

"somestring".charAt(index) 

와

"somestring"(index) 

스칼라는 문자를 얻기 위해 문자열을 배열로 취급하기 때문입니다.