एक रॉक, पेपर, कैंची, छिपकली, स्पॉक गेम कौन जीतेगा?

Question

इस खेल के बारे में कई सवाल हैं , यहां तक ​​कि एक राजा-की-पहाड़ी प्रतियोगिता भी । लेकिन मुझे लगता है कि उन सभी चुनौतियों और प्रतियोगिताओं को एक गेम के विजेता को स्वचालित रूप से निर्धारित करने का एक तरीका चाहिए। इसलिए:

चुनौती

["rock", "paper", "scissors", "lizard", "spock"]खिलाड़ी 1 और खिलाड़ी 2 के चयन का प्रतिनिधित्व करने वाली सीमा में दो इनपुट को देखते हुए , मैच का विजेता निर्धारित करें।

नियम

[Winner] [action]    [loser]
-----------------------------
scissors cut         paper
paper    covers      rock
rock     crushes     lizard
lizard   poisons     spock
spock    smashes     scissors
scissors decapitates lizard
lizard   eats        paper
paper    disproves   spock
spock    vaporizes   rock
rock     crushes     scissors

प्रतिबंध

• इनपुट दी गई श्रेणी में तार की एक जोड़ी होगी (कोई अन्य तार का उपयोग नहीं किया जा सकता है)। जब तक आप उल्लिखित किसी भी मान का प्रतिनिधित्व करते हैं, तब तक आप चार्ट के सरणियों का उपयोग कर सकते हैं।
• आप चुन सकते हैं कि इनपुट स्ट्रिंग्स के लिए लोअरकेस, अपरकेस ( "ROCK") या कैमल केस ( "Rock") का उपयोग करें, जब तक कि चुना गया मामला सभी इनपुट के लिए समान हो।
• आउटपुट मानों की एक तिकड़ी होगी जो विजेता को निर्धारित करता है, जो कुछ भी हो सकता है जब तक आप उत्तर संगत होते हैं। उदाहरण: 1यदि पहला इनपुट जीतता है, 2यदि दूसरा इनपुट जीतता है, 0यदि कोई टाई है। या हो सकता है Aकि अगर पहला इनपुट जीतता है, Bअगर दूसरा इनपुट जीतता है, <empty string>अगर कोई टाई है।

लक्ष्य

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटा कार्यक्रम / विधि / कार्य / लंबोदर हो सकता है!

टेस्ट

[Input 1] [Input 2] [Output: 1/2/0]
-----------------------------------
 rock      paper     2
 rock      scissors  1
 lizard    spock     1
 spock     rock      1
 spock     paper     2
 rock      rock      0

Comments

यह सैंडबॉक्स से आता है ।

— चार्ली

बहुत संबंधित ।

— स्टीवी ग्रिफिन

मैंने इसे लिंक किए गए प्रश्न के डुप्लिकेट के रूप में बंद कर दिया है क्योंकि इसका सिर्फ 2 नए मूल्यों के साथ एक ही सवाल है और IO पर थोड़ी भिन्नता है।

— गेहूं जादूगर

@ इनपुट में कभी-कभी थोड़ा सा परिवर्तन बहुत भिन्न आउटपुट उत्पन्न करता है। प्रश्न काफी हद तक समान हो सकते हैं लेकिन दो नए मूल्य विचार करने के लिए अधिक मामले बनाते हैं, इसलिए यहां उपयोग किए गए एल्गोरिदम अलग हैं जो लोगों को फिर से सोचने के लिए बनाते हैं ( cakeचाल के साथ उत्तर देखें )।

— चार्ली

मैं सहमत हूँ, और फिर से खोलने के लिए मतदान किया।

— जीबी

Answer 1

पायथन 3 , 68 50 48 बाइट्स

संपादित करें: नील से 3 चालें, और मिस्टर एक्सकोडर से 2

