चुनाव में जीत किसे मिलेगी?

Question

यह एक चुनौती है जिसमें दो लोग, 1 और 2, कार्यालय के लिए चल रहे हैं। लोग 1 और 2 की दुनिया में कुछ तरीकों से निश्चित रूप से मतदान करते हैं, जो उम्मीदवारों को चुनाव से पहले परिणामों का पता लगाने की अनुमति दे सकते हैं।

ध्यान दें: इसका मतलब किसी भी बाहरी चुनाव या अन्य राजनीतिक घटनाओं का उल्लेख नहीं है।

दो लोग ऑफिस के लिए दौड़ रहे हैं। हम इन लोगों को 1 और 2. बुलाएंगे, क्योंकि वे दोनों जानना चाहते हैं कि क्या वे चुनाव जीतेंगे, वे लोगों के अपने ज्ञान और कुछ कोड का उपयोग करने का निर्णय लेते हैं ताकि यह पता लगाया जा सके कि परिणाम क्या होगा। सरकारी खर्च को कम से कम करने की इच्छा के कारण, कोड को यथासंभव छोटा होना चाहिए।

आपका कार्य: मतदान, आउटपुट जो चुनाव जीतता है, उसके आधार पर लोगों की एक स्ट्रिंग को देखते हुए।

1 और 2 की मजेदार और रोमांचक दुनिया में पाँच प्रकार के लोग हैं:

• A: जो लोग निश्चित रूप से 1 वोट देंगे।
• B: जो लोग निश्चित रूप से 2 को वोट देंगे।
• X: जो लोग अपने बाईं ओर के व्यक्ति को वोट देंगे, उन्हें वोट देंगे। यदि उनके बाईं ओर कोई व्यक्ति नहीं है, तो वे वोट देते हैं जो भी उनके दाहिने तरफ है वह वोट देगा। यदि यह स्पष्ट नहीं है कि उनके अधिकार वाला व्यक्ति किसे वोट दे रहा है, तो वे मतदान नहीं करते हैं।
• Y: लोग उस व्यक्ति के विपरीत वोट देंगे जो उनके बाईं ओर है। यदि कोई व्यक्ति उनके बाईं ओर नहीं है, तो वे जो भी उनके दाईं ओर है, उसके विपरीत वोट देते हैं। यदि यह स्पष्ट नहीं है कि उनके अधिकार वाला व्यक्ति किसे वोट दे रहा है, तो वे मतदान नहीं करते हैं।
• N: जो लोग वोट नहीं देते हैं।

यह बाएं से दाएं का मूल्यांकन किया जाता है।

उदाहरण:

जिसे भी "मूल्यांकन" किया जा रहा है, वह स्पष्टता के लिए लोअरकेस में है।

Input: `XXAYAN`
        xX      Votes for whoever their friend is voting for. Their friend has not decided yet, so it is unclear, so they do not vote.
        Xx      Person to left is voting "none" so votes "none."
          a     Votes for 1
          Ay    Since person on left is voting for 1, votes for 2.
            a   Votes for 1
             n  Does not vote

अंतिम मतदान:

• 2 लोगों ने 1 वोट दिया

• 1 लोगों ने 2 को वोट दिया

• 3 लोगों ने मतदान नहीं किया

1 में सबसे अधिक वोट हैं, इसलिए 1 जीत!

परीक्षण के मामलों:

