ASCII हिल्बर्ट कर्व

Question

एक पूर्णांक nआउटपुट को देखते हुए ASCII में हिल्बर्ट कर्व के nवें पुनरावृत्ति को वर्णों का उपयोग करते हुए और ।_|

यहाँ पहले 4 पुनरावृत्तियों हैं:

n=1
 _ 
| |

n=2
 _   _ 
| |_| |
|_   _|
 _| |_

n=3
 _   _   _   _ 
| |_| | | |_| |
|_   _| |_   _|
 _| |_____| |_ 
|  ___   ___  |
|_|  _| |_  |_|
 _  |_   _|  _ 
| |___| |___| |

n=4
 _   _   _   _   _   _   _   _ 
| |_| | | |_| | | |_| | | |_| |
|_   _| |_   _| |_   _| |_   _|
 _| |_____| |_   _| |_____| |_ 
|  ___   ___  | |  ___   ___  |
|_|  _| |_  |_| |_|  _| |_  |_|
 _  |_   _|  _   _  |_   _|  _ 
| |___| |___| |_| |___| |___| |
|_   ___   ___   ___   ___   _|
 _| |_  |_|  _| |_  |_|  _| |_ 
|  _  |  _  |_   _|  _  |  _  |
|_| |_| | |___| |___| | |_| |_|
 _   _  |  ___   ___  |  _   _ 
| |_| | |_|  _| |_  |_| | |_| |
|_   _|  _  |_   _|  _  |_   _|
 _| |___| |___| |___| |___| |_ 

स्पष्टीकरण

• मेरा प्रश्न हिल्बर्ट वक्र को आकर्षित करने और स्लैश का उपयोग करके हिल्बर्ट वक्र को आकर्षित करने के समान है ।
• अंडरस्कोर ( _) और वर्टिकल बार ( |) के बीच रूपांतरण वह u=2*v-1स्थान uहै जहां _s vकी संख्या है और |s की संख्या है ।
• मेरी मूल पोस्ट के साथ निरंतरता बनाए रखने के लिए वक्र को नीचे से शुरू और समाप्त होना चाहिए।
• आपके पास एक पूर्ण कार्यक्रम या एक फ़ंक्शन हो सकता है।
• स्टडआउट (या कुछ इसी तरह) के लिए आउटपुट।
• आपके पास श्वेत-रिक्त स्थान हो सकते हैं या पीछे चल सकते हैं, आउटपुट को बस इतना ऊपर की ओर ले जाने की आवश्यकता है कि यह उदाहरणों की तरह दिखे।
• यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे कम जवाब।

Comments

क्या आप अपने पोस्ट में हिल्बर्ट कर्व की परिभाषा और ASCII संस्करण का निर्माण कैसे किया जाता है, इसके सटीक विवरण शामिल कर सकते हैं?

— लोवोजो

@Busas_Pett: नहीं kolmogorov-complexity

— shooqie

@shooqie उस पर कुछ बहस है मेटा पर

— ट्राइकोप्लाक्स

@Lovjo मैंने "क्लेरिएशन" के तहत अंडरस्कोर (_) और वर्टिकल बार (!) की लंबाई के बारे में एक बिंदु में जोड़ा, अगर अधिक जानकारी या कठोर परिभाषा अभी भी चाहिए तो कृपया मुझे बताएं।

— Bobas_Pett

@shooqie i ने टैग को हटा दिया

— Bobas_Pett

Answer 1

Befunge, 444 368 323 बाइट्स