प्रत्येक इनपुट स्ट्रिंग का एक अलग चौथा वर्ण है, इसलिए मैं उन्हें अलग करने के लिए उपयोग कर रहा हूं। यदि आप चक्र (कैंची, कागज, चट्टान, छिपकली, चोंच) में तत्वों को व्यवस्थित करते हैं, तो प्रत्येक तत्व तत्व को सीधे उसके बाद और तत्व 3 को दाईं ओर, चक्रीय रूप से धड़कता है। इसलिए हम चक्र में इनपुट की स्थिति को घटाते हैं। यदि वह संख्या 0 है, तो यह एक टाई है। यदि यह 1 या 3 है, तो यह पहले खिलाड़ी की जीत है। मेरे मूल समाधान में, चक्र का अंतर खेल के परिणामों को अलग करने के लिए "210100" स्ट्रिंग में अनुक्रमित होगा। नील ने किसी तरह यह पता लगाया कि 7 को जोड़कर और मापांक द्वारा इंडेक्सिंग के बिना पूरा किया जा सकता है। 3. संपादित करें: मूल रूप से मैंने स्ट्रिंग की पहचान करने के लिए दूसरे वर्ण का उपयोग किया था, लेकिन यदि आप चौथे का उपयोग करते हैं और चक्र को उल्टा करते हैं, तो आपको केक मिलता है। और हम सभी अधिक केक का उपयोग कर सकते हैं।

lambda x,y,z="cake".find:(7+z(y[3])-z(x[3]))%5%3

इसे ऑनलाइन आज़माएं!

पुराना संस्करण:

lambda x,y,z="caoip".index:(7+z(y[1])-z(x[1]))%5%3

इसे ऑनलाइन आज़माएं!

मूल संस्करण:

b="caoip"
def r(x,y):return"210100"[(b.index(y[1])-b.index(x[1]))%5]

इसे ऑनलाइन आज़माएं!

Comments

50 बाइट्स: इसे ऑनलाइन आज़माएं!

— नील

PPCG में आपका स्वागत है!

— स्टेडीबॉक्स

49 बाइट्स: इसे ऑनलाइन आज़माएं! (स्विचन के .indexलिए .find)

— श्री एक्सकोडर

48 बाइट्स: इसे ऑनलाइन आज़माएं! (आप की जरूरत नहीं है p, "chaoi"पर्याप्त है)

— श्री एक्सकोडर

Answer 2

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

करी सिंटैक्स में इनपुट लेता है (a)(b)। रिटर्न 0अगर एक जीत, 1अगर B जीत, या falseएक टाई के लिए।

a=>b=>a!=b&&a>b^614>>((g=s=>parseInt(s,31)%9)(a)^g(b))&1

डेमो

let f =

a=>b=>a!=b&&a>b^614>>((g=s=>parseInt(s,31)%9)(a)^g(b))&1

console.log('[Tie]');
console.log(f("paper"   )("paper"   ))

console.log('[A wins]');
console.log(f("scissors")("paper"   ))
console.log(f("paper"   )("rock"    ))
console.log(f("rock"    )("lizard"  ))
console.log(f("lizard"  )("spock"   ))
console.log(f("spock"   )("scissors"))
console.log(f("scissors")("lizard"  ))
console.log(f("lizard"  )("paper"   ))
console.log(f("paper"   )("spock"   ))
console.log(f("spock"   )("rock"    ))
console.log(f("rock"    )("scissors"))

console.log('[B wins]');
console.log(f("paper"   )("scissors"))
console.log(f("rock"    )("paper"   ))
console.log(f("lizard"  )("rock"    ))
console.log(f("spock"   )("lizard"  ))
console.log(f("scissors")("spock"   ))
console.log(f("lizard"  )("scissors"))
console.log(f("paper"   )("lizard"  ))
console.log(f("spock"   )("paper"   ))
console.log(f("rock"    )("spock"   ))
console.log(f("scissors")("rock"    ))

कैसे?

हम हैश फ़ंक्शन H () को इस प्रकार परिभाषित करते हैं :

H = s => parseInt(s, 31) % 9

यह देता है:

s          | H(s)
-----------+-----
"rock"     |  2
"paper"    |  8
"scissors" |  1
"lizard"   |  3
"spock"    |  4

दो इनपुट ए और बी को देखते हुए , हम निम्नलिखित कथनों पर विचार करते हैं:

1. क्या हमारे पास एक> बी है ? (अलंकारिक क्रम में)
2. b क्या गेम जीतता है?
3. N = H (a) XOR H (b) का मान क्या है ?

