ड्रैगन कर्व ड्रा करें


19

आप आज के लिए काम करते हैं: एक ड्रैगन वक्र बनाएं!

मामले में आप नहीं जानते कि ड्रैगन वक्र क्या है, यहाँ एक परिचयात्मक विहार्ट वीडियो है (वास्तव में अच्छा है, कृपया देखें!)।

आपका काम: एक ड्रैगन वक्र खींचना, कम से कम 9 बार iterated। आपको 9 के माध्यम से पुनरावृत्तियों को दिखाने की आवश्यकता नहीं है, आपको केवल 9 पुनरावृत्तियों को पूरा करने (कम से कम) के बाद उत्पादित अंतिम वक्र को दिखाना होगा। वक्र को बिंदुओं को जोड़ने वाली सीधी रेखाओं के रूप में खींचा जाना चाहिए; आउटपुट को नीचे दी गई छवियों में से एक से मेल खाना चाहिए जो 9 या अधिक पुनरावृत्तियों (प्रतिबिंब, रोटेशन, स्केलिंग और लाइन चौड़ाई, लाइन रंग और पृष्ठभूमि रंग में भिन्नता) को दर्शाता है। आपका आउटपुट इतना बड़ा होना चाहिए कि अलग-अलग लाइनें और "बॉक्स" जो वे बनाते हैं, उन्हें एक-दूसरे से अलग किया जा सके; अगर दो रेखाएं वक्र में अंतर नहीं करती हैं, तो उन्हें आउटपुट में समान या आसन्न पिक्सेल पर कब्जा नहीं करना चाहिए (उनके बीच दिखाई देने वाली पृष्ठभूमि का कम से कम एक पिक्सेल होना चाहिए)। आप छवि को स्क्रीन पर प्रदर्शित कर सकते हैं या छवि को फ़ाइल में सहेजा गया है। आउटपुट चित्रमय होना चाहिए - यह ASCII कला नहीं हो सकता है।

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

कृपया अपने कार्यक्रम के आउटपुट की एक छवि शामिल करें।

यहाँ छवि विवरण दर्ज करें

यदि आप वीडियो देखते हैं तो इस अनुच्छेद को छोड़ दें:आप में से जिन्होंने वीडियो नहीं देखने का फैसला किया है, उनके लिए ड्रैगन वक्र के पहले 12 पुनरावृत्तियों को नीचे दिखाया गया है। इस कार्य के प्रयोजनों के लिए, एक ड्रैगन वक्र एक वक्र है जो निम्नलिखित नियम द्वारा उत्पन्न होता है: वर्तमान वक्र के अंत-बिंदु को लें, उस अंत बिंदु के चारों ओर 90 डिग्री घुमाया हुआ दूसरा वक्र बनाएं ताकि मूल का अंत-बिंदु वक्र नए वक्र का प्रारंभिक बिंदु है, और दो वक्रों को एक ही वक्र में मिलाते हैं जहां वे मिलते हैं। नीचे दर्शाई गई छवियों में, प्रत्येक नई पुनरावृत्ति प्रत्येक पुनरावृत्ति के बिंदु-बिंदु के चारों ओर पिछले पुनरावृत्ति 90 डिग्री घड़ी-वार घुमाकर उत्पन्न की जाती है। जब वक्र को स्क्रीन पर प्रदर्शित किया जाता है, तो यह स्पष्ट नहीं होता है कि कौन सा छोर "अंत-बिंदु" के रूप में गिना जाता है, हालांकि जब वक्र को बिंदुओं के एक सरणी के रूप में संग्रहीत किया जाता है, तो अंतिम बिंदु के रूप में "अंत-बिंदु" को परिभाषित करना आसान होता है। सरणी।

एससीआई कला की सराहना की जाती है, लेकिन इसे स्वीकार नहीं किया जाता है: यह ग्राफिकल आउटपुट है, एससीआई-आर्ट नहीं।


3
आकार, रंग, आदि के बारे में कोई विशिष्टताओं हैं? जैसा कि यह है सटीक उत्पादन थोड़ा अस्पष्ट है।
R।


6
मैंने ड्रैगन-वक्र टैग हटा दिया क्योंकि यह कुछ भी जोड़ने के लिए प्रतीत नहीं हुआ
ब्लू


