टूर्नामेंट का राजा कौन है?

Question

पृष्ठभूमि

एक राउंड-रॉबिन टूर्नामेंट पर विचार करें, जिसमें प्रत्येक प्रतियोगी प्रत्येक दूसरे प्रतियोगी के खिलाफ एक खेल खेलता है। कोई ड्रॉ नहीं है, इसलिए हर गेम में एक विजेता और एक हारे हुए व्यक्ति होता है। एक प्रतियोगी A टूर्नामेंट का एक राजा होता है, यदि हर दूसरे प्रतियोगी B के लिए , A A बी को हरा देता है , या A दूसरे प्रतियोगी C को हरा देता है, जो B को हरा देता है । यह दिखाया जा सकता है कि हर टूर्नामेंट में कम से कम एक राजा होता है (हालाँकि कई हो सकते हैं)। इस चुनौती में, आपका काम किसी दिए गए टूर्नामेंट के राजाओं को ढूंढना है।

इनपुट और आउटपुट

आपका इनपुट एक N × Nबूलियन मैट्रिक्स है T, और वैकल्पिक रूप N ≥ 2से प्रतियोगियों की संख्या । प्रत्येक प्रविष्टि T[i][j]प्रतियोगियों के बीच खेल के परिणाम का प्रतिनिधित्व करता है iऔर jमान 1 के लिए एक जीत का प्रतिनिधित्व करने के साथ, iऔर 0 के लिए एक जीत j। ध्यान दें कि T[i][j] == 1-T[j][i]यदि i != j। 0 के Tहोते के विकर्ण ।

T0-आधारित या 1-आधारित अनुक्रमण का उपयोग करके, आपका आउटपुट टूर्नामेंट में राजाओं की सूची का प्रतिनिधित्व करेगा। राजाओं का आदेश अप्रासंगिक है, लेकिन डुप्लिकेट नहीं होना चाहिए।

इनपुट और आउटपुट दोनों को किसी भी उचित प्रारूप में लिया जा सकता है।

नियम और स्कोरिंग

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

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

ये परीक्षण मामले 0-आधारित अनुक्रमण का उपयोग करते हैं। 1-आधारित अनुक्रमण के लिए, प्रत्येक आउटपुट मान बढ़ाएँ।

 2 [[0,0],[1,0]] -> [1]
 3 [[0,1,0],[0,0,0],[1,1,0]] -> [2]
 3 [[0,1,0],[0,0,1],[1,0,0]] -> [0,1,2]
 4 [[0,1,1,1],[0,0,1,0],[0,0,0,0],[0,1,1,0]] -> [0]
 4 [[0,1,1,0],[0,0,1,0],[0,0,0,1],[1,1,0,0]] -> [0,2,3]
 5 [[0,1,0,0,1],[0,0,0,0,1],[1,1,0,0,0],[1,1,1,0,1],[0,0,1,0,0]] -> [3]
 5 [[0,1,0,1,0],[0,0,1,1,1],[1,0,0,0,0],[0,0,1,0,1],[1,0,1,0,0]] -> [0,1,4]
 5 [[0,0,0,0,0],[1,0,1,1,0],[1,0,0,0,1],[1,0,1,0,1],[1,1,0,0,0]] -> [1,3,4]
 6 [[0,0,0,0,0,0],[1,0,1,1,0,0],[1,0,0,1,1,0],[1,0,0,0,1,1],[1,1,0,0,0,1],[1,1,1,0,0,0]] -> [1,2,3,4,5]
 6 [[0,0,1,1,1,0],[1,0,0,1,1,1],[0,1,0,0,1,0],[0,0,1,0,0,1],[0,0,0,1,0,1],[1,0,1,0,0,0]] -> [0,1,2,3,5]
 6 [[0,1,1,0,0,1],[0,0,0,1,0,1],[0,1,0,1,1,0],[1,0,0,0,1,1],[1,1,0,0,0,0],[0,0,1,0,1,0]] -> [0,1,2,3,4,5]
 8 [[0,0,1,1,0,1,1,1],[1,0,1,0,1,1,0,0],[0,0,0,1,1,0,0,0],[0,1,0,0,0,1,0,0],[1,0,0,1,0,1,0,0],[0,0,1,0,0,0,1,0],[0,1,1,1,1,0,0,1],[0,1,1,1,1,1,0,0]] -> [0,1,4,6,7]
