हाइपरक्यूब के किनारों पर

Question

आपका काम एक फ़ंक्शन या प्रोग्राम लिखना होगा, जो एक पूर्णांक n>0को इनपुट के रूप में लेगा और n-dimensional हाइपरक्यूब के किनारों की एक सूची को आउटपुट करेगा । ग्राफ सिद्धांत में एक किनारे को 2-ट्यूल ऑफ वर्टिस (या कोनों, यदि आप चाहें) के रूप में परिभाषित किया गया है, जो जुड़े हुए हैं।

उदाहरण 1

1-आयामी हाइपरक्यूब एक पंक्ति है और इसमें दो कोने हैं, जिन्हें हम कॉल करेंगे aऔर b।

इसलिए, आउटपुट होगा:

[[a, b]]

उदाहरण 2

4-आयामी हाइपरक्यूब (या टेसेरेक्ट) में 32 किनारों होते हैं और इसका ग्राफ इस तरह दिखता है

और आउटपुट इस तरह दिख सकता है

[[a, b], [a, c], [a, e], [a, i], [b, d], [b, f], [b, j], [c, d], [c, g], [c, k], [d, h], [d, l], [e, f], [e, g], [e, m], [f, h], [f, n], [g, h], [g, o], [h, p], [i, j], [i, k], [i, m], [j, l], [j, n], [k, l], [k, o], [l, p], [m, n], [m, o], [n, p], [o, p]]

नियम

• जब तक नाम अद्वितीय है, तब तक आप किसी भी तरह से शीर्षकों को नाम दे सकते हैं।
• किनारों अनिर्दिष्ट कर रहे हैं, यानी [a, b]और [b, a]एक ही किनारे माना जाता है।
• आपके आउटपुट में डुप्लिकेट किनारे नहीं होने चाहिए।
• आउटपुट किसी भी समझदार प्रारूप में हो सकता है।
• मानक खामियों को मना किया जाता है।

स्कोरिंग

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

Comments

सम्बंधित। सम्बंधित।

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

तो [१,२], [२,३] आदि ठीक है?

— R

@EasterlyIrk हां।

— मर्फी

किनारों को किसी भी क्रम में आउटपुट किया जा सकता है, है ना?

— लुइस मेन्डो

@DonMuesli राइट।

— मर्फी

Answer 1

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

ạ/S’
2ṗœc2ÇÐḟ

इसे यहाँ आज़माएँ। इनपुट के लिए 3, आउटपुट है:

[[[1, 1, 1], [1, 1, 2]],
 [[1, 1, 1], [1, 2, 1]],
 [[1, 1, 1], [2, 1, 1]],
 [[1, 1, 2], [1, 2, 2]],
 [[1, 1, 2], [2, 1, 2]],
 [[1, 2, 1], [1, 2, 2]],
 [[1, 2, 1], [2, 2, 1]],
 [[1, 2, 2], [2, 2, 2]],
 [[2, 1, 1], [2, 1, 2]],
 [[2, 1, 1], [2, 2, 1]],
 [[2, 1, 2], [2, 2, 2]],
 [[2, 2, 1], [2, 2, 2]]]

मुझे उम्मीद [1, 1, 1]है कि ठीक है "नाम"।

व्याख्या

पहली पंक्ति किनारों की एक जोड़ी पर एक "विधेय" है: [A, B] ạ/S’के बराबर है sum(abs(A - B)) - 1, जो शून्य (झूठी-वाई) iff है Aऔर Bबिल्कुल एक समन्वय में भिन्न है।

दूसरी पंक्ति मुख्य कार्यक्रम है:

• 2ṗ(कार्तीय शक्ति [1, 2]) के साथ सभी किनारों को उत्पन्न करें ।
• का उपयोग कर सभी संभव जोड़े प्राप्त करें œc2(प्रतिस्थापन के बिना आकार दो के संयोजन)।
• केवल पहले से परिभाषित विधेय को संतुष्ट करने वाले तत्व रखें ( ÐḟÇ)।

Comments

ạ/S’और 2ṗœc2ÇÐḟबाइट्स के एक जोड़े को बचाने के लिए।

— डेनिस

c/P=2, 2ṗṗ2ÇÐfकाम भी करता है।

— डेनिस

स्मार्ट "नामकरण" योजना! निश्चित रूप से नियमों के भीतर।

— मर्फी

Answer 2

पायथन 2, 54 56 62 बाइट्स

lambda n:{tuple({k/n,k/n^1<<k%n})for k in range(n<<n)}

डुप्लिकेट किनारों को सेट का एक सेट बनाकर हटा दिया जाता है, सिवाय इसके कि अजगर को सेट तत्वों को धोने योग्य होना चाहिए, इसलिए उन्हें टुपल्स में बदल दिया जाता है। ध्यान दें कि सेट {a,b}और {b,a}समान हैं और एक ही ट्यूपल में परिवर्तित होते हैं। xsot ने 2 बाइट्स के साथ बचाया n<<n।

यह 49 बाइट्स तक काटा जा सकता है यदि सेट के तार ठीक आउटपुट स्वरूप हैं