3
यह कोई डुप्लिकेट नहीं है; इसे हल करने के लिए प्रोग्रामिंग तकनीक काफी भिन्न हैं (शायद चारकोल को छोड़कर)। अधिकांश उत्तर कछुए ग्राफिक्स लाइब्रेरी का उपयोग करते हैं, जो एएससीआईआई के संदर्भ में बिल्कुल भी काम नहीं करेगा।

जवाबों:


2

x86, MSDOS, 16 बाइट्स

मैंने यह कुछ समय पहले लिखा था, मेरी जानकारी में एक ड्रैगन फ्रैक्टल के उत्पादन की सबसे छोटी दिनचर्या। यह कोई वास्तविक पुनरावृत्तियों का उपयोग करता है, बल्कि सीधे अंतिम छवि दिखाते हुए भग्न के अंदर हर निहित असतत पिक्सेल को प्लॉट करता है । यह इस पैक में कई अन्य छोटे प्रस्तुतियों के साथ शामिल है । 16 बाइट संस्करण के रूप में संभव के रूप में ड्रैगन फ्रैक्टल प्राप्त करने के लिए मेरे प्रयास का अंत था, यह 32 बाइट उत्पादन के साथ 2014 से शुरू हुआ ।

हेक्स

14 10 19 CA D1 FA 10 DE 01 D1 CD 10 B4 0C EB F0

कोड

S: 
adc al,0x10
sbb dx,cx       
sar dx,0x01 
adc dh,bl
add cx,dx
int 0x10
mov ah,0x0C
jmp short S

स्क्रीनशॉट


1
यह ... कमाल है, कम से कम कहने के लिए। मैं इसे कैसे चलाऊंगा?
जे। एंटोनियो पेरेज़

सबसे तेज़ तरीका एक DosBox ऑनलाइन होगा, twt86.co?c=FBAZytH6EN4B0c0QtAzr8A%3D%3D आप यहाँ स्रोत की प्रतिलिपि बना सकते हैं और इसे खुद वहीं संकलित कर सकते हैं। क्लासिक तरीका यह है कि आप DosBox (0.74) को डाउनलोड करें और इसे वहां चलाएं। सबसे वास्तविक तरीका एक MSDos या FreeDos Bootstick (Rufus) प्राप्त करना है, और इसे असली #noemu के लिए चलाना है;)
HellMood

9

पायथन 2/3, 169 167 150 111 98 78 बाइट्स

चुनौती चश्मा के अनुसार, ध्यान दें कि आयात बाइट गिनती में शामिल नहीं है।

39 (!) बाइट्स और @ nedla2004 को अन्य 13 के लिए बचाने के लिए @AlexHall का धन्यवाद

from turtle import*
o=[90]
for z in o*9:o+=[90]+[-x for x in o[::-1]]
fd(5)
for i in o:rt(i);fd(5)

एक सूची या दाएं (90) और बाएं (-90) मुड़ने से शुरू होता है, फिर सूची के माध्यम से जाता है और कछुए को स्थानांतरित करता है।

उत्पन्न उत्पादन: यहाँ छवि विवरण दर्ज करें

संपादित करें: यदि यह बहुत उबाऊ है, speed(0)तो पहले से ठीक पहले जोड़ें fd(5)। यह वही चलाएगा, सिवाय कछुए के बहुत तेजी से आगे बढ़ेगा।


एक तस्वीर अच्छी होगी :)
क्रिक्सी लिथोस

क्या आप आउटपुट की तस्वीर या स्क्रीनशॉट पोस्ट कर सकते हैं? यह भी स्पष्ट नहीं है कि यह कोड स्क्रीन पर कुछ भी प्रिंट करता है
जे एंटोनियो पेरेज़

आपकी छवि कट गई
जे एंटोनियो पेरेज़

अब तय किया जाना चाहिए :)
थियो

@AlexHall धन्यवाद! मैं जानता था कि उस पाश को बनाने का एक तरीका रहा होगा छोटा :)
Theo

8

लोगो, 43 बाइट्स

for[i 1 512][fd 9 lt :i/(bitand :i -:i)*90]