20 [[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1],[1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1],[0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1],[0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1],[1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1],[0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1],[0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0],[1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0],[1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1],[1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1],[1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0],[0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1],[0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1],[1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1],[0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1],[0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1],[0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1],[0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1],[1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]] -> [0,1,3,4,5,7,8,11,15,17,18]

Comments

(क्या कोई रन टाइम या मेमोरी लिमिट है?) कोई बात नहीं। मैंने कल्पना को पूरी तरह गलत समझा।

— डेनिस

@ डेनिस नोप। जब तक आपका कार्यक्रम सैद्धांतिक रूप से असीमित समय और स्मृति को देखते हुए काम करेगा, तब तक आप ठीक हैं।

— जर्गब

बस स्पष्ट करने के लिए: टी [ए] [बी] टी [बी] [ए] के समान मैच है, लेकिन विपरीत कोण से देखा जाता है, इसलिए टी [ए] [बी] ==! टी [बी] [ए]

— edc65

@ edc65 यह एक अच्छा अवलोकन है। मैंने इसे चुनौती में संपादित किया।

— जरगब

Answer 1

मतलाब, 36 35 29 बाइट्स

@(T,N)find(sum(T*T>-T,2)>N-2)

आइए हम पता करें कि क्या iराजा है। फिर प्रत्येक jमूल्य के लिए T[i][j]==1 OR there is a k such that T[i][k] * T[k][l] == 1। लेकिन दूसरी स्थिति को भी बदला जा सकता है sum_over_k(T[i][k] * T[k][l])>0, लेकिन यह मैट्रिक्स की एक प्रविष्टि है T*T(यदि आप मानते हैंT मैट्रिक्स के रूप में )। ORतो जोड़कर पुनः बजाया जा सकता है T, कि परिणाम के लिए तो हम सिर्फ जांच करने के लिए करता है, तो है n-1पंक्ति के मूल्यों iकी T*T+Tहै कि क्या देखने के लिए शून्य से अधिक कर रहे हैं, iराजा है। यह वही है जो मेरा कार्य करता है।

(यह MATLAB है, इसलिए सूचकांक 1-आधारित हैं।)

MATLAB मैट्रिसेस को अर्धविराम के साथ लाइन डेलिमिटर के रूप में एन्कोड किया जाना चाहिए:

[[0,0,0,0,0];[1,0,1,1,0];[1,0,0,0,1];[1,0,1,0,1];[1,1,0,0,0]] 

Comments

आप शायद कुछ बाइट्स को इनपुट के रूप में प्रतियोगियों की संख्या लेने के बजाय बचा सकते हैंsize(T,1)

— लुइस मेंडो

Answer 2

जेली, 13 12 11 बाइट्स

a"€¹o/€oḅ1M

आउटपुट 1-आधारित है। इसे ऑनलाइन आज़माएं!

वैकल्पिक रूप से, सरणी हेरफेर के बजाय बिटवाइज़ ऑपरेटरों का उपयोग करना:

×Ḅ|/€|ḄBS€M

फिर से, आउटपुट 1-आधारित है। इसे ऑनलाइन आज़माएं!

पृष्ठभूमि

प्रतियोगी के लिए एक , हम सब पा सकते हैं बी ऐसी है कि एक हरा सी हरा बी सभी पंक्तियों है कि एक के अनुरूप लेकर सी ऐसी है कि सी एक हरा । आईएफआर बी ^वीं के प्रवेश सी ^वें है 1 , हम उस राशि सी बी को हराया ।

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

