रॉक, पेपर, कैंची, छिपकली, बंद [बंद]

Question

एक फ़ंक्शन बनाएं जो इनपुट के रूप में दो स्ट्रिंग्स लेगा और परिणाम के लिए एकल आउटपुट लौटाएगा। सबसे लोकप्रिय जवाब जीतता है।

रॉक-पेपर-कैंची-छिपकली-स्पॉक के नियम हैं:

• कैंची ने कागज को काट दिया
• पेपर कवर रॉक
• रॉक ने छिपकली को कुचल दिया
• छिपकली जहर Spock
• शॉक स्मैश कैंची
• कैंची छिपकली को नष्ट कर देती है
• छिपकली कागज खाती है
• पेपर स्पॉक को नापसंद करता है
• स्पॉक रॉक को वाष्पीकृत करता है
• रॉक कैंची को तोड़ते हैं

हर संभव इनपुट मामले के लिए आउटपुट है:

winner('Scissors', 'Paper') -> 'Scissors cut Paper'
winner('Scissors', 'Rock') -> 'Rock breaks Scissors'
winner('Scissors', 'Spock') -> 'Spock smashes Scissors'
winner('Scissors', 'Lizard') -> 'Scissors decapitate Lizard'
winner('Scissors', 'Scissors') -> 'Scissors tie Scissors'
winner('Paper', 'Rock') -> 'Paper covers Rock'
winner('Paper', 'Spock') -> 'Paper disproves Spock'
winner('Paper', 'Lizard') -> 'Lizard eats Paper'
winner('Paper', 'Scissors') -> 'Scissors cut Paper'
winner('Paper', 'Paper') -> 'Paper ties Paper'
winner('Rock', 'Spock') -> 'Spock vaporizes Rock'
winner('Rock', 'Lizard') -> 'Rock crushes Lizard'
winner('Rock', 'Scissors') -> 'Rock breaks Scissors'
winner('Rock', 'Paper') -> 'Paper covers Rock'
winner('Rock', 'Rock') -> 'Rock ties Rock'
winner('Lizard', 'Rock') -> 'Rock crushes Lizard'
winner('Lizard', 'Spock') -> 'Lizard poisons Spock'
winner('Lizard', 'Scissors') -> 'Scissors decapitate Lizard'
winner('Lizard', 'Paper') -> 'Lizard eats Paper'
winner('Lizard', 'Lizard') -> 'Lizard ties Lizard'
winner('Spock', 'Rock') -> 'Spock vaporizes Rock'
winner('Spock', 'Lizard') -> 'Lizard poisons Spock'
winner('Spock', 'Scissors') -> 'Spock smashes Scissors'
winner('Spock', 'Paper') -> 'Paper disproves Spock'
winner('Spock', 'Spock') -> 'Spock ties Spock'

@ सीन चेशायर द्वारा सुझाई गई अतिरिक्त चुनौती: इस साइट से कस्टम सूची की अनुमति दें। एन-आइटम सूची के साथ, आइटम पहले (n-1) / 2 से हार जाता है, और निम्नलिखित पर जीतता है (n-1/2)

Comments

25-एलिमेंट लुकअप टेबल बनाना एक चुनौती नहीं है, और लोकप्रिय होना एक कोड-चुनौती नहीं है ।

— पीटर टेलर

और जब मैं कहता हूं कि लोकप्रिय होना एक कोड-चुनौती नहीं है : उस टैग की व्याख्या शुरू होती है एक कोड चुनौती कोड आकार के अलावा एक उद्देश्य मानदंड के लिए प्रोग्रामिंग पहेली को हल करने के लिए रचनात्मक तरीकों के लिए एक प्रतियोगिता है। "सबसे लोकप्रिय उत्तर जीतता है" एक उद्देश्य मानदंड नहीं है: आप किसी को दो उत्तरों का पाठ नहीं दे सकते हैं और उनसे पूछ सकते हैं जो सबसे लोकप्रिय है।

— पीटर टेलर

@PeterTaylor, dansalmo सही है, जब तक कि लुकअप टेबल एक लूप में है: यह कॉनवे का एक प्रसिद्ध प्रमेय है: en.wikipedia.org/wiki/FRACTRAN