&1>\1-:v
0v^*2\<_$00p>
_>:10p\:20pv^_@#-*2g00:+1,+55$
^!-<v*2g000<>$#<0>>-\:v
g2*^>>10g20g+v \ ^*84g_$:88+g,89+g,\1+:00
v#*!-1g02!g01_4^2_
>::00g2*-!\1-:10g-\20g-++>v
87+#^\#p01#<<v!`g01/2\+76:_
vv1-^#1-g01:\_$:2/20g`!
_ 2/^>:10g#vv#`g02/4*3:\+77
v>0p^^/2:/2_
<^2-1-g02</2`#*3:
0g+10p2*:^*3_1
! "#%$
%$"#!
 !!##%
|||_
 _ __

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

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

इसलिए हमने जो दृष्टिकोण यहां लिया है वह एक सूत्र के साथ आना है जो हमें बताता है कि किसी दिए गए x, y समन्वय के लिए कौन सा वर्ण आउटपुट है। यह समझने के लिए कि यह कैसे काम करता है, यह ASCII प्रतिपादन के साथ शुरू करने के लिए की अनदेखी करने के लिए सबसे आसान है, और बस के रूप में बॉक्स पात्रों से बना वक्र के बारे में सोच: ┌, ┐, └, ┘, │, और ─।

जब हम इस तरह वक्र को देखते हैं, तो हम तुरंत देख सकते हैं कि दाहिने हाथ की तरफ बाएं हाथ की तरफ का एक सटीक दर्पण है। सही पर वर्ण बस बाईं तरफ के अपने साथी को देख, और यह क्षैतिज दर्शाती द्वारा निर्धारित किया जा सकता (यानी की घटनाओं ┌और ┐लगा दिया जाता था, के रूप में कर रहे हैं └और ┘)।

फिर निचले बाएं कोने को देखते हुए, फिर से हम देख सकते हैं कि निचला आधा शीर्ष आधा का प्रतिबिंब है। इस प्रकार तल पर पात्रों बस ऊपर अपने साथी को देख, और यह खड़ी दर्शाती द्वारा निर्धारित कर रहे हैं (यानी की घटनाओं ┌और └लगा दिया जाता था, के रूप में कर रहे हैं ┐और ┘)।

इस कोने का शेष आधा हिस्सा थोड़ा कम स्पष्ट है। दाहिने हाथ के ब्लॉक को तिरछे ब्लॉक के ऊर्ध्वाधर प्रतिबिंब से प्राप्त किया जा सकता है जो इसके समीप है।

और बाएं हाथ का ब्लॉक पूर्ण वक्र के बाईं ओर ब्लॉक के ऊर्ध्वाधर प्रतिबिंब से प्राप्त किया जा सकता है।

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

इसलिए शीर्ष स्तर के अलावा किसी भी चीज़ में, नीचे के कोने के पात्रों को एक विशेष मामले के रूप में नियंत्रित करने की आवश्यकता होती है, जहाँ ┌चरित्र को परिलक्षित किया जाता है ─, और │चरित्र को परिलक्षित किया जाता है └।

लेकिन इसके अलावा, हम वास्तव में इस प्रक्रिया को पुनरावर्ती रूप से दोहरा सकते हैं। अंतिम स्तर पर हम शीर्ष बाएँ वर्ण को हार्डकोड करते हैं ┌, और उसके नीचे वर्ण │।

अब जब हमारे पास एक विशेष x पर वक्र के आकार को निर्धारित करने का एक तरीका है, y समन्वय करते हैं, तो हम कैसे ASIIII प्रतिपादन में अनुवाद करते हैं? यह वास्तव में सिर्फ एक साधारण मानचित्रण है जो प्रत्येक संभव टाइल का दो ASCII वर्णों में अनुवाद करता है।

• ┌बन जाता है  _(अंतरिक्ष प्लस अंडरस्कोर)
• ┐  (दो स्थान) बन जाता है
• └बन जाता है |_(वर्टिकल बार प्लस अंडरस्कोर)
• ┘बन जाता है | (वर्टिकल बार प्लस स्पेस)
• │बन जाता है | (फिर से एक वर्टिकल बार प्लस स्पेस)
• ─बन जाता है __(दो अंडरस्कोर)

यह मानचित्रण पहली बार में सहज नहीं है, लेकिन आप यह देख सकते हैं कि जब यह दो संगत रेंडरिंग को एक साथ देखता है तो यह कैसे काम करता है।

और मूल रूप से यह सब वहाँ है। वास्तव में Befunge में इस एल्गोरिथ्म को लागू करना पूरी तरह से एक और समस्या है, लेकिन मैं उस स्पष्टीकरण को दूसरी बार छोड़ दूँगा।

Answer 2

सी, 267 बाइट्स

const n=4,s=1<<n,a[]={1,-s,-1,s};l,p,q;
t(d){d&=3;p-q||printf("%.2s",&"__|      _|       |___ _|_| | | "[l*8+d*2]);p+=a[l=d];}
h(d,r,n){n--&&(h(d+r,-r,n),t(d+r),h(d,r,n),t(d),h(d,r,n),t(d-r),h(d-r,-r,n));}
main(){for(;p=s*s-s,l=1,q<s*s;++q%s||putchar(10))h(0,1,n),t(3);}

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

h()हलबर्ट वक्र के स्ट्रोक उत्पन्न करने के लिए पुनरावर्तन का उपयोग करता है। t()यदि कलम की स्थिति pवर्तमान उत्पादन की स्थिति के बराबर है, तो केवल स्ट्रोक चरित्र को प्रिंट करता है q।

यह अक्षम लेकिन सरल है।

यदि वक्र शीर्ष-बाईं ओर शुरू होता है, तो कोड को 256 बाइट्स तक कम किया जा सकता है।

Comments

सुझाएँ puts("")बजाय putchar(10)और "..."+l*8+d*2के बजाय &"..."[l*8+d*2]और n--?h(d+r...-r,n):0के बजायn--&&(h(d+r...-r,n))

— ceilingcat