क्या यह द्विदलीय है?

Question

एक द्विदलीय ग्राफ एक ग्राफ होता है, जिसके कोने को दो असमान सेटों में विभाजित किया जा सकता है, जैसे कि कोई धार एक ही सेट में दो कोने जोड़ता है। एक ग्राफ द्विदलीय है यदि और केवल यदि यह 2-रंगीन है।

---

चुनौती

आपका कार्य एक अप्रत्यक्ष सरल ग्राफ के आसन्न मैट्रिक्स को दिया जाता है, यह निर्धारित करता है कि क्या यह द्विदलीय ग्राफ है। यही है, अगर एक किनारे कोने को जोड़ता है i और j, दोनों (i, j) और (j, i) मैट्रिक्स की प्रविष्टि 1 है।

चूंकि ग्राफ़ अप्रत्यक्ष और सरल है, इसकी आसन्न मैट्रिक्स सममित है और इसमें केवल 0 और 1 है।

विशिष्ट तथ्य

आपको इनपुट के रूप में एक एन-बाय-एन मैट्रिक्स लेना चाहिए (किसी भी रूप में, उदाहरणों की सूची, तार की सूची, सी- int**लाइक और आकार, चपटा सरणी, कच्चा इनपुट, आदि)।

फ़ंक्शन / प्रोग्राम को एक सत्य मान वापस करना चाहिए / करना चाहिए यदि ग्राफ द्विपादित है, और मिथ्या है अन्यथा।

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

['00101',
 '00010',
 '10001',
 '01000',
 '10100'] : False
['010100',
 '100011',
 '000100',
 '101000',
 '010000',
 '010000'] : True (divide into {0, 2, 4, 5} and {1, 3})
['00',
 '00'] : True

स्कोरिंग

उत्तर की गणना करने वाले बिल्डरों पर सीधे प्रतिबंध लगा दिया जाता है।

यह कोड-गोल्फ है , इसलिए इस महीने के अंत में सबसे छोटा कार्यक्रम (बाइट्स में) जीत गया!

Comments

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

— पीटर टेलर

@PeterTaylor हाँ, लेकिन इस समस्या को हल करने के सरल तरीके हैं।

— कोलेरा सु

@ColeraSu सत्य / मिथ्या के बजाय, क्या हम झूठे और सत्य के -1लिए किसी भी गैर-नकारात्मक पूर्णांक के लिए वापस आ सकते हैं ?

— श्री Xcoder

@ मिशालारोव 0-> मिथ्या, >0-> सामान्य रूप से मानक सत्य / झूठे नियमों द्वारा सत्य की अनुमति दी जाती है। -1और ≥ 0यह आम नहीं है, इसलिए मैंने पूछा है।

— श्री एक्सकोडर

@ Mr.Xcoder यह ठीक है।

— कोलेरा सु

Answer 1

भूसी , 17 बाइट्स

§V¤=ṁΣṠMSȯDfm¬ṀfΠ

एक सकारात्मक पूर्णांक प्रिंट करता है यदि ग्राफ द्विदलीय है, 0यदि नहीं। इसे ऑनलाइन आज़माएं!

व्याख्या

यह एक क्रूर बल दृष्टिकोण है: खांचे के सभी सबसेट एस के माध्यम से पुनरावृति , और देखें कि क्या ग्राफ के सभी किनारे एस और इसके पूरक के बीच हैं।

§V¤=ṁΣṠMSȯDfm¬ṀfΠ  Implicit input: binary matrix M.
                Π  Cartesian product; result is X.
                   Elements of X are binary lists representing subsets of vertices.
                   If M contains an all-0 row, the corresponding vertex is never chosen,
                   but it is irrelevant anyway, since it has no neighbors.
                   All-1 rows do not occur, as the graph is simple.
      ṠM           For each list S in X:
              Ṁf   Filter each row of M by S, keeping the bits at the truthy indices of S,
        S  fm¬     then filter the result by the element-wise negation of S,
         ȯD        and concatenate the resulting matrix to itself.
                   Now we have, for each subset S, a matrix containing the edges
                   from S to its complement, twice.
