15

यह तीन खिलाड़ियों का खेल है, एक हाथ से खेलना।

उसी समय, प्रत्येक खिलाड़ी 0 से 5 उंगलियों के साथ अपना हाथ बढ़ाता है।

यदि सभी खिलाड़ी एक ही तरह की (सम या विषम) संख्या दिखाते हैं, तो कोई विजेता नहीं है। लेकिन इसके अलावा, खिलाड़ी अलग तरह की दो अन्य जीत दिखा रहा है।

 P l a y e r s
A      B      C       Winner

Even   Even   Even    No winner
Odd    Odd    Odd     No winner
Even   Odd    Odd     Player A
Odd    Even   Even    Player A
Even   Odd    Even    Player B
Odd    Even   Odd     Player B
Odd    Odd    Even    Player C
Even   Even   Odd     Player C

अनुरोधित उपकरण तर्कों का उपयोग कर सकता है (0 और 5 के बीच संख्यात्मक के रूप में 3 तर्क) या STDIN (पंक्ति द्वारा 3 मान, रिक्त स्थान द्वारा अलग)।

इनपुट की जांच करने की कोई आवश्यकता नहीं है: अनियमित इनपुट अप्रत्याशित उत्पादन कर सकता है।

खिलाड़ी A से खिलाड़ी C तक लाइन पर तर्क या मूल्य बाएं से दाएं दिए गए हैं ।

आउटपुट केवल शामिल होना चाहिए A, Bया C(पूंजीकृत) या स्ट्रिंग no one(कम मामले में, एक नियमित रूप से स्थान के साथ)।

टूल केवल एक बार या सभी इनपुट लाइनों पर एक फिल्टर के रूप में काम कर सकता है।

सबसे छोटा कोड जीत।

code-golf number game

— एफ। होरी
स्रोत

6

एक [राजा-की-पहाड़ी] के रूप में अधिक दिलचस्प हो सकता है। खेल खेलते हैं।

— dmckee --- पूर्व-मध्यस्थ ने बिल्ली का बच्चा

मुझे आश्चर्य है कि हमारे पास 5 उंगलियां कैसे हैं (इसलिए 3 विषम और 2 अंगुलियों की संख्या भी संभव है) जीतने की रणनीति को प्रभावित करती है ...

— ओलिवियर दुलैक

@OlivierDulac, 0 भी एक सम संख्या है।

— पीटर टेलर

इस गेम के नियम में हां, विषम संख्याओं (0 2 4 बनाम 1 3 5) की तुलना में भी यही मौका मिलता है

— F. Hauri

@PeterTaylor: धन्यवाद, मैंने प्रश्न को गलत बताया (और मुझे नहीं लगा कि यह गिनती होगी)।

— ओलिवियर दुलाक

12

एपीएल ( 34 30)

(1⍳⍨+/∘.=⍨2|⎕)⊃'ABC',⊂'no one'

स्पष्टीकरण:

2|⎕: इनपुट की एक पंक्ति पढ़ें, प्रत्येक संख्या के mod-2 को लें (सूची दें, अर्थात 1 0 1)
∘.=⍨: वेक्टर में प्रत्येक तत्व की तुलना वेक्टर में प्रत्येक तत्व से करते हैं, मैट्रिक्स देते हैं
+/: मैट्रिक्स की पंक्तियों को योग करें, प्रत्येक तत्व के लिए देना कि यह कितने तत्वों के बराबर था। यदि दो समान और एक अलग थे, तो अब हमारे पास एक वेक्टर है 2 1 2जहां 1अलग-अलग होते हैं। यदि वे सभी समान थे, तो हम प्राप्त करते हैं 3 3 3।
1⍳⍨: की स्थिति का पता लगाएं 1। यदि कोई नहीं है 1, तो यह इस मामले में वेक्टर की लंबाई से एक अधिक है 4।
⊃'ABC',⊂'no one': दिए गए इंडेक्स पर स्ट्रिंग प्रदर्शित करें।