(1) और (2) से, हम यह घटाते हैं कि क्या > b का परिणाम सही विजेता प्राप्त करने के लिए उलटा होना चाहिए और हम इस ध्वज को N-th बिट में लुकअप बिटमास्क में संग्रहीत करते हैं ।

a        | H(a) | b        | H(b) | N  | a > b | b wins | invert
---------+------+----------+------+----+-------+--------+-------
rock     |   2  | paper    |   8  | 10 | Yes   | Yes    | No
rock     |   2  | scissors |   1  |  3 | No    | No     | No
rock     |   2  | lizard   |   3  |  1 | Yes   | No     | Yes
rock     |   2  | spock    |   4  |  6 | No    | Yes    | Yes
paper    |   8  | rock     |   2  | 10 | No    | No     | No
paper    |   8  | scissors |   1  |  9 | No    | Yes    | Yes
paper    |   8  | lizard   |   3  | 11 | Yes   | Yes    | No
paper    |   8  | spock    |   4  | 12 | No    | No     | No
scissors |   1  | rock     |   2  |  3 | Yes   | Yes    | No
scissors |   1  | paper    |   8  |  9 | Yes   | No     | Yes
scissors |   1  | lizard   |   3  |  2 | Yes   | No     | Yes
scissors |   1  | spock    |   4  |  5 | No    | Yes    | Yes
lizard   |   3  | rock     |   2  |  1 | No    | Yes    | Yes
lizard   |   3  | paper    |   8  | 11 | No    | No     | No
lizard   |   3  | scissors |   1  |  2 | No    | Yes    | Yes
lizard   |   3  | spock    |   4  |  7 | No    | No     | No
spock    |   4  | rock     |   2  |  6 | Yes   | No     | Yes
spock    |   4  | paper    |   8  | 12 | Yes   | Yes    | No
spock    |   4  | scissors |   1  |  5 | Yes   | No     | Yes
spock    |   4  | lizard   |   3  |  7 | Yes   | Yes    | No

इसलिए बिट्स:

bit | value
----+-----------
 0  | 0 (unused)
 1  | 1
 2  | 1
 3  | 0
 4  | 0 (unused)
 5  | 1
 6  | 1
 7  | 0
 8  | 0 (unused)
 9  | 1
10  | 0
11  | 0
12  | 0

इसे नीचे से ऊपर तक पढ़ना और अग्रणी शून्य को अनदेखा करना, यह 1001100110 , या 614 दशमलव में देता है ।

Answer 3

05AB1E , 16 बाइट्स

ε'³²s3èk}Æ7+5%3%

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

बहुत अच्छा उपयोग करता है cakeसे -trick user507295

ε       }          # apply to each in the input pair
    s3è            # get the 4th letter
 '³²   k           # get its cake-index
         Æ         # reduce by subtraction
          7+       # add 7
            5%3%   # mod by 5 and then 3

Answer 4

रूबी , 36 बाइट्स

->a,b{(2+a.sum%88%6-b.sum%88%6)%5%3}

रिटर्न 0अगर 1 खिलाड़ी जीतता है, 1अगर 2 खिलाड़ी जीतता है, और 2एक ड्रॉ के लिए।

User507295 के उत्तर के आधार पर लेकिन हैश प्रदर्शन करने के लिए एक गणितीय सूत्र का उपयोग करता है। a.sumस्ट्रिंग a, मॉड के सभी ASCII कोड का योग है 1<<16और एक अल्पविकसित चेकसम के रूप में अभिप्रेत है। निम्न कोड का उपयोग करके हैश पाया गया था:

1.upto(99){|j|p j,["scissors","paper","rock","lizard","spock"].map{|i|i.sum%j%6}}

इसने दो मान उत्पन्न किए, jजिसमें लोअरकेस अक्षरों के लिए एक उपयुक्त हैश दिया, अर्थात् 88 और 80, दोनों ने अवरोही अनुक्रम दिया [3,2,1,0,4](या [4,3,2,1,0]यदि स्पॉक को शुरुआत में चक्रित किया गया।)

