नकारात्मक अंतरिक्ष रेखांकन

Question

कार्य

आपको एक सकारात्मक पूर्णांक दिया जाएगा और आपको कई नोड्स के साथ " आत्म-पूरक ग्राफ " का उत्पादन करना होगा । यदि आप नहीं जानते कि एक आत्म-पूरक ग्राफ क्या है, तो विकिपीडिया लेख आपकी मदद नहीं करेगा, इसलिए नीचे दो स्पष्टीकरण हैं, एक तकनीकी और एक गैर-तकनीकी।

गैर तकनिकि

एक ग्राफ नोड्स का एक सेट है जो लाइनों द्वारा जुड़ा हुआ है। प्रत्येक जोड़ी बिंदुओं को एक पंक्ति या कोई भी नहीं जोड़ा जा सकता है। एक ग्राफ का "पूरक" एक ग्राफ लेने और उन सभी नोड्स को जोड़ने का परिणाम है जो जुड़े नहीं हैं और सभी नोड्स को डिस्कनेक्ट कर रहे हैं।

एक आत्म-पूरक ग्राफ एक ग्राफ है जिसका पूरक मूल के आकार में पुन: व्यवस्थित किया जा सकता है। नीचे एक आत्म-पूरक ग्राफ और कैसे के एक प्रदर्शन का एक उदाहरण है।

यहाँ 5 नोड्स के साथ एक ग्राफ दिया गया है:

हम उन सभी स्थानों को उजागर करेंगे जहां कनेक्शन लाल बिंदीदार रेखाओं के साथ जा सकते हैं:

अब हम लाल और काले किनारों की अदला-बदली करके ग्राफ के पूरक को देखेंगे:

यह मूल ग्राफ़ की तरह नहीं दिखता है लेकिन अगर हम नोड्स को इस तरह घुमाते हैं (प्रत्येक चरण दो नोड्स स्वैप करता है):

हमें मूल ग्राफ मिलता है! ग्राफ और उसके पूरक समान ग्राफ हैं

तकनीकी

एक आत्म-पूरक ग्राफ एक ग्राफ है जो इसके पूरक के लिए आइसोमोर्फिक है।

विशेष विवरण

जो भी विधि आपको सबसे अच्छी लगती है उसके माध्यम से आपको एक सकारात्मक पूर्णांक प्राप्त होगा। और आप जिस भी विधि को उपयुक्त समझेंगे उसमें एक ग्राफ का उत्पादन करेंगे, इसमें सम्‍मिलित मैट्रिक्स फॉर्म , एडजेंसी लिस्‍ट फॉर्म और पाठ्यक्रम के चित्रों तक सीमित नहीं है ! आउटपुट ग्राफ का अपना पूरक होना चाहिए और पूर्णांक इनपुट के रूप में कई नोड्स होना चाहिए। यदि ऐसा कोई ग्राफ़ मौजूद नहीं है, तो आपको फ़र्ज़ी मान का उत्पादन करना होगा।

यह कोड-गोल्फ है और आपको अपने बाइट काउंट को कम से कम करना चाहिए।

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

नीचे कई n के लिए संभावित आउटपुट की तस्वीरें हैं

4

5

9

Comments

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

— xnor

@xnor मैं इसे शामिल करना भूल गया। अभी तय किया है।

— तदर्थ गार्फ हंटर

क्या हमें नकारात्मक जानकारी को संभालना है?

— xnor

@xnor No. मैं बधाई देने के लिए सवाल ठीक करूंगा

— Ad Hoc Garf Hunter

