स्लैश का उपयोग करके हिल्बर्ट वक्र खींचें

Question

हिल्बर्ट वक्र एक स्पेस फिलिंग भग्न है कि एक के रूप में प्रतिनिधित्व किया जा सकता है Lindenmayer प्रणाली लगातार पीढ़ियों के साथ कि इस तरह देखो:

^{के लिए धन्यवाद http://www.texample.net/tikz/examples/hilbert-curve/ छवि के लिए।}

लक्ष्य

सबसे कम संभव प्रोग्राम (बाइट्स में) लिखें जो स्टड से एक सकारात्मक पूर्णांक n लेता है और केवल आगे स्लैश, बैकवर्ड स्लैश, स्पेस और न्यूलाइन का उपयोग करके nth ऑर्डर हिल्बर्ट वक्र को स्टडआउट तक खींचता है।

उदाहरण के लिए, यदि इनपुट 1आउटपुट है तो होना चाहिए

 \
\/

यदि इनपुट है 2तो आउटपुट होना चाहिए

  /
  \/\
/\   \
 / /\/
 \ \
  \/

यदि इनपुट है 3तो आउटपुट होना चाहिए

       \
     /\/
    /   /\
    \/\ \ \
  /\  / / /
 / /  \/  \/\
 \ \/\  /\   \
\/   / / / /\/
  /\/ /  \ \
  \   \/\ \/
   \/\   \
     / /\/
     \ \
      \/

और इसी तरह। (वे अच्छे लग रहे हैं यदि आप उन्हें कम लाइन रिक्ति के साथ कुछ में पेस्ट करते हैं।)

आउटपुट में कर्व के छोरों के ऊपर या नीचे की नई सीमाएं नहीं होनी चाहिए, न ही किसी भी लाइनों पर कोई अनुगामी स्थान।

Answer 1

रूबी, 247 230 205 अक्षर

r=?D
y=d=0
z=(1..2*x=2**gets.to_i.times{r.gsub!(/\w/){$&<?H?'-H~+D~D+~H-':'+D~-H~H-~D+'}}-1).map{' '*2*x}
r.bytes{|c|c>99?(z[y-=s=-~d/2%2][x-=1-d/2]='/\\'[d%2]
x+=d/2
y+=1-s):d-=c
d%=4}
puts z.map &:rstrip

लिंडेनमेयर प्रतिनिधित्व ( यहां कोशिश करें ) का उपयोग करके एक एएससीआईआई-कछुआ दृष्टिकोण ।

कुछ और गोल्फिंग के लिए @Ventero को धन्यवाद ।

Comments

इसे थोड़ा और गढ़ा, आशा है कि आपको कोई आपत्ति नहीं: ideone.com/kvcPWT - .map(&:rstrip)को "नो ट्रेलिंग स्पेस" की आवश्यकता को पूरा करने के लिए जोड़ा जाना था।

— वेंटरो

@ वेंटरो धन्यवाद। आशा है कि आपको कोई आपत्ति नहीं है कि मैंने आपका समाधान ले लिया है - आप मानचित्र तर्क के आसपास के परग्रहों को भी त्याग सकते हैं।

— हॉवर्ड

आह, बिल्कुल! मैंने यह भी महसूस किया कि कुल 205 वर्णों के xलिए yऔर ( असाइनमेंट को छोटा करना) की परिभाषा को इनलाइन करना और इसे छोटा करना संभव है d(पहले जैसा ही लिंक देखें)।

— वेंतोरो

Answer 2

अजगर, 282

from numpy import*
def r(n):
 x=2**n-2;b=3*x/2+1;c=x/2+1;a=zeros((x*2+2,)*2,int);a[x+1,x+1]=1;a[b,x/2]=a[x/2,b]=-1
 if n>1:s=r(n-1);a[:x,c:b]=rot90(s,3)*-1;a[c:b,:x]|=rot90(s)*-1;a[c:b,x+2:]|=s;a[x+2:,c:b]|=s
 return a
for l in r(input()):print''.join(' /\\'[c] for c in l).rstrip()

यह पिछले क्रम से बाहर nth आदेश हिल्बर्ट वक्र के निर्माण के लिए एक पुनरावर्ती दृष्टिकोण का उपयोग करता है। बेहतर स्लाइसिंग और हेरफेर के लिए कर्व्स को 2d अंक के रूप में दर्शाया गया है।

यहाँ कुछ उदाहरण हैं:

$ python hilbert.py
2
  /
  \/\
/\   \
 / /\/
 \ \
  \/
$ python hilbert.py
3
       \
     /\/
    /   /\
    \/\ \ \
  /\  / / /
 / /  \/  \/\
 \ \/\  /\   \
\/   / / / /\/
  /\/ /  \ \
  \   \/\ \/
   \/\   \
     / /\/
     \ \
      \/
$ python hilbert.py
4
              /
              \/\
            /\   \
           / / /\/
           \ \ \  /\
         /\/  \/  \ \
        /   /\  /\/ /
        \/\ \ \ \   \/\
      /\  / /  \ \/\   \
     / /  \/ /\/   / /\/
     \ \/\  /   /\/ /   /\
   /\/   /  \/\ \   \/\ \ \
  /   /\/ /\  / / /\  / / /
  \/\ \  / /  \/ / /  \/  \/\
/\   \ \ \ \/\   \ \/\  /\   \
 / /\/  \/   / /\/   / / / /\/
 \ \  /\  /\/  \  /\/ /  \ \
  \/  \ \ \  /\/  \   \/\ \/
    /\/ / / /   /\ \/\   \
    \   \/  \/\ \ \  / /\/
     \/\  /\  / / /  \ \
       / / /  \/  \/\ \/
       \ \ \/\  /\   \
        \/   / / / /\/
          /\/ /  \ \
          \   \/\ \/
           \/\   \
             / /\/
             \ \
              \/

Answer 3

Malsys - 234 221 वर्ण

मुझे यहाँ कुछ L- सिस्टम की गंध आती है :) Malsys ऑनलाइन L- सिस्टम दुभाषिया है। यह वास्तव में गंभीर प्रविष्टि नहीं है, लेकिन मुझे लगा कि यह समाधान कुछ दिलचस्प है।