जैसा कि अन्य उत्तरों में बताया गया है, एक हैश जो उपरोक्त अनुक्रम में लगातार तत्वों के लिए एक निरंतर अंतर modulo 5 देता है, (h[a]-h[b])%5सूत्र को काम करने के लिए आवश्यक है । प्रत्येक तत्व तत्व 1 या 3 स्थानों को दाईं ओर धड़कता है और तत्व 2 या 4 स्थानों को दाईं ओर खो देता है।

इसे ऑनलाइन आज़माएं!

Answer 5

जावास्क्रिप्ट (ईएस 6), 63 54 53 49 बाइट्स

f=
(l,r,g=s=>"cake".search(s[3]))=>(7+g(r)-g(l))%5%3

<div onchange=o.textContent=`RLT`[f(a.selectedOptions[0].value,b.selectedOptions[0].value)]>L: <select id=a><option>Rock<option>Paper<option>Scissors<option>Lizard<option>Spock</select> R: <select id=b><option>Rock<option>Paper<option>Scissors<option>Lizard<option>Spock</select> Winner: <span id=o>T

मेरे गोल्फ का पोर्ट @ व्हाट्सडू के उत्तर पर। नोट: स्निपेट सांख्यिक परिणाम को कुछ कम अप्राप्य में बदल देता है। संपादित करें: @Annauld के लिए 1 बाइट धन्यवाद सहेजा गया। @ ब्वॉयज की बदौलत 4 बाइट्स बचाए।

Comments

@ ओवीजी, मैंने अपने गोल्फ को व्हाट्सएप के उत्तर के लिए पर्याप्त रूप से पोर्ट नहीं किया ...

— नील

Answer 6

सी, 53bytes

a="FÈ..J..ÁE";
z=*++y==*++x?0:a[*y&47>>1]>>*++x&7&1+1;

मैंने इस समस्या को एक राज्य मशीन के रूप में माना है, जिसमें से दो, पांच राज्य इनपुट द्वारा परिभाषित 25 राज्य हैं।

बिट्स की एक सरणी के भीतर राज्यों के परिणामों को परिभाषित करके। मैं इनपुट के भीतर अद्वितीय मार्करों का उपयोग करके परिणामों को ऊपर देखता हूं।

जैसा कि अन्य समाधानों में उल्लेख किया गया है, संभव इनपुट के बीच वर्ण 2, 3 और 4 अद्वितीय हैं। मैंने वर्ण 2 और 3 पर ध्यान केंद्रित किया है जिसका उपयोग मैं अपने उत्तर सरणी में उपयुक्त बिट का चयन करने के लिए करता हूं।

चरित्र 2 के भीतर, बिट्स 1 के माध्यम से 4 स्पष्ट रूप से इनपुट की पहचान करते हैं। इन बिट्स को मास्क करके और उचित रूप से शिफ्ट करने से [कि "* y & 47 >> 1"] है, इनपुट 0, 1, 4, 7 या 8 के रूप में नोट किया जा सकता है। इसलिए मेरे उत्तर स्ट्रिंग में 9 अक्षर हैं। (अलग दिलचस्प बिट्स)

character 2:
a 61   011 0000 1
c 63   011 0001 1
i 69   011 0100 1
p 70   011 1000 0
o 6f   011 0111 1

चरित्र 3 के भीतर, बिट्स 0, 1 और 2 स्पष्ट रूप से इनपुट की पहचान करते हैं। इन बिट्स को मास्क करके (शिफ्टिंग की आवश्यकता नहीं है) [कि "* x & 7"], इनपुट को 0, 1, 2, 3 या 7 के रूप में नोट किया जा सकता है। (अलग दिलचस्प बिट्स)

character 3
p 70   01110 000
i 69   01101 001
z 7a   01111 010
o 6f   01101 111
c 63   01100 011

उत्तर स्ट्रिंग को उपयुक्त वर्णों के लिए बिट्स में भरकर गणना की जा सकती है।

0th char represents X=paper
1st char represents X=scissors
4th char represents X=Lizard
7th char represents X=Rock
8th char represents X=Spock

0th bit represents Y=Paper
1st bit represents Y=Scissors
2nd bit represents Y=Lizard
3rd bit represents Y=Rock
7th bit represents Y=Spock