आप इनपुट और आउटपुट के रूप में अन्य वर्णों या मूल्यों का उपयोग कर सकते हैं, जब तक कि वे अलग-अलग हों। (उदाहरण के लिए: अक्षरों के बजाय संख्याएँ, विभिन्न अक्षर, निचले अक्षर, सत्य / मिथ्या या सकारात्मक / नकारात्मक (आउटपुट के लिए, आदि)

Input -> Output

"AAAA" -> 1
"BBBB" -> 2
"BBAXY" -> 2
"BAXYBNXBAYXBN" -> 2
"XXAYAN" -> 1
"AAAABXXXX" -> 2
"AXNXXXXAYB" -> 1
"NANNY" -> 1
"XA" -> 1
"YAB" -> 2
"XY" -> anything (do not need to handle test cases with no victor)
"AB" -> anything (do not need to handle test cases with no victor)

Comments

@EriktheOutgolfer ANNY सिर्फ A NN के समान है। NX और NY NN बन जाते हैं।

— कॉमरेड स्पार्कलपनी

यह निर्दिष्ट करने के लायक हो सकता है कि इसके noneविपरीत है none, अगर NYटिप्पणियों में व्यवहार सही है।

— कामिल दकरी

IMHO होना चाहिए testcases के साथ शुरुआत XA, XB, YAऔर YB।

— नील

मई इनपुट में केवल 1 अक्षर हैं? जैसे "A", "X", "Y", "N"।

— TSH

क्या आउटपुट के दो अलग-अलग मूल्य हैं या क्या हम उदाहरण के लिए किसी भी सकारात्मक पूर्णांक को आउटपुट कर सकते हैं यदि 1 जीतता है और कोई नकारात्मक पूर्णांक 2 जीतता है?

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

Answer 1

पर्ल 5, 56 80 72 65 53 बाइट्स

पहली स्थिति में X या Y और दूसरे में A या B को संभालने के लिए +26 बाइट्स। आउटपुट है 1यदि 1 खाली (पर्ल में गलत मान) जीतता है अन्यथा।

s/^X(.)/$1$1/,s/A\KX|B\KY|^Y(?=B)/A/|s/B\KX|A\KY|^Y(?=A)/B/&&redo;$_=y/A//>y/B//

TIO

का उपयोग करने Pऔर Sइसके बजाय Xऔर Yवर्णों पर xor ऑपरेशन का उपयोग करने की अनुमति देता है, कुछ और बाइट्स को बचाएगा

s/(?|^(P|S)(?=(A|B))|(A|B)\K(P|S))/P^$1^$2/e&&redo;$_=y/A//>y/B//

शाखा रीसेट समूह का उपयोग करता है (?|.. |.. ), ताकि $1 $2शाखा में संबंधित समूह को संदर्भित किया जा सके। का उपयोग करते हुए \0और \3के बजाय XऔरY

$_=s/^\W(?=(\w))|(\w)\K\W/$1.$2^$&/e?redo:y/A//>y/B//

72 बाइट्स

65 बाइट्स

53 बाइट्स

Comments

मेरी अंतिम समझ से उन्हें किसी भी अधिक नहीं गिना जाता है

— नहुएल फौइउल

यह सही ढंग से Xऔर Yस्ट्रिंग की शुरुआत में संभाल नहीं करता है । कोशिश करो XBAऔर YAB।

— ग्रिमी

@ ग्रैमी, अपडेटेड

— नाहुएल फौइउल

Answer 2

जावा 8, 153 141 135 131 129 बाइट्स

a->{int l=a.length,t,r=0,i=-1;for(;++i<l;r+=(t=a[i]=a[i]>4?t<3?t^3:3:a[i]>3?t:a[i])>2?0:3-t*2)t=a[i>0?i-1:i<l-1?i+1:i];return r;}

एक पूर्णांक सरणी का उपयोग इनपुट के साथ करता है A=1, B=2, N=3, X=4, Y=5और एक सकारात्मक पूर्णांक ( >= 1) आउटपुट देता है यदि A जीतता है, तो एक नकारात्मक पूर्णांक ( <= -1) यदि B जीतता है, या 0यदि यह ड्रा है।

-18 बाइट्स की बदौलत @ OlivierGrégoire ।

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

स्पष्टीकरण:

a->{                      // Method with int-array parameter and boolean return-type
  int l=a.length,         //  Length of the input-array
      t,                  //  Temp integer, uninitialized
      r=0,                //  Result-integer, starting at 0
  i=-1;for(;++i<l         //  Loop `i` in the range [0, l):
           ;              //    After every iteration:
            r+=           //     Increase the result by:
             (t=a[i]=     //       Change `i`'th item in the array to:
                 a[i]>4?  //        If the `i`'th item is a 5:
                  t<3?    //         If `t` is 1 or 2:
                   t^3    //          Use `t` Bitwise-XOR 3 to invert it
                          //          (1 becomes 2; 2 becomes 1)
                  :       //         Else (`t` is 3, 4, or 5 instead):
                   3      //          Set it to 3
                 :a[i]>3? //        Else-if the `i`'th item is a 4:
                  t       //         Set it to `t`
                 :        //        Else (the `i`'th item is a 1, 2 or 3):
                  a[i])   //         Leave it unchanged
             )>2?         //      And if this new `i`'th value is 3, 4, or 5:
              0           //       Leave the result the same by increasing it with 0
             :            //      Else (it's 1 or 2 instead):
              3-t*2;      //       Increase it by 3 minus two times the `i`'th value
                          //       (which is 1 for 1; and -1 for 2)
         t=               //   Set `t` to:
           a[i>0?         //    If `i` is not the first item:
              i-1         //     Set `t` to the previous (`i-1`'th) value
             :i<l-1?      //    Else-if `i` is not the last item:
              i+1         //     Set `t` to the next (`i+1`'th) value
             :            //    Else (`i` is the first or last item):
              i];         //     Set `t` to the current item itself
  return r;}              //  Return the result
                          //  (positive if A wins; negative if B wins; 0 if it's draw)

Comments

i=0;for(int n:a)i+=n<2?1:n<3?-1:0;return i>0;कुछ बाइट्स बाइट्स बचाता है।

— ओलिवियर ग्रेजायर

दरअसल, i=0;for(int n:a)i+=n>2?0:3-n*2;return i>0;और भी छोटा है।

— ओलिवियर ग्रेजायर

@ OlivierGrégoire धन्यवाद! जब मैंने आपकी पहली टिप्पणी देखी, तो मुझे कुछ कम लगने वाला था, लेकिन आपने मुझे अपनी दूसरी टिप्पणी से हरा दिया। ;)

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