§V                 1-based index of the first matrix
  ¤=               that equals M
    ṁΣ             by the sum of all rows, i.e. total number of 1s.
                   Implicitly print.

Comments

@ Mr.Xcoder ठीक है, मान लीजिए M = [[1,2,3],[4,5,6],[7,8,9]]और S = [1,0,1]( Mप्रोग्राम में हमेशा एक द्विआधारी मैट्रिक्स है, लेकिन इस तरह से व्याख्या करना आसान है)। की प्रत्येक पंक्ति को छानने Mसे Sदेता है [[1,3],[4,6],[7,9]]: प्रत्येक पंक्ति के लिए, मैं उन सूचकांकों में तत्वों जहां को दूर Sएक 0. है तो मैं निगेट Sतत्व के लिहाज से प्राप्त करने के लिए [0,1,0], और फिल्टर Mहै कि द्वारा प्राप्त करने के लिए [[4,6]]: प्रथम और अंतिम पंक्तियों इसी सूचकांकों में 0 है , इसलिए उन्हें हटा दिया जाता है।

— जर्गर्ब नोव

Answer 2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 26 25 बाइट्स

Tr[#//.x_:>#.#.Clip@x]<1&

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

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

एक आसन्न मैट्रिक्स A को देखते हुए, हम B = A से शुरू होने का निश्चित बिंदु पाते हैं और फिर B को A ² B से बदल देते हैं, कभी-कभी मान 1 से 1. बड़ा हो जाता है। इस प्रक्रिया का k ^वें चरण Clipखोजने वाली शक्तियों के बराबर है। एक ^{2k + 1} , जिसमें (i, j) प्रविष्टि लंबाई 2k + 1 के रास्तों की संख्या को शीर्ष i से j में गिना जाता है; इसलिए निश्चित बिंदु समाप्त होता है एक गैर-शून्य (i, j) प्रविष्टि iff हम विषम चरणों में i से j तक जा सकते हैं।

विशेष रूप से, निश्चित बिंदु के विकर्ण में नॉनजेरो प्रविष्टियां होती हैं, जब एक शीर्ष स्वयं एक विषम संख्या में चरणों में पहुंच सकता है: यदि कोई विषम चक्र है। तो निश्चित बिंदु का ट्रेस 0 है यदि और केवल अगर ग्राफ द्विपदीय है।

इस फॉर्म का एक और 25-बाइट समाधान है Tr[#O@n//.x_:>#.#.x]===0&, यदि यह किसी को इस बारे में कोई विचार देता है कि बाइट की गिनती को और भी कम कैसे किया जाए।

पिछले प्रयास

मैंने इस उत्तर को निपटाने से पहले इस पर कई दृष्टिकोण आजमाए हैं।

26 बाइट्स: मैट्रिक्स घातीय

N@Tr[#.MatrixExp[#.#]]==0&

इसके अलावा आसन्न मैट्रिक्स की विषम शक्तियों पर निर्भर करता है। चूंकि x * exp (x ² ) x + x ³ + x ^{5/2 है} ! + x ⁴ / ४! + ..., जब x एक मैट्रिक्स है तो A की प्रत्येक विषम शक्ति के लिए यह एक सकारात्मक शब्द है, इसलिए इसमें शून्य ट्रेस iff A का विषम चक्र होगा। यह समाधान बड़े मैट्रिसेस के लिए बहुत धीमा है।

29 बाइट्स: बड़ी विषम शक्ति

Tr[#.##&@@#~Table~Tr[2#!]]<1&

एन मैट्रिक्स एन द्वारा एन के लिए, ए ^{2 एन + 1} पाता है और फिर विकर्ण जांच करता है। यहाँ, #~Table~Tr[2#!]n इनपुट मैट्रिक्स द्वारा n के 2n प्रतियां, और उत्पन्न #.##& @@ {a,b,c,d}करने के लिए unpacks a.a.b.c.d, एक साथ जोड़ कर एक परिणाम के रूप मैट्रिक्स के 2n + 1 प्रतियां।

53 बाइट्स: लाप्लासियन मैट्रिक्स

(e=Eigenvalues)[(d=DiagonalMatrix[Tr/@#])+#]==e[d-#]&

वर्णक्रमीय ग्राफ सिद्धांत ( इस पीडीएफ में 1.3.10 प्रस्ताव ) में अस्पष्ट परिणाम का उपयोग करता है ।

Comments

मुझे लगता है कि आप अपने साथ और अधिक कुशल विधि से बाइट्स के एक जोड़े को दाढ़ी कर सकते हैं Tr[#.Nest[#.#&,#,Tr[#!]]]<1&। (यह एक अविश्वसनीय जवाब है जो हर बार जब मैं इसे देखता हूं तो बेहतर होता रहता है!)

— एक पेड़

यह कम बाइट्स है कि अर्ध-निर्मित (दो कार्यों की आवश्यकता)BipartiteGraphQ@AdjacencyGraph@#&

— केली लोवेर

@ केलीलॉउडर: बड़े मैट्रिसेस के लिए अवेलेबल ऑब्जेक्ट्स के MatrixExpसंदर्भ में परिणाम मिलते Rootहैं, जो जोड़े जाने पर स्वचालित रूप से सरल नहीं होते हैं। N@बलों इन Roots संख्यानुसार ताकि truthiness तो मूल्यांकन किया जा सकता की गणना की जा करने के लिए।

— माइकल सीफ़र्ट

@Notatree आपका दृष्टिकोण वास्तव में कुछ बाइट्स से हट जाता है, लेकिन उनकी लागत होती है; 18x18 मैट्रिसेस के लिए, यह 1000 गुना धीमा है, और यह वहां से भी बदतर हो जाता है। मुझे लगता है कि अगर मैं यह परिवर्तन करता हूं, तो मैं कुशल विधि को "कुशल" कहने का अधिकार खो देता हूं।

— मिशा लावरोव

@ केलीलौड आप BipartiteGraphQ@*AdjacencyGraphइसे छोटा कर सकते हैं , लेकिन यह अभी भी लंबा है।

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

Answer 3

जावास्क्रिप्ट, 78 बाइट्स

m=>!m.some((l,i)=>m.some((_,s)=>(l=m.map(t=>t.some((c,o)=>c&&l[o])))[i]&&s%2))

इनपुट सरणी 0/1 की सरणी, आउटपुट सही / गलत।

f = 

m=>!m.some((l,i)=>m.some((_,s)=>(l=m.map(t=>t.some((c,o)=>c&&l[o])))[i]&&s%2))

run = () => o.value=f(i.value.trim().split('\n').map(v=>v.trim().split('').map(t=>+t)))

<textarea id=i oninput="o.value=''" style="width:100%;display:block;">010100
100011
000100
101000
010000
010000
</textarea>
<button type=button onclick="run()">Run</button>
<div>Result = <output id=o></output></div>

Answer 4

पायथ , 25 बाइट्स

xmyss.D.DRx0dQx1d.nM*FQss

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

यह -1मिथ्या और सत्य के लिए किसी भी गैर-नकारात्मक पूर्णांक के लिए लौटता है।

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

xmyss.D.DRx0dQx1d.nM * FQss ~ पूर्ण कार्यक्रम, STDIN से एक आसन्न मैट्रिक्स प्राप्त करता है।

                    * एफक्यू ~ कार्टेसियन उत्पाद द्वारा कम (गुना)।
                 .nM ~ प्रत्येक को समतल करें।
 m ~ एक चर d के साथ नक्शा।
         RQ ~ इनपुट में प्रत्येक तत्व के लिए,
       .D ~ अनुक्रमित पर तत्वों को हटाएं ...
          x0d ~ d में 0 के सभी सूचकांक।
     .D ~ और इस सूची से तत्वों को अनुक्रमित पर हटाएं ...
              X1d ~ d में 1 के सभी सूचकांक।
    s ~ चपटा।
   s ~ सम। मैं इस्तेमाल कर सकता था अगर [] प्रकट नहीं होता।
  y ~ दोहरा।
x ~ उपरोक्त मानचित्रण में, का पहला सूचकांक प्राप्त करें ...
                       ss ~ इनपुट मैट्रिक्स में 1 की कुल संख्या।

यह d315e19 प्रतिबद्ध में काम करता है , वर्तमान पायथ संस्करण TiO है।