— बूथ

@dansalmo आपके द्वारा लिंक की गई चुनौती लोकप्रियता-प्रतियोगिता टैग के अस्तित्व से पहले बनाई गई थी ।

— प्रिमो जूल

चुनौती में जोड़ने के लिए एक सुझाव - कस्टम सूची, जैसे कि इस साइट से 101 आइटम तक जाने की अनुमति दें । एन-आइटम सूची के साथ, आइटम पहले (n-1) / 2 से हार जाता है, और (n-1) / 2 से अधिक जीतता है

— SeanC

Answer 1

एपीएल

vs←{
    n←'Scissors' 'Paper' 'Rock' 'Lizard' 'Spock'
    x←n⍳⊂⍺ ⋄ y←n⍳⊂⍵ ⋄ X←⍺ ⋄ Y←⍵ ⋄ r←{X,⍵,⊂Y}
    x=y:     r (-x=0)↓'ties'
    y=5|1+x: r x⌷'cut' 'covers' 'crushes' 'poisons' 'smashes'
    y=5|3+x: r x⌷'decapitate' 'disproves' 'breaks' 'eats' 'vaporizes'
    ⍵∇⍺
}

टाई / टाई सहित सभी मामलों में आवश्यक रूप से आउटपुट। वास्तविक शब्दों को छोड़कर कोई लुकअप टेबल नहीं।

आप इसे http://ngn.github.io/apl/web/ पर आज़मा सकते हैं

'Spock' vs 'Paper'
Paper  disproves  Spock

APL सिर्फ जानता है!

Comments

+1, अब तक कभी एपीएल पर ध्यान नहीं दिया गया। Mesmerizing। आपकी संरचना भी मस्त है। मुझे आखिरी पंक्ति सबसे अच्छी लगती है।

— dansalmo

@dansalmo धन्यवाद :) मुझे यह बहुत पसंद है। और अब धन्यवाद के लिए github.com/ngn/apl हमारे पास एक खुला स्रोत और वेब-तैयार दुभाषिया है (दशकों से केवल व्यावसायिक व्याख्याकार थे)

— तोबिया

@dansalmo btw, एपीएल आपको जिस तरह की फंक्शनल कोडिंग के लिए परफेक्ट लगता है, वह आप पायथन में कर रहे हैं (जो मुझे अच्छा लगता है)

— टोबिया

Answer 2

एसईडी

#!/bin/sed
#expects input as 2 words, eg: scissors paper

s/^.*$/\L&/
s/$/;scissors cut paper covers rock crushes lizard poisons spock smashes scissors decapitates lizard eats paper disproves spock vaporizes rock breaks scissors/
t a
:a
s/^\(\w\+\)\s\+\(\w\+\);.*\1 \(\w\+\) \2.*$/\u\1 \3 \u\2/
s/^\(\w\+\)\s\+\(\w\+\);.*\2 \(\w\+\) \1.*$/\u\2 \3 \u\1/
t b
s/^\(\w\+\)\s\+\1;\(\1\?\(s\?\)\).*$/\u\1 tie\3 \u\1/
:b

Comments

यह है ... शैतानी।

— वेन कॉनराड

Answer 3

यहां किसी भी आकार के एक नियम स्ट्रिंग पर आधारित एक सामान्य समाधान है। यह उचित नाम "स्पॉक" के लिए सही कैपिटलाइज़ेशन करता है और प्लेजर ऑब्जेक्ट्स के लिए 'टाई' के बजाय 'टाई' को निर्दिष्ट करने के लिए नियमों की अनुमति देता है।

def winner(p1, p2):
    rules = ('scissors cut paper covers rock crushes lizard poisons Spock'
    ' smashes scissors decapitate lizard eats paper disproves Spock vaporizes'
    ' rock breaks scissors tie scissors'.split())

    idxs = sorted(set(i for i, x in enumerate(rules) 
                      if x.lower() in (p1.lower(), p2.lower())))
    idx = [i for i, j in zip(idxs, idxs[1:]) if j-i == 2]
    s=' '.join(rules[idx[0]:idx[0]+3] if idx 
          else (rules[idxs[0]], 'ties', rules[idxs[0]]))
    return s[0].upper()+s[1:]