lambda n:{`{k/n,k/n^1<<k%n}`for k in range(n<<n)}

जो आउटपुट देता है

set(['set([1, 3])', 'set([2, 3])', 'set([0, 2])', 'set([0, 1])'])

---

lambda n:[(k/n,k/n^1<<k%n)for k in range(n*2**n)if k/n&1<<k%n]

सबसे पहले, आइए समाधान के एक पुराने संस्करण को देखें।

lambda n:[(i,i^2**j)for i in range(2**n)for j in range(n)if i&2**j]

अंतराल में प्रत्येक संख्या [0,2^n)अपने n-बिट बाइनरी स्ट्रिंग्स द्वारा दिए गए निर्देशांक के साथ एक शीर्ष से मेल खाती है । यदि वे एक-दूसरे से भिन्न होते हैं, तो एक से दूसरे में, अगर x 2 की शक्ति से xor-ing प्राप्त किया जाता है, तो समीपस्थ हैं।

यह अनाम फ़ंक्शन प्रत्येक शीर्ष और हर बिट स्थिति को फ्लिप करने के लिए सभी संभव किनारों को उत्पन्न करता है। दोनों दिशाओं में एक किनारे की नकल से बचने के लिए, केवल 1 0 के लिए फ़्लिप किया जाता है।

अधिक golfed समाधान में, kएनकोड दोनों के लिए किया जाता iहै और jके माध्यम से k=n*i+j, जिसमें से (i,j)के रूप में निकाला जा सकता है (k/n,k%n)। यह समझ में एक पाश बचाता है। सही ऑपरेटर पूर्वता होने के कारण शक्तियां की 2जाती हैं 1<<।

प्रत्येक जोड़ी को उत्पन्न करने और चेक करने का एक वैकल्पिक तरीका यदि वे थोड़ा अलग हैं तो अधिक लंबा लगता है (70 बाइट्स)

lambda n:[(i,x)for i in range(2**n)for x in range(i)if(i^x)&(i^x)-1<1] 

Comments

n*2**nबस हैn<<n

— xsot

पायथन 3.5 पर स्विच करना, lambda n:{(*{k//n,k//n^1<<k%n},)for k in range(n<<n)}एक बाइट बचाता है। (तारांकित अभिव्यक्ति तीन को बचाती है, लेकिन विभाजन सिंटैक्स दो खो देता है।) हालांकि, मुझे पूरा यकीन है कि आपके पास जो 49-बाइट समाधान है वह ठीक है।

— लिन

Answer 3

गणितज्ञ, 48 24 बाइट्स

EdgeList@*HypercubeGraph

एक अनाम फ़ंक्शन जो बिल्ट-इन का उपयोग करता है।

Comments

आह, बिल्ट-इन! जैसा कि आपको वर्णमाला का नाम वर्णानुक्रम में रखने की आवश्यकता नहीं है, आप इसे छोड़ सकते हैं FromLetterNumber। मुझे भी लगता EdgeList@*HypercubeGraphहै कि एक मान्य उत्तर है।

— मर्फी

Answer 4

जावास्क्रिप्ट (स्पाइडरमैन 30+), 69 64 बाइट्स

n=>[for(i of Array(n<<n).keys())if(i/n&(j=1<<i%n))[i/n^j,i/n^0]]

यह @ xnor के पायथन 2 समाधान के एक बंदरगाह के रूप में शुरू हुआ था, लेकिन मैं एक लूप का उपयोग करने के लिए कोड को फिर से लिखकर 9 बाइट्स को बचाने में सक्षम था। संपादित करें: i@ xnor के अद्यतित समाधान के अनुसार, एक अन्य 5 बाइट्स को अन्य तरीके से विभाजित करके सहेजा गया, जो अब एकल लूप का उपयोग करता है।

Answer 5

MATL , 20 बाइट्स

2i^:qt!Z~Zltk=XR2#fh

यह भाषा / संकलक के वर्तमान संस्करण (14.0.0) के साथ काम करता है ।

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

व्याख्या

यह @ xnor के उत्तर के समान कमोबेश उसी विचार का उपयोग करता है ।

2i^    % take input n and compute 2^n
:q     % range [0,1,...,2^n-1] (row vector)
t!     % duplicate, transpose into a column vector
Z~     % bitwise XOR with broadcast
Zl     % binary logarithm
tk     % duplicate and round down
=      % true if equal, i.e. for powers of 2
XR     % upper triangular part, above diagonal
2#f    % row and index columns of nonzero values
h      % concatenate vertically

Answer 6

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

fq1.aT.c^U2Q2

इनपुट 3 पर आउटपुट :

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

स्पष्टीकरण:

fq1.aT.c^U2Q2
                  Implicit: input = Q
        ^U2Q      All Q entry lists made from [0, 1].
      .c    2     All 2 element combinations of them.
f                 Filter them on
   .aT            The length of the vector
 q1               Equaling 1.

Answer 7

पायथन 2: 59 बाइट्स

lambda n:[(a,a|1<<l)for a in range(2**n)for l in range(n)if~a&1<<l]