Http://www.calormen.com/jslogo/# पर दुभाषिए के साथ प्रयास करें

यह मेरे पिछले ASCII कला उत्तर और विकिपीडिया पर सूत्र के समान सिद्धांत का उपयोग करता है, सिवाय इसके कि मैंने प्रश्न में छवि से मेल खाने की दिशा को उलट दिया:

पहले, n को उस रूप में व्यक्त करें k*(2^m)जहां k एक विषम संख्या है। Nth टर्न की दिशा k mod 4 द्वारा निर्धारित की जाती है, जब k को 4 से विभाजित किया जाता है तो शेष बचे। यदि k mod 4 1 है तो nth टर्न R L है; यदि k mod 4 3 है तो nth टर्न L R है

bitand :i -:iकम से कम महत्वपूर्ण बिट पाता है i। हम इसके लिए आवश्यक विषम संख्या iको iसही मात्रा में विभाजित करने के लिए विभाजित करते हैं k। बाएँ और दाएँ घुमाव के बीच अंतर करने की कोई आवश्यकता नहीं है; हम सिर्फ k*90डिग्री से बायें मुड़ते हैं और इस तथ्य पर भरोसा करते हैं कि रोटेशन हमारे लिए मोडुलो प्रदर्शन करने के लिए एक मोडुलो 360 ओपेरा है।

उत्पादन

htयदि आवश्यक हो तो कछुए को छिपाने के लिए उपयोग करें।

यहाँ छवि विवरण दर्ज करें

आउटपुट (संशोधित)

निम्नलिखित दर्शाता है कि वक्र एक ही किनारा कैसे है।

bk 6 for[i 1 512][fd 6 rt :i/(bitand :i -:i)%4*45-90 fd 3 rt :i/(bitand :i -:i)%4*45-90]

यहाँ छवि विवरण दर्ज करें


4

लिंडेनमस्म , 51 बाइट्स

लिंडेनमासएम एक ऐसी भाषा थी जिसे मैंने कुछ समय पहले एक चुनौती के लिए बनाया था जो हमेशा के लिए सैंडबॉक्स में रहेगी। यह ड्रैगन कर्व्स, फ्रैक्टल प्लांट्स, सीरपिन्स्की ट्राइएंगल, आदि जैसी चीजों को खींचने के लिए लिंडेनमेयर सिस्टम की अवधारणा का उपयोग करता है ।

स्रोत कोड इस प्रकार है:

STT
AXI FX
INC 9
SET F 0
RPL X X+YF+
RPL Y -FX-Y
END

n = 6उदाहरण के लिए इसे सेट करने के लिए:

STT
AXI FX
INC 6
SET F 0
RPL X X+YF+
RPL Y -FX-Y
END

यह पायथन 3 के माध्यम से निम्नलिखित छवि तैयार करता है turtle:

6 पीढ़ियों

पुनरावृत्तियों के लिए थोड़ी संख्या में अंतर हो सकता है, क्योंकि लिंडेनमायर प्रणाली में पहला पुनरावृत्ति एक एकल पंक्ति है। यहाँ यह कैसा दिखता है n = 10:

10 पीढ़ियों

बस मज़े के लिए, यह 15 पीढ़ियों के साथ कैसा दिखता है ( MOV 2इसे थोड़ा छोटा बनाने के लिए अतिरिक्त निर्देश के साथ):

15 पीढ़ियाँ

एक बार जब आप (के साथ 20 पीढ़ियों के लिए उठो MOV 0.5) आप वास्तव में नहीं अब और लाइनों देख सकते हैं, और इसे बनाने के लिए कई कदम बहुत लेता है (के जोड़े +-और -+बाहर अनुकूलित नहीं कर रहे हैं)। यहाँ आपको क्या मिलेगा:

20 पीढ़ियों

ध्यान दें कि वर्तमान दुभाषिया छोटी मात्रा में पीढ़ियों के लिए चित्रमय मुद्दों को प्रस्तुत कर सकता है, अर्थात संभवतः स्क्रीन पर नहीं आ रहा है। दुर्भाग्य से जब यह दुभाषिया बनाया गया था तो कोई समस्या नहीं थी, पायथन 3 में एक संभावित बदलाव के कारण यह हो सकता है या यह सिर्फ एक प्रणाली हो सकती है