पहले लूप में दूसरे लूप को मर्ज करके 131 बाइट्स । हालांकि, यह सही नहीं लगता है, और कुछ परीक्षण मामलों को जोड़ना पड़ सकता है ...

— ओलिवियर ग्राएगोइरे

@ OlivierGrégoire धन्यवाद! यह अस्थायी चर के साथ कुछ और विलय करके गोल्फ 4 और बाइट्स करने में सक्षम है। और इसके बारे में क्या गलत लगता है? यदि आप System.out.println(java.util.Arrays.toString(a));लूप के बाद जोड़ते हैं तो आप इसे बदल सकते हैं जैसा कि आप उम्मीद करेंगे (imo)। आपको लगता है कि किस तरह का परीक्षण मामला गलत परिणाम देगा और कोड के किस हिस्से के कारण होगा?

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

Answer 3

हास्केल, 60 50 48 59 बाइट्स

l#(v:o)|v<2=v+v#o|n<-(3-v)*l=n+n#o
_#_=0
f x=rem(x!!1)2#x>0

उपयोग 1के लिए A, -1के लिए B, 0के लिए N, 2के लिए Xऔर 4के लिए Y। रिटर्न Trueअगर Aजीतता है, और False।

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

इनपुट सूची के नीचे पुनरावर्ती तरीके से हम 1प्रत्येक वोट के लिए A, -1प्रत्येक वोट के लिए Bऔर 0"नो वोट" के लिए जोड़ते हैं । lआखिरी वोट है, vअगला है। यदि v=1, -1या 0(या v<2) हम इसे योग में जोड़ते हैं। अगर v"वोट वही" ( Xचुनौती में, 2मेरे समाधान के लिए) हम रखते हैं और जोड़ते हैं l( (3-2)*l= l)। यदि v"वोट विपरीत" है ( Yचुनौती में, 4मेरे समाधान के लिए) हम पहले नकारात्मक l( (3-4)*l= -l) और फिर इसे जोड़ते हैं। बेस केस खाली सूची है जो योग से शुरू होती है 0। पुनरावर्तन lसेट के साथ शुरू किया जाता है rem s 2जहां परsइनपुट सूची का दूसरा तत्व है ( x!!1)। rem s 2नक्शे 1और -1खुद को, अन्य सभी मूल्यों को 0। फिक्स वोट उपेक्षा lवैसे भी [*] और Xया Yअगर यह एक ठीक वोट सही पड़ोसी मिलता है। यदि कुल योग सकारात्मक है, तो Aजीतता है।

