ASCII दिन की कला # 2 - प्रवाह सांप

Question

एक प्रवाह नाग, यह भी एक Gosper वक्र रूप में जाना जाता है, एक भग्न वक्र, एक सरल प्रक्रिया के प्रत्येक आदेश / यात्रा के साथ आकार में तेजी से बढ़ रही है। निर्माण के बारे में विवरण और विभिन्न आदेशों के लिए कुछ उदाहरण नीचे दिए गए हैं:

ऑर्डर 1 फ्लो स्नेक :

____
\__ \
__/

ऑर्डर 2 फ्लो स्नेक :

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

आदेश 3 प्रवाह नाग :

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

निर्माण

7 किनारों और 8 कोने (नीचे लेबल) युक्त पथ के निर्माण के लिए ऑर्डर 1 फ्लो स्नेक पर विचार करें। व्यवहार्यता के लिए बढ़े हुए:

4____5____6
 \         \
 3\____2   7\
       /
0____1/

अब प्रत्येक अगले आदेश के लिए, आप किनारों को इस मूल क्रम 1 पैटर्न के घुमाए गए संस्करण से बदल देंगे। किनारों को बदलने के लिए निम्नलिखित 3 नियमों का उपयोग करें:

1 एक क्षैतिज किनारे के लिए, इसे मूल आकार के साथ बदलें:

________
\       \
 \____   \
     /
____/

2 एक /किनारे के लिए ( 12उपरोक्त निर्माण में), इसे निम्न घुमाए गए संस्करण से बदलें:

 /
/   ____
\  /   /
 \/   /
     /
____/

3 एक \किनारे के लिए ( 34और 67ऊपर), इसे निम्नलिखित घुमाए गए संस्करण के साथ बदलें:

 /
/   ____ 
\   \   \
 \   \   \
  \  /
   \/

उदाहरण के लिए, ऑर्डर 1 लेबल से कोने के साथ क्रम 2 जैसा दिखेगा

            ________
            \       \
  ________   \____   \6
  \       \      /   /
   \____   \5___/   /   ____
       /            \   \   \
  4___/   ________   \   \   \7
 /        \       \   \  /
/   ____   \____   \2  \/
\   \   \      /   /
 \   \   \3___/   /   ____
  \  /            \  /   /
   \/   ________   \/   /
        \       \      /
         \____   \1___/
             /
        0___/

अब किसी भी उच्च क्रम के लिए, आप वर्तमान स्तर को लंबाई 1 /, 1 \या 2 के किनारों में तोड़ते हैं _और प्रक्रिया को दोहराते हैं। ध्यान दें कि प्रतिस्थापित करने के बाद भी, किसी भी दो लगातार किनारों के बीच के सामान्य कोने अभी भी मेल खा रहे हैं।

चुनौती

• आपको एक पूर्ण कार्यक्रम का एक फ़ंक्शन लिखना होगा जो NSTDIN / ARGV / फ़ंक्शन तर्क के माध्यम से एक पूर्णांक प्राप्त करता है या निकटतम समकक्ष और NSTDOUT पर ऑर्डर फ़्लो स्नेक को प्रिंट करता है ।
• इनपुट पूर्णांक हमेशा से अधिक होता है 0।
• कोई भी अग्रणी स्थान नहीं होना चाहिए जो पैटर्न का हिस्सा नहीं हैं।
• न्यूनतम बाउंडिंग आयत को पूरी तरह से भरने के लिए पैटर्न को पैड करने के लिए या तो कोई अनुगामी स्थान या पर्याप्त अनुगामी स्थान नहीं होना चाहिए।
• अनुगामी न्यूलाइन वैकल्पिक है।

मजेदार तथ्य