— मारीनस
स्रोत

सूचकांक की गणना करने के लिए सरणी-उन्मुख प्रोग्रामिंग का अच्छा, अच्छा उपयोग।

— फायर

8

गणितज्ञ, ४५ ४३ ४२ ४१ वर्ण

f="no one"[A,B,C]〚Mod[Tr@#-#,2].{2,1,0}〛&

उदाहरण:

f[{0 ,0, 0}]

कोई नहीं

f[{1, 3, 5}]

कोई नहीं

f[{2, 3, 5}]

ए

f[{2, 3, 4}]

बी

43 42 चार्ट के साथ एक और समाधान :

f=Mod[Tr@#-#-1,2].{A,B,C}/._+__->"no one"&

— alephalpha
स्रोत

5

पॉवरशेल, 65

param($a,$b,$c)"@ABCCBA@"[$a%2+$b%2*2+$c%2*4]-replace"@","no one"

— डैंको डर्बीक
स्रोत

धन्यवाद। इसने मुझे अपने रॉक, पेपर, कैंची स्क्रिप्ट को छोटा करने पर एक विचार दिया !

— इज़्ज़ी

4

बेगुंज -98, 61 50 45 वर्ण

&&&:11p+2%2*\11g+2%+:"@"+#@\#,_0"eno on">:#,_

Fors की चतुर अभिव्यक्ति का उपयोग करता है अभी तक कुछ और पात्रों को शेव करने के लिए। अब सिंगल-लाइन (यानी Unefunge- संगत)! एक गेम जीतने तक पढ़ता है; @एक शॉट कार्यक्रम के लिए अंत में जोड़ें ।

इनपुट मोड 2 को एक द्विआधारी संख्या के रूप में मानता है, जैसा कि मेरे जेएस उत्तर के साथ है, फिर एसी के लिए लुकअप पर निर्भर करता है और यदि कोई आउट-ऑफ-बाउंड्स (यदि''A 'है, तो परीक्षण करके मुझे' कोई भी 'वापस नहीं आता है, जो मुझे अनुमति देता है) पास के कोड को डेटा के रूप में उपयोग करने के लिए: D)।

भिन्नता जो इनपुट की एक पंक्ति को पढ़ती है, आउटपुट उत्पन्न करती है, इनपुट की एक नई लाइन पढ़ती है, आदि जब तक कोई गेम तय नहीं किया जाता है (अर्थात 'कोई नहीं'):

&2%4*&2%2*&2%++1g:" "#@-#,_0"eno on">:#,_
 CBAABC

— जुगनू
स्रोत

मैंने अपने जवाब के लिए इसे मछली के लिए भेज दिया। मैंने आपको नोट किया। +1 btw

— क्रंचर

4

एपीएल, ३०

(1+2=/2|⎕)⊃'BA'('C',⊂'no one')

अगर मुझे कॉन्फ़िगरेशन द्वारा सिस्टम चर को बदलने की अनुमति दी जाती है, तो 2 चार्ट बंद किए जा सकते हैं। (विशेष रूप से, सूचकांक मूल ⎕IOको 0 में बदलते हुए )

निर्णायक सा

यदि हम एक ही तरह से सभी बाधाओं का प्रतिनिधित्व करते हैं और सभी उसी तरह से विकसित होते हैं, तो एक जोड़ी-वार समानता ऑपरेशन सभी 4 मामलों को अलग कर सकता है: 0 0बी जीत के लिए, 0 1ए जीत के लिए, आदि।

व्याख्या

2|⎕अनुक्रमण के लिए इनपुट और मॉड 2
2=/जोड़ी-वार समानता
1+जोड़ें 1 जोड़ें (एपीएल सरणियां डिफ़ॉल्ट रूप से 1-आधारित हैं)

'BA'('C',⊂'no one')नेस्टेड सरणी नेस्टेड सरणी
⊃से सही तत्व बाहर निकालता है

— TwiNight
स्रोत

3

C: 88 वर्ण

दुर्भाग्य से सी, हमेशा की तरह, बहुत सारे अनावश्यक जंक की आवश्यकता होती है। लेकिन फिर भी, जिसमें कोई अन्य भाषा लिख सकता है =**++b+**(++और इसका वास्तव में कुछ मतलब है? काफी सरल।

main(int a,char**b){(a=**++b+**(++b+1)&1|2*(**b+**++b&1))?putchar(a+64):puts("no one");}

बस तर्कों के रूप में तीन नंबरों को पास करें, और voilà!

— Fors
स्रोत

क्या उन पूर्वनिर्धारणों का सटीक क्रम निर्दिष्ट है? मैंने सोचा कि यह नहीं था ... हालांकि, आप उन्हें *b[1]बिना किसी अंतर के लिए आदि के साथ बदल सकते हैं (हालांकि लालित्य में कुछ नुकसान .. :()

— फायरफली

रूबी में:: s = "=**++b+**(++"पी पूरी गंभीरता से, वाह, यह कैसे ... वह भी कैसे काम करता है? : हे

— दरवाज़े

@Doorknob यह बहुत ही चालाक है, लेकिन यदि आप bइसके बजाय अनुक्रमण के साथ dereferencing और preincrements स्थानापन्न करते हैं , और कुछ को सुंदर प्रिंट करते हैं, तो आपको इसका पता लगाने में सक्षम होना चाहिए। : डी (कलम और कागज भी, जिसके परिणामस्वरूप सत्य तालिका के लिए मदद करता है)

— फायरफली

3

GolfScript (31 वर्ण)

~]{1&}%.$1=!?)'no one
A
B
C'n/=

बहुत सरल तर्क: इनपुट मोडुलो 2 को कम करें, फिर एक कॉपी को सॉर्ट करें। सॉर्ट किए गए सरणी का मध्य आइटम बहुमत में है, इसलिए एक इंडेक्स की तलाश करें जो अलग है (और इसलिए अल्पसंख्यक में)।

— पीटर टेलर
स्रोत

3

रूबी (फ़ंक्शन बॉडी), 42 वर्ण

3 संख्यात्मक तर्क मान लिया जाये a, bऔर c:

['zCBAABCz'[a%2*4|b%2*2|c%2],'no one'].min

रूबी (कमांड लाइन टूल), 61 वर्ण

संस्करण 1 62 वर्णों में आता है:

$><<["zCBAABCz"[$*.reduce(0){|i,n|i*2|n.to_i%2}],'no one'].min

लेकिन, डैरेन स्टोन के जवाब को बंद करने से , संस्करण 2 नीचे 61 अक्षरों में बदल जाता है:

i=0;$*.map{|n|i+=i+n.to_i%2};$><<['zCBAABCz'[i],'no one'].min

— जोनाथन हेफ़नर
स्रोत

3

रूबी, 61 वर्ण

w=0
$*.map{|p|w+=w+p.to_i%2}
$><<%w(no\ one C B A)[w>3?w^7:w]

— डैरेन स्टोन
स्रोत

['no one',?C,?B,?A]== %w(no\ one C B A)(2 वर्ण सहेजे गए)।

— डानिएरो

अच्छा लगा। लागू किया है कि। धन्यवाद!

— डैरेन स्टोन

2

जावास्क्रिप्ट (नोड), 87 वर्ण

p=process.argv;console.log("ABC"[3-Math.min(x=p[2]%2*4+p[3]%2*2+p[4]%2,7-x)]||"no one")

गेंद लुढ़कने के लिए ... तीन अतिरिक्त तर्कों के रूप में इनपुट की उम्मीद है। इनपुट / आउटपुट के लिए निम्न पैटर्न का उपयोग /करता है ( "नो-वन" का प्रतिनिधित्व करता है):

  A B C  res  #
 ───────────────
  0 0 0   /   0
  0 0 1   C   1
  0 1 0   B   2
  0 1 1   A   3
  1 0 0   A   4
  1 0 1   B   5
  1 1 0   C   6
  1 1 1   /   7

— जुगनू
स्रोत

2

GolfScript, 36 35 33 अक्षर

~]0\{1&\.++}/'no one
C
B
A'n/.$+=

STDIN से वर्णित इनपुट लेता है। आप कोड का परीक्षण ऑनलाइन भी कर सकते हैं ।

— हावर्ड
स्रोत

2

पर्ल, 84 अक्षर।

$x=oct"0b".join"",map{$_%2}<>=~/(\d)/g;print"",('no one','C','B','A')[$x>=4?7-$x:$x]

<>=~/(\d)/g अलग-अलग अंकों में इनपुट लाइन को पार्स करता है
map{$_%2 यह सूची लेता है और मान 2 mod (सम या विषम) की गणना करता है
oct"0b".join"", मॉड मानों की इस सूची को लेता है, उन्हें एक स्ट्रिंग में जोड़ता है, एक ऑक्टल स्पेसियर जोड़ता है, और स्ट्रिंग को एक संख्या में परिवर्तित करता है।

मूल रूप से मैंने जो किया वह एक सत्य तालिका बनाने के लिए था, और फिर इसे सावधानीपूर्वक फिर से व्यवस्थित किया ताकि मेरे पास एक उलटा ऑपरेशन हो $x == 4। तो अगर $x >=4, हमने उलटा किया[$x>=4?7-$x:$x] जिसे हम एरे में इंडेक्स करते थे('no one','C','B','A')

इसका सबसे छोटा संभव कोड नहीं है, लेकिन इसका वास्तव में शोर नहीं है ... जो अपने आप में उल्लेखनीय है।

पर्ल: 74 अक्षर + 3 झंडे = 77, साथ चलते हैं perl -anE '(code)'

s/(\d)\s*/$1%2/eg;$x=oct"0b".$_;say"",("no one","C","B","A")[$x>3?7-$x:$x]

यह एक सुधार है, ऑटोसप्लिट (-ए) का लाभ उठाकर, (-ई) कहते हैं, और अंत में पता लगाते हैं कि तुलना के साथ क्या गलत था।

— जो
स्रोत

>=4इसके बजाय बस क्यों >3? टिप्स के लिए +1 जो '0b'.मुझे पहले नहीं पता था

— F. Hauri

मैंने डिबगर (> 3 और> = 4) में दोनों की कोशिश की, और मुझे यकीन नहीं है कि क्यों, लेकिन> = 4 ने काम किया, लेकिन> 3 नहीं किया। मैं इसकी व्याख्या नहीं कर सकता (संभवतया बोर्बड डिबगर?) मेरी खुद की संतुष्टि के लिए

— जो

आपको लगता है कि दोनों गणनाओं में एक अतिरिक्त चार है, जो मैंने तय किया था। इसके अलावा, झंडे पात्रों के रूप में गिने जाते हैं।

— दरवाज़े

2

कॉमन लिस्प, 114 106 70 चार्ट

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

(defun f(a b c)(elt'(no_one c a b)(+(mod(- b c)2)(*(mod(- a b)2)2)))))

पुराना एल्गोरिथ्म:

(defun f(h)(let*((o(mapcar #'oddp h))(p(position 1(mapcar(lambda(x)(count x o))o))))(if p(elt'(a b c)p)"no one")))

— पॉल रिक्टर
स्रोत

2

अजगर 2, 54

f=lambda a,b,c:[['no one','C'],'BA'][(a^b)&1][(a^c)&1]

— TheCrypt
स्रोत

1

गणितज्ञ 100 94 89

f=If[(t=Tally[b=Boole@OddQ@#][[-1,2]])==1,{"A","B","C"}[[Position[b,t][[-1,1]]]],"no one"]&

परिक्षण

f[{5, 3, 1}]
f[{2, 0, 4}]
f[{0, 1, 2}]
f[{0, 1, 3}]
f[{1, 3, 0}]

"कोई नहीं"
"कोई नहीं"
"बी"
"ए"
"सी"

— DavidC
स्रोत

1

हास्केल, 97

main=interact$(["no one","A","B","C"]!!).(\x->min x$7-x).foldr(\y x->x*2+mod y 2)0.map read.words

— रॉबिन ग्रीन
स्रोत

1

आर 67

z="no one";c("A","B","C",z,z)[match(2-sum(x<-scan()%%2),c(x,2,-1))]

— flodel
स्रोत

दिलचस्प! मैं इसका परीक्षण कैसे कर सकता हूं? मुझे क्या चलाना होगा (शायद एक शेबंग?)

— एफ। होरी

आपको एक इंटरैक्टिव आर सत्र शुरू करना होगा (उदाहरण के लिए /usr/bin/R) फिर ऊपर कोड दर्ज करें। scan()वह है जो आपको इनपुट के लिए संकेत देगा: एक उदाहरण टाइप करना होगा 1[space]3[space]5[space][enter][enter]और आप no oneस्क्रीन पर मुद्रित संबंधित आउटपुट (यहां, ) देखेंगे। आप यहाँ R डाउनलोड कर सकते हैं: cran.r-project.org/mirrors.html

— flodel

1

सी, 85 चार्ट

main(int j,char**p){puts("C\0A\0B\0no one"+((**++p&1)*2+(**++p&1)^(**++p&1?0:3))*2);}

मेरे रूबी जवाब के रूप में छोटा नहीं है, लेकिन मैं इसके साथ खुश हूँ, maincruft को देखते हुए ।

— डैरेन स्टोन
स्रोत

1

मछली - 41

:&+2%2*$&+2%+:"@"+!;$!o :?#"eno on"!;ooo<

Stole FireFly के मुखर जवाब और इसे मछली में पोर्ट किया क्योंकि मछली में रजिस्टरों का उपयोग करने से हमें कुछ पात्रों को दाढ़ी बनाने की अनुमति मिलती है। हालांकि ऑपरेटर नहीं है, तो क्षैतिज नहीं होने पर कुछ अक्षर खो दिए हैं।

यह तर्कों के माध्यम से पैरामीटर लेता है।

python fish.py evenodd.fish -v 2 2 2  
no one
python fish.py evenodd.fish -v 2 3 2  
B
python fish.py evenodd.fish -v 2 3 3  
A
python fish.py evenodd.fish -v 3 3 4  
C

— क्रंचर
स्रोत

Ooooooooooo अच्छा है!

— एफ। हौरी

ह्म, मछली हुह। क्या आपके पास ट्रैम्पोलिन है? यदि ऐसा है, तो शायद आप #@...<एक चार्ट को बचाने के लिए अंत में (बराबर के) का उपयोग कर सकते हैं । ओह, और आपका वर्तमान कोड मुझे 42 वर्णों की तरह लग रहा है, इसलिए कि आपकी गिनती की संख्या में कमी आई है। :)

— फायरफली

@ पूरी तरह से धन्यवाद! यह एक चार को बचाने के लिए, और तुम सही हो, मैं एक से गिना गया था। मेरे टेक्स्ट एडिटर ने अंत में "कॉल 43" कहा। लेकिन निश्चित रूप से, एक खाली लाइन पर कर्सर "कॉल 1" कहता है।

— Cruncher

1

स्मॉलटाक, 128 अक्षर

[:c|o:=c collect:[:e|e odd].k:=o collect:[:e|o occurrencesOf:e].u:=k indexOf:1.^(u>0)ifTrue:[#($a $b $c)at:u]ifFalse:['no one']]

value:एक संग्रह के साथ भेजें

— पॉल रिक्टर
स्रोत

1

जावास्क्रिप्ट (ईएस 6) / कॉफीस्क्रिप्ट, 50 बाइट्स

जुगनू के उत्तर के अनुसार सत्य तालिका का उपयोग करता है, लेकिन चरित्र अभिगम में अधिक प्रत्यक्ष दृष्टिकोण लेता है:

f=(a,b,c)=>'CBAABC'[(a%2*4+b%2*2+c%2)-1]||'no one' // JavaScript

f=(a,b,c)->'CBAABC'[(a%2*4+b%2*2+c%2)-1]||'no one'  # CoffeeScript

डेमो

// Translated into ES5 for browser compatibility
f=function(a,b,c){return'CBAABC'[(a%2*4+b%2*2+c%2)-1]||'no one'}

//f=(a,b,c)=>'CBAABC'[(a%2*4+b%2*2+c%2)-1]||'no one'

for(i=6;i--;)
  for(j=6;j--;)
    for(k=6;k--;)
      O.innerHTML += i + ', ' + j + ', ' + k + ' => ' + f(i,j,k) + "\n"

<pre id=O></pre>

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

— rink.attendant.6
स्रोत

0

अजगर 3, 115

l=[int(x)%2for x in input().split()];0if[print("ABC"[i])for i,x in enumerate(l)if l.count(x)%2]else print("no one")

— रामचंद्र आप्टे
स्रोत

0

अजगर 3, 114

r=[0,3,2,1,1,2,3,0][int("".join(map(str,(int(x)%2for x in input().split()))),2)];print("ABC"[r-1]if r else"no one")

— रामचंद्र आप्टे
स्रोत

0

दो अलग-अलग भाषाओं में दो अलग-अलग विधि + भिन्नताएं -> 6 उत्तर

इस ऑपरेशन के लिए अनिवार्य रूप से 2 तरीके हैं:

array आधारित: किसी सरणी से उत्तर लेने की तुलना में 3 अंकों की एक द्विआधारी संख्या का निर्माण
count आधारित: भी और विषम गणना, और देखो अगर वहाँ एक है count == 1

पर्ल 71 (सरणी आधारित + भिन्नता)

s/(.)\s*/$1&1/eg;$==oct"0b".$_;$==$=>3?7-$=:$=;say$=?chr 68-$=:"no one"

में से एक मेरी सबसे छोटा पर्ल:

s/(.)\s*/$1&1/eg;इस तरह की स्ट्रिंग को बदलने 1 2 3में101
$==oct"0b".$_; बाइनरी को ऑक्टा में बदलना (उसी के अनुसार, 8 से कम)
$==$=>3?7-$=:$=;अगर > 3ऑपरेशन 7-। (वहाँ से no one== 0)
say$=?chr 68-$=:"no one"यदि नहीं 0, तो मूल्य से प्रिंट प्रिंट करें, अन्यथा प्रिंट करें no one।

पर्ल 71 (सरणी आधारित)

s/(.)\s*/$1&1/eg;$==oct"0b".$_;say@{["no one",qw{A B C}]}[$=>3?7-$=:$=]

प्रिंट चरण में थोड़ा अलग: आउटपुट एक 'सरणी' पर आधारित है ।

पर्ल 81 (गणना आधारित)

$c=A;map{$a[$_%2]=$c++;$b[$_%2]++}split;say$b[0]==1?$a[0]:$b[0]==2?$a[1]:"no one"

अलग अर्थ:

$c=Aसाथ में एक काउंटर सी शुरू करें A।
map{$a[$_%2]=$c++;$b[$_%2]++}splitकाउंटर बी गिनती और भी विषम, एक ही दुकान जो एक
say$b[0]==1?$a[0]: अगर काउंटर भी == 1? भी प्रिंट भी खिलाड़ी।
$b[0]==2?$a[1]:अगर काउंटर भी == 2? भी अजीब खिलाड़ी प्रिंट ।
:"no one"और प्रिंट करें no one।

बाश 85 (सरणी आधारित)

c=$((($1%2)<<2|($2&1)*2+($3%2)));((c>3))&&c=$((7-c));o=("no one" C B A);echo ${o[c]}

यह मेरे दूसरे पर्ल संस्करण पर आधारित है:

c=$((($1%2)<<2|($2&1)*2+($3%2))) सूचकांक बना।
- $ 1% 2 का उपयोग करके बाइनरी में पहले आर्ग को रूपांतरित करें mod
- $ 2 और 1 का उपयोग करके बाइनरी में दूसरे आरजी को बदलना and
- << 2 शिफ्ट-टू-लेफ्ट एक ही है*4
- * 2 गुणा 2 से अधिक है <<1।
((c>3))&&c=$((7-c)) अगर c> = 4 तो c = 7-c।
o=() एक सरणी घोषित करें
echo ${o[c]} सरणी के आधार पर

बैश 133 (गणना आधारित)

a[$1&1]=A;a[$2&1]=B;a[$3&1]=C;((b[$1&1]++));((b[$2&1]++));((b[$3&1]++))
case $b in 1)echo ${a[0]};;2)echo ${a[1]};;*)echo no one;esac

a[$1&1]=A;a[$2&1]=B;a[$3&1]=Cएक [भी] और एक [विषम] चर में खिलाड़ी की दुकान
((b[$1&1]++));((b[$2&1]++));((b[$3&1]++))बी में भी / विषम गणना ।
case $b in 1) echo ${a[0]} मामले में भी काउंटर == 1 खिलाड़ी भी प्रिंट करें
2)echo ${a[1]};; मामला यहां तक कि काउंटर == 2 प्रिंट विषम खिलाड़ी
*)echo no one;esacऔर प्रिंट करें no one।

बैश 133 (गणना आधारित)

a[$1&1]=A;a[$2&1]=B;a[$3&1]=C;((b[$1&1]++));((b[$2&1]++));((b[$3&1]++))
((b==1))&&echo ${a[0]}||(((b==2))&&echo ${a[1]}||echo no one)

इसके बजाय bash की स्थिति और कमांड समूह का उपयोग करते हुए समान संस्करण case ... esac

— एफ। होरी
स्रोत

0

गेम मेकर लैंग्वेज, 116

मेरा नया जवाब FireFly के फॉर्मूले पर बहुत निर्भर करता है:

a[1]="no one"a[2]='A'a[3]='B'a[4]='C'return a[(3-min(b=argument0 mod 2*4+argument1 mod 2*2+argument2 mod 2,7-b)||1)]

वर्ष 0, के रूप में अप्रारंभीकृत चर के साथ संकलित कोड 183 अक्षर:

a=argument0 mod 2b=argument1 mod 2c=argument2 mod 2if((a&&b&&c)||(!a&&!b&&!c))return "no one" else{if((a&&b)||(!a&&!b))return "C" else{if((a&&c)||(!a&&!c))return "B" else return "A"}}

# 1 संपादित करें - पूरे अलग कोड

— Timtech
स्रोत

दिलचस्प !? मैं इस भाषा को पहले नहीं जानता था! लेकिन जैसा कि यह भाषा सरणी के उपयोग की अनुमति देती है, यह कोड इस नौकरी के लिए सबसे छोटा संभव नहीं लगता है।

— एफ। हौरी

@ F.Hauri हां, मैं इसे छोटा करने के लिए सरणियों का उपयोग करने की कोशिश कर रहा हूं।

— टाइमटेक

0

क्लोजर, 116

(fn[& h](let[a(map #(bit-and % 1)h)](["no one"\A\B\C](+(.indexOf(map(fn[x](reduce +(map #(if(= x %)1 0)a)))a)1)1))))

— omiel
स्रोत

0

वाबा, ११६

Function z(q,r,s)
a="A":b="B":c="C":d="no one"
z=Array(d,c,b,a,a,b,c,d)((q And 1)*4+(r And 1)*2+(s And 1))
End Function

के साथ ?z(1,2,3)एक चर के साथ कॉल या असाइन करें q=z(1,2,3), या यहां तक कि एक्सेल के भीतर यूडीएफ के रूप =z(1,2,3)में उपयोग करें, और अपने एक्सेल फॉर्मूला में उपयोग करें

— SeanC
स्रोत

0

पायथन 3, 80 वर्ण

r=int(input().replace(' ',''),2)
print(['no one','C','B','A'][7-r if r>3 else r])

नोट: इनपुट '1' [विषम] या '0' [सम] होना चाहिए। उदाहरण के लिए:

> 1 1 0
C
> 1 1 1
no one

— धारा
स्रोत

चुनौती के लिए इनपुट "रिक्त स्थान से अलग" होना आवश्यक है। शायद वहाँ एक तरीका है प्रभावी ढंग से गोल्फ splitऔर joinइसलिए आप अभी भी अपने (बहुत स्मार्ट) int(...input...)विचार का उपयोग कर सकते हैं । ?

— डैरेन स्टोन

आप '0b'+मुझे लगता है कि हटा सकते हैं , कम से कम यह मुझे बेमानी int(input(),2)लगता है , और सिर्फ एक REPL में काम करने लगता है।

— फायरफली

@DarrenStone मैंने बदले में एक स्ट्रिंग का उपयोग किया, संपादित देखें

— धरा

@FireFly धन्यवाद, आप सही हैं, मैंने अपना उत्तर संपादित किया। मैंने पहले पायथन 2 के साथ कोड का परीक्षण किया, जहां '0b' की जरूरत थी।

— धरा

चुनौती के लिए इनपुट को 0 से 5. तक की संख्या स्वीकार करने की आवश्यकता होती है

— पीटर टेलर

0

जावा, 226 वर्ण

void func(int a, int b, int c){
    a = a%2;
    b = b%2;
    c = c%2;
    String out = "B";
    if((a+b+c)==0 || (a+b+c)==3)
        out = "no one";
    else if(a==b)
        out = "C";
    else if(b==c)
        out = "A";
    System.out.println(out);
}

— अनुराग
स्रोत

0

C 101 96

सी, शायद सबसे तुच्छ उदाहरण (कुछ टेर्नरी ऑपरेशन):

main(int v,char** c){(v=c[1]==c[2]?c[1]==c[3]?0:3:c[1]==c[3]?2:1)?puts("no one"):putchar(v+64);}

— tasegula
स्रोत

सम या विषम: तीन खिलाड़ी

एपीएल ( 34 30)

गणितज्ञ, ४५ ४३ ४२ ४१ वर्ण

उदाहरण:

43 42 चार्ट के साथ एक और समाधान :

पॉवरशेल, 65

बेगुंज -98, 61 50 45 वर्ण

एपीएल, ३०

C: 88 वर्ण

GolfScript (31 वर्ण)

रूबी (फ़ंक्शन बॉडी), 42 वर्ण

रूबी (कमांड लाइन टूल), 61 वर्ण

रूबी, 61 वर्ण

जावास्क्रिप्ट (नोड), 87 वर्ण

GolfScript, 36 35 33 अक्षर

कॉमन लिस्प, 114 106 70 चार्ट

अजगर 2, 54

गणितज्ञ 100 94 89

हास्केल, 97

आर 67

सी, 85 चार्ट

स्मॉलटाक, 128 अक्षर

जावास्क्रिप्ट (ईएस 6) / कॉफीस्क्रिप्ट, 50 बाइट्स

डेमो

अजगर 3, 115

अजगर 3, 114

दो अलग-अलग भाषाओं में दो अलग-अलग विधि + भिन्नताएं -> 6 उत्तर

पर्ल 71 (सरणी आधारित + भिन्नता)

पर्ल 71 (सरणी आधारित)

पर्ल 81 (गणना आधारित)

बाश 85 (सरणी आधारित)

बैश 133 (गणना आधारित)

बैश 133 (गणना आधारित)

गेम मेकर लैंग्वेज, 116

क्लोजर, 116

वाबा, ११६

पायथन 3, 80 वर्ण

C 101 96