[*] यह [1]काम की तरह फिक्स वोटों के साथ सिंगलटन सूचियों को बनाता है , क्योंकि हास्केल के आलसीपन के कारण दूसरे तत्व तक पहुंच का मूल्यांकन कभी नहीं किया जाता है। इनपुट की तरह [2]त्रुटि के साथ विफल, लेकिन विचार करने की जरूरत नहीं है।

Comments

यह सही ढंग से X और Y को बाएं पड़ोसियों के बिना नहीं संभालता है

— ग्रिममी

@ ग्रेमी: इशारा करने के लिए धन्यवाद। फिक्स्ड।

— नमि

Answer 4

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

पूर्णांक के एक सरणी के रूप में इनपुट लेता है: = एन, = ए, = बी, = वाई, = एक्स।$0$$1$$2$$4$$8$

रिटर्न अगर पहले उम्मीदवार जीत या है, तो 2 उम्मीदवार जीत।$false$$true$

a=>a.reduce((v,x,i)=>v+~~[,1,-1][p=x?x&3||~-x%7^(p&3||a[i+1]&3):0],p=0)<0

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

Answer 5

05AB1E , 34 33 32 30 बाइट्स

gFÐNè©2@iNx1.S-èDÄ2‹*D(‚®èNǝ]O

एक पूर्णांक-सरणी का उपयोग इनपुट के रूप में करता है A=-1, B=1, N=0, X=2, Y=3और एक नकारात्मक पूर्णांक ( <= -1) के रूप में आउटपुट करता है यदि A जीतता है, तो एक सकारात्मक पूर्णांक ( >= 1) यदि B जीतता है, या 0यदि यह ड्रा है।

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

स्पष्टीकरण:

g             # Take the length of the (implicit) input-list
              #  i.e. [3,1,3,3,2,0,1] → 7
 F            # Loop `N` in the range [0, length):
  Ð           #  Triplicate the list at the top of the stack
              #  (which is the implicit input-list in the first iteration)
   Nè         #  Get the `N`'th item of the list
              #   i.e. [3,1,3,3,2,0,1] and `N`=0 → 3
              #   i.e. [-1,1,-1,3,2,0,1] and `N`=3 → 3
     ©        #  Store it in the register (without popping)
   2@i        #  If it's larger than or equal to 2 (so either 2 or 3):
      Nx      #   Push `N` and `N` doubled both to the stack
              #    i.e. `N`=0 → 0 and 0
              #    i.e. `N`=3 → 3 and 6
        1.S   #   Compare the double integer with 1 (-1 if N*2<1; 0 if N*2==1; 1 if N*2>1)
              #   (So this will be -1 in the first iteration, otherwise it will be 1)
              #    i.e. 0 → -1
              #    i.e. 6 → 1
           -è #   Subtract that from the index, and index it into the list
              #    i.e. `N`=0 and -1 → 1 (first item, so get the next index)
              #     → [3,1,3,3,2,0,1] and 1 → 1
              #    i.e. `N`=3 and 1 → 2 (fourth item, so get the previous index)
              #     → [-1,1,-1,3,2,0,1] and 2 → -1
      D       #   Duplicate that value
       Ä2‹    #   Check if that value is -1, 0, or 1 (abs(i) < 2) (truthy=1; falsey=0)
          *   #   And multiply that with the value
              #   (remains the same if truthy; or becomes 0 if falsey)
      D(‚     #   Pair it with its negative (-1 becomes [-1,1]; 1 becomes [1,-1])
         ®è   #   And index the `N`'th value (from the register) into it (with wraparound)
              #   (if it was a 2, it uses the unchanged (first) value of the pair;
              #    if it was a 3, it uses the negative (second) value of the pair)
              #     i.e. [1,-1] and 3 → -1
              #     i.e. [-1,1] and 3 → 1
      Nǝ      #   And replace the `N`'th value with this
              #    i.e. [3,1,3,3,2,0,1], `N`=0 and -1 → [-1,1,3,3,2,0,1]
              #    i.e. [-1,1,-1,3,2,0,1], `N`=3 and 1 → [-1,1,-1,1,2,0,1]
 ]            # Close both the if-statement and loop
  O           # Sum the modified list (which now only contains -1, 0, or 1)
              #  i.e. [-1,1,-1,1,1,0,1] → 2