• फ्लो स्नेक स्नो फ्लेक्स का एक शब्द प्ले है, जो यह पैटर्न ऑर्डर 2 और इसके बाद के संस्करण जैसा दिखता है
• फ्लो और स्नेक्स वास्तव में पैटर्न में एक भूमिका निभाते हैं क्योंकि पैटर्न पूरे एकल प्रवाह से बना होता है।
• यदि आप ध्यान से देखते हैं, तो क्रम 2 (और उच्चतर) पैटर्न में वर्तमान 1 पैटर्न के घुमाव शामिल होते हैं जो वर्तमान और पिछले किनारे के आम शीर्ष पर होते हैं।
• फ्लो स्नेक का एक नॉन ASCII वैरिएंट है जो यहां और कई अन्य स्थानों पर पाया जा सकता है ।

यह बाइट्स जीत में कोड-गोल्फ इतना छोटा कोड है!

---

लीडरबोर्ड

श्रृंखला की पहली पोस्ट एक लीडरबोर्ड उत्पन्न करती है।

यह सुनिश्चित करने के लिए कि आपके उत्तर दिखाए गए हैं, कृपया प्रत्येक मार्कलाइन के साथ निम्नलिखित मार्केड टेम्प्लेट का उपयोग करके प्रत्येक उत्तर को शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Comments

अगर मैं सही तरीके से समझूं, तो आकार 1,2,3 2x बढ़े हुए हैं, इसलिए 2 में नीचे की पंक्ति 4 undescores से बनी होनी चाहिए, न कि 3.

— edc65

@ edc65 उदाहरणों में आकार पूरी तरह से आकार के हैं। अगर आप कंस्ट्रक्शन पार्ट के बारे में बात कर रहे हैं, तो हाँ, यह बड़ा हो गया है और 3 अंडरस्कोर हैं ताकि किनारे की संख्या 4 की जगह ले ले

— ऑप्टिमाइज़र

लेकिन आकार 2 में कोई बढ़त संख्या नहीं है (निर्माण भाग में, हाँ)। आकृति 2 का निचला भाग आकृति के तल के बराबर होना चाहिए।

— edc65

@ edc65 ओह, वहाँ !. फिक्स्ड!

— ऑप्टिमाइज़र

मैंने शीर्षक को "स्नो फ्लेक्स" के रूप में पढ़ा और असली शीर्षक पर ध्यान नहीं दिया जब तक कि आपने अंतर पर ध्यान नहीं दिया।

— mbomb007

Answer 1

सीजेएम, 144 बाइट्स

