रॉक, पॉलीग्लॉट, कैंची


68

एक प्रोग्राम लिखें जो तीन भाषाओं में एक बहुभाषाविद है जो रॉक-पेपर-कैंची खेलता है ।

कार्यक्रम के किसी भी संस्करण के लिए इनपुट हमेशा स्ट्रिंग rockया paperया में से एक होता है scissors

पहली भाषा में प्रोग्राम को रॉक-पेपर-कैंची पसंद का उत्पादन करना चाहिए जो इनपुट को हराता है:

Input     Output
rock      paper
paper     scissors
scissors  rock

दूसरी भाषा में प्रोग्राम को रॉक-पेपर-कैंची पसंद को आउटपुट करना होगा जो इनपुट को जोड़ता है:

Input     Output
rock      rock
paper     paper
scissors  scissors

तीसरी भाषा में प्रोग्राम को रॉक-पेपर-कैंची पसंद को आउटपुट करना होगा जो इनपुट को खो देता है:

Input     Output
rock      scissors
paper     rock
scissors  paper

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर उच्च मतदान वाला उत्तर है।

इनपुट और / या आउटपुट में वैकल्पिक रूप से एक अनुगामी न्यूलाइन हो सकती है लेकिन अन्यथा केवल सादे rock/ paper/ scissorsस्ट्रिंग्स होनी चाहिए । आपको अपर केस का उपयोग कर सकते ROCK, PAPER, SCISSORSवांछित है।

आप एक ही भाषा के विभिन्न संस्करणों (उदाहरण पायथन 2 और 3) का उपयोग नहीं कर सकते हैं


क्या भाषा से बाहर निकलने में त्रुटि हो सकती है?
कृति लीथोस

2
@KritiiLithos मेटा कंसेंशन के साथ जाएं । "मुझे लगता है कि एक त्रुटि या एक अपवाद के साथ समाप्त करना यहाँ ठीक है, जब तक कि यह STDOUT को आवारा उत्पादन नहीं करता है।"
केल्विन के शौक

2
पॉलीग्लॉट्स के साथ कभी भी निश्चित नहीं हैं, क्या अलग-अलग भाषाएं अलग-अलग तरीकों से इनपुट ले सकती हैं?
जोनाथन एलन

3
@JonathanAllan यह ठीक है। कुछ भाषा सेटों के लिए जो केवल इनपुट के कुछ निश्चित रूप हैं, यह आवश्यक होगा।
केल्विन के शौक

छिपकली, स्पॉक का क्या हुआ? bigbangtheory.wikia.com/wiki/Rock_Paper_Screens_Lizard_Spock
Ole Tange

जवाबों:


60

पायथन, ब्रेनफक और जावास्क्रिप्ट, 100 बाइट्स के तहत 103 99 बाइट्स याय!

0,[.5,];p=["rock","scissors","paper"]
1//1;lambda x:p[p.index(x)-1];"""
x=>p[-~p.indexOf(x)%3]//"""

पाइथन में, यह एक फ़ंक्शन को परिभाषित करता है जो इनपुट को धड़कता है, ब्रेनफक में यह सिर्फ एक साधारण बिल्ली कार्यक्रम है, और जावास्क्रिप्ट में यह खो देता है। यहां एक संस्करण है जो फ़ंक्शन को एक नाम देता है f, और जावास्क्रिप्ट और पायथन 3 में इनपुट के लिए भी संकेत देता है:

0,[.5,];p=["rock","scissors","paper"]
1//1;f=lambda x:p[p.index(x)-1];"""
f=x=>p[-~p.indexOf(x)%3]//"""

1//1;"""
console.log(f(prompt())) // JavaScript
1//1"""; print(f(input())) # Python

इसे ऑनलाइन (पुराने संस्करण) आज़माएं: पायथन , ब्रेनफ़क , जावास्क्रिप्ट

स्पष्टीकरण:

पायथन में, """..."""एक बहुस्तरीय स्ट्रिंग है, जिसका उपयोग किसी भी टोकन के रूप में किया जा सकता है। जब स्टैंड-अलोन रखा जाता है तो यह कुछ भी नहीं करता है। मैं इसका उपयोग पायथन से जावास्क्रिप्ट कोड को "छिपाने" के लिए करता हूं। उसी के लिए चला जाता है (0,[.5,])बिट, यह एक युक्त सिर्फ एक टपल है 0और की एक सूची 5, और यह भी 1//1, भाग //अजगर में पूर्णांक विभाजन है, लेकिन जावास्क्रिप्ट में एक टिप्पणी शुरू होता है। ये कोड इन टोकन से छीन लिया गया है:

p=["rock","scissors","paper"]
lambda x:p[p.index(x)-1]

पहली पंक्ति बहुत आत्म-व्याख्यात्मक है, यह सिर्फ pरॉक-पेपर-कैंची में विभिन्न विकल्पों को शामिल करने के लिए सूची को परिभाषित करती है । दूसरी पंक्ति एक अनाम फ़ंक्शन को परिभाषित करती है जो एक तर्क लेती है x, और उस विकल्प को वापस देती है जो धड़कता है x(उदाहरण के लिए पिछले तत्व आदि p)


जावास्क्रिप्ट में, //एकल-लाइन टिप्पणी को दर्शाता है। पाइथन के समान, एकल टोकन को अनदेखा कर दिया जाता है, इसलिए इन टोकन का कोड हटा दिया जाता है:

p=["rock","scissors","paper"]
x=>p[-~p.indexOf(x)%3]

यह पाइथन के समान ही काम करता है, पहले pविकल्पों को शामिल करने के लिए सूची सेट करके और फिर एक गुमनाम फ़ंक्शन को परिभाषित करता है जो खोने का विकल्प देता है। -~xके रूप में ही है, x+1लेकिन उच्च वरीयता के साथ इतना है कि मैं parens छोड़ सकते हैं।


ब्रेनफक में, इसे छोड़कर प्रत्येक वर्ण +-,.[]<>हटा दिया जाता है:

,[.,][,,]
[.-]
>[-.]

कमांड ,इनपुट के एक बाइट को पढ़ता है, .इसे प्रिंट करता है और [...]लूप करता है जबकि मान गैर-शून्य है। यह कार्यक्रम तब क्या करता है, इनपुट को पढ़ा जाता है और एक बार में एक चरित्र को तब तक छापता \0है जब तक कि चरित्र नहीं मिल जाता। चूंकि हमारे पास कोड में नहीं है, इसलिए हम बाकी प्रोग्राम को अनदेखा कर सकते हैं। वास्तव में, यह उपयोगकर्ता को जो भी प्रकार देता है, प्रभावी ढंग से उन्हें बांधता है।


एक बहुत ही समान समाधान पर काम कर रहा था, लेकिन आपने मुझे इसे हरा दिया :)। आपको जावास्क्रिप्ट TIO लिंक btw को अपडेट करना होगा, यह अन्य दो से अलग है।
डिंप

2
x=>p[p.indexOf(x)+1]||"rock"//"""को छोटा किया जा सकता हैx=>p[(p.indexOf(x)+1)%3]//"""
ल्यूक

13
+1 मैंने कभी भी ब्रेनफक को इतने अच्छे से छिपा हुआ नहीं देखा। आमतौर पर यह स्पष्ट है कि अगर एक बहुभुज में भी बीएफ होता है। इस एक में नहीं!
vsz

मुझे लगता है कि आप एक बाइट या दो को बचाने के लिए BF प्रोग्राम को थोड़ा इधर-उधर कर सकते हैं:1//1,[.5,];
ETHproductions