Answer 6

रेटिना 0.8.2 , 70 बाइट्स

AY
AB
BY
BA
}`(A|B)X
$1$1
^X(A|B)|^Y[AB]
$1$1
+`N|X|Y|AB|BA

.+|(?<=B)

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। 0एक टाई के लिए आउटपुट । स्पष्टीकरण:

AY
AB
BY
BA

Yतय मत वाले लोगों के अधिकार के लिए मतदाताओं को संभालें ।

}`(A|B)X
$1$1

Xनिर्धारित मत वाले लोगों के अधिकार में मतदाताओं को संभालें , और फिर तब तक लूप करें जब तक कि सभी संभव मतों Yऔर Xमतों का निर्णय न किया जा सके।

^X(A|B)|^Y[AB]
$1$1

Xएक निर्धारित मत के बगल में एक प्रारंभिक मतदाता, और एक निश्चित मत के बगल में एक प्रारंभिक मतदाता को संभालें Y। चूंकि यह मतदाता निर्धारित वोट के विपरीत मतदान करेगा, हम इस मामले में दोनों वोटों को हटा सकते हैं।

+`N|X|Y|AB|BA

किसी भी शेष वोट या अनिर्धारित वोट को न हटाएं, और निर्णय किए गए वोटों के सभी जोड़े को रद्द कर दें। तब तक दोहराएं जब तक कि सभी संभावित वोट रद्द न हो जाएं। एक टाई के मामले में, कुछ भी नहीं छोड़ा जाएगा, अन्यथा शेष वोट सभी एक ही प्रकार के होंगे।

.+|(?<=B)

1यदि कोई वोट हैं तो आउटपुट , लेकिन 2अगर वे Bवोट हैं।

Answer 7

जावास्क्रिप्ट (Node.js) , 42 बाइट्स

s=>s.map(c=>x+=l=c%2|l*c/2,l=s[x=1]%2)|x>1

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

1 बाइट्स सहेजें, झबरा के लिए धन्यवाद।

---

• पूर्णांक सरणी के रूप में इनपुट जहां एन = 0, ए = -1, बी = 1, एक्स = 2, वाई = -2;
• आउटपुट 1 = मिथ्या, 2 = सत्य

Comments

आपका TIO आउटपुट लगता है 0, 1और 3इसके बजाय 1और 2?

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

@ केविनक्रूजसेन लेकिन ओपी ने सत्य बनाम झूठे को उत्पादन की अनुमति दी अगर मैं सही तरीके से समझूं। फाल्सी का मतलब है 1 ने गेम जीता और सत्य का मतलब 2 जीता।

— tsh

आह ठीक है, 3जे एस में भी सत्य है भूल गया । मैं हमेशा 0/ के 1रूप में / झूठी / सच्चाई के बारे में सोचता हूं । और चूंकि हमें अब अलग आउटपुट की जरूरत नहीं है, इसलिए 0= 1 जीत और >= 1= 2 जीत भी ठीक है। तो +1 मुझसे।

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

ऐसा लगता है कि आप तार्किक या के बजाय बिटवाइज़ OR का उपयोग करके बाइट बचा सकते हैं।

— झबरा

@ अजीब तो अजीब है। यह काम करता हैं।

— tsh

Answer 8

अजगर 3 2, 125 121 117 बाइट्स

(जोनाथन फ्रेच को धन्यवाद)