0_]0a{{_[0X3Y0_5]f+W@#%~}%}ri*{_[YXW0WW]3/If=WI6%2>#f*.+}fI]2ew{$_0=\1f=~-
"__1a /L \2,"S/=(@\+\~.+}%_2f<_:.e>\:.e<:M.-:)~S*a*\{M.-~3$3$=\tt}/zN*

स्क्रॉलिंग से बचने के लिए न्यूलाइन जोड़ा गया। इसे ऑनलाइन आज़माएं

कार्यक्रम कई चरणों में काम करता है:

1. प्रारंभिक भग्न (आदेश 1) आंदोलन की दिशा का प्रतिनिधित्व करते हुए 7 कोणों (अवधारणात्मक, 60 ° के गुणकों) के अनुक्रम के रूप में एन्कोड किया गया है
2. भग्न एक क्षैतिज खंड (क्रम 0 भग्न) के लिए "लागू" होता है, जो एन क्रम में सभी "आंदोलनों" को उत्पन्न करने के लिए एन बार होता है।
3. [0 0] से शुरू होकर, आंदोलनों को [xy] निर्देशांक के साथ अंकों के अनुक्रम में अनुवादित किया जाता है
4. प्रत्येक सेगमेंट (अंकों की जोड़ी) को 1 या 2 [xyc] ट्रिपल में बदल दिया जाता है, निर्देशांक x पर वर्ण c का प्रतिनिधित्व करता है। y
5. बाउंडिंग आयत निर्धारित किया जाता है, निर्देशांक समायोजित किए जाते हैं और रिक्त स्थान का एक मैट्रिक्स उत्पन्न होता है
6. प्रत्येक ट्रिपल के लिए, वर्ण c को स्थिति x, y को मैट्रिक्स में रखा जाता है, और अंतिम मैट्रिक्स को आउटपुट के लिए समायोजित किया जाता है

Comments

यह उत्तर बाइट एन्कोडिंग से लाभ के लिए पर्याप्त है: goo.gl/D1tMoc

— डेनिस

@ डेनिस मुझे यकीन नहीं है कि मैंने इसे गोल्फ किया है ... और आपने इसे ब्लॉक में क्यों रखा है?

— aditsu

मुझे वास्तव में यकीन नहीं है ... आपका उत्तर काफी प्रभावशाली है। मैंने इस अधिकार को पाने के लिए पूरा दिन लगा दिया।

— डेनिस

@ डेनिस धन्यवाद; btw, क्या आपको लगता है कि गैर-मुद्रण योग्य / नियंत्रण वर्णों का उपयोग करना आम तौर पर ठीक है? मैं आमतौर पर उनसे बचने की कोशिश करता हूं

— एडिट्स

अगर मैं बाइट की गिनती बढ़ाए बिना उनसे बच सकता हूं, तो मैं करता हूं। लेकिन छोटा कम है। : P इस तरह के मामलों में जहां मैं कुछ स्ट्रिंग या सरणी के बजाय कोड को ही संपीड़ित करता हूं, मैं आमतौर पर उत्तर में दोनों संस्करणों को शामिल करता हूं।

— डेनिस

Answer 2

पायथन 2, 428 411 388 बाइट्स

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

आकार भी एक मुद्दा था, और मैं बस एक 5*3**nपक्षीय वर्ग के बीच में शुरू कर रहा था और बाद में चीजों को काट रहा था, हालांकि अगर मैं आकार की गणना करने के लिए बेहतर तरीके के बारे में सोच सकता हूं तो मैं इसे बदल सकता हूं।

n=input();s=5*3**n
r=[s*[" "]for i in[0]*s]
def D(n,x,y,t=0):
 if n<1:
    x-=t%2<1;y+=t%3>1;r[y][x]='_/\\'[t/2]
    if t<2:r[y][x+2*t-1]='_'
    return[-1,2,0,1,0,1][t]+x,y-(2<t<5)
 for c in[int(i)^t%2for i in"424050035512124224003"[t/2::3]][::(t^1)-t]:x,y=D(n-1,x,y,c)
 return x,y
D(n,s/2,s/2)
S=[''.join(c).rstrip()for c in r]
for l in[c[min(c.find('\\')%s for c in S):]for c in S if c]:print l

Comments

वाह, यह बहुत बढ़िया है। एएओडी # 1 पर एक शॉट देना चाहते हैं?

— ऑप्टिमाइज़र

r=[s*[" "]for i in range(s)]-> r=[[" "]*s]*s]कुछ बाइट्स शेव करेंगे

— सेपरक्वल

@sirpercival दुर्भाग्य से यह काम नहीं करेगा क्योंकि कैसे* परस्पर वस्तुओं को दोहराता है ।

— grc

ओह, ठीक है, मैं भूल गया

— साहसी

आप कुछ बाइट्स को इनलाइन करके , लूप के लिए प्रिंटिंग के लिए lस्विच print'\n'.join()करने, उपयोग return[...][t]+x,करने और कोष्ठकों को हटाने से बचा सकते हैं (t%2)। इसके अलावा, min(c.find('\\')%s for c in S)यदि आप सूची का नाम बदलते हैं तो आप इसका उपयोग कर सकते हैं Sताकि यह प्रारंभिक मूल्य को अधिलेखित न करे s।

— GRC

Answer 3

जावास्क्रिप्ट ( ईएस 6 ), 356 362 370

यह एक मुश्किल है ...

प्रत्येक आकृति को पथ के रूप में संग्रहीत किया जाता है। 6 बुनियादी भवन खंड हैं (3 + 3 पिछड़े)