इससे पहले कि किसी को एक उत्तर को आधार बनाने का विचार आता है GraphData@{"SelfComplementary",{#,1}}&, मेरा मानना ​​है कि बस nवोल्फ्राम के डेटाबेस से कम के लिए कुछ उदाहरण लोड करता है, इसलिए यह मनमाने ढंग से बड़े इनपुट के लिए काम नहीं करेगा।

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

Answer 1

हास्केल , 77 बाइट्स

f n=[(a,b)|b<-[1..n],a<-[1..b-1],mod n 4<2,mod(a+(last$b:[a|odd n,n==b]))4<2]

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

यह तय करने के लिए एक आसान-से-स्पष्ट स्पष्ट मानदंड का उपयोग करता है कि क्या एक (a,b)ग्राफ ग्राफ में है। इस एल्गोरिथ्म को इंस्टेंट करता है , मान modulo 4 के बीच क्रमपरिवर्तन साइकिल के साथ

4*m -> 4*m+1 -> 4*m+2 -> 4*m+3 -> 4*m

हम उन किनारों को शामिल करते हैं जिनके दो समापन बिंदु वर्धमान 0 या 1 मोडुलो 4 में जोड़ते हैं। ध्यान दें कि इस क्रमपरिवर्तन के अनुसार साइकलिंग वर्टिकल प्रत्येक जोड़ पर 2 modulo 4 को वर्टेक्स योग में जोड़ता है, और इसलिए किनारों और गैर-किनारों को स्वैप करता है। यह कोने को पूरक करने वाले वर्टिकल का क्रमांकन देता है।

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

यदि कोने की संख्या 0 या 1 मोडुलो 4 नहीं है, तो कोई भी आत्म-पूरक ग्राफ़ संभव नहीं है क्योंकि पूर्ण ग्राफ़ में किनारों की एक विषम संख्या है

कुल मिलाकर, यहां स्थितियां हैं:

• यदि इनपुट n 0 या 1 मॉडुलो 4 नहीं है, तो रिक्त सूची का उत्पादन करें
• अन्यथा यदि n भी है, सभी किनारों में शामिल हैं (a,b)के साथ a<bऔर a+b0 या 1 सापेक्ष 4 के बराबर।
• अन्यथा यदि n विषम है, तो भी ऐसा ही करें, लेकिन इसके बजाय फॉर्म के किनारों को शामिल करें, (a,n)जब यह एक है।

कोड दूसरे और तीसरे मामलों को जोड़ती है जब स्थिति mod(a+b)4<2को mod(a+a)4<2दोनों के साथ बदलकर odd nऔर b==n।

Answer 2

ब्रेकीलॉग 2 , 24 बाइट्स

{⟦₁⊇Ċ}ᶠpḍ.(\\ᵐcdl?∨?<2)∧

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

यह एक फ़ंक्शन है जो दो आसन्न सूचियों से मिलकर एक जोड़ी देता है: एक ग्राफ के लिए, एक पूरक ग्राफ के लिए। (TIO पर ब्रेकीलॉग दुभाषिया में, आप Zकमांड लाइन तर्क के रूप में एक पूर्ण कार्यक्रम के बजाय एक फ़ंक्शन का मूल्यांकन करने के लिए कह सकते हैं ।) उदाहरण के लिए, इनपुट के लिए आउटपुट 5है:

[[[1,2],[1,3],[1,5],[3,5],[4,5]],[[2,5],[2,3],[2,4],[3,4],[1,4]]]

यहाँ वह है जो एक छवि के रूप में दिखता है (दो रेखांकन दिखाते हुए):

जैसा कि प्रोलॉग-आधारित भाषाओं में आम है, फ़ंक्शन एक से अधिक कॉल पैटर्न का समर्थन करता है। विशेष रूप से, यदि आप इसे एक जनरेटर के रूप में उपयोग करने का प्रयास करते हैं, तो यह दी गई संख्याओं के साथ सभी संभव स्व-पूरक रेखांकन का उत्पादन करेगा (हालांकि मैंने इस मामले को प्रयोग करने योग्य बनाने के लिए कोई प्रयास नहीं किया, और विशेष रूप से यह प्रत्येक का उत्पादन करेगा। रेखांकन कई बार प्रत्येक)।

व्याख्या

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

{⟦₁⊇Ċ}ᶠpḍ.(\\ᵐcdl?∨?<2)∧
 ⟦₁                       The range [1, 2, …, ?], where ? is the input
   ⊇                      A subset of that range…
    Ċ                     …which has exactly two elements
{    }ᶠ                   A list of everything that fits the above description
{⟦₁⊇Ċ}ᶠ                   All edges that could exist in a ?-element graph
       p                  Find a permutation of these…
        ḍ                 …so that splitting it into two equal parts…
          (       ∨   )   …either:
               dl?          produces ? distinct elements
           \                after transposing it
            \ᵐ              and transposing its elements
              c             and flattening one level;
                          or:
                   ?<2      ? was less than 2
         .             ∧  Once you've found it, . specifies what to output

संयोग से, मैंने (∨?<2)0 और 1. के विशेष मामलों से निपटने के लिए पूरे 6 बाइट्स (कार्यक्रम के ended, वर्ण ) खर्च करने का अंत किया , लेकिन निराशा की बात है, लेकिन यह विशेष मामलों की प्रकृति है।

\\ᵐcdl?खंड एक छोटे से समझना कठिन है, तो यहां एक काम उदाहरण है। इसका उद्देश्य यह जांचना है कि क्या कोई ग्राफ़ है और इसका पूरक है, ग्राफ़ में संबंधित किनारों के साथ और सूचियों के भीतर एक ही क्रम में पूरक है। ग्राफ / पूरक जोड़ी कार्यक्रम का अंतिम आउटपुट बन जाती है। यहाँ एक उदाहरण मामला है:

[[[1,2],[1,3],[1,5],[3,5],[4,5]],[[2,5],[2,3],[2,4],[3,4],[1,4]]]

इसे ट्रांसपोज़ करने से हमें ग्राफ और पूरक के बीच संबंधित किनारों की एक सूची मिलती है:

[[[1,2],[2,5]],[[1,3],[2,3]],[[1,5],[2,4]],[[3,5],[3,4]],[[4,5],[1,4]]

अगला, हम सूची तत्वों के अंदर स्थानांतरित करते हैं और एक स्तर को समतल करते हैं; यह हमें ग्राफ और पूरक के बीच संबंधित तत्वों के जोड़े की सूची देता है:

[[1,2],[2,5],[1,2],[3,3],[1,2],[5,4],[3,3],[5,4],[4,1],[5,4]]

स्पष्ट रूप से, हम यहां जो चाहते हैं, वह है कि प्रत्येक तत्व से शुरू होने वाली 1 से अधिक जोड़ी न हो (इस प्रकार यह साबित होता है कि ग्राफ के तत्व और पूरक 1-टू -1 पत्राचार में हैं)। हम लगभग यह कहकर सत्यापित कर सकते हैं कि सूची में बिल्कुल ?अलग तत्व हैं (यानी संख्या के बराबर भिन्न तत्व हैं)। इस मामले में, परीक्षण सफल होता है; अलग तत्व हैं:

[[1,2],[2,5],[3,3],[5,4],[4,1]]

हालांकि, यह एक संभावित समस्या के लिए जगह छोड़ देता है; यदि किसी शीर्ष को पूरी तरह से मूल ग्राफ़ में काट दिया जाता है, तो उसके पत्राचार का उल्लेख नहीं किया जाएगा, कुछ शीर्ष शीर्ष से डुप्लिकेट पत्राचार के लिए जगह छोड़कर। यदि यह मामला है, पूरक ग्राफ कि शिखर के बीच बढ़त होनी चाहिए (व्यापकता की हानि के बिना, चलो कहते हैं कि यह बताने के 1), और हर दूसरे शिखर, और इसलिए पत्राचार की सूची में शामिल होंगे [1,2], [1,3], ..., [1, ?]। जब ?बड़ा होता है, तो इससे अधिक पत्राचार होगा, जिससे हमें अन्यथा होगा, इसलिए कोई समस्या नहीं है। एकमात्र मुद्दा तब होता है जब ?3 या उससे कम होता है, जिस स्थिति में हम केवल एक अतिरिक्त पत्राचार (एक को हटाते हुए) जोड़ते हैं1इनपुट में नहीं दिखाई दे रहा है); हालाँकि, यह व्यवहार में कोई समस्या नहीं है, क्योंकि 3-तत्व ग्राफ पर 3 संभावित किनारे हैं, जो एक विषम संख्या है (इसी तरह, 2-तत्व ग्राफ पर 1 संभावित किनारे भी एक विषम संख्या है), और इस प्रकार परीक्षण \कदम पर विफल हो जाएगा (आप एक रैग्ड सूची को स्थानांतरित नहीं कर सकते, अर्थात जिनके तत्व अलग-अलग लंबाई के हैं)।

Comments

के बीच का अंतर zऔर \वह यह है कि zजिसका अर्थ है कि, चक्रीय जिप है [[1,2,3],["a"]]किया जा रहा है खत्म हो जाएगा [[1,"a"],[2,"a"],[3,"a"]]के साथ zहै, जबकि इसके लिए असफल हो जायेगी \। \अभी केवल वर्ग मैट्रिसेस पर काम करता है; भविष्य का कार्यान्वयन इसे काम की तरह करेगा z, सिवाय चक्रीय रूप से नहीं।

— घातक

मैं वास्तव में अपने आप को अंतर का पता लगा सकता हूं, लेकिन स्पष्टीकरण लिखने के बाद ही। यह विशेष समाधान आयतों पर काम करने वाले `` पर निर्भर करता है (हालाँकि यह केवल 2 बाइट्स लेता है यदि आप उस चरण का लाभ नहीं उठा सकते हैं)।

Answer 3

बीबीसी बेसिक, 161 बाइट्स

टोकन बाईस 140 बाइट्स

Http://www.bbcbasic.co.uk/bbcwin/bbcwin.html पर दुभाषिए को डाउनलोड करें

I.m:IF2ANDm ORm<4P.0:END
r=400n=-2A.m:t=2*PI/n:F.i=1TOn*n:a=i DIVn:b=i MODn:c=b:IFa+b A.2a*=t:b*=t:L.r+r*SINa,r+r*COSa,r+r*SINb,r+r*COSb:IF 1A.m A.c DRAWr*3,0
N.

अघोषित कोड

  INPUTm                           :REM get input
  IF2ANDm ORm<4PRINT0:END          :REM if m=4x+2 or 4x+3 or less than 4, print 0 and exit
  r=400                            :REM radius of diagram
  n=-2ANDm                         :REM n = m truncated to an even number
  t=2*PI/n                         :REM t = 1/n turns
  FORi=1TOn*n                      :REM for each combination of vertices
    a=i DIVn                       :REM extract a and b
    b=i MODn                       :REM make a copy of c
    c=b                            :REM if a+b MOD 4 = 2 or 3, convert a and b to angles and draw edge.
    IFa+b AND2 a*=t:b*=t:LINEr+r*SINa,r+r*COSa,r+r*SINb,r+r*COSb:IF 1ANDm ANDc DRAWr*3,0
  NEXT                             :REM if m is odd and c is odd, draw a line to the additional vertex for m=4x+1 input.

व्याख्या

यह Xnor के समान एल्गोरिथ्म का उपयोग करता है, लेकिन एक आरेखीय आउटपुट पैदा करता है।

जहां nफॉर्म का है 4x+2या 4x+3कोई समाधान नहीं है क्योंकि किनारों की संख्या विषम है।

जहां n4x का रूप है, हम एक सर्कल में सभी छोरों को व्यवस्थित करते हैं और उन किनारों को आकर्षित करते हैं जहां (a+b) mod 42 या 3 है (0 या 1 नहीं जैसा कि गोल्फर कारणों से है। यह इसलिए Xnor द्वारा दिए गए समाधान का पूरक है।)

इसे अधिक चित्रात्मक अर्थों में देखने के लिए, हम हर दूसरे शीर्ष को लेते हैं और किनारों को 1 और 2 स्थानों पर एंटिक्लॉकवाइज दिशा में खींचते हैं। यह nसमानांतर दिशाओं को परिभाषित करता है, कुल का आधा। फिर हम इन समानांतर सभी अन्य किनारों में जोड़ते हैं।

पूरक को प्रत्येक किनारे विनिर्देश में 1 और बी दोनों को जोड़कर या चित्र को 1/nबारी-बारी से आरेखित करके पाया जा सकता है ।

जहां nफॉर्म 4x + 1 है, हम एक और शीर्ष जोड़ते हैं, जो 4x ग्राफ के हर दूसरे शीर्ष से जुड़ा हुआ है। यदि इसे केंद्र में रखा गया था, तो आरेख की समरूपता संरक्षित की जाएगी, लेकिन मैंने इसे स्पष्टता के लिए बिंदुओं के मुख्य सर्कल के बाहर रखने का विकल्प चुना।

उत्पादन

4x + 1 के लिए पहले कुछ मामले निम्नलिखित हैं। 4x मामलों को नीचे दाईं ओर और उसके संबंधित किनारों पर शीर्ष को हटाकर देखा जा सकता है।

Answer 4

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

f=(n,a=[],v=n*~-n/4)=>v%1?0:eval(n>5?f(n-=4,a)&&'for(i=0;i<n;)a.push([i,n+1],[i++,n+2]);a.push([n,++n],[n,++n],[n,++n])-v':'for(l=x=0;x<n;x++)for(y=x;y<n;y++)l<v&y>>x&1?l=a.push([x,y]):a')||a

यह फ़ंक्शन एक आसन्न सूची देता है। यह दो एल्गोरिदम का उपयोग करता है, और खाली पूरक ग्राफ़ और गैर-आउटपुट के बीच अंतर करता 0है []जब कोई भी मौजूद नहीं होता है। पहला एल्गोरिथ्म बीआईटी विधेयकों का उपयोग करके निर्मित राडो ग्राफ पर आधारित है , और वैध 0-, 1-, 4- और 5-क्रम पूरक ग्राफ बनाता है। अन्य एल्गोरिथ्म, जो गणित में हमारे दोस्तों द्वारा पाया जाता है , एक मान्य V वर्टेक्स पूरक ग्राफ के साथ 4-पथ जोड़कर एक मान्य V + 4 वर्टेक्स पूरक पूरक ग्राफ़ बनाता है।

यह वैध पूरक ग्राफ (उपयोग n*~-n/4%1) के अस्तित्व की पुष्टि करने के लिए इनपुट को मान्य करने से शुरू होता है , और यदि वह विफल रहता है, तो रिटर्न 0। यह तब जाँच करता है कि क्या n>5और n-4मामले में एक वैध निचले क्रम के समाधान का निर्माण करने के लिए पुनरावर्ती करता है, तो पुनरावृत्ति श्रृंखला को वापस करने के तरीके पर वापस आसन्न सूची में 4-जोड़ लागू करता है। अंत में, यदि n>5सच नहीं है, यह से iterates 0करने n-1के लिए xऔर yजाँच करता है, और अगर (y>>x)&1सच है। यदि ऐसा है, तो उन नोड्स को जोड़ दिया जाता है।

यहाँ फ़ंक्शन का एक और पठनीय प्रारूप है, जिसमें टर्नरी ऑपरेटरों का विस्तार इफ-स्टेटमेंट्स और eval()इनबिल्ड के साथ किया गया है:

// precalculate amount of required vertices in v
f = (n, a = [], v = n*~-n / 4) => {
  // if amount is non-integer
  if (v % 1) {
    // no valid complementary graph
    return 0;
  } else {
    if (n > 5) {
      // generate valid (n-4)-order complementary graph
      f(n -= 4, a);
      // apply 4-path addition
      for (i = 0; i < n;)
        a.push([i, n+1],[i++, n+2]);
      a.push([n, ++n], [n, ++n], [n, ++n]);
    } else {
      // construct Rado graph using BIT predicate
      for(l = x = 0; x < n; x++)
        for(y = x; y < n; y++)
          // if amount of pairs is less than required and xth bit of y is high
          if (l < v && (y>>x & 1))
            // vertices x and y should be paired
            a.push([x,y]);
    }
    return a;
  }
};

डेमो

f=(n,a=[],v=n*~-n/4)=>v%1?0:eval(n>5?f(n-=4,a)&&'for(i=0;i<n;)a.push([i,n+1],[i++,n+2]);a.push([n,++n],[n,++n],[n,++n])-v':'for(l=x=0;x<n;x++)for(y=x;y<n;y++)l<v&y>>x&1?l=a.push([x,y]):a')||a

<input type="number" onchange="o.textContent=JSON.stringify(f(this.value))"><pre id="o"></pre>