गाँठ की संरचना के आधार पर एक गाँठ के 2-डी आरेख को खींचने के लिए एक कार्यक्रम लिखें। एक गाँठ वास्तव में ऐसा लगता है जैसे: रस्सी का एक लूप जो बंधा हुआ है। गणित में, एक गाँठ आरेख से पता चलता है कि गाँठ बनाने के लिए रस्सी का एक टुकड़ा अपने आप पर या नीचे कहाँ से पार होता है। कुछ उदाहरण गाँठ चित्र नीचे दिखाए गए हैं:
उस पंक्ति में एक विराम होता है जहाँ रस्सी स्वयं से पार हो जाती है।
इनपुट: गाँठ का वर्णन करने वाला इनपुट पूर्णांक का एक सरणी है। एक गाँठ जहाँ रस्सी को n n से अधिक बार पार किया जाता है , को n पूर्णांकों की एक सरणी के रूप में दर्शाया जा सकता है , प्रत्येक का मान श्रेणी [0, n-1] में होता है। इस सरणी K को कॉल करते हैं ।
एक गाँठ का वर्णन करने वाले एरे को प्राप्त करने के लिए, प्रत्येक सेगमेंट को n-1 के माध्यम से संख्या दें। खंड 0 सेगमेंट 1 तक जाना चाहिए, जिससे सेगमेंट 2 तक जाना चाहिए, जिससे सेगमेंट 3 तक ले जाना चाहिए, और तब तक जब तक खंड n-1 लूप वापस नहीं हो जाता है और सेगमेंट की ओर जाता है 0. एक खंड समाप्त होता है जब रस्सी का एक और सेगमेंट उस पर पार हो जाता है ( आरेख में लाइन में एक ब्रेक द्वारा दर्शाया गया है)। आइए सरलतम गाँठ लें - ट्रेफ़िल गाँठ। जब हम सेग्मेंट्स की संख्या बढ़ाते हैं, तो खंड 2 समाप्त होता है जब खंड 2 उस पर पार हो जाता है; खंड 1 तब समाप्त होता है जब खंड 0 इसके पार हो जाता है; और खंड 2 तब समाप्त होता है जब खंड 1 उसके पार हो जाता है। इस प्रकार, गाँठ का वर्णन करने वाला सरणी [2, 0, 1] है। सामान्य तौर पर, सेगमेंट एक्स की शुरुआत होती है जहां सेगमेंट एक्स -1 मॉड एन छोड़ा जाता है, और जहां सेगमेंट के [एक्स] इसके ऊपर से पार होता है।
नीचे की छवि गाँठ आरेखों को दिखाती है, जिसमें लेबल वाले सेगमेंट और गाँठ का वर्णन करने वाली संगत सरणियाँ होती हैं।
शीर्ष तीन आरेख सच समुद्री मील हैं, जबकि नीचे तीन रस्सी के छोर हैं जो अपने आप को पार करते हैं लेकिन वास्तव में नॉटेड होते हैं (लेकिन जिनके पास अभी भी समान कोड हैं)।
आपका कार्य एक फ़ंक्शन लिखना है जो पूर्णांक K की एक सरणी लेता है (आप इसे कुछ अलग कह सकते हैं) जो एक गाँठ का वर्णन करता है (या रस्सी की लूप जो वास्तव में गाँठ नहीं है), और जो कि संबंधित गाँठ आरेख का उत्पादन करता है, जैसा कि ऊपर वर्णित है। उदाहरण। यदि आप कर सकते हैं, तो अपने कोड या स्पष्टीकरण के एक ungolfed संस्करण प्रदान करें, और अपने कोड के नमूना आउटपुट भी प्रदान करें। एक ही गाँठ का अक्सर कई अलग-अलग तरीकों से प्रतिनिधित्व किया जा सकता है, लेकिन अगर आपके फ़ंक्शन आउटपुट को संतुष्ट करता है गाँठ आरेख में इनपुट है, तो यह संभव प्रतिनिधित्वों में से एक है, आपका समाधान मान्य है।
यह कोड-गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कोड है। रस्सी का प्रतिनिधित्व करने वाली रेखा में 1 पिक्सेल की मोटाई हो सकती है, हालांकि इसके नीचे और ओवर-क्रॉसिंग को स्पष्ट रूप से अलग-अलग होना चाहिए (रस्सी में ब्रेक का आकार दोनों तरफ कम से कम पिक्सेल की रस्सी से मोटाई से अधिक होना चाहिए) ।
मैं उन उत्तरों को अपवाह करूंगा जो अंतर्निहित गाँठ सिद्धांत क्षमताओं पर भरोसा करते हैं, लेकिन अंत में जो चुना जाता है वह अंतर्निहित गाँठ सिद्धांत क्षमताओं पर भरोसा नहीं कर सकता है।
मेरे संकेतन के बारे में मैं जो कुछ भी जानता हूं: मेरा मानना है कि ऐसे मूल्य हैं, जो किसी भी गाँठ या अननोट के अनुरूप नहीं लगते हैं। उदाहरण के लिए, अनुक्रम [2, 3, 4, 0, 1] को आकर्षित करना असंभव प्रतीत होता है।
उस के अलावा, मान लीजिए कि आप एक क्रॉसिंग लेते हैं और उस क्रॉसिंग से शुरू करते हुए, एक दिशा में रस्सी के मार्ग का अनुसरण करते हैं और प्रत्येक अनलम्बे क्रॉसिंग को लेबल करते हैं जो आप सक्सेसफुल अधिक से अधिक अभिन्न मूल्यों के साथ आते हैं। बारी-बारी से गांठों के लिए, मेरे अंकन को इस तरह के लेबलिंग में बदलने के लिए एक सरल एल्गोरिथ्म है, और बारी-बारी से गांठों के लिए इस लेबलिंग को गॉस कोड में परिवर्तित करना तुच्छ है:
template<size_t n> array<int, 2*n> LabelAlternatingKnot(array<int, n> end_at)
{
array<int, n> end_of;
for(int i=0;i<n;++i) end_of[end_at[i]] = i;
array<int, 2*n> p;
for(int& i : p) i = -1;
int unique = 0;
for(int i=0;i<n;i++)
{
if(p[2*i] < 0)
{
p[2*i] = unique;
p[2*end_of[i] + 1] = unique;
++unique;
}
if(p[2*i+1] < 0)
{
p[2*i+1] = unique;
p[2*end_at[i]] = unique;
++unique;
}
}
return p;
}
template<size_t n> auto GetGaussCode(array<int, n> end_at)
{
auto crossings = LabelAlternatingKnot(end_at);
for(int& i : crossings) ++i;
for(int i=1;i<2*n;i+=2) crossings[i] = -crossings[i];
return crossings;
}KnotDataगणितज्ञ में उपयोग नहीं कर सकता ...: '(
Knot! उदाहरण उपयोग: << Units`; Convert[Knot, Mile/Hour]पैदावार 1.1507794480235425 Mile/Hour। (मुझे लगता है कि यह सच है या गलत है इसकी परवाह किए बिना मजाकिया है; लेकिन यह वास्तव में सच है।)