परिणाम:

>>> winner('spock', 'paper')
'Paper disproves Spock'
>>> winner('spock', 'lizard')
'Lizard poisons Spock'
>>> winner('Paper', 'lizard')
'Lizard eats paper'
>>> winner('Paper', 'Paper')
'Paper ties paper'
>>> winner('scissors',  'scissors')
'Scissors tie scissors'    

Comments

परिभाषित करते समय rulesआप शाब्दिक संयोजन के बजाय एक बहुस्तरीय स्ट्रिंग का उपयोग कर सकते हैं। यह आपको निरर्थक कोष्ठक को हटाने की अनुमति देता है।

— बकुरीउ

Answer 4

अजगर

class Participant (object):
    def __str__(self): return str(type(self)).split(".")[-1].split("'")[0]
    def is_a(self, cls): return (type(self) is cls)
    def do(self, method, victim): return "%s %ss %s" % (self, method, victim)

class Rock (Participant):
        def fight(self, opponent):
                return (self.do("break", opponent)  if opponent.is_a(Scissors) else
                        self.do("crushe", opponent) if opponent.is_a(Lizard)   else
                        None)

class Paper (Participant):
        def fight(self, opponent):
                return (self.do("cover", opponent)    if opponent.is_a(Rock)  else
                        self.do("disprove", opponent) if opponent.is_a(Spock) else
                        None)

class Scissors (Participant):
        def fight(self, opponent):
                return (self.do("cut", opponent)       if opponent.is_a(Paper)  else
                        self.do("decaitate", opponent) if opponent.is_a(Lizard) else
                        None)

class Lizard (Participant):
        def fight(self, opponent):
                return (self.do("poison", opponent) if opponent.is_a(Spock) else
                        self.do("eat", opponent)    if opponent.is_a(Paper) else
                        None)

class Spock (Participant):
        def fight(self, opponent):
                return (self.do("vaporize", opponent) if opponent.is_a(Rock)     else
                        self.do("smashe", opponent)    if opponent.is_a(Scissors) else
                        None)

def winner(a, b):
    a,b = ( eval(x+"()") for x in (a,b))
    return a.fight(b) or b.fight(a) or a.do("tie", b)

Comments

कैंची बहुवचन हैं, इसलिए "कट।" रों " कागज और "decaitate रों " छिपकली "गलत है (पिछले एक एक पी भी याद करते हैं) और।" स्पॉक smashs स्मैश "" होना चाहिए ";)

— daniero

@ डानिएरो, धन्यवाद। मैंने कैंची की समस्या पर ध्यान दिया, लेकिन इसे ठीक करने से चीजें जटिल हो गईं। अब "स्मैश" ठीक करना।

— बदसूरत

@ डैनियल "कैंची" बहुवचन है। "कैंची" भी विलक्षण है। देखें en.wiktionary.org/wiki/scissors

— DavidC

इतना सूक्ष्म। इसे प्यार करना।

— काओ जूल

Answer 5

अजगर

def winner(p1, p2):
    actors = ['Paper', 'Scissors', 'Spock', 'Lizard', 'Rock']
    verbs = {'RoLi':'crushes', 'RoSc':'breaks', 'LiSp':'poisons',
             'LiPa':'eats', 'SpSc':'smashes', 'SpRo':'vaporizes', 
             'ScPa':'cut', 'ScLi':'decapitate', 'PaRo':'covers', 
             'PaSp':'disproves', 'ScSc':'tie'}
    p1, p2 = actors.index(p1), actors.index(p2)
    winner, loser = ((p1, p2), (p2, p1))[(1,0,1,0,1)[p1 - p2]]
    return ' '.join([actors[winner],
                     verbs.get(actors[winner][0:2] + actors[loser][0:2],
                               'ties'),
                     actors[loser]])

Comments

वैसे, "शिथिल" "तंग" के विपरीत है। "हारने वाला" "विजेता" के विपरीत है। और यह आपको अपने कोड में कुछ अक्षर बचाएगा।

— जो

Answer 6