Malsys का सिंटैक्स वास्तव में गोल्फ के लिए अच्छा नहीं है क्योंकि इसमें बहुत सारे लंबे कीवर्ड हैं लेकिन फिर भी, यह काफी छोटा, पठनीय और अभिव्यंजक है।

lsystem HilbertCurveAscii {
    set symbols axiom = R;
    set iterations = 5;
    set rightAngleSlashMode = true;
    interpret F as DrawLine;
    interpret + as TurnLeft;
    interpret - as TurnRight;
    rewrite L to + R F - L F L - F R +;
    rewrite R to - L F + R F R + F L -;
}
process all with HexAsciiRenderer;

http://malsys.cz/g/3DcVFMWn

दुभाषिया: http://malsys.cz/Process

गोल्फ संस्करण:

lsystem H{set symbols axiom=R;set iterations=3;set
rightAngleSlashMode=1;interpret.as DrawLine;interpret+as
TurnLeft;interpret-as TurnRight;rewrite L to+R.-L.L-.R+;rewrite
R to-L.+R.R+.L-;}process H with HexAsciiRenderer;

और कैसे Ascii हेक्सागोनल गोस्पर वक्र के बारे में? :)

      ____
 ____ \__ \
 \__ \__/ / __
 __/ ____ \ \ \
/ __ \__ \ \/
\ \ \__/ / __
 \/ ____ \/ /
    \__ \__/
    __/

http://malsys.cz/g/ae5v5vGB

Answer 4

जावास्क्रिप्ट (ईएस 6) 313 340

वास्तव में खराब प्रथाओं का उपयोग करके हटाए गए कुछ चरित्र को संपादित करें - जैसे फ़ंक्शन एच से वापसी मूल्य के बजाय वैश्विक चर डब्ल्यू

प्रत्येक x के लिए x, y की दूरी d ( विकिपीडिया देखें ) के लिए x, y स्थिति बदलकर और यदि निकटतम स्थान जुड़े हुए हैं, तो सत्यापित करें,

फ़ायर्फ़ॉक्स कंसोल में परीक्षण करें। पॉपअप के माध्यम से इनपुट, कंसोल.लॉग के माध्यम से आउटपुट।

कोई अनुगामी स्थान नहीं हैं और छवि के ऊपर या नीचे कोई नया अंक नहीं है। लेकिन प्रत्येक पंक्ति को एक नई रेखा के साथ समाप्त किया जाता है, मुझे लगता है कि यह आस्की कला की छवि बनाने का सही तरीका है।

n=1<<prompt(),d=n-1
H=(s,x,y)=>{for(w=0;s>>=1;)p=x&s,q=y&s,w+=s*s*(3*!!p^!!q),q||(p&&(x=s-1-x,y=s-1-y),[x,y]=[y,x])}
for(r=t='';++r<d+n;t+='\n')for(r>d?(x=r-d,f=x-1):(f=d-r,x=0),t+=' '.repeat(f),z=r-x;x<=z;)
h=H(n,y=r-x,x)|w,H(n,y,x-1),x?t+=' \\'[h-w<2&w-h<2]:0,H(n,y-1,x++),y?t+=' /'[h-w<2&w-h<2]:0
console.log(t)