4

अंडरलोड, 196 बाइट्स

()()(<svg width="99" height="147">)S(<g transform="translate):S((33,33)">)S((3,0)rotate)*a(*a(~*)*~("><path d="M0h3" stroke="#"/>)~*a(*)**:(-90)a~^~(90)a~^)*::*:**:*^S(</g>)(:*)::*:**:*^S(</svg>)S

मुझे लगा कि इस चुनौती को कम-शक्ति वाले एसोलंग में आज़माना दिलचस्प हो सकता है; इतनी कम संख्या वाली भाषा के लिए अंडरलोड काफी अच्छी तरह से करता है।

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

अंडरलोड में एक ड्रैगन वक्र का स्क्रीनशॉट

हमें छवि का आकार स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता है। छवि के लिए एक उपयुक्त अभिविन्यास चुनना, न्यूनतम कानूनी आकार में सब कुछ आरेखण करना, और चुनौती द्वारा निर्दिष्ट पुनरावृत्तियों की न्यूनतम संख्या करना, हमें एक छवि प्रदान करता है जो बस एक बाइट को बचाने के लिए 99 पिक्सेल चौड़े में फिट बैठता है। यह अच्छा है जब चीजें इस तरह से काम करती हैं।

छवि को चित्रित करने के लिए इस्तेमाल किया जाने वाला सामान्य एल्गोरिदम दो चर बनाए रखना है (अंडरलोड चर का नाम नहीं देता है, लेकिन मैंने उन्हें एक्स और वाई के रूप में सोचा था ), दोनों शुरू में खाली थे। फिर हम बार-बार ( x , y ) को बदल देते हैं ( x , बाएँ मुड़ते हैं और आगे बढ़ते हैं, y ) और ( x , दाएँ मुड़ते हैं और आगे बढ़ते हैं, y )। दस पुनरावृत्तियों के बाद, दोनों x और y एक नौ पुनरावृत्ति ड्रैगन वक्र रखते हैं।

कुछ माइक्रो-ऑप्टिमाइज़ेशन और अंडरलोड-विशिष्ट ट्रिक्स भी हैं। स्टैक के शीर्ष के साथ बहुत अधिक खिलवाड़ से बचने के लिए, प्रत्येक लूप पुनरावृत्ति, हम x और y को फ़ंक्शन में जोड़कर शुरू करते हैं "कंक्रीटिंग द्वारा बनाई गई स्ट्रिंग लौटाएं: x , एक टर्न इंस्ट्रक्शन, फ़ंक्शन तर्क, एक चाल- आगे का निर्देश, और y । " यह फ़ंक्शन केवल स्टैक पर एक स्थान में समा जाता है, तो हम यह नकल कर सकते हैं, से कॉल करने की -90एक तर्क के रूप, डुप्लिकेट के तहत वापसी मान स्वैप, और से कॉल करने की 90एक तर्क के रूप, के लिए नए मूल्यों की पकड़ पाने के लिए एक्स और वाईस्टैक के शीर्ष दो तत्वों (जो अब तक सबसे अधिक सुलभ हैं) से अधिक को छूने की आवश्यकता के बिना। यह फ़ंक्शन रनटाइम पर कोड-जनरेट किया गया है। जनरेटर स्वयं भी रन-टाइम पर कोड-जनरेट किया जाता है, ताकि <g transform="translateछवि के मूल को सेट करने के लिए उपयोग किए जाने वाले स्ट्रिंग का पुन: उपयोग करने की अनुमति मिल सके । हम पहले सभी खुले टैग उत्पन्न करते हैं, और क्योंकि सभी नज़दीकी टैग बस हैं </g>, हम 1024 नज़दीकी टैग को केवल स्ट्रिंग को दोहराकर, उन्हें खुले टैग से मिलान करने की चिंता किए बिना आउटपुट कर सकते हैं। (अंडरलोड में कुशलता से संख्या लिखना अपने आप में एक दिलचस्प समस्या है; (:*)::*:**:*संभवतः 1024 लिखने का सबसे कुशल तरीका है, हालांकि, "2 की शक्ति (1 + 2 × 2) × 2" में अनुवाद करना)।

अंडरलोड में कोई ग्राफिक्स लाइब्रेरी नहीं है, इसलिए मैं एक निश्चित स्थिति में ड्राइंग लाइनों के संयोजन का उपयोग करके एसवीजी का उत्पादन करता हूं, और किसी दिए गए बिंदु के चारों ओर छवि को घुमाता हूं; कलम को मोड़ने के बजाय हम कागज को मोड़ देते हैं। विचार यह है कि एक रेखा खींचकर, पूरी छवि को घुमाना, दूसरी रेखा खींचना, चित्र को फिर से घुमाना आदि, हम किसी भी अंकगणित को करने या किसी भी ग्राफिक्स पुस्तकालयों का उपयोग किए बिना प्रभावी ढंग से कछुए ग्राफिक्स का अनुकरण कर सकते हैं, क्योंकि सभी रेखाएँ खींची गई हैं। उसी स्थान पर। बेशक, इसका मतलब है कि हमारे पास कुछ बहुत ही नेस्टेड रोटेट-द-इमेज टैग हैं, जो कई एसवीजी दर्शकों को भ्रमित करते हैं।

छवि को स्टाइल करना बाइट काउंट के खिलाफ गिना जाएगा, इसलिए मुझे छवि प्रदर्शित करने के लिए आवश्यक न्यूनतम स्टाइल देने की आवश्यकता थी। यह पता चला है stroke="#", जो "कम से कम कुछ रंग की आवश्यकता है" के रूप में अधिक या कम अनुवाद करता है; यह इसे काले रंग में चित्रित करने के लिए विस्तारित किया जा रहा है। (सामान्य रूप से आप रंग निर्दिष्ट करेंगे, जैसे कि, "# 000"।) पृष्ठभूमि डिफ़ॉल्ट रूप से पारदर्शी है। हम एक स्ट्रोक की चौड़ाई निर्दिष्ट नहीं करते हैं, लेकिन आँख से सूक्ति द्वारा चुना गया विकल्प सब कुछ दिखाई देता है।

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

कुछ ऐसा है जिसके बारे में मुझे थोड़ी बेचैनी है कि यहाँ केवल 1023 लाइन सेगमेंट ही प्रतीत होते हैं, और हम 1024 की उम्मीद करेंगे। ऐसा हो सकता है कि अंत में से एक सेगमेंट को इस एल्गोरिथ्म के साथ तैयार नहीं किया जा रहा है (यह होगा) इसके बजाय अगले पुनरावृत्ति पर तैयार)। यदि यह अयोग्य है, तो कार्यक्रम को अनुकूलित करना संभव हो सकता है, लेकिन यह अच्छी तरह से लंबे समय तक समाप्त हो सकता है। (ऐसा नहीं है कि यह चुनौती वैसे भी प्रतियोगिता जीतने वाली है; पहले से ही कई छोटी प्रविष्टियाँ हैं।)


4

MATL , 26 बाइट्स

0J1_h9:"tPJ*h]hYsXG15Y01ZG

यदि दो अक्षों में भिन्न पैमाने स्वीकार किए जाते हैं, तो कोड को 19 बाइट्स में घटाया जा सकता है:

0J1_h9:"tPJ*h]hYsXG

नीचे दिए गए आंकड़े समान-स्केल (26-बाइट) संस्करण के अनुरूप हैं।

उपरोक्त कोड 9-वें (0-आधारित) पुनरावृत्ति का उत्पादन करता है, जो चुनौती में दसवीं छवि है:

यहाँ छवि विवरण दर्ज करें

अन्य मानों के 9लिए कोड में परिवर्तन होता है , या iनंबर को उपयोगकर्ता इनपुट के रूप में लेने के लिए इसे बदल देता है । उदाहरण के लिए, इसके लिए परिणाम 13है:

यहाँ छवि विवरण दर्ज करें

व्याख्या

यह कॉम्प्लेक्स प्लेन में वक्र द्वारा पीछा किए गए चरणों की एक सरणी बनाने के लिए एक लूप का उपयोग करता है । उदाहरण के लिए, पहले दो चरण 1j(ऊपर) और -1(बाएं) हैं।

प्रत्येक पुनरावृत्ति में, अब तक के चरणों की सरणी की प्रतिलिपि बनाई गई है। सरणी की प्रतिलिपि को उलटा किया जाता है , (90 डिग्री को घुमाने के लिए) से गुणा किया जाता है 1j, और मूल तक पहुंचाया जाता है।

लूप के बाद, चरणों का एक संचयी योग वास्तविक अंक देता है, जो तब जटिल विमान में चढ़ाया जाता है।

0                          % Push 0
 J1_h                      % Push array [1j, -1]. This defines the first two steps
     9:                    % Push [1, 2, ..., 9]
       "                   % For each
        t                  %   Duplicate the array of steps so far
         P                 %   Reverse
          J*               %   Multiply by 1j
            h              %   Concatenate horizontally to previous steps
             ]             % End
              h            % Concatenate with the initial 0
               Ys          % Cumulative sum
                 XG        % Plot. Complex numbers are plotted with real and imag as x and y
                   15Y0    % Push string 'equal'
                       1ZG % Set equal scale in the two axes