तथ्य की बात के रूप में, मुझे लगता है कि आप []अधिक बाइट्स को बचाने के लिए दूसरी लाइन पर मौजूदा का उपयोग कर सकते हैं :1//1,;lambda x:p[p.index(x,0)+-1];"""
ETHproductions

40

पायथन 2, रूबी, रेटिना, 90 83 बाइट्स

-7 बाइट्स मूल्य स्याही के लिए धन्यवाद

s=['rock','paper','scissors']
print s[s.index((0and gets or input()))+(0and-2or-1)]

इसे ऑनलाइन आज़माएं: पायथन , रूबी , रेटिना

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


andऑपरेटर की व्यापकता है or, इसलिए s.index(0and STDIN.gets or input())काम करता है। इसके अलावा, रूबी के getsलिए एक उपनाम है STDIN.gets
मूल्य इंक

10
+1 अलग-अलग तरीकों से कोड टिप्पणी नहीं करने के लिए!
लेओ

@ValueInk धन्यवाद! मुझे लगा कि रूबी में इनपुट प्राप्त करने के लिए और अधिक संक्षिप्त तरीका होना चाहिए, और यह पता चला है कि
गणित नशेड़ी

21

वी, ब्रेन-फ्लैक, और पायथन 2, 97, 86, 81, 77 , 75 बाइट्स

o='rock paper scissors'.split()
lambda s:o[o.index(s)-1]#ddt.C rHd*wywVp

दो बाइट्स @ nmjcman101 की बदौलत बच गईं!

यह सुपर मजेदार था! मुझे यह उत्तर बहुत पसंद है क्योंकि यह उन भाषाओं का एक शांत अवलोकन है जो मुझे पसंद हैं: मेरा पसंदीदा संपादक, मेरी पसंदीदा गैर-गूढ़ भाषा और मैंने जो भाषा लिखी है। (तकनीकी रूप से अजगर 3 बेहतर है, लेकिन अजगर 2 गोल्फ खिलाड़ी है ¯\_(ツ)_/¯)।

इसे ऑनलाइन आज़माएं! पाइथन में (थोड़ा संशोधित तो आप आउटपुट देख सकते हैं), जो प्रिंट करता है जो इनपुट को खो देता है।

इसे ऑनलाइन आज़माएं! ब्रेन-फ्लैक में, जो इनपुट के साथ संबंध रखता है।

इसे ऑनलाइन आज़माएं! V में, जो प्रिंट करता है जो इनपुट को धड़कता है।

चूँकि V, अप्राप्य ASCII वर्णों पर निर्भर करता है, यहाँ एक हेक्सडम्प है:

00000000: 6f3d 2772 6f63 6b20 7061 7065 7220 7363  o='rock paper sc
00000010: 6973 736f 7273 272e 7370 6c69 7428 290a  issors'.split().
00000020: 6c61 6d62 6461 2073 3a6f 5b6f 2e69 6e64  lambda s:o[o.ind
00000030: 6578 2873 292d 315d 231b 6464 742e 4320  ex(s)-1]#.ddt.C 
00000040: 720e 1b48 642a 7779 7756 70              r..Hd*wywVp

स्पष्टीकरण:

अजगर

अजगर में, यह बहुत सीधा है। हम तीन तत्वों की एक सूची को परिभाषित करते हैं, और इनपुट से ठीक पहले तत्व को वापस करते हैं। चूंकि -1पीछे के तत्व को लौटाता है, यह परिपत्र रूप से काम करता है, और यह सब बहुत सीधा और आसान है। फिर, सब कुछ के बाद #एक टिप्पणी है।

ब्रेन-आलोचना

यह वह जगह है भी मस्तिष्क आलोचना में बेहद सरल। अगर हमें जीत या हार का सामना करना पड़ता, तो यह शायद कई सौ बाइट्स होते। लेकिन यह वास्तव में 0 बाइट्स में काम करता है। कार्यक्रम की शुरुआत पर, सभी इनपुट स्टैक पर लोड होते हैं। कार्यक्रम के अंत में, पूरे स्टैक को स्पष्ट रूप से मुद्रित किया जाता है।