हर पंक्ति के लिए इसे दोहराते हुए, हम प्रत्येक वेक्टर में 1 की संख्या की गणना करते हैं , इसलिए प्रत्येक ए बीट के प्रतियोगियों की मात्रा की गणना करते हैं । मैक्सिमल टूर्नामेंट के राजाओं के अनुरूप है।

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

a"€¹o/€oḅ1M  Main link. Argument: M (matrix)

   ¹         Yield M.
  €          For each row of M:
a"           Take the logical AND of each entry of that row and the corr. row of M.
    o/€      Reduce each resulting matrix by logical OR.
       o     Take the logical OR of the entries of the resulting maxtrix and the
             corr. entries of M.
        ḅ1   Convert each row from base 1 to integer, i.e. sum its elements.
          M  Get all indices of maximal sums.

×Ḅ|/€|ḄBS€M  Main link. Argument: M (matrix)

 Ḅ           Convert each row of M from base 2 to integer. Result: R
×            Multiply the entries of each column of M by the corr. integer.
  |/€        Reduce each row fo the resulting matrix by bitwise OR.
     |Ḅ      Bitwise OR the results with R.
       BS€   Convert to binary and reduce by sum.
             This counts the number of set bits for each integer.
          M  Get all indices of maximal popcounts.

Comments

आप जानते हैं, लोग इन्हें पोस्ट करते रहते हैं और एक्स "बाइट्स" कहते हैं, लेकिन क्या "enc" वास्तव में किसी भी मानक एन्कोडिंग में 1 बाइट में एन्कोडेड है? क्षमा करें, लेकिन मुझे ये हाइपर-कंडेंस्ड स्टैक-आधारित भाषाएं पूरी तरह से निर्बाध लगती हैं, क्योंकि ऐसा लगता है कि हर कल्पनीय फ़ंक्शन को एक यूनिकोड वर्ण को आवंटित करने के लिए सिर्फ धोखा देना है।

— मट्टपुत्तनम

@MattPutnam जेली अपने स्वयं के कस्टम एन्कोडिंग का उपयोग करती है । (इसके अलावा यह स्टैक-आधारित नहीं है)

— एक स्पैगेटो

@MattPutnam में मेरी समान भावनाएँ हैं, लेकिन वे पारंपरिक गोल्फ से बिल्कुल अलग नहीं हैं। कोई भी पारंपरिक भाषाओं को सिर्फ इसलिए नहीं देखता है क्योंकि ये मौजूद हैं, और अन्य एसई साइटों के विपरीत, यह बिल्कुल 'इस जवाब को उस उत्तर से बेहतर है' नहीं है। इसके अलावा, जबकि तकनीकी रूप से अस्वीकृत नहीं है, वे एक प्रश्न का समर्थन करने के लिए भाषा को नहीं बदलते हैं (हालांकि वे इस तथ्य के बाद, भविष्य के सवालों के लिए एक उपयोगी शॉर्टकट का एहसास कर सकते हैं और इसे एक ऑपरेशन बना सकते हैं)।

— corsiKa

ये एल्गोरिदम राजाओं का उत्पादन क्यों करते हैं?

— xnor

@ डेनिस अब मैं देखता हूं, इसका मूल रूप से बूलियन मैट्रिक्स गुणा तर्क या बिट अंकगणितीय के माध्यम से किया जाता है। वास्तविक मैट्रिक्स गुणन छोटा नहीं होगा?

— २०:३

Answer 3

सुन्न, 54 बाइट्स का उपयोग करते हुए पायथन

import numpy
lambda M:(M**0+M+M*M).all(1).nonzero()[0]

एक संख्यात्मक मैट्रिक्स में ले जाता है, 0-आधारित सूचकांकों की एक संख्यात्मक पंक्ति मैट्रिक्स को आउटपुट करता है।

राजा के बारे में सोचने का एक और तरीका एक प्रतियोगी के रूप में है, जिसके लिए सभी प्रतियोगी राजा के संघ में होते हैं, लोग राजा को हराते हैं, और उन लोगों को हराते हैं। दूसरे शब्दों में, प्रत्येक प्रतियोगी के लिए, "बीट" रिलेशनशिप के बीच राजा से अधिकतम 2 की लंबाई का रास्ता है।