आपका उत्तर प्रभावशाली है :) क्या आपको कोड की व्याख्या प्रदान करने में कोई आपत्ति है?
जे। एंटोनियो पेरेज़

@ जॉर्ज धन्यवाद! संपन्न हुआ
लुइस मेंडो

"19-बाइट" और "26-बाइट" संस्करण जो आप प्रदान करते हैं, समान हैं। मुझे लगता है कि यहाँ एक कॉपी और पेस्ट त्रुटि है?

@ ais523 वास्तव में! अब ठीक किया गया, धन्यवाद के लिए धन्यवाद। BTW इसे यहां एक्शन में देखा जा सकता है (प्रायोगिक कंपाइलर; पेज को रिफ्रेश करने की आवश्यकता हो सकती है)
लुइस मेंडो

3

गणितज्ञ 86 बाइट्स

{1,-1}
r=Reverse;Graphics@Line@Nest[Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&,{{0,0},%},9]

यह कैसे काम करता है: {1,-1}आउटपुट {1,-1}। यह मूल रूप से "स्टैक पर धकेलता है"। इस मान के साथ वापस बुलाया जा सकता है %r=Reverseमूल रूप से सिर्फ रिवर्स फ़ंक्शन का नाम बदलता है क्योंकि मैं इसे कोड में दो बार उपयोग करता हूं। Graphics@Line@केवल बिंदुओं की सूची लेता है और उन्हें जोड़ने के लिए एक लाइन खींचता है। समस्या का वास्तविक मांस इस कोड सेगमेंट में होता है Nest[Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&,{{0,0},%},9]:। Lemme आपको बताता है - वह खंड f ****** ck के रूप में जटिल है। यहाँ क्या Nestहै: Nest[f,x,9]कॉल करने के परिणाम को आउटपुट करता है f[f[f[f[f[f[f[f[f[x]]]]]]]]]