रूबी, अंकगणित दृष्टिकोण

अभिनेताओं को इस तरह से एक सरणी में व्यवस्थित किया जा सकता कर सकते हैं कि प्रत्येक अभिनेता a[i]अभिनेताओं के खिलाफ जीत a[i+1]और a[i+2], 5 सापेक्ष, उदाहरण के लिए:

%w(Scissors Lizard Paper Spock Rock)

फिर, एक अभिनेता के लिए Aसूचकांक के साथ iहम कैसे वह खिलाफ अभिनेता मेल खाता देख सकते हैं Bसूचकांक के साथ jकार्य करकेresult = (j-i)%5 : परिणाम 1और 2अर्थ यह है कि एक अभिनेता के 1 या क्रमशः उसके सामने 2 स्थानों against अभिनेता एक जीता; 3और 4इसी तरह से वह सरणी में उसके पीछे एक अभिनेता के खिलाफ हार गए। 0एक मतलब है। (ध्यान दें कि यह भाषा पर निर्भर हो सकता है; रूबी में (j-i)%5 == (5+j-i)%5भी जब j>i।)

मेरे कोड का सबसे दिलचस्प हिस्सा इस संपत्ति का उपयोग दो अभिनेताओं के सूचकांकों के एक छँटाई समारोह को खोजने के लिए है। वापसी मान -1, 0 या 1 होगा जैसा कि यह होना चाहिए :

winner,loser = [i,j].sort { |x,y| ((y-x)%5+1)/2-1 }

ये रही पूरी बात:

def battle p1,p2
    who = %w(Scissors Lizard Paper Spock Rock)
    how = %w(cut decapitate poisons eats covers disproves smashes vaporizes crushes breaks)
    i,j = [p1,p2].map { |s| who.find_index s }

    winner,loser = [i,j].sort { |x,y| ((y-x)%5+1)/2-1 }

    method = (winner-loser)%5/2
    what = method == 0 && "ties" || how[winner*2 + method-1]

    return "#{who[winner]} #{what} #{who[loser]}"
end

Answer 7

अजगर

---

  def winner(p,q):
        if p==q:
           return(' '.join([p,'tie',q]))
        d = {'ca':'cut','ao':'covers','oi':'crushes','ip':'poisons','pc': 'smashes','ci':'decapitate','ia':'eats', 'ap':'disproves', 'po':'vaporizes','oc': 'breaks'}
        [a,b] = [p[1],q[1]]
        try:
           return(' '.join([p,d[a+b],q]))
        except KeyError:
           return(' '.join([q,d[b+a],p]))

एक मुश्किल शब्दकोश का उपयोग करना।

Comments

अच्छा है। return(' '.join([p,'tie' + 's'*(p[1]!='c'),q]))क्रिया तनाव को सही करेगा।

— डैनसमो

Answer 8

सी#

मान्यताओं

विरोधियों को एक एन-आइटम सरणी में व्यवस्थित किया जाता है जहां खिलाड़ी (n-1) / 2 खिलाड़ियों को उनके आगे हरा देते हैं और उनके पीछे (n-1) / 2 खिलाड़ियों से हार जाते हैं। (यहां तक ​​कि लंबाई सूचियों के साथ, खिलाड़ी ((n-1) / 2 + 1) अपने पीछे के खिलाड़ियों से हार जाता है)

प्लेयर क्रियाओं को एक सरणी में व्यवस्थित किया जाता है, जहां [(indexOfPlayer * (n-1) / 2)] से [(indexOfPlayer * (n-1) / 2)] + (n-2) / 2 - 1 की सीमा के भीतर क्रियाएँ होती हैं ]।

अतिरिक्त जानकारी

CircularBuffer<T>एक "असीम" पता योग्य सरणी बनाने के लिए एक सरणी के चारों ओर एक आवरण है। IndexOfसमारोह सरणी की वास्तविक सीमा के भीतर एक आइटम के सूचकांक देता है।

कक्षा

public class RockPaperScissors<T> where T : IComparable
{
    private CircularBuffer<T> players;
    private CircularBuffer<T> actions;

    private RockPaperScissors() { }