Comments

के alertबजाय का उपयोग करके आप कुछ वर्ण सहेज सकते हैं console.log। आपके पास forचौथी पंक्ति के बाद एक अतिरिक्त स्थान भी है , और आपको उस अंतिम पंक्ति के विराम से छुटकारा पाने में सक्षम होना चाहिए।

— बॉब

@ याकूब वास्तव में मैं कुछ 15 पात्रों को बचा सकता हूं, मैंने वैसे भी 300 से अधिक मैं देख कर छोड़ दिया। मुझे 'अलर्ट' का उपयोग करना पसंद नहीं है क्योंकि छवि एक निश्चित पिच फ़ॉन्ट के बिना पूरी तरह से पहचानने योग्य नहीं है

— edc65

Answer 5

पर्ल, 270 वर्ण

सुपर गोल्फ

$_=A,%d=<A -BF+AFA+FB- B +AF-BFB-FA+>,$x=2**($n=<>)-2;eval's/A|B/$d{$&}/g;'x$n;s/A|B//g;map{if(/F/){if($r+$p==3){$y+=$p<=>$r}else{$x+=$r<2?$r-$p:$p-$r}$s[($r-1)%4>1?$x--:$x++][$r>1?$y--:$y++]=qw(/ \\)[($p=$r)%2]}else{($r+=2*/-/-1)%=4}}/./g;map{print map{$_||$"}@$_,$/}@s

इतना गोल्फ नहीं है

$_=A,%d=<A -BF+AFA+FB- B +AF-BFB-FA+>,$x=2**($n=<>)-2;
eval's/A|B/$d{$&}/g;'x$n;
s/A|B//g;
map{if(/F/){
    if($r+$p==3){$y+=$p<=>$r}else{$x+=$r<2?$r-$p:$p-$r}
        $s[($r-1)%4>1?$x--:$x++][$r>1?$y--:$y++]=qw(/ \\)[($p=$r)%2]
    }else{
        ($r+=2*/-/-1)%=4
    }
}/./g;
map{print map{$_||$"}@$_,$/}@s

शायद मैं इसे और अधिक नीचे गोल्फ कर सकता हूं अगर मैं पर्ल को बेहतर तरीके से समझ पाऊं। लाइन 1 में परिभाषित उत्पादन नियमों का उपयोग करके लिंडेनमेयर सिस्टम दृष्टिकोण का उपयोग करता है।

Answer 6

एपीएल (Dyalog यूनिकोड) , 90 बाइट्स ^SBCS

⎕∘←¨' +$'⎕r''¨↓1↓∘⍉∘⌽⍣4⊢' /\'[{3|(⊢+⍉)2@(¯1 0+3 1×s÷2)s⊢(¯.5×≢⍵)⊖(2×s←⍴⍵)↑⍵,⍨-⊖⍵}⍣⎕⊢2 2⍴0]

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

2 2⍴0 जीरो का एक 2x2 मैट्रिक्स

{ }⍣⎕ इनपुट एन और एक फ़ंक्शन एन बार लागू करें

⍵,⍨-⊖⍵ मैट्रिक्स के बाईं ओर एक लंबवत उलट और खुद की नकारात्मक प्रतिलिपि

(2×s←⍴⍵)↑शून्य के साथ पैड ताकि आयाम (के रूप में याद किया गया s) दो बार तर्क के हों

¯.5×≢⍵ इसे लंबवत रूप से केंद्र करने के लिए नीचे की ओर घुमाएं, पैडिंग शून्य के बीच सैंडविच

2@(¯1 0+3 1×s÷2) विशिष्ट स्थानों पर 2-एस लगाएं - ये फ्रैक्टल के छोटे उदाहरणों के बीच लिंकिंग स्लैश हैं

(⊢+⍉) मैट्रिक्स को अपने ट्रांसपोज़्ड स्व के साथ जोड़ें

3|modulo 3; हमने नकार का इस्तेमाल किया है, इसलिए कृपया ध्यान दें कि -1≡2 (mod 3) और -2 (1 (mod 3)

' /\'[ ] स्ट्रिंग में सूचक तत्वों के रूप में मैट्रिक्स तत्वों का उपयोग करें ' /\'

1↓∘⍉∘⌽⍣4 सभी पक्षों से 1-तत्व-वाइड खाली मार्जिन ट्रिम करें

↓ लाइनों में विभाजित

' +$'⎕r''¨ प्रत्येक से अनुगामी रिक्त स्थान निकालें (इस चुनौती के लिए यह आवश्यक है)

⎕∘←¨ उत्पादन प्रत्येक