मैट्रिक्स I + M + M*Mप्रत्येक स्रोत से प्रत्येक लक्ष्य के लिए 0, 1, या 2 चरणों के पथों की संख्या को एन्कोड करता है। एक खिलाड़ी एक राजा होता है यदि इस मैट्रिक्स की उनकी पंक्ति में केवल सकारात्मक प्रविष्टियाँ होती हैं। चूँकि 0 फाल्सी है, allहमें बताता है कि क्या कोई पंक्ति सभी गैर-शून्य है। हम इसे प्रत्येक पंक्ति पर लागू करते हैं और नॉनज़रो परिणामों के सूचकांकों का उत्पादन करते हैं।

Comments

बिल्कुल मेरे दृष्टिकोण की तरह दिखता है, लेकिन एक अलग व्याख्या के साथ, दिलचस्प =)

— त्रुटी

Answer 4

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

a=>a.map((b,i)=>b.every((c,j)=>c|i==j|b.some((d,k)=>d&a[k][j]))&&r.push(i),r=[])&&r

Comments

आप 1 को a => a.map ((b, i) => b.every ((c, j = = c = i ==) के साथ सहेज सकते हैं। j | b.some ((d, k) => d & a [ k] [j])) && i + १) .filter (a => a) लेकिन इसका मतलब है कि आपको १-अनुक्रमित आउटपुट करना होगा जो एक गंभीर बमर है

— चार्ली व्यान

Answer 5

MATL , 12 10 9 बाइट्स

Xy+HY^!Af

इनपुट है: पहले प्रतियोगियों की संख्या, और एक अलग लाइन पर अर्धविराम द्वारा अलग की गई पंक्तियों के साथ एक मैट्रिक्स। आउटपुट 1-आधारित है।

उदाहरण के लिए, पांचवें परीक्षण मामले में इनपुट है

4
[0,1,1,0; 0,0,1,0; 0,0,0,1; 1,1,0,0]

और अंतिम परीक्षण मामले में इनपुट है

20
[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1; 1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1; 0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1; 0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1; 1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1; 0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1; 0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0; 1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0; 1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1; 1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1; 1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0; 0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1; 0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1; 1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1; 0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1; 0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1; 0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1; 0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1; 1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0; 0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]

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

व्याख्या

Xy    % Implicitly take input: number. Push identity matrix with that size
+     % Implicitly take input: matrix. Add to identity matrix
HY^   % Matrix square
!     % Transpose
A     % Row vector with true entries for columns that contain all nonzero values
f     % Indices of nonzero values

Comments

MATL <जेली \ / एम

— दोष

Answer 6

जावास्क्रिप्ट 136 131 131 121 112 बाइट्स

(n,m)=>m.map((a,k)=>eval(a.map((o,i)=>o||eval(a.map((p,j)=>p&&m[j][i]).join`|`)).join`+`)>n-2&&k+1).filter(a=>a)

---

कॉल का उपयोग करें:

f=(n,m)=>m.map((a,k)=>eval(a.map((o,i)=>o||eval(a.map((p,j)=>p&&m[j][i]).join`|`)).join`+`)>n-2&&k+1).filter(a=>a)

f(20,[[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1],
     [1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1],
     [0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1],         
     [0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1],
     [1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1],         
     [0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1],
     [0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0],         
     [1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0],
     [1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1],         
     [1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1],
     [1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0],         
     [0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1],
     [0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1],         
     [1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1],
     [0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1],         
     [0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1],
     [0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1],         
     [0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1],
     [1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0],             
     [0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]])

वॉचआउट क्योंकि आउटपुट 1-अनुक्रमित है (कुछ बाइट्स को 0s बनाम फ़ालसे को फ़िल्टर करने की कोशिश नहीं की जाती है)