    public RockPaperScissors(T[] opponents, T[] actions)
    {
        this.players = new CircularBuffer<T>(opponents);
        this.actions = new CircularBuffer<T>(actions);
    }

    public string Battle(T a, T b)
    {
        int indexA = players.IndexOf(a);
        int indexB = players.IndexOf(b);

        if (indexA == -1 || indexB == -1)
        {
            return "A dark rift opens in the side of the arena.\n" +
                   "Out of it begins to crawl a creature of such unimaginable\n" +
                   "horror, that the spectators very minds are rendered\n" +
                   "but a mass of gibbering, grey jelly. The horrific creature\n" +
                   "wins the match by virtue of rendering all possible opponents\n" +
                   "completely incapable of conscious thought.";
        }

        int range = (players.Length - 1) / 2;

        if (indexA == indexB)
        {
            return "'Tis a tie!";
        }
        else
        {
            indexB = indexB < indexA ? indexB + players.Length : indexB;
            if (indexA + range < indexB)
            {
                // A Lost
                indexB = indexB >= players.Length ? indexB - players.Length : indexB;
                int actionIndex = indexB * range + (indexA > indexB ? indexA - indexB : (indexA + players.Length) - indexB) - 1;

                return players[indexB] + " " + actions[actionIndex] + " " + players[indexA];
            }
            else
            {
                // A Won
                int actionIndex = indexA * range + (indexB - indexA) - 1;

                return players[indexA] + " " + actions[actionIndex] + " " + players[indexB];
            }
        }
    }
}

उदाहरण

string[] players = new string[] { "Scissors", "Lizard", "Paper", "Spock", "Rock" };
string[] actions = new string[] { "decapitates", "cuts", "eats", "poisons", "disproves", "covers", "vaporizes", "smashes", "breaks", "crushes" };

RockPaperScissors<string> rps = new RockPaperScissors<string>(players, actions);

foreach (string player1 in players)
{
    foreach (string player2 in players)
    {
        Console.WriteLine(rps.Battle(player1, player2));
    }
}
Console.ReadKey(true);

Answer 9

अजगर, वन-लाइनर

winner=lambda a,b:(
    [a+" ties "+b]+
    [x for x in 
        "Scissors cut Paper,Paper covers Rock,Rock crushes Lizard,Lizard poisons Spock,Spock smashes Scissors,Scissors decapitate Lizard,Lizard eats Paper,Paper disproves Spock,Spock vaporizes Rock,Rock break Scissors"
        .split(',') 
     if a in x and b in x])[a!=b]

Comments

बहुत ही शांत! आपको .split(', ')एक साथ, नियमों, नियमों को जाम नहीं करना पड़ सकता है।

— dansalmo

@dansalmo, धन्यवाद, लेकिन मुझे JammingTheRules में कोई नुकसान नहीं हुआ। हालांकि यह एक गोल्फ प्रतियोगिता नहीं है, मुझे लगता है कि छोटी बेहतर है।

— 12

Answer 10

बस एक छोटी सी बात मैं लेकर आया:

echo "winners('Paper', 'Rock')"|sed -r ":a;s/[^ ]*'([[:alpha:]]+)'./\1/;ta;h;s/([[:alpha:]]+) ([[:alpha:]]+)/\2 \1/;G"|awk '{while(getline line<"rules"){split(line,a," ");if(match(a[1],$1)&&match(a[3],$2))print line};close("rules")}' IGNORECASE=1

यहां, नियम सभी नियमों से युक्त फ़ाइल है।

Answer 11

अजगर

@ टोबिया के एपीएल कोड से प्रेरित।

def winner(p1, p2):
  x,y = map(lambda s:'  scparolisp'.find(s.lower())/2, (p1[:2], p2[:2]))
  v = (' cut covers crushes poisons smashes'.split(' ')[x*(y in (x+1, x-4))] or
       ' decapitate disproves breaks eats vaporizes'.split(' ')[x*(y in (x+3, x-2))])
  return ' '.join((p1.capitalize(), v or 'tie'+'s'*(x!=1), p2)) if v or p1==p2 \
    else winner(p2, p1)

परिणाम:

>>> winner('Spock', 'paper')
'Paper disproves Spock'
>>> winner('Spock', 'lizard')
'Lizard poisons Spock'
>>> winner('paper', 'lizard')
'Lizard eats paper'
>>> winner('paper', 'paper')
'Paper ties paper'
>>> winner('scissors',  'scissors')
'Scissors tie scissors'    

Answer 12

सी ++

#include <stdio.h>
#include <string>
#include <map>
using namespace std ;
map<string,int> type = { {"Scissors",0},{"Paper",1},{"Rock",2},{"Lizard",3},{"Spock",4} };
map<pair<int,int>, string> joiner = {
  {{0,1}, " cuts "},{{0,3}, " decapitates "}, {{1,2}, " covers "},{{1,4}, " disproves "},
  {{2,3}, " crushes "},{{2,0}, " crushes "},  {{3,4}, " poisons "},{{3,1}, " eats "},
  {{4,0}, " smashes "},{{4,2}, " vaporizes "},
} ;
// return 0 if first loses, return 1 if 2nd wins
int winner( pair<int,int> p ) {
  return (p.first+1)%5!=p.second && (p.first+3)%5!=p.second ;
}
string winner( string sa, string sb ) {
  pair<int,int> pa = {type[sa],type[sb]};
  int w = winner( pa ) ;
  if( w )  swap(pa.first,pa.second), swap(sa,sb) ;
  return sa+(pa.first==pa.second?" Ties ":joiner[pa])+sb ;
}

थोड़ा सा परीक्षण

int main(int argc, const char * argv[])
{
  for( pair<const string&, int> a : type )
    for( pair<const string&, int> b : type )
      puts( winner( a.first, b.first ).c_str() ) ;
}

Answer 13

जावास्क्रिप्ट

function winner(c1,c2){
    var c = ["Scissors", "Paper", "Rock", "Lizard", "Spock"];
    var method={
        1:["cut", "covers", "crushes", "poisons", "smashes"],
        2:["decapitate", "disproves", "breaks", "eats", "vaporizes"]};
    //Initial hypothesis: first argument wins
    var win = [c.indexOf(c1),c.indexOf(c2)];
    //Check for equality
    var diff = win[0] - win[1];
    if(diff === 0){
        return c1 + ((win[0]===0)?" tie ":" ties ") + c2;
    }
    //If s is -1 we'll swap the order of win[] array
    var s = (diff>0)?1:-1;
    diff = Math.abs(diff);
    if(diff >2){
        diff = 5-diff;
        s= s * -1;
    }
    s=(diff==1)?s*-1:s;
    if(s === -1){
        win = [win[1],win[0]];
    }
    return c[win[0]] + " " + method[diff][win[0]] + " " + c[win[1]];
}

Answer 14

जावास्क्रिप्ट

मैं देखता हूं कि यह एक गोल्फ प्रतियोगिता नहीं है, लेकिन मैं इस धागे को खोजने से पहले थोड़ी देर के लिए इस पहेली से लड़खड़ा गया था, इसलिए यहां जाता हूं।

यहाँ 278 अक्षरों में (मानक) js संस्करण है:

function winner(a,b){var c={rock:0,paper:1,scissors:2,spock:3,lizard:4},d="crushe,crushe,cover,disprove,cut,decapitate,smashe,vaporize,poison,eat".split(","),i=c[a],j=c[b],I=i==(j+3)%5;return i^j?i==(j+1)%5||I?a+" "+d[i*2+I]+"s "+b:b+" "+d[j*2+(j==(i+3)%5)]+"s "+a:a+" ties "+b}

259 वर्णों में E6 सुविधाओं (संभवतः केवल फ़ायरफ़ॉक्स में काम करता है) का उपयोग कर एक:

winner=(a,b,c={rock:0,paper:1,scissors:2,spock:3,lizard:4},d="crushe,crushe,cover,disprove,cut,decapitate,smashe,vaporize,poison,eat".split(","),i=c[a],j=c[b],I=i==(j+3)%5)=>i^j?i==(j+1)%5||I?a+" "+d[i*2+I]+"s "+b:b+" "+d[j*2+(j==(i+3)%5)]+"s "+a:a+" ties "+b