def f(x):
    for i,v in enumerate(x):n=x[i-(i>0)];x[i]=(v>3)*n+abs(n-1)*(v<0)+x[i]*(0<v<4)
    print x.count(1)>x.count(0)

टैब इंडेंटेशन का उपयोग करना

इनपुट: एस की सूची intजहां 'ए' = 1, 'बी' = 0, 'एक्स' = 4, 'एन' = 3, 'वाई' = - 1 है, इसलिए "एएएए" है [1, 1, 1, 1]और "एक्सएक्सएएन" है [4, 4, 1, -1, 1, 3]।

[{'A': 1, 'B': 0, 'X': 4, 'N': 3, 'Y': -1}[c] for c in s] स्ट्रिंग्स को आवश्यक इनपुट प्रारूप में बदल देगा।

आप इसे ऑनलाइन आज़मा सकते हैं ! (सुझाव के लिए जोनाथन फ्रेच को धन्यवाद)

Comments

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

— जोनाथन फ्रीच

एक गोल्फ टिप के रूप में, के (i, i-1)[i>0]बराबर होना चाहिए i-(i>0)।

— जोनाथन फ्रीच

इसके अलावा, आपका ifशायद बन सकता है x[i]+=(v>3)*n+abs(n-1)*(v<0)। तब आप गैर-कंपाउंड स्टेटमेंट (उपयोग करके ;) को उसी लाइन पर ले जाकर इंडेंटेशन पर सेव कर सकते हैं for।

— जोनाथन फ्रीच

@JonathanFrech आपका बहुत-बहुत धन्यवाद; मुझे उम्मीद है कि मैंने इनपुट को बेहतर तरीके से समझाया

— user24343

Answer 9

पर्ल 5, 54 बाइट्स

s/^\W(?=(\w))|(\w)\K\W/$1^$2^$&/e&&redo;$_=y/A//>y/B//

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

उपयोग Aके लिए A, Bके लिए B, Nके लिए N, \0के लिए Xऔर \3Y के लिए (पिछले दो जा रहा है शाब्दिक नियंत्रण वर्ण)। चाल यह है कि Aबिटवाइज़-एक्सर \3बराबर है B, और इसके विपरीत।

Comments

यह मेरे उत्तर के कई विचारों का उपयोग करता है, मुझे यकीन नहीं था कि हम गैर प्रिंट करने योग्य चरित्र को इनपुट और आउटपुट के रूप में उपयोग कर सकते हैं, सिवाय इसके कि मुझे

— बैकलैश

Answer 10

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

a=>(i=($=_=>'AB'.search(_)+1)(a[1],o=0),[...a].map(v=>(r=['NAB','NBA']['XY'.search(x)],p=r?r[i]:v,i=$(p),o+='NA'.search(p))),o>0?1:2)

ओपी में दिए गए प्रारूप के साथ एक स्ट्रिंग में ले जाता है और 1 रिटर्न देता है यदि उम्मीदवार 1 जीता और 2 अन्यथा (मैं इसे स्वीकार करूंगा, मैं भी पक्षपाती हूं)।

Answer 11

पायथन 2 , 95 73 बाइट्स

lambda(v):sum([l for l in[2*int(v[1]/2)]for i in v for l in[i*l**(i%2)]])

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

---

• पूर्णांक सरणी के रूप में इनपुट जहां एन = 0, ए = -2, बी = 2, एक्स = 1, वाई = -1;
• आउटपुट नकारात्मक = ए, 0 = ड्रा, सकारात्मक = बी
• यदि पहला इनपुट X या Y है, तो 2 * int (v [1] / 2) मैप्स खुद या 0 से दूसरे स्थान पर है

बग फिक्स की आवश्यकता थी जो अतिरिक्त बाइट्स को जोड़ते थे, लेकिन @ स्टेपेन के लिए मेमने के लिए धन्यवाद इसे 95 तक कम कर दिया

Comments

व्हाट्सएप को हटाकर 74 बाइट्स और फंक्शन को लैम्ब्डा फंक्शन में बदलना

— स्टीफन