एक बार जब हम सभी अप्रासंगिक पात्रों को हटा देते हैं, तो कोड मस्तिष्क-परत देखता है

()[()]

जो बस का मूल्यांकन करता है 1 + -1, लेकिन चूंकि इस मूल्य का उपयोग नहीं किया जाता है, इसलिए यह एनओओपी है।

वी

यहाँ है जहाँ यह थोड़ा अजीब हो जाता है। अजगर सूची का नामकरण oमनमाना लग सकता है, लेकिन यह निश्चित रूप से नहीं है। V में, oएक नई लाइन खोलता है, और हमें इन्सर्ट मोड में डालता है। फिर,

='rock paper scissors'.split()
lambda s:o[o.index(s)-1]#

बफर में डाला जाता है। उसके बाद, संबंधित कोड है:

<esc>ddxxf'C r<C-n><esc>Hd*wywVp

स्पष्टीकरण:

<esc>                          " Return to normal mode
     dd                        " Delete this line. Now the cursor is on '='
       t.                      " Move the cursor forward to the "'"
         C                     " Delete everything after the "'", and enter insert mode
           r                   " From insert mode, enter '<space>r'
            <C-n>              " Autocomplete the current word based on what is currently in the buffer
                               " Since only one word starts with 'r', this will insert 'rock'
                 <esc>         " Leave back to normal mode
                      H        " Go to the first line (where the input is)
                       d*      " Delete everything up until the next occurence of the input
                         w     " Move forward one word
                          yw   " Yank the word under the cursor
                            Vp " And paste that word over the current line, delete everything else

@WheatWizard Python में, कोई कारण नहीं है (सिवाय इसके कि यह एक ही लंबाई है)। लेकिन यह खंडहर सब कुछ वी में
DJMcMayhem

@WheatWizard कॉज V एक बहुत ही अजीब भाषा है, और यह इसके लिए एक बहुत ही अजीब काम है। सब कुछ बहुत हद तक पात्रों के लेआउट पर निर्भर करता है, और .split()फिर आपके समाधान में दिखाई देने वाली विभिन्न कोष्ठक और उद्धरणों से छुटकारा पाना आसान है।
DJMcMayhem

सुपर माइनर, लेकिन आप xxइसे हटा सकते हैं और इसे 2कमांड के साथ बदल सकते हैं 2f'क्योंकि बाद में वैसे भी ='हटा दिया जाएगा d*। संपादित करें: आप इसे बनाने में सक्षम हो सकते हैं t.?
nmjcman101

@ nmjcman101 ऊह, मीठा, भयानक विचार। पारितोषिक के लिए धन्यवाद!
DJMcMayhem

16

सीजाम , रेटिना , पीएचपी, 92 86 85 बाइट्स

ECHO["rock",0,"scissors","paper"][ORD(READLINE())%4];
#];"scissors  paper rock"S/rci=

-rध्वज का उपयोग करके PHP में चलाया जाना चाहिए ।

इसे CJam में आज़माएं

इसे रेटिना में आज़माएं

इसे PHP में आज़माएं

CJam

CJam में, सभी कैपिटल अक्षर पूर्वनिर्धारित चर हैं। पहली पंक्ति में, इनमें से कई मान स्टैक पर धकेल दिए जाते हैं, साथ ही कुछ स्ट्रिंग और सरणी शाब्दिक के साथ। कुछ वेतन वृद्धि, गिरावट और अन्य ऑपरेशन किए जाते हैं।

उस सब के बाद, स्टैक को एक सरणी ( ]) और त्याग ( ;) में लपेटा जाता है , इसलिए उस सामान में से कोई भी बिल्कुल भी मायने नहीं रखता है। मुख्य CJam कार्यक्रम बस है:

"scissors  paper rock"S/rci=