• 0विकर्ण ऊपर बाएं से दाएं ( 4पीछे)
• 1विकर्ण नीचे दाएँ ( 5पिछड़े) को छोड़ दिया
• 2क्षैतिज बाएं से दाएं ( 6पिछड़े)

हर एक के लिए, ऑर्डर बढ़ने पर लागू होने वाला एक प्रतिस्थापित कदम है:

• 0-> 0645001(पिछड़ा 4-> 5441024)
• 1-> 2116501(पिछड़ा 5-> 5412556)
• 2-> 2160224(पिछड़ा 6-> 0664256)

मान hसरणी में पूर्वनिर्मित, भले ही तत्व 4..6 का उपयोग कर 0..2 से प्राप्त किया जा सकता है

;[...h[n]].reverse().map(x=>x^4).join('')

दिए गए आदेश के लिए आकार प्राप्त करने के लिए, पथ को चर में बार-बार प्रतिस्थापन को लागू करने के लिए बनाया गया है। फिर मुख्य लूप पी चर पर पुनरावृत्त होता है और जी [] सरणी के अंदर आकार खींचता है, जहां प्रत्येक तत्व एक पंक्ति है।
स्थिति (0,0) पर शुरू, प्रत्येक सूचकांक नकारात्मक हो सकता है (उच्च आदेशों में y सूचकांक)। जब भी मुझे कोई नकारात्मक y मान मिलता है मैं सभी y सरणी को स्थानांतरित करने वाले नकारात्मक y अनुक्रमित से बचता हूं। मुझे परवाह नहीं है अगर एक्स इंडेक्स नकारात्मक हो जाता है, जैसा कि जेएस नकारात्मक इंडेक्स में अनुमति है, बस प्रबंधन करने के लिए थोड़ा और मुश्किल है।
अंतिम चरण में, मैं .map का उपयोग करते हुए मुख्य सरणी को स्कैन करता हूं, लेकिन प्रत्येक पंक्ति के लिए मुझे bचर का उपयोग करने के लिए एक स्पष्ट ((;)) लूप का उपयोग करना होगा जो कि कम से कम x सूचकांक रखता है (जो कि <0 होगा)।
मेंconsole.log संस्करण एक आसान अग्रणी न्यूलाइन है, जिसे स्निपेट संस्करण में आसानी से एक अनुगामी न्यूलाइन स्वैपिंग 2 पंक्तियों के रूप में बनाया जा सकता है।

f=o=>{
  g=[],x=y=b=0,
  h='064500192116501921602249954410249541255690664256'.split(9);
  for(p=h[2];--o;)p=p.replace(/./g,c=>h[c]);
  for(t of p)
    z='\\/_'[s=t&3],
    d=s-(s<1),
    t>3&&(x-=d,y+=s<2),
    y<0&&(y++,g=[,...g]),r=g[y]=g[y]||[],
    s?s>1?r[x]=r[x+1]=z:r[x]=z:r[x-1]=z,
    t<3&&(x+=d,y-=s<2),
    x<b?b=x:0;
  g.map(r=>
  {
    o+='\n';
    for(x=b;x<r.length;)o+=r[x++]||' '
  },o='');
  console.log(o)
}

काम करने के लिए आसान स्निपेट (फ़ायरफ़ॉक्स में):

f=o=>{
  g=[],x=y=b=0,
  h='064500192116501921602249954410249541255690664256'.split(9);
  for(p=h[2];--o;)p=p.replace(/./g,c=>h[c]);
  for(t of p)
    z='\\/_'[s=t&3],
    d=s-(s<1),
    t>3&&(x-=d,y+=s<2),
    y<0&&(y++,g=[,...g]),r=g[y]=g[y]||[],
    s?s>1?r[x]=r[x+1]=z:r[x]=z:r[x-1]=z,
    t<3&&(x+=d,y-=s<2),
    x<b?b=x:0;
  g.map(r=>
  {
    for(x=b;x<r.length;)o+=r[x++]||' ';
    o+='\n'
  },o='');
  return o
}

// TEST