मेरे कोड में, यह पहला तर्क fहै:Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]& , दूसरा तर्क xहै {{0,0},%}(जो करने के लिए मूल्यांकन करता है {{0,0},{1,-1}}), और तीसरा तर्क है nजो सिर्फ 9 (जो सिर्फ दूसरा तर्क 9 बार के लिए पहला तर्क लागू होगा) है।

सभी का सबसे जटिल हिस्सा यह पहला तर्क है: Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]& जो लगभग शुद्ध सिंथैटिक चीनी का एक विशाल गड़बड़ है। मैं वास्तव में इस एक के लिए गणित की वाक्यगत चीनी का दुरुपयोग कर रहा था । कोड की वह पंक्ति एक अनाम फ़ंक्शन के गणितीय संस्करण का प्रतिनिधित्व करती है, चीजों को छोटा करने के अलावा, मैंने वास्तव में उस अनाम फ़ंक्शन के भीतर दो अलग-अलग अनाम कार्यों को परिभाषित किया है। हां, यह कानूनी है, लोग। चलो इसे तोड़ दो।

Joinदो तर्क देता है। पहला हैl=Last@#;h=#-l&/@# , और दूसरा है r[r@#%&/@h]

सम्मिलित होने का पहला तर्क: "मुख्य" अनाम फ़ंक्शन के अंदर, #वक्र में वर्तमान पुनरावृत्ति पर सभी बिंदुओं की एक सूची है। तो l=Last@#;इसका मतलब है "उन बिंदुओं की सूची में बिंदु लें जिन्हें आपने इनपुट के रूप में प्राप्त किया है, और उस बिंदु को चर पर असाइन करें l। अगला खंड,h=#-l&/@# थोड़ा और अधिक जटिल है। इसका मतलब है" आपके पास एक फ़ंक्शन है। यह फ़ंक्शन इनपुट के रूप में एक बिंदु लेता है, इससे घटाता lहै, और परिणाम देता है। अब, उस फ़ंक्शन को शिफ्ट किए गए बिंदुओं की सूची बनाने के लिए इनपुट के रूप में प्राप्त बिंदुओं की सूची में प्रत्येक तत्व पर लागू करें, और उस नई सूची को चर पर असाइन करें h