"scissors  paper rock"        e# Push this string
                      S/      e# Split it on spaces
                        r     e# Read the input
                         c    e# Cast to char (returns the first character in the string)
                          i   e# Cast to int (its codepoint)
                           =  e# Get the index of the split array (CJam has modular arrays)

रेटिना

यह लगभग धोखा लगता है ...

रेटिना ECHO["rock",0,"scissors","paper"][ORD(READLINE())%4];इनपुट में रेगेक्स के किसी भी मैच को स्थानापन्न करेगा #];"scissors paper rock"S/rci=। जो भी इस regex से मेल खाता है, यह निश्चित रूप से कुछ भी मिलान नहीं करती rock, paperया scissors, इसलिए कोई प्रतिस्थापन किया जाता है। अनमॉडिफाइड इनपुट तब निहित रूप से आउटपुट होता है।

पीएचपी

दूसरी पंक्ति एक टिप्पणी है, इसलिए इसे अनदेखा किया जाता है।

पहली पंक्ति CJam भाग के समान एल्गोरिथ्म का उपयोग करती है, लेकिन परिणामों के विभिन्न क्रमों के साथ।


1
TIL PHP फ़ंक्शन असंवेदनशील हैं।
gcampbell

14

सी, सी ++, पायथन; 227 226 216 बाइट्स

@Mat को एक बाइट धन्यवाद दिया!

#include<stdio.h>/*
f=lambda a:"rock"if a[0]=="r"else"paper"if a[0]=="p"else"scissors"
"""*/
int f(char*b){puts(sizeof'b'-1?*b=='r'?"paper":*b=='s'?"rock":"scissors":*b=='r'?"scissors":*b=='s'?"paper":"rock");}
//"""

fसभी भाषाओं में एक फ़ंक्शन को परिभाषित करता है । C में जीतता है, Python में टाई करता है, C ++ में हारता है। जैसे C ++ हमेशा करता / करती है

/*और के बीच का हिस्सा */C और C ++ में एक टिप्पणी ब्लॉक है जबकि यह पायथन में लंबो फंक्शन डिक्लेरेशन है। यह मूल रूप से फ़ंक्शन तर्क के पहले चरित्र की तुलना करता है और उस अक्षर से शुरू होने वाले कदम को लौटाता है।