fs=9;
O.style.fontSize=fs+'px'

function zoom(d) { 
  d += fs;
  if (d > 1 && d < 40)
    fs=d, O.style.fontSize=d+'px'
}

#O {
  font-size: 9px;
  line-height: 1em;
}

<input id=I value=3><button onclick='O.innerHTML=f(I.value)'>-></button>
<button onclick="zoom(2)">Zoom +</button><button onclick="zoom(-2)">Zoom -</button>
<br>
<pre id=O></pre>

Answer 4

हास्केल, 265 बाइट्स

(?)=div
(%)=mod
t[a,b]=[3*a+b,2*b-a]
_#[0,0]=0
0#_=3
n#p=[352,6497,2466,-1]!!((n-1)#t[(s+3)?7|s<-p])?(4^p!!0%7)%4
0&_=0
n&p=(n-1)&t p+maximum(abs<$>sum p:p)
n!b=n&[1,-b]
f n=putStr$unlines[["__ \\/   "!!(2*n#t[a?2,-b]+a%2)|a<-[b-n!2+1..b+n!2+0^n?3]]|b<-[-n!0..n!0]]

(नोट: GHC पर 7.10 से पहले, आप जोड़ने की आवश्यकता होगी import Control.Applicativeया बदलने के abs<$>साथ map abs$।)

Ideone.com पर ऑनलाइन रन करें

f n :: Int -> IO ()स्तर nबहता है। ड्राइंग को वक्र के बजाय बिटमैप क्रम में गणना की जाती है, जो एल्गोरिथ्म को ओ (एन) अंतरिक्ष (यानी ड्राइंग आकार में लॉगरिदमिक) में चलाने की अनुमति देता है। मेरे बाइट्स का लगभग आधा हिस्सा कंप्यूटिंग में खर्च किया जाता है, जिसे खींचने के लिए आयत बनाई जाती है!

Comments

मैंने लॉगिन किया और अब यह काम करता है! अच्छा!

— ऑप्टिमाइज़र

यह पता चला है कि यह पहले Ideone.com पर नहीं चला था क्योंकि मैं 64-बिट मान रहा था। अभी तय किया गया है (2 बाइट्स का त्याग)।

— एंडर्स कासोर्ग

यह ठीक है कि लॉगिन के लिए केवल पुष्टि के लिए मेरी ईमेल आईडी की आवश्यकता थी ..

— ऑप्टिमाइज़र

Answer 5

पर्ल, 334 316 309

$_=2;eval's/./(map{($_,"\1"x7^reverse)}2003140,2034225,4351440)[$&]/ge;'x($s=<>);
s/2|3/$&$&/g;$x=$y=3**$s-1;s!.!'$r{'.qw($y--,$x++ ++$y,--$x $y,$x++ $y,--$x
$y--,--$x ++$y,$x++)[$&]."}=$&+1"!eeg;y!1-6!//__\\!,s/^$x//,s/ *$/
/,print for
grep{/^ */;$x&=$&;$'}map{/^/;$x=join'',map$r{$',$_}||$",@f}@f=0..3**$s*2

मानक इनपुट पर लिया गया पैरामीटर। मुझे परखो ।

Answer 6

हास्केल, 469 419 390 385 365 बाइट्स

फ़ंक्शन f :: Int-> IO () इनपुट के रूप में एक पूर्णांक लेता है और प्रवाह साँप को प्रिंट करता है

e 0=[0,0];e 5=[5,5];e x=[x]
f n=putStr.t$e=<<g n[0]
k=map$(53-).fromEnum
g 0=id
g n=g(n-1).(=<<)(k.(words"5402553 5440124 1334253 2031224 1345110 2003510"!!))
x=s$k"444666555666"
y=s$k"564645554545"
r l=[minimum l..maximum l]
s _[]=[];s w(x:y)=w!!(x+6):map(+w!!x)(s w y)
t w=unlines[["_/\\\\/_ "!!(last$6:[z|(c,d,z)<-zip3(x w)(y w)w,c==i&&d==j])|i<-r.x$w]|j<-r.y$w]

Comments

यह 2 × बढ़े हुए आंकड़े पैदा करता है। मुझे लगता है कि सवाल शीर्ष पर छोटे आंकड़े के लिए पूछ रहा है, और केवल 2 × बढ़े हुए आंकड़ों का इस्तेमाल किया गया है ताकि यह समझाया जा सके कि फ्लोअनेक का निर्माण कैसे किया जाता है।

— एंडर्स केसरग

तुम सही हो। मैंने इसे ठीक किया

— डेमियन

आप $की परिभाषा में उपयोग कर सकते हैं k, और जिसके (!!)aसाथ (a!!)कुछ कोष्ठकों से छुटकारा पा सकते हैं। इसके अलावा, आप अपने आप से बहुत सारी चालें जानते हैं। नाइस

— गर्वित हेकलर

Answer 7

सी, 479 474 468 427 बाइट्स

मेरे द्वारा अनुमान लगाए गए पर्ल और हास्केल लोगों की कोई पिटाई नहीं हुई है, लेकिन चूंकि यहां कोई सी जमा नहीं है:

#define C char
C *q="053400121154012150223433102343124450553245";X,Y,K,L,M,N,i,c,x,y,o;F(C*p,
int l,C d){if(d){l*=7;C s[l];for(i=0;i<l;i++)s[i]=q[(p[i/7]%8)*7+i%7];return F
(s,l,d-1);}x=0;y=0;o=32;while(l--){c=*p++%8;for(i=!(c%3)+1;i--;) {K=x<K?x:K;L=
y<L?y:L;M=x>M?x:M;N=y>N?y:N;y+=c&&c<3;x-=c%5>1;if(x==X&y==Y)o="_\\/"[c%3];y-=c
>3;x+=c%5<2;}}return X<M?o:10;}main(l){F(q,7,l);for(Y=L;Y<N;Y++)for(X=K;X<=M;X
++)putchar(F(q,7,l));}

एक अटोई () कॉल पर स्थान बचाने के लिए, कार्यक्रम के लिए पारित तर्कों की संख्या का उपयोग स्तर के लिए किया जाता है।

कार्यक्रम ओ (एन ^ 3) या बदतर में चलता है; पहले पथ की गणना न्यूनतम / अधिकतम निर्देशांक खोजने के लिए एक बार की जाती है, फिर प्रत्येक (x, y) जोड़ी के लिए उस विशिष्ट स्थान पर वर्ण खोजने के लिए एक बार गणना की जाती है। बहुत धीमी गति से, लेकिन स्मृति प्रशासन पर बचाता है।

उदाहरण http://codepad.org/ZGc648Xi पर चलते हैं

Comments

के X,Y,K,L,M,N,i,j,c;बजाय int X,Y,K,L,M,N,i,j,c;और के main(l)बजाय का उपयोग करेंvoid main(int l)

— Spikatrix

हाँ, धन्यवाद, मैं पहले से ही उन और थोड़ा और अधिक मुंडा, मैं एक नया संस्करण डालूँगा।

— ज़ेव

नवीनतम संस्करण में आउटपुट को छंटनी की जा रही है और सिरों पर थोड़ा सा बंद है।

— ऑप्टिमाइज़र

मैंने गलत बूँद अपलोड की, यह ठीक होनी चाहिए।

— ज़ेव

Answer 8

पायथन 2, 523 502 475 473 467 450 437 बाइट्स

l=[0]
for _ in l*input():l=sum([map(int,'004545112323312312531204045045050445212331'[t::6])for t in l],[])
p=[]
x=y=q=w=Q=W=0
for t in l:T=t|4==5;c=t in{2,4};C=t<3;q=min(q,x);Q=max(Q,x+C);w=min(w,y);W=max(W,y);a=C*2-1;a*=2-(t%3!=0);b=(1-T&c,-1)[T&1-c];x+=(a,0)[C];y+=(0,b)[c];p+=[(x,y)];x+=(0,a)[C];y+=(b,0)[c]
s=[[' ']*(Q-q)for _ in[0]*(W-w+1)]
for t,(x,y)in zip(l,p):x-=q;s[y-w][x:x+1+(t%3<1)]='_/\_'[t%3::3]
for S in s:print''.join(S)

Pffft, मुझे एक 3 घंटे की लागत, लेकिन करने के लिए मजेदार था!

कार्य को कई चरणों में विभाजित करने का विचार है:

1. दिखावे के क्रम में सभी किनारों (0-5 के रूप में एन्कोडेड) की गणना करें (इसलिए सांप की शुरुआत से अंत तक)
2. किनारों में से प्रत्येक के लिए स्थिति की गणना करें (और x और y के लिए न्यूनतम और अधिकतम मानों को बचाएं)
3. इसमें शामिल स्ट्रिंग्स का निर्माण करें (और ऑफसेट करने के लिए न्यूनतम मान का उपयोग करें, ताकि हमें नकारात्मक संकेत न मिले)
4. स्ट्रिंग्स प्रिंट करें

यहां कोड को अनछुए रूप में रखा गया है:

# The input
n = int(input())

# The idea:
# Use a series of types (_, /, \, %), and positions (x, y)
# Forwards:   0: __  1: /  2: \
# Backwards:  3: __  4: /  5: \

# The parts
pieces = [
    "0135002",
    "0113451",
    "4221502",
    "5332043",
    "4210443",
    "5324551"
]
# The final types list
types = [0]
for _ in range(n):
    old = types
    types = []
    for t in old:
        types.extend(map(int,pieces[t]))

# Calculate the list of positions (and store the mins and max')
pos = []
top = False
x = 0
y = 0
minX = 0
minY = 0
maxX = 0
maxY = 0
for t in types:
    # Calculate dx
    dx = 1 if t < 3 else -1
    if t%3==0:
        dx *= 2         # If it's an underscore, double the horizontal size
    # Calculate dy
    top = t in {1, 5}
    dy = 0
    if top and t in {0, 3, 1, 5}:
        dy = -1
    if not top and t in {2, 4}:
        dy = 1
    # If backwards, add dx before adding the position to the list
    if t>2:
        x += dx
    # If top to bottom, add dy before adding the position to the list
    if t in {2,4}:
        y += dy
    # Add the current position to the list
    pos += [(x, y)]
    # In the normal cases (going forward and up) modify the x and y after changing the position
    if t<3:
        x += dx
    if t not in {2, 4}:
        y += dy
    # Store the max and min vars
    minX = min(minX, x)
    maxX = max(maxX, x + (t<3)) # For forward chars, add one to the length (we never end with __'s)
    minY = min(minY, y)
    maxY = max(maxY, y)

# Create the string (a grid of charachters)
s = [[' '] * (maxX - minX) for _ in range(maxY - minY + 1)]
for k, (x, y) in enumerate(pos):
    x -= minX
    y -= minY
    t = types[k]
    char = '/'
    if t % 3 == 0:
        char = '__'
    if t % 3 == 2:
        char = '\\'
    s[y][x : x + len(char)] = char

# Print the string
for printString in s:
    print("".join(printString))

संपादित करें: मैंने # 3 के लिए अपने उत्तर के साथ संगत होने के लिए भाषा को अजगर 2 में बदल दिया, (और यह 6 और बाइट्स भी बचाता है)

Comments

अच्छी नौकरी; एक साधारण सुधार आप कर सकते हैं बदल रहा है किया जाएगा l.extend(x)करने के लिए l+=x। इसके अलावा आप शायद codegolf.stackexchange.com/questions/54/… का उपयोग कर सकते हैं इसके बजाय .split()आप का उपयोग करें (मैंने अपने उत्तर में ऐसा ही कुछ किया था)

— केएसएबी

@ धन्यवाद थैंक्स, मैं अब बहुत बेवकूफ महसूस कर रहा हूंextend

— मैटी

Answer 9

परी / जीपी, 395

एक्स, वाई चरित्र पदों पर लूपिंग और प्रिंट करने के लिए क्या गणना करें। मध्यम प्रयास कम से कम, व्हाट्सएप और टिप्पणी के साथ रन बनाए।

k=3;
{
  S = quadgen(-12);  \\ sqrt(-3)
  w = (1 + S)/2;     \\ sixth root of unity
  b = 2 + w;         \\ base

  \\ base b low digit position under 2*Re+4*Im mod 7 index
  P = [0, w^2, 1, w, w^4, w^3, w^5];
  \\ rotation state table
  T = 7*[0,0,1,0,0,1,2, 1,2,1,0,1,1,2, 2,2,2,0,0,1,2];
  C = ["_","_",  " ","\\",  "/"," "];

  \\ extents
  X = 2*sum(i=0,k-1, vecmax(real(b^i*P)));
  Y = 2*sum(i=0,k-1, vecmax(imag(b^i*P)));

  for(y = -Y, Y,
     for(x = -X+!!k, X+(k<3),  \\ adjusted when endpoint is X limit
        z = (x- (o = (x+y)%2) - y*S)/2;
        v = vector(k,i,
                   z = (z - P[ d = (2*real(z) + 4*imag(z)) % 7 + 1 ])/b;
                   d);
        print1( C[if(z,3,
                     r = 0;
                     forstep(i=#v,1, -1, r = T[r+v[i]];);
                     r%5 + o + 1)]) );  \\ r=0,7,14 mod 5 is 0,2,4
     print())
}

प्रत्येक वर्ण षट्कोण कोशिका का पहला या दूसरा भाग है। एक सेल स्थान एक जटिल संख्या z है जो कि आधार b = 2 + w में अंकों के साथ 0, 1, w ^ 2, ..., w ^ 5, जहां w = e ^ (2pi / 6) एकता की छठी जड़ है। उन अंकों को केवल 1 से 7 के अंतर के रूप में रखा जाता है, फिर नेट रोटेशन के लिए एक स्टेट टेबल के माध्यम से उच्च से निम्न में ले जाया जाता है। यह एड Shouten द्वारा फ्लोकेन कोड की शैली में है (xytoi) लेकिन केवल शुद्ध रोटेशन के लिए, पथ के साथ "एन" सूचकांक में अंक नहीं बना रहे हैं। विस्तार आकृति के केंद्र में एक मूल 0 के सापेक्ष हैं। जब तक सीमा एक समापन बिंदु नहीं है तब तक ये 2-वर्ण षट्भुज के मध्य होते हैं और इनमें से केवल 1 वर्ण की आवश्यकता होती है। लेकिन जब साँप शुरू होता है और / या अंत में एक्स सीमा 2 चर की आवश्यकता होती है, जो k = 0 प्रारंभ और k <3 अंत होता है। Pari में sqrt (-3) बिल्टिन की तरह "क्वाड्स" है लेकिन इसे वास्तविक और काल्पनिक भागों के साथ अलग-अलग किया जा सकता है।

Comments

यह व्हाट्सएप की अग्रणी और अनुगामी के बारे में नियमों को पूरी तरह से संतुष्ट नहीं करता है।

— एंडर्स केसरग

धन्यवाद, मैं संशोधित। आपके हैस्केल ने मुझे एक घंटे के लिए एक एक्स से हरा दिया, वाई लूप ने किया। प्रतीक्षा करने से पहले पोस्ट किया जाना चाहिए कि क्या आगे प्रेरणा आएगी :-)।

— केविन राइड

अब सांप का एक सिरा k = 0, 1, 2. के लिए काट दिया जाता है (गणित इस तरह से परेशान कर रहा है - मुझे इससे भी निपटना था।)

— एंडर्स कासोर्ग

आह प्रिय, जब समापन बिंदु एक्स अधिकतम है। हम्म।

— केविन राईड