Join का दूसरा तर्क: r[r@#%&/@h] शाब्दिक रूप से सबसे जटिल वाक्यविन्यास है जो मैंने कभी लिखा है। मैं विश्वास नहीं कर सकता कि किसी भी कोड सेगमेंट में कुछ हो सकता है जैसे @#%&/@- ऐसा लगता है कि मैं किसी प्रोग्राम के बीच में कार्टून कैरेक्टर की तरह शाप दे रहा हूं! लेकिन इसे तोड़ना संभव है। याद रखें - r[x]बिंदुओं की एक सूची लेता है और उस सूची को रिवर्स ऑर्डर में लौटाता है। r@#%&एक अनाम फ़ंक्शन है जो इसके इनपुट को उलट देता है, फिर इसे स्टोर किए गए मूल्य से गुणा करता है% (जो है {1,-1}) , और परिणाम देता है। मूल रूप से यह 90 डिग्री के इनपुट पर घूमता है, लेकिन कोड में जितना संभव हो उतना कम लिख सकता है। फिर r@#%&/@hइसका अर्थ है "एक नई सूची को आउटपुट करें जो कि h90 डिग्री घुमाए गए हर बिंदु पर है ।"

तो कुल मिलाकर, Join[l=Last@#;h=#-l&/@#,r[r@#*%&/@h]]&एक फ़ंक्शन है जो एक इनपुट के रूप में बिंदुओं की एक सूची लेता है, और वक्र की अगली पुनरावृत्ति प्राप्त करने के लिए 90 डिग्री घुमाए गए बिंदुओं की एक ही सूची में जोड़ता है। ड्रैगन वक्र प्राप्त करने के लिए यह 9 बार दोहराया जाता है। तब यह परिणाम की सूची स्क्रीन के लिए एक लाइन के रूप में तैयार है। और आउटपुट:

यहाँ छवि विवरण दर्ज करें


3
मैं सिर्फ एक अशक्त वेक्टर लिखने के लिए अजीब चाल पाया: 0{,}... काम करता है क्योंकि 0 xहै 0लगभग किसी भी के लिए xऔर {,}के लिए वाक्यात्मक चीनी है {Null,Null}
मार्टिन एंडर

3

पायथन 2, 43 बाइट्स

यह उत्तर 43 बाइट्स है जिसमें आयात विवरण शामिल नहीं है और यह काफी हद तक लेवल रिवर सेंट के लोगो उत्तर और i/(i&-i)उनके कोड में उनके उपयोग पर आधारित है । इसे trinket.io पर ऑनलाइन आज़माएं

from turtle import*
for i in range(1,513):fd(9);rt(90*i/(i&-i))

यहाँ आउटपुट की एक तस्वीर है।

यहाँ छवि विवरण दर्ज करें


जहां तक ​​मुझे पता है, आपको अपने कुल बाइट काउंट में आयात स्टेटमेंट से बाइट काउंट को शामिल करना होगा।
थियो

1
@ थियो, सिर्फ चुनौती विनिर्देश से उद्धृत:The shortest code in bytes wins, however include directives for libraries shouldn't be included in the byte count, and you may use graphics libraries or other libraries written for your language of choice if they were written before the posting.
शर्लक

3

गणितज्ञ, ५६ ५५ बाइट्स

Graphics@Line@AnglePath[Pi/2JacobiSymbol[-1,Range@512]]

यहाँ छवि विवरण दर्ज करें

स्पष्टीकरण: OEIS A034947

सिर्फ मनोरंजन के लिए, यहां 19 वें पुनरावृत्ति का एक रंगीन संस्करण है।

यहाँ छवि विवरण दर्ज करें


2

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

का उपयोग करते हुए AnglePath

Graphics@Line@AnglePath[Pi/2Nest[Join[#,{1},-Reverse@#]&,{},9]]

नौ पुनरावृत्तियों



0

हास्केल + आरेख, 179 बाइट्स

import Diagrams.Prelude
import Diagrams.Backend.SVG
d 1=hrule 1<>vrule 1
d n=d(n-1)<>d(n-1)#reverseTrail#rotateBy(1/4)
main=renderSVG"d"(mkWidth 99)$strokeT(d 9::Trail V2 Double)

आउटपुट पारदर्शी पृष्ठभूमि के साथ एक 99 पिक्सेल चौड़ी svg फ़ाइल है (एक छवि 9 पिक्सेल चौड़ी एक स्ट्रोक के लिए कुछ भी पुनरावृत्ति करने के लिए बहुत मोटी होती है)। यहां इसे एक सफेद पृष्ठभूमि पर रखा गया है और इसे बनाया गया है:

ड्रैगन नंबर नौ


0

बवास , 518 बाइट्स

tosh है स्क्रैच है , लेकिन ब्लॉक के बजाय टेक्स्ट के साथ। 518 बाइट्स पर, यह उत्तर संभवतः जावा से भी बदतर है।

यह उत्तर @ थियो के पायथन उत्तर के समान तर्क का उपयोग करता है , लेकिन संख्याओं के बजाय "L" और "R" के स्ट्रिंग्स के साथ, जैसा कि स्क्रैच (और इस प्रकार tosh) की सूची क्षमताएं भयानक हैं।

आप इसे यहां स्क्रैच प्रोजेक्ट के रूप में चला सकते हैं । (स्क्रैच परियोजनाओं को संकलित करने के लिए)

when flag clicked
set path to "R"
go to x: -50 y: 100
point in direction 90
pen down
set pen size to 2
clear
repeat 9
    set path copy to path
    set path to join (path) "R"
    set i to length of path copy
    repeat length of path copy
        if letter i of path copy = "R" then
            set path to join (path) "L"
        else
            set path to join (path) "R"
        end
        change i by -1
    end
end
set i to 0
repeat length of path
    change i by 1
    if letter i of path = "R" then
         turn cw 90 degrees
    else
         turn ccw 90 degrees
    end
    move 7 steps
end  

स्पष्टीकरण:

when flag clicked
set path to "R"
go to x: -50 y: 100
point in direction 90
pen down
set pen size to 2
clear

जब हरे झंडे को क्लिक किया जाता है ( when flag clicked), "R" का पथ चर सेट करता है, तो यह पहला भाग प्रोग्राम को रन बनाता है , और उचित अवस्था में स्प्राइट और स्टेज को खींचने के लिए तैयार हो जाता है।

repeat 9
    set path copy to path
    set path to join (path) "R"
    set i to length of path copy
    repeat length of path copy
        if letter i of path copy = "R" then
            set path to join (path) "L"
        else
            set path to join (path) "R"
        end
        change i by -1
    end
end

अब हम पाथ जनरेशन कोड पर पहुँचते हैं। यह संख्या के बजाय "R" और "L" के तारों को छोड़कर @ थियो के पायथन उत्तर के समान तर्क का उपयोग करता है , और हम सूची बोध के बजाय नेस्टेड छोरों का उपयोग करते हैं।

set i to 0
repeat length of path
    change i by 1
    if letter i of path = "R" then
         turn cw 90 degrees
    else
         turn ccw 90 degrees
    end
    move 7 steps
end  

अंत में, हम पथ चर के प्रत्येक अक्षर से गुजरते हुए और अक्षर के आधार पर बाएं या दाएं मुड़कर रास्ता बनाते हैं।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.