तो, चार सेट में चार जहां वाई जीतता है

char  7654 3210   in hex    in ascii
0     0100 0110    46         F
1     1100 1000    c8         È
2     0100 0000    d/c        .
3     0100 0000    d/c        .
4     0100 1010    4a         J
5     0100 0000    d/c        .
6     0100 0000    d/c        .
7     1100 0001    c1         Á
8     0100 0101    45         E

फिर तर्क बस इतना है: यदि दूसरा चार समान है तो ड्रा करें, अन्यथा, वाई के दूसरे चरित्र के आधार पर एससीआई चार प्राप्त करें और बिट्स को एक्स के तीसरे चरित्र द्वारा स्थानांतरित करें और एक जोड़ें। यह ड्रॉ के लिए 0, एक्स जीत के लिए 1 और वाई जीत के लिए 2 उत्तर बनाता है।

Comments

PPCG में आपका स्वागत है! यह एक बेहतरीन, सुविचारित जवाब है।

— FantaC

Answer 7

क्लोजर, 130 118 बाइट्स

मेरे अजीब उपयोग से छुटकारा पाकर -12 बाइट्स comp।

(fn[& m](let[[p q](map #(apply +(map int(take 2 %)))m)d(- p q)](cond(= d 0)0(#{5 -16 12 -14 13 1 4 -18 2 11}d)1 1 2)))

मुझे लगा कि मैं चालाक हो रहा था, लेकिन यह कुछ अन्य उत्तरों की तुलना में भोलापन था, और बहुत लंबे समय तक।

प्रत्येक चाल स्ट्रिंग के पहले 2 अक्षर लेता है, चार कोड प्राप्त करता है, और उन्हें रकम देता है। यह तब प्राप्त करने के लिए रकम को घटाता है d। यदि d0 है, तो इसका टाई (0), यदि यह सेट में है #{5 -16 12 -14 13 1 4 -18 2 11}, तो p1 जीत (1), और, P2 जीत (2)।

(defn decide [& moves] ; Using varargs so I don't need to duplicate the steps.
  ; Pop the first 2 chars of each string, convert them to their ASCII code, and sum them.
  (let [[p1 p2] (map #(apply + (map int (take 2 %))) moves)
        d (- p1 p2)]

    (cond
      (= d 0) ; A tie
      0

      (#{5 -16 12 -14 13
         1 4 -18 2 11} d) ; P1 Wins
      1

      :else ; P2 Wins
      2)))

"मैजिक नंबर" पाने के लिए जो परिभाषित करता है कि पी 1 जीत जाता है, तो मैं भाग गया

(let [ms ["rock", "paper", "scissors", "lizard", "spock"]]
  (for [p1 ms
        p2 ms]

    ; Same as above
    (let [[p q] (map #(apply + (map int (take 2 %))) [p1 p2])
          d (- p q)]

      [p1 p2 d])))

जो dप्रत्येक संभावित परिदृश्य के लिए मूल्यों की एक सूची तैयार करता है:

(["rock" "rock" 0]
 ["rock" "paper" 16]
 ["rock" "scissors" 11]
 ["rock" "lizard" 12]
 ["rock" "spock" -2]
 ["paper" "rock" -16]
 ["paper" "paper" 0]
 ["paper" "scissors" -5]
 ["paper" "lizard" -4]
 ["paper" "spock" -18]
 ["scissors" "rock" -11]
 ["scissors" "paper" 5]
 ["scissors" "scissors" 0]
 ["scissors" "lizard" 1]
 ["scissors" "spock" -13]
 ["lizard" "rock" -12]
 ["lizard" "paper" 4]
 ["lizard" "scissors" -1]
 ["lizard" "lizard" 0]
 ["lizard" "spock" -14]
 ["spock" "rock" 2]
 ["spock" "paper" 18]
 ["spock" "scissors" 13]
 ["spock" "lizard" 14]
 ["spock" "spock" 0])

फिर मैंने इस आउटपुट के खिलाफ जीत चार्ट की तुलना की। सौभाग्य से वहाँ 0 के अलावा कोई "टकराव" नहीं थे।