"""एस के बीच का हिस्सा पायथन में एक बहुस्तरीय स्ट्रिंग है जबकि यह C और C ++ दोनों में फ़ंक्शन डिक्लेरेशन है। sizeof'b'-1यदि मौजूदा भाषा C ++ की है तो आंकड़े बाहर। इसका एक सत्य मूल्य है यदि आकार 1 से अधिक है, तो एक मिथ्या मूल्य अन्यथा। सी चरित्र में शाब्दिक 4-बाइट लंबे प्रकार के होते हैं जबकि C ++ में वे एक एकल बाइट प्रकार होते हैं। फिर भाषा का पता लगने के बाद यह इनपुट और आउटपुट के पहले अक्षर को देखता है।

सी

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

सी ++

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

अजगर

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


4
"पायथन में एक टिप्पणी ब्लॉक" के बीच का हिस्सा है "यह वास्तव में एक
बहुस्तरीय

10

सी ++, आर, सी; 252 240 226 220 209 बाइट्स

#define b/*
M=function()cat(readline())
#*/
#import<stdio.h>
#define M()main(){int i=0;char t[9];char*u;char*s[]={"rock","paper","scissors"};scanf("%s",t);for(;*t-*s[i++];);puts(s[(i+=sizeof('a')==1)%3]);}
M()

C और C ++ के बीच अंतर का उपयोग करता है कि एक वर्ण शाब्दिक का आकार C में 4 बाइट्स और C ++ में 1 बाइट है।

सी ++:

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

आर:

नतीजा:

> #define b/*
> M=function()cat(readline())
> #*/
> #import<stdio.h>
> #define M()main(){int i=0;char t[9];char*u;char*s[]={"rock","paper","scissors"};scanf("%s",t);for(;*t-*s[i++];);puts(s[(i+=sizeof('a')==1)%3]);}
> M()
rock
rock

सी:

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


8

गॉक, रेटिना, पर्ल; 68 बाइट्स

{eval"\$_=uc<>"}{$_=/[Sk]/?"paper":/[Pc]/?"rock":"scissors"}{print}

(अंत में एक नई पंक्ति के साथ)

गौक (विजेता)

पर्ल की खातिर कुछ जंक, फिर लाइन कंटेंट ( $_, जो $0वैरिएबल _अपरिभाषित है, उसी के अनुसार) के आधार पर परिवर्तित करें कि क्या इसमें ए kया है c, तो परिणाम प्रिंट करें। भागने के दृश्यों के बारे में किसी भी चेतावनी को अनदेखा करें, मेरा मतलब था कि ऐसा करना।

{a_string_that_is_ignored}
{$_ = /[Sk]/ ? "paper" : /[Pc]/ ? "rock" : "scissors"}
{print}

रेटिना (टाई)

बेसिक सनसेट और अन्य के रूप में एक ही चाल : पहली पंक्ति पर कुछ मूर्खतापूर्ण regexp के मैचों को दूसरी पंक्ति की सामग्री से बदलें, ताकि इनपुट के माध्यम से गुजरें।

पर्ल (हारे हुए)

एक पंक्ति पढ़ें और इसे अपरकेस में बदलें, फिर इसमें शामिल अक्षर के आधार पर एक शब्द चुनें और परिणाम प्रिंट करें। पहला और आखिरी चरण evalउन्हें जाग से छिपाने के लिए उपयोग किया जाता है।

$_ = uc <>;
$_ = /[Sk]/ ? "paper" : /[Pc]/ ? "rock" : "scissors";
print $_

गौक, रेटिना perl -p,; 57 बाइट्स

मैं इसे एक बोनस के रूप में दर्ज कर रहा हूं क्योंकि कमांड लाइन स्विच perl -pको इस साइट पर सामान्य नियमों द्वारा कार्यक्रम का हिस्सा माना जाता है, जिससे यह पॉलीग्लॉट नहीं होगा।

{eval"\$_=uc"}$_=/[Sk]/?"paper":/[Pc]/?"rock":"scissors"

फिर से रेटिना के लिए एक अंतिम नई पंक्ति के साथ । इस बार, perl -pआउटपुट को स्वचालित रूप से प्रिंट करने के लिए, पर्ल ओवरहेड काफी कम हो गया है। मैं असाइनमेंट को awk$_ में एक अंतर्निहित प्रिंट को ट्रिगर करने की अनुमति दे सकता हूं ।


क्या आप शायद उनमें से प्रत्येक के लिए एक TIO लिंक (या परीक्षण के लिए एक समान ऑनलाइन-संकलक) जोड़ सकते हैं?
केविन क्रूज़सेन

@ केविनक्रूजसेन जोड़ा गया। TIO के लिए आउटपुट perl -pरिक्त है, यह TIO पर बग होना चाहिए।
गिल्स

7

> <>, रेटिना, पायथन 2: 144 127 123 बाइट्स

1 बाइट ने एक स्थान को हटाकर @Loovjo को धन्यवाद दिया

4 बाइट्स ने @ mbomb007 की inputबजाय धन्यवाद का उपयोग करके बचायाraw_input

#v"PAPER"v?%4-2{"SCISSORS"v?%2:i
#>ooooo; >oooooooo<"ROCK"~<
a="KRS".index(input()[-1])
print["SCISSORS","ROCK","PAPER"][a]

TNB में एक चुनौती के रूप में पोस्ट किया गया , मैंने भाषाओं के इस संयोजन को आज़माने का फैसला किया।

> <>

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

IP सही से चलना शुरू करता है।

#                      Reflect the IP so that it now moves left and it wraps around the grid
i:                     Take one character as input and duplicate it

संभावित वर्ण जिन्हें इनपुट में लिया जाएगा वे हैं PRS(चूंकि प्रोग्राम केवल पहला वर्ण लेता है)। उनके ASCII-मान हैं 80, 81और 82

2%                     Take the modulo 2 of the character. Yields 0, 1, 0 for P, R, S respectively
?v                     If this value is non-zero (ie the input was ROCK), go down, otherwise skip this instruction

यदि इनपुट रॉक था, तो यही होगा:

<                      Start moving to the left
~                      Pop the top most value on the stack (which is the original value of R and not the duplicate)
"KCOR"                 Push these characters onto the stack
<                      Move left
oooo                   Output "ROCK" as characters (in turn these characters are popped)
o                      Pop the top value on the stack and output it; but since the stack is empty, the program errors out and exits promptly.

अन्यथा, यदि इनपुट था SCISSORSया PAPER, यह वही है जो आईपी का सामना करेगा:

"SROSSICS"             Push these characters onto the stack
{                      Shift the stack, so the the original value of the first char of the input would come to the top
2-4%                   Subtract 2 and take modulo 4 of the ASCII-value (yields 2, 0 for P, S respectively)
?v                     If it is non-zero, go down, otherwise skip this instruction

यदि इनपुट था PAPER, तो:

>ooooooooo             Output all characters on the stack (ie "SCISSORS")
<                      Start moving left
o                      Pop a value on the stack and output it; since the stack is empty, this gives an error and the program exits.

अन्यथा (यदि इनपुट था SCISSORS):

"REPAP"                Push these characters onto the stack
v>ooooo;               Output them and exit the program (without any errors).

रेटिना

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

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

अजगर २

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

पायथन प्रोग्राम को "एस के बीच में डालने के लिए इनपुट की आवश्यकता होती है ।

पहले दो पंक्तियाँ पायथन में टिप्पणियाँ हैं।

a="KRS".index(input()[-1])             # Get the index of the last character of the input in "KRS"
print["SCISSORS","ROCK","PAPER"][a]    # Print the ath index of that array

मुझे नहीं लगता printकि अंतिम पंक्ति में स्थान आवश्यक है।
लोवोजो

आप उपयोग कर सकते हैं input()के बजाय raw_input()
mbomb007

@Lovjo टिप के लिए धन्यवाद :)
क्रिकेई लिथोस

@ mbomb007 यह काम करने के लिए प्रतीत नहीं होता है
क्रिस्सी लिथोस

@KritixiLithos यह काम करता है अजगर हिस्सा उद्धरण के साथ इनपुट लेता है, तो
undergroundmonorail

0

रूबी, क्लोजर, कॉमन लिस्प - 251 बाइट्स

(print(eval '(if()({(quote SCISSORS)(quote PAPER)(quote PAPER)(quote ROCK)(quote ROCK)(quote SCISSORS)}(read))(eval(quote(nth(position(read)(quote("SCISSORS""PAPER""ROCK")):test(quote string-equal))(quote(ROCK SCISSORS PAPER))))))))
;'['"'+gets+'"']))

व्हॉट्सएप के साथ अधिक पठनीय संस्करण:

(print(eval '(if() ; distinguish between CLojure and Common Lisp
    ({(quote SCISSORS)(quote PAPER)(quote PAPER)
       (quote ROCK)(quote ROCK)(quote SCISSORS)}(read)) ; use hash-map as a function
    (eval(quote(nth ; find index of the input arg in the list
       (position(read)(quote("SCISSORS""PAPER""ROCK")):test(quote string-equal))  
    (quote(ROCK SCISSORS PAPER))))))))
 ;'['"'+gets+'"'])) ; ruby indexation

क्लोजर हमेशा जीतता है, रूबी हमेशा ड्रॉ करता है, कॉमन लिस्प हमेशा हारता है।

रूबी के लिए 'एस के अंदर सब कुछ एक स्ट्रिंग है। यह दो लाइनों में फैला है। फिर यह []एक स्ट्रिंग तर्क के साथ ऑपरेटर का उपयोग करता है जो स्ट्रिंग में मौजूद होने पर स्ट्रिंग को स्वयं वापस करता है। परिणाम छपा हुआ है, रूबी सिर्फ इनपुट को प्रतिबिंबित करती है।

दूसरी पंक्ति क्लोजर और कॉमन लिस्प के लिए एक टिप्पणी है। का एक गुच्छा evalऔर quoteइस्तेमाल किया जाना है क्योंकि क्लोजर को यह सुनिश्चित करने की आवश्यकता है कि सभी प्रतीक वैध हैं। कोड का पुन: उपयोग करना अच्छा होगा, लेकिन यहां तक ​​कि nthफ़ंक्शन का इन भाषाओं में अलग-अलग हस्ताक्षर हैं। मूल रूप से क्लोजर के if()लिए सच का मूल्यांकन करता है और यह पहली शाखा में जाता है जब स्टैंर्ड से पढ़े गए तर्क के साथ संभावित वेरिएंट का हैश-मैप कहा जाता है। आम लिस्प दूसरी शाखा में जाता है, यह सूची में स्टड से तर्क की स्थिति का पता लगाता है और परिणामी सूची से संबंधित आइटम देता है।

मुझे लगता है कि कॉमन लिस्प पार्ट को और अधिक गोल्फ किया जा सकता है।

इसे ऑनलाइन देखें: रूबी , कॉमन लिस्प , क्लोजर


0

स्काला, जावास्क्रिप्ट और ओक, 167 बाइट्स

s=>{var a="paper,scissors,rock".split(",")/*/**/a[-1]="rock"
return a[a.indexOf(s)-1];`*/a((a.indexOf(s)+1)%3)//`//Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!
}

इसे स्कैला में आज़माएं इसे जावास्क्रिप्ट में आज़माएँ, Ook के ब्रेनफ़क संस्करण को आज़माएँ

स्काला - जीतता है

s=>{                                                      //define an anonymous function
  var a="paper,scissors,rock".split(",")                  //generate the array
  /* /* */ a[-1]="rock"                                   //scala supports nested comments,
  return a[a.indexOf(s)-1];`                              //so this comment...
  */                                                      //...ends here
  a((a.indexOf(s)+1)%3)                                   //return the winning string
  //`//Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!  //another comment
}

जावास्क्रिप्ट - खो देता है

s=>{                                                   //define an anonymous function
  var a="paper,scissors,rock".split(",")               //generate the array
  /*/**/                                               //a comment
  a[-1]="rock"                                         //put "rock" at index -1
  return a[a.indexOf(s)-1];                            //return the string that loses
  `*/a((a.indexOf(s)+1)%3)//`                          //a string
  //Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!  //a comment
}

उक! - संबंध

Ook हिस्सा Ook के लिए सरल ब्रेनफ़ॉक कैट प्रोग्राम है ,[.,]

s=>{var a="paper,scissors,rock".split(",")/*/**/a[-1]="rock"   //random stuff
return a[a.indexOf(s)-1];`*/a((a.indexOf(s)+1)%3)//`//         //more random stuff
Ook. Ook. Ook! Ook? Ook. Ook! Ook! Ook. Ook? Ook!              //the program
}                                                              //random stuff

यदि आप उपयोग करते हैं a[(a.indexOf(s)+2)%3]तो आपको सेट करने की आवश्यकता नहीं है a[-1]="rock"। इसके अलावा, क्या आप Ook कोड को जावास्क्रिप्ट स्ट्रिंग के अंदर भी नहीं डाल सकते हैं?
नील
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.