70

"रॉक", "पेपर", या "कैंची" के दो स्ट्रिंग इनपुट को देखते हुए, आरपीएस दौर के परिणाम को निर्धारित करें । आउटपुट 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

आपको इनपुट के रूप में सटीक स्ट्रिंग्स "रॉक", "पेपर", और "कैंची" का उपयोग करना चाहिए। आप चुन सकते हैं कि पहले खिलाड़ियों की पसंद (लगातार) पहली या दूसरी दी गई है। आप वैकल्पिक रूप से उन्हें एकल-पात्र या खाली विभाजक के साथ एकल इनपुट के रूप में ले सकते हैं। इनपुट आपके इनपुट प्रारूप में तीन विकल्पों में से 9 संभावित युग्मों में से एक की गारंटी है।

आउटपुट संख्या 1, 0, या -1, या इसके स्ट्रिंग प्रतिनिधित्व होना चाहिए। झांकियां ठीक हैं। तो हैं +1, +0,और -0।

संबंधित: एक आरपीएस खेल कोडिंग

लीडरबोर्ड:

कोड स्निपेट दिखाएं

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>

स्निपेट का विस्तार करें

code-golf game

— XNOR
स्रोत

क्या खाली विभाजक के साथ एकल इनपुट का मतलब उदाहरण के लिए "रॉकपेपर" है?

— एमिग्ना

1

@Eigna हाँ, लेकिन के रूप में पूंजीकृत RockPaper।

— xnor

15

मुझे उम्मीद थी कि इससे अधिक मजेदार था, मेरे भगवान ऐसा करने के लिए कुछ शांत तरीके हैं।

— जादू ऑक्टोपस Urn

क्या इनपुट दो तारों का एक सरणी हो सकता है?

— लुइस मेंडो

@LuisMendo हाँ।

— xnor

73

ग्रूवी, 67 56 50 बाइट्स

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

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

पता चलता है कि रॉक, पेपर, कैंची खेल में एक बहुत अच्छा गुण है।
A और b के स्ट्रिंग्स को देखते हुए, प्रत्येक के पहले अक्षर को लें, जिसके परिणाम निम्न में से दो हैं:R,P,S

संभावित मानों की संपूर्ण सूची (जब 2 विकल्प संयुक्त हों):

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 द्वारा सुझाया गया था और फिर 6 बिट्स की कुल बचत के लिए @titus द्वारा परीक्षण किया गया था ।

ग्रूवी की दोहरी गोलाई गुणों का उपयोग करते हुए, यह रॉक-पेपर-कैंची के लिए सही आउटपुट में परिणाम करता है।

05AB1E , 10 बाइट्स (गैर-प्रतिस्पर्धात्मक)

Ç¥13T/*.½ò

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

10/26/2017 जोड़े गए नए आदेशों का उपयोग करके उसी उत्तर को 05AB1E पर पोर्ट किया गया।

— जादू ऑक्टोपस Urn
स्रोत

3

क्या आप इसका उपयोग करके इसे कम नहीं कर सकते -sin(x) = sin(-x), इसका मतलब है कि बस aऔर के क्रम को उलट देना bऔर अग्रणी को गिराना है -? इसके अलावा, हार्डकोडिंग की 4/Piतरह एक सन्निकटन 1.273पर्याप्त हो सकता है, 1.3या 9/7या 5/4।

— दोष

2

पुनश्च: मैं इसे ऑनलाइन आजमाने के लिए एक लिंक बनाने का भी सुझाव देता हूं ताकि मेरे जैसे लोग आपके सबमिशन के साथ खेल सकें =)

— त्रुटिपूर्ण

3

के sin(b-a)बजाए आप 1 बाइट बचा सकते हैं -sin(a-b)। शानदार खोज!

— टाइटस

2

के 1.3बजाय गुणा करके एक और 7 बाइट्स सहेजें 4/Math.PI; यह पर्याप्त रूप से सटीक है।

— टाइटस

1

@ क्रूसोकोम्पुटिंगXX=ASCII=Y=Wanted output RR=82-82=0=0 PP=83-83=0=0 SS=80-80=0=0

— क्रेग 8806

44

सी, 50 35 बाइट्स

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

fविभाजक के बिना, दोनों खिलाड़ियों से युक्त स्ट्रिंग के साथ कॉल करें , और यह लौटेगा कि क्या पहले वाला जीता है।

स्पष्टीकरण:

नौ संभावित तारों को देखकर, यह पता चला है कि स्तंभ 7 और 8 पर अक्षर जोड़े अद्वितीय हैं:

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

ऑफसेट और सैवेज short*इन पत्र जोड़े को पुनः प्राप्त करने के लिए डाली गई , और उन्हें संख्याओं के रूप में व्याख्या करते हैं:

तब यह खोजने 51और 4बनाए रखने के लिए क्रूरता की बात थी , जिसने इन संख्याओं को क्रमिक रूप से कम करने के लिए लागू किया:

3 0 0 1 1 1 2 2 2

जो अंत में एक और शेष से निपटने के लिए एकदम सही है, और परिणाम ऑफसेट करना।

इसे कोलिरु पर लाइव देखें

— क्वेंटिन
स्रोत

बस -f(i)दूसरे खिलाड़ी के स्कोर की गणना करने के लिए गणना की तरह कुछ भी न करें - अप्रत्याशित आउटपुट का परिणाम होगा!

— nnonneo

4

@nneonneo -(f(i))को ठीक काम करना चाहिए। मैक्रों मज़ेदार हैं!

— nwp

18

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)

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

— flawr
स्रोत

16

शुद्ध बैश, 31

उधार लेना @ डेनिस का सूत्र :

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

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

पिछला उत्तर:

शुद्ध बैश, 43 35

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

प्रत्येक आर्ग की स्ट्रिंग लंबाई जाओ ( 4, 5, 8क्रमशः रॉक, कागज के लिए, कैंची)
XOR 3 के साथ प्रत्येक को देने के लिए 7, 6, 11(जो ले लिया जब आधुनिक 3 दे 1, 0, 2)
फिर वांछित परिणाम प्राप्त करने के लिए आधुनिक 3 के साथ घटाना और बेला।

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

— डिजिटल आघात
स्रोत

15

पायथन , 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)
]

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

— डेनिस
स्रोत

14

गणितज्ञ, 32 बाइट्स

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

वर्णों की सूचियों की एक ऑर्डर की गई जोड़ी, जैसे कि {{"R","o","c","k"},{"P","a","p","e","r"}}, और लौटकर कार्य करना -1|0|1।

मैं केवल तीन इनपुट शब्दों से बचने के लिए कोड चाहता था, लेकिन साथ ही साथ फ़ंक्शन नाम भी ToCharacterCode; इसलिए मैंने 4,5,8इसके बजाय इनपुट शब्दों की लंबाई के साथ काम किया , और उन लंबाई के एक छोटे से कार्य की तलाश की, जिसने अलग-अलग उत्तर दिए हैं modulo 3. (2 द्वारा पूर्णांक विभाजन गणितीय रूप से आशाजनक है, लेकिन उन कार्यों का गणित में बहुत लंबा नाम है।)

यह पता चला है कि (लंबाई - 3) के भाज्य को लेते हुए उत्तर दिए गए हैं 1,2,120, जो 1,-1,0मोडुलो 3 हैं । फिर हम सिर्फ गणना करते हैं, मोडुलो 3, दो मूल्यों का अंतर (डॉट उत्पाद के माध्यम से {1,-1}.{x,y} = x-y, जो कि एक अच्छा तरीका है दो मान एक सूची में हैं)।

— ग्रेग मार्टिन
स्रोत

1

"यह पता चला है ..." आप इन चीजों के लिए एक आँख है

— 22

12

रूबी, 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किसी भी तरह से दौर)।

मुझे एक चरित्र को बचाने के लिए होर्वाथ डेविड के लिए धन्यवाद, और मुझे एक और 5 बचाने के लिए जीबी के लिए धन्यवाद।

— गैरेथ
स्रोत

आप एक अनाम मेमने का उपयोग कर सकते हैं और 2 पात्रों को बचा सकते हैं।

— जीबी

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

— गैरेथ

वह धोखा नहीं है। बेनामी कार्यों को डिफ़ॉल्ट रूप से अनुमति दी जाती है।

— डेनिस

@ डेनिस आप इसे बिना बताए कॉल नहीं कर सकते। ऐसा लगता है कि मुझे धोखा दे रहा है, और अनाम कार्यों के बिना भाषाओं पर अनुचित है जिन्हें एक नाम को परिभाषित करना है।

— गैरेथ

जरूर आप कर सकते हो। tio.run/nexus/…

— डेनिस

10

पायथन , 39 36 34 33 बाइट्स

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

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

यह काम किस प्रकार करता है

आइए x की छह प्रतियों की लंबाई और y मोडुलो 7 की एक प्रति के कुछ मूल्यों पर एक नजर डालते हैं ।

                                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 के परिणाम को o (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₂

सौभाग्य से, पिछले कॉलम में बिट्स सभी एक-दूसरे से सहमत हैं, इसलिए हम उन्हें एक पूर्णांक n बनाने के लिए और ओ (एक्स, वाई) को 2 के रूप में पुनः प्राप्त कर सकते हैं - ((एन (ओ (एक्स, वाई))% 4) । N का मान 94 है ।

— डेनिस
स्रोत

9

रेटिना , 35 31 बाइट्स

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

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

व्याख्या

यह दो चरणों में काम करता है। सबसे पहले, हम संबंधित जानकारी के लिए ऋण चिह्न प्रिंट करते हैं। फिर हम 0संबंधों और 1अन्यथा के लिए प्रिंट करते हैं।

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

यह दो चरण है। )एक साथ दूसरे चरण समूहों उन में, *उन्हें एक सूखी रन बनाता है (जिसके बाद वे प्रोसेस किया गया इनपुट स्ट्रिंग बहाल हो जाएगा मतलब है, लेकिन परिणाम मुद्रित किया जाएगा) और \पीछे linefeed की छपाई को रोकता है। एक साथ -लागू होने पर दो चरण एक साथ प्रिंट होंगे।

पहले चरण एक है Gप्रतिनिधि मंच है जो केवल लाइन रहता है अगर यह होता है या तो k P, r Sया s R। ये उन मामलों के अनुरूप हैं, जहाँ हमें आउटपुट की आवश्यकता है -1। यदि यह उन मामलों में से एक नहीं है, तो इनपुट को एक रिक्त स्ट्रिंग से बदल दिया जाएगा।

दूसरे चरण की जगह .+(पूरे स्ट्रिंग, लेकिन केवल अगर इसमें कम से कम एक चरित्र होता है) -। तो यह -उन तीन मामलों के लिए प्रिंट करता है और अन्यथा कुछ भी नहीं।

D`\w+
 .

यह दो और चरण है। पहला चरण एक Deduplication है। यह शब्दों से मेल खाता है और डुप्लिकेट को निकालता है। इसलिए यदि और केवल यदि इनपुट एक टाई है, तो यह दूसरा शब्द छोड़ता है।

दूसरे चरण के मैचों की संख्या को गिना जाता है ., जो किसी भी वर्ण द्वारा पीछा किया जाने वाला स्थान है। यदि इनपुट एक टाई था, और दूसरा शब्द हटा दिया गया था, तो यह परिणाम है 0। अन्यथा, दूसरा शब्द अभी भी जगह में है, और एक मैच है, इसलिए यह 1इसके बजाय प्रिंट करता है।

— मार्टिन एंडर
स्रोत

यहाँ इनपुट स्ट्रिंग लंबाई के आधार पर एक अलग दृष्टिकोण है । यह आपकी तुलना में अधिक लंबा है, लेकिन मुझे आश्चर्य है कि क्या इसे किसी भी अधिक नीचे गिराया जा सकता है?

— डिजिटल ट्रामा

@DigitalTrauma यह एक बहुत ही अच्छा विचार है, लेकिन मैं इसे छोटा करने के लिए कुछ भी नहीं देख रहा हूं। मुझे लगता है कि आपको इसे वैसे भी पोस्ट करना चाहिए (और यदि आप हेडर में पहली पंक्ति को स्थानांतरित करते हैं तो TIO इसे बाइट की गिनती में शामिल नहीं करेगा)।

— मार्टिन एंडर

8

05AB1E , 18 17 15 10 9 बाइट्स

डिजिटल ट्रॉमा की इनपुट लंबाई चाल के साथ 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

— Emigna
स्रोत

तुम मेरी मस्ती को Ç¥13T/*.½òहराओ :( WHY IT WORKS? NOBODY KNOWS।

— Magic Octopus Urn

@MagicOctopusUrn: Uuuh, यह निश्चित रूप से एक अजीब है। आउटपुट के रूप में इंट को वापस करने के लिए इनपुट प्रारूप क्या होगा?

— Emigna

['R','P']: P यह इसका एक पोर्ट है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: ओह, हाँ, मैं उस एक के बारे में भूल गया था। इस चुनौती का मेरा पसंदीदा जवाब :)

— एमिगा

6

जेली , 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.

— डेनिस
स्रोत

6

पायथन 2 , 46 40 बाइट्स

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

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

@ डेनिस को कई धन्यवाद देने के साथ मुझे उसका ऑनलाइन टेस्ट कोड आजमाने और मुझे 6 बाइट बचाने के लिए धन्यवाद।

संपादित करें

@ hashcode55 - बहुत सुंदर जैसा कि आप वर्णन करते हैं। (x! = y, -1) एक दो तत्व अनुक्रम है और [x [०] + y [०] inRRR '] किस तत्व को लेना है। यदि x का पहला अक्षर + y का पहला अक्षर वर्ण सूची में है तो यह True या 1 का मूल्यांकन करेगा (x! = Y, -1) [1] वापस आ जाएगा। यदि ऐसा नहीं है तो (x! = Y, -1) [0]। यह वह जगह है जहाँ यह थोड़ा मुश्किल हो जाता है। पहला तत्व अपने आप में एक और प्रभावी ढंग से है अगर। यदि x! = Y है तो पहला तत्व ट्रू होगा अन्यथा यह गलत होगा, यदि x [0] + y [0] inRRR 'गलत है तो या तो True या गलत x x = y के आधार पर वापस आ जाएगा। द + थोड़ा डरपोक है और इसके लिए @ डेनिस को फिर से धन्यवाद। X! = Y एक शाब्दिक सही या गलत लौटाएगा। हमें 1 या 0. की आवश्यकता है। मुझे अभी भी पता नहीं है कि यह रूपांतरण कैसे + करता है। मैं केवल यह मान सकता हूं कि ट्रू / फाल्स पर एक गणितीय ऑपरेटर का उपयोग करके यह पूर्णांक समकक्ष के रूप में देखने के लिए मजबूर कर रहा है। जाहिर है -1 के सामने + अभी भी -1 लौटेगा।

उम्मीद है की यह मदद करेगा!

— ElPedro
स्रोत

नमस्ते! क्या आप मुझे बता सकते हैं कि यह वाक्य रचना कैसे काम कर रही है? तार्किक रूप से अनुमान लगाते हुए, (x!=y,-1)यह काम कर रहा है जैसे, यदि सूची एक वास्तविक उत्पन्न करती है तो -1 और x!=y। उस +संकेत का उपयोग क्या है ? इस तरह के वाक्यविन्यास का दस्तावेजीकरण करने वाला स्रोत वास्तव में मददगार होगा!

— हैशकोड

@ hashcode55 - मैंने अपने उत्तर में एक स्पष्टीकरण जोड़ा है।

— एलपेड्रो

+इस मामले में - के बारे में आपकी अनिश्चितता का जवाब देने के लिए , यह एक अपरिपक्व प्लस है, पसंद है +10, और अनिवार्य रूप से एक पूर्णांक में बदलने का एक छोटा तरीका है।

— फ्लिपकार्ट

साभार @FlipTack किंडा ने अनुमान लगाया कि यह क्या कर रहा है लेकिन उचित स्पष्टीकरण के लिए धन्यवाद।

— ElPedro

@ElPedro बहुत बहुत धन्यवाद! कि वास्तव में मेरी मदद की।

— hashcode55

5

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

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

इस तथ्य का उपयोग करता है कि रॉक-पेपर-कैंची चक्रीय है। जावास्क्रिप्ट में न तो स्पेसशिप है और न ही संतुलित टर्नरी ऑपरेटर, अन्यथा इसका जवाब होगा (a,b)=>((b<=>'Rock')-(a<=>'Rock'))%%3।

संपादित करें: Savash 8 बाइट्स के लिए @WashingtonGuedes धन्यवाद।

— नील
स्रोत

1

@WashingtonGuedes मैं इससे भी बेहतर कर सकता हूं!

— नील

आप 1 बाइट बचाने के लिए करी कर सकते हैं

— MayorMonty

मैंने इसे चलाने की कोशिश की और हमेशा 0

— विटिम.स

5

MATL , 14 13 बाइट्स

TTt_0vic1Z)d)

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

यदि पहले स्ट्रिंग के प्रारंभिक अक्षर का ASCII कोड दूसरी स्ट्रिंग से घटाया जाता है, तो हमें नीचे D कॉलम में मान मिलता है । मोडुलो 5 लेने से मूल्य M मिलता है । कोष्ठक में अंतिम मूल्य वांछित परिणाम है, आर ।

                        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 के बराबर पांच प्रविष्टियों की एक सरणी में अनुक्रमित करके किया जा सकता है। चूंकि 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

— लुइस मेंडो
स्रोत

5

CJam , 12 बाइट्स

0XXWW]rcrc-=

दो इनपुट अंतरिक्ष-अलग हैं। उनके आदेश को चुनौती पाठ के संबंध में उलट दिया गया है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

मेरे MATL उत्तर का अनुवाद । यह इस तथ्य का शोषण करता है कि cएक स्ट्रिंग पर सीजेएम (कन्वर्ट में चार) को लागू किया जाता है। इसके अलावा, मैपिंग के लिए सरणी भिन्न है क्योंकि 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

— लुइस मेंडो
स्रोत

5

सीजाम, 15 14 12 बाइट्स

rW=rW=-J+3%(

प्रत्येक स्ट्रिंग के अंतिम वर्ण का एससीआई कोड लें, फिर रिटर्न:

(a1 - a2 + 19) % 3 - 1

इसे यहाँ टेस्ट करें !

— अरनॉड
स्रोत

5

पायथन 3, 54 बाइट्स

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

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

4

जावा 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;}

Ungolfed:

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।
2 xसे विभाजित अब परीक्षण मामलों के लिए निम्नलिखित है:
- 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
  }
}

आउटपुट:

— केविन क्रूज़सेन
स्रोत

जिज्ञासा से बाहर दूसरा पत्र क्यों? मेरे पास एक ही तरीका था (थोड़े) लेकिन पहले अक्षर का इस्तेमाल किया।

— मैजिक ऑक्टोपस Urn

@carusocomputing खैर, मैंने देखा कि अधिकांश अन्य लोग या तो पहले अक्षर या लंबाई का उपयोग कर रहे थे, और कुछ और आज़माना चाहते थे। मैं पहली बार तीसरे पत्र (इस्तेमाल किया c, p, iASCII मूल्यों के साथ) 99, 112और 105, के रूप में वे सबसे अधिक उपयोगी लग रहा था, और देखा कि यह बन जाएगा 4, 2, 0 अगर मैं उसके बाद ही सापेक्ष 5. किया मैं समझ मैं दोनों घटाना थी, इसलिए 4, 2 और 0 अधिक उपयोग के नहीं थे। लगभग कुछ गड़बड़ी / परीक्षण-और-त्रुटि के बाद मैंने दूसरे पत्र की कोशिश की और उसी modulo 5 के साथ अधिक उपयोगी परिणाम प्राप्त कर रहा था। फिर मैं जल्दी से ऊपर प्रस्तुत समाधान पर आया। :)

— केविन क्रूज़सेन

@carusocomputing एक अद्वितीय दृष्टिकोण की कोशिश करना चाहता था, और यह देखते हुए कि मैं इस तरह के समाधानों में बहुत बुरा हूं, यह कुछ अन्य समाधानों जितना छोटा नहीं है, लेकिन फिर भी अद्वितीय है (जो मेरा प्रारंभिक लक्ष्य था)। :)

— केविन क्रूज़सेन

4

डीसी, १,

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

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

ध्यान दें कि एसटीडिन पर एक पंक्ति में दो आर्ग्स (अंतरिक्ष-अलग) पारित किए जाते हैं। आर्गों को वर्ग कोष्ठक में समाहित किया गया है [ ]क्योंकि यह dcइसके तार को पसंद करता है।

dcहै बहुत सीमित स्ट्रिंग हैंडलिंग, लेकिन यह पता चला जिन्हें आप कर सकते से एक का उपयोग है Zआदेश एक स्ट्रिंग की लंबाई, जो सौभाग्य से "रॉक" के लिए अलग है प्राप्त करने के लिए, "कागज" और "कैंची", और बस हिसाब से काफी हो सकता है वांछित परिणाम देने के लिए जोड़ तोड़।

— डिजिटल आघात
स्रोत

4

PHP, 34 बाइट्स

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

— user63956
स्रोत

3

अजगर, १६

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

ऑनलाइन ।

— डिजिटल आघात
स्रोत

3

सी #, 85 84 बाइट्स

1 बाइट को बचाया, TheLethalCoder के लिए धन्यवाद

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;

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

— होर्वाथ डेविड
स्रोत

करीने का उपयोग करके एक बाइट को बचाएंa=>b=>...

— TheLethalCoder

3

जावास्क्रिप्ट, 37 , 32 , 31 बाइट्स

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

यदि बराबर बी, आउटपुट शून्य है।

अन्यथा, यदि x की तुलना में अधिक से अधिक 12 (कैंची और कागज की तुलना) की लंबाई नहीं है, तो जाँच का परिणाम xor।
यदि यह 1 रिटर्न देता है, तो इसे वापस लौटाएं।

यदि यह 0 देता है, तो -1 के साथ बदलने के लिए OR ऑपरेटर का उपयोग करें।

— Grax32
स्रोत

क्या आप इसे a=>b=>एक बाइट को बचाने के लिए एक करी फ़ंक्शन के रूप में लिख सकते हैं ?

— 21

हाँ। साभार @FlipTack

— Grax32

2

बैच, 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

— नील
स्रोत

2

पर्ल, 33 बाइट्स

कोड + -pध्वज के 32 बाइट्स ।

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

इसे चलाने के लिए:

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

मार्टिन एंडर के रेटिना उत्तर के rexx का उपयोग करके 3 बाइट्स सहेजे गए । (मेरा पिछला रेगेक्स था /R.*P|P.*S|S.*R/)

स्पष्टीकरण:

पहले, /(.+) \1/जांचता है कि इनपुट में एक ही शब्द दो बार है, यदि हां, तो परिणाम है 0। अन्यथा, /k P|r S|s R/उस मामले से निपटता है जहां जवाब है -1। यदि यह अंतिम रेगेक्स गलत है, तो -/k P|r S|s R/गलत है, इसलिए हम वापस लौट आते हैं 1।

— बापू
स्रोत

2

जेली , 9 बाइट्स

L€^3Iæ%1.

यह @ DigitalTrauma के बैश उत्तर से एल्गोरिथ्म का उपयोग करता है ।

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

यह काम किस प्रकार करता है

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

— डेनिस
स्रोत

डेमिट, मैं जेली पर पढ़ना शुरू करने वाला था। ओह ठीक है, यहाँ यह अजगर में है । +1।

— डिजिटल ट्रामा

2

जाप , 19 बाइट्स

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

यहाँ यह कोशिश करो!

_{कारुसोकोम्पुटिंग के समाधान से प्रेरित}

पुराना 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!}

— ओलिवर
स्रोत

1

आप का उपयोग करके शुरू कर सकता है ©के बजाय &&, बदल रहा है Ug0 cकरने के लिए Ug c(के साथ एक ही V) और जगह -1के साथ J। यह जेएस जवाब की तुलना में अभी भी काफी लंबा है , शायद आप इससे कुछ विचार ले सकते हैं

— ETHproductions

— ओलिवर

1

वास्तव में आप बस कर सकते हैं W=Uc। मुझे नहीं पता कि मैं यह क्यों भूल जाता हूं कि cकिसी भी स्ट्रिंग पर काम करता है: P

— ETHproductions

2

PHP, 55 53 बाइट्स

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

पहले अक्षरों के आस्की मान लेता है (कमांड लाइन के तर्कों से): 82,80,83
% 6: 4,2,5
% 4: 0,2,1
अंतर (बा):
- पीएस: 1-2, एसआर: 2-0, आरपी: 2-0 -> -1 या 2; + 3,% 3 -> 2
- एसपी: 2-1, आरएस: 0-2, पीआर: 0-2 -> -2 या 1; + 3,% 3 -> 1
- आर आर, पीपी, एसएस: 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;

carusocomputingeds जवाब का एक गोल्फ पोर्ट :

3 बाइट्स @ user59178 द्वारा सेव की गई

— टाइटस
स्रोत

1

साइन संस्करण के लिए बदल कर 3 बाइट्स बचा सकता है के लिए round(x)साथ2*x^0

— user59178

2

पर्ल, 25 बाइट्स

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

-pविकल्प के लिए कोड 24 बाइट्स +1 बाइट ।

इनपुट बिना विभाजक के स्टड पर होना चाहिए, जैसे:

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

पहला regexp पहले खिलाड़ी की जीत के लिए खोज करता है, दूसरा अपने नुकसान के लिए। अंतर छपा है।

— mik
स्रोत

1

स्काला, 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)

क्योंकि स्काला आपको वर्ण प्राप्त करने के उद्देश्य से स्ट्रिंग के रूप में व्यवहार करने देता है।

— Archmage
स्रोत

यह पूरी तरह से गोल्फ हो सकता है। शुरुआत के लिए, आपको यहां अधिकांश चुनौतियों में एक पूर्ण कार्यक्रम के बजाय एक फ़ंक्शन करने की अनुमति है, इसलिए पूरे ऑब्जेक्ट के बजाय ऐप चीज़ को फैलता है और आर्ग्स से खींचता है, कुछ इस तरह की कोशिश करें: डीईएफ जी (ए: सीक्यू, बी: सीक) = ...

— एतान

इसके अतिरिक्त, आपको मूल्य प्रिंट करने की आवश्यकता नहीं है। यह रिटर्निंग पर्याप्त है, जो कि स्केला के गोल्फिंग के समय बहुत अच्छा है, क्योंकि रिटर्न फ्री है। और आप ग्रोवी उत्तर में पोस्ट की गई चाल का उपयोग करके इसे और भी बेहतर बना सकते हैं, जो स्काला में लगभग समान रूप से काम करता है।

— ईथन

स्कोर रॉक-पेपर-कैंची

ग्रूवी, 67 56 50 बाइट्स

05AB1E , 10 बाइट्स (गैर-प्रतिस्पर्धात्मक)

सी, 50 35 बाइट्स

स्पष्टीकरण:

MATLAB / ऑक्टेव , 63 54 52 बाइट्स

शुद्ध बैश, 31

शुद्ध बैश, 43 35

पायथन , 40 30 बाइट्स

पृष्ठभूमि

गणितज्ञ, 32 बाइट्स

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

पायथन , 39 36 34 33 बाइट्स

यह काम किस प्रकार करता है

रेटिना , 35 31 बाइट्स

व्याख्या

05AB1E , 18 17 15 10 9 बाइट्स

जेली , 8 बाइट्स

यह काम किस प्रकार करता है

पायथन 2 , 46 40 बाइट्स

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

MATL , 14 13 बाइट्स

व्याख्या

CJam , 12 बाइट्स

व्याख्या

सीजाम, 15 14 12 बाइट्स

पायथन 3, 54 बाइट्स

जावा 7, 82 बाइट्स

डीसी, १,

PHP, 34 बाइट्स

अजगर, १६

सी #, 85 84 बाइट्स

जावास्क्रिप्ट, 37 , 32 , 31 बाइट्स

बैच, 116 बाइट्स

पर्ल, 33 बाइट्स

जेली , 9 बाइट्स

यह काम किस प्रकार करता है

जाप , 19 बाइट्स

PHP, 55 53 बाइट्स

पर्ल, 25 बाइट्स

स्काला, 148 बाइट्स