एक ASCII Padovan सर्पिल उत्पन्न करें

Question

^{यह इस चुनौती का ASCII संस्करण है । प्रारंभिक पोस्ट मार्टिन एंडर के अनुरोध के अनुसार अलग हो गया था}

परिचय

फाइबोनैचि अनुक्रम के समान, पैडोवैन सीक्वेंस ( OEIS A000931 ) संख्याओं का एक क्रम है जो अनुक्रम में पिछले शब्दों को जोड़कर निर्मित होता है। प्रारंभिक मान इस प्रकार हैं:

P(0) = P(1) = P(2) = 1

0, 1, और 2 शब्द सभी 1 हैं। पुनरावृत्ति संबंध नीचे बताया गया है:

P(n) = P(n - 2) + P(n - 3)

इस प्रकार, यह निम्नलिखित अनुक्रम देता है:

1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37, 49, 65, 86, 114, 151, 200, 265, 351, ...

समबाहु त्रिभुज की लंबाई के रूप में इन संख्याओं का उपयोग करने से आपको एक अच्छा सर्पिल प्राप्त होता है, जब आप उन सभी को एक साथ रखते हैं, जैसे कि फिबोनाची सर्पिल:

^{चित्र विकिपीडिया के सौजन्य से}

---

कार्य

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

 /\
/__\

इसलिए, उदाहरण के लिए, यदि इनपुट 5 (5 वां शब्द) था, तो आउटपुट होना चाहिए:

   /\
  /  \
 /    \
/______\
\      /\
 \    /__\ 
  \  /\  /
   \/__\/

पहले 5 पद 1, 1, 1, 2, 2 थे, इसलिए त्रिकोण में फैलाव के कारण 2, 2, 2, 4, 4 की लंबाई थी। इनपुट 8 के लिए एक और उदाहरण:

     __________
   /\          /\
  /  \        /  \
 /    \      /    \
/______\    /      \
\      /\  /        \
 \    /__\/          \
  \  /\  /            \
   \/__\/______________\
    \                  /
     \                /
      \              /
       \            /
        \          /
         \        /
          \      /
           \    /
            \  /
             \/

नियम

• आपको परिणाम प्रिंट करना होगा, और इनपुट टर्म संख्या के अनुरूप एक पूर्णांक होना चाहिए
• अनुगामी और अग्रणी नई सूचियों की अनुमति है, रेखाओं के बाद रिक्त स्थान को भी अनुमति दी जाती है
• आपका सबमिशन कम से कम 10 वीं अवधि (9) तक का होना चाहिए।
• आपका सबमिशन एक पूर्ण प्रोग्राम या फ़ंक्शन होना चाहिए जो इनपुट लेता है और परिणाम प्रिंट करता है
• 60 डिग्री गुणकों में आउटपुट के रोटेशन की अनुमति है, लेकिन त्रिकोण का आकार प्रतिनिधित्व के साथ ही रहना चाहिए
• काउंटर-क्लॉक वाइज जाने की भी अनुमति है
• मानक खामियों को मना किया जाता है

आप मान सकते हैं कि इनपुट> 0 होगा और इनपुट का सही प्रारूप दिया जाएगा।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है। सभी को नए साल की शुभकामनाएँ!

Comments

मेरी भाषा Turtlèd आधार 10 इनपुट ले सकती है, और इसे ठीक कर सकती है, लेकिन यह चुनौती इतनी आसान होगी यदि यह बिना किसी इनपुट के ले जाए। क्या इसकी अनुमति होगी?

— विध्वंसक नींबू

@DestructibleWatermelon हाँ। इनपुट को पूर्णांक होना चाहिए, किसी प्रकार के रूप में।

— एंड्रयू ली

ठंडा। मैं अब इस पर काम करना शुरू करूंगा

— विनाशकारी नींबू

प्रतीक्षा वास्तव में यह अभी भी बहुत मुश्किल है

— विनाशकारी नींबू

Answer 1

Befunge, 871 836 798 बाइट्स

&00p45*:10p20p030p240p050p060p9010gp9110gp1910gp1-91+10gpv
<v-g03+g06*2g041g055_v#!:%6:p06p05+p04g05g06:g04<p*54+292<
->10g:1\g3+:70p110gv >:5- #v_550g:01-\2*40g+1-30g
/\110:\-g03:\1:g055 _v#!-4:<vp01:-1g01-g03-1\-
^1<v07+1:g07< p08p < >:1-#v_550g:01-\40g+60g+1-30g-50g>v
 _0>p80gp:5-|v1\+66\:p\0\9:$<:p02:+1g02-g03+g06-\g04\1:<
0v|-g00:+1$$<>\p907^>p:!7v>3-#v_550g:30g+:30p1\0\-
1>10g+::0\g3-:70p\0^^07<v<>50#<g::30g+:30p-1-01-\
v >\$0gg> :1+10gg1- #v_^>0g10gg*+\:!2*-70g2+10gv>:#->#,"_"$#1_:1#<p
+1+g03$_^#`gg011+3:+3<g07\+*2+*`0:-\gg01+5g07:g<>1#,-#*:#8>#4_$#:^#
>55+,p30g40p10gg10g1>#v_
#v:#p0$#8_:$#<g!#@_0^ >
 >>:180gg`>>#|_:2+80gg:!v
3+^g\0p08:<vgg08+2::+3<$_100p1-v>g,\80gg+\80gp:2+90g:!01p\80gp
!#^_80g:1+^>\180gg`+!#^_20g80g`
5*g10!g09p04-1-\0\+g04:gg08:p09<^3`0:gg08+1:::$$_1#!-#\\:,#\<g

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

जैसा कि अक्सर Befunge के साथ होता है, ट्रिक एक एल्गोरिथ्म के साथ आ रही है जो हमें पैटर्न को ऊपर से नीचे तक रेंडर करने की अनुमति देता है, क्योंकि यह केवल उपलब्ध स्थान के साथ मेमोरी में इसे प्रस्तुत करना संभव नहीं है।

जिस तरह से यह काम करता है वह पहले एक साधारण डेटा संरचना का निर्माण करता है जो कि सर्पिल को खींचने के लिए आवश्यक किनारों का प्रतिनिधित्व करता है। दूसरा चरण फिर उस संरचना को ऊपर से नीचे तक पार्स करता है, जो आउटपुट के प्रत्येक लाइन के लिए आवश्यक किनारे के टुकड़ों को प्रस्तुत करता है।

इस तकनीक का उपयोग करके, हम 8-बिट मेमोरी सेल्स में ओवरफ्लो समस्या शुरू होने से पहले संदर्भ कार्यान्वयन में n = 15 तक का समर्थन कर सकते हैं। एक बड़े सेल आकार के साथ दुभाषिया स्मृति से बाहर चलाने से पहले n = 25 तक समर्थन करने में सक्षम होना चाहिए।

Comments

यह बहुत प्रभावशाली है ... लेकिन क्या आप पाते हैं कि आप इन कार्यक्रमों को पढ़ने में सक्षम हैं? मेरे लिए यह बहुत यादृच्छिक लग रहा है। यह डेटा संरचना का निर्माण कैसे करता है? यह किस तरह की डेटा संरचना का उपयोग करता है? धन्यवाद!

— उज्ज्वल

Answer 2

जाओ, 768 बाइट्स

func 卷(n int){
    数:=0
    p:=[]int{1,1,1}
    for i:=3;i<n;i++ {p=append(p,p[i-2]+p[i-3])}
    宽:=p[len(p)-1]*10+10
    素:=make([]int,宽*宽)
    for 数=range 素 {素[数]=32}
    for i:=0;i<数;i+=宽 {素[i]=10}
    态:=[]int{1,1,宽/2,宽/2,92}
    表:=[70]int{}
    s:="SRSQTSPQQ!QOQP~QQQQQQSQR~ORQR!OPOPTSQRQ$QPPQNQPPPXQQQQQQRRQXQRRRNOQPQ$"
    for i:=range s {表[i]=int(s[i])-33-48}
    表[49],表[59]=48,48
    for i:=0;i<4*n;i++ {
        梴:=p[i/4]*2
        if 态[1]==0 {梴=梴*2-2}
        for k:=0;k<梴;k++ {
            址:=(态[2]+态[3]*宽)%len(素)
            if 素[址]==32 {素[址]=态[4]}
            态[2]+=态[0]
            态[3]+=态[1]
        }
        数=((态[0]+1)*2+态[1]+1)*5
        if i%4>2 {数+=35}
        for k:=0;k<5;k++ {态[k]+=表[数+k]}
    }
    for i:=0;i<宽*宽;i++ {fmt.Printf("%c",rune(素[i]))}
}

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

यह काम किस प्रकार करता है

मूल रूप से मैं ASCII पिक्सेल ग्रिड पर लोगो की तरह एक 'ड्राइंग कछुए' का अनुकरण करता हूं, लेकिन कछुआ केवल इन तीन कमांडों को कर सकता है:

rt   - right turn, turn 120 degrees right (1/3 of a Turn)
rth  - right turn half, turn  60 degrees right (1/6 of a Turn)
fd n - forward, go forward n steps, drawing a trail of _, /, or \

अब प्रत्येक त्रिभुज के लिए, मैं इस तरह से जाता हूं, जहां P, 2x है nth Padovan नंबर:

fd P
rt
fd P
rt 
fd P
rt
fd P
rth

चौथे 'fd' का अर्थ है कि मैं प्रत्येक त्रिभुज के पहले पक्ष को पुन: खोज रहा हूं। यह अगले त्रिकोण के लिए एक अच्छा प्रारंभिक बिंदु पर वापस जाने में मदद करता है। आधा-दायाँ मोड़ सुनिश्चित करता है कि अगला त्रिकोण उचित अभिविन्यास में होगा।

---

कछुए को गोल्फ करने के लिए, मैं 5 राज्य चर सरणी में संग्रहीत करता हूं,: x स्थिति, y स्थिति, x वेग, y वेग और 'ड्रॉइंग रन'। प्रत्येक एनीमेशन फ्रेम में, x + = x वेग, y + = y वेग, और रनर को खींचा जाता है।

फिर मैंने टेबल सेट किया 表 जो बताता है कि वास्तव में बारी कैसे करें। ASCII कला के काम करने के तरीके के कारण टर्न कोड मुश्किल है। यह पिक्सेल डिस्प्ले की तरह सीधा आंदोलन नहीं है। एक्स और वाई वेग द्वारा निर्धारित कछुए की दिशा, उचित दिखने के लिए मोड़ प्राप्त करने के लिए आवश्यक परिवर्तनों का निर्धारण करती है।

चालू करने के लिए, यह वर्तमान x और y वेग को देखता है, और उन्हें एक सूचकांक में जोड़ता है।

xv = x velocity, yv = y velocity. 
i.e. a turtle facing down and to the right has 
xv of 1, and yv of 1. It can only face 6 
different directions. Formula is (xv+1)*2+yv+1

xv  yv    index
-1  -1    0
-1   0    1
-1   1    2
 1  -1    4
 1   0    5
 1   1    6

इस सूचकांक का उपयोग तालिका 5 में 5 मानों के एक सेट को देखने के लिए किया जाता है। तालिका में उन 5 मूल्यों को राज्य 态 में 5 चर में से प्रत्येक में जोड़ा जाता है। फिर कछुए को प्रभावी रूप से बदल दिया जाता है, और अगले 'fd' के लिए तैयार होता है।

आरटी के लिए, आधा सही मोड़,। तालिका का एक अलग खंड है। यह 7 * 5 या 35 से ऑफसेट है, 表 में पहली तालिका से प्रविष्टियां।

अन्त में मैंने टेबल के पूर्णांक के कुछ सरल एन्कोटि को एससीआई स्ट्रिंग में किया।

मुझे पता है कि मैं हंजी को हटाकर 'बाइट्स बचा सकता हूं' लेकिन जैसा मैंने कहा, यह इष्टतम नहीं है और अधिक गोल्फिंग संभव है ... जब कोई अन्य संभावित अनुकूलन नहीं होगा तो मैं उन्हें हटा दूंगा। उन हनीजी का वास्तव में अर्थ उनके वास्तविक अर्थ पर आधारित है, और भले ही मैं चीनी नहीं जानता, यह मुझे कार्यक्रम के बारे में सोचने में मदद करता है।

数  index number
宽  screen width
素  pixel data
梴  length of side of triangle
态  current state
址  address of pixel
表  state transition table

कोड का परीक्षण करने के लिए आपको इस हेडर के साथ पूर्ण गोलंग फ़ाइल की आवश्यकता होगी

package main
import "fmt"

और यह पाद

func main ()  {
    for i := 0; i<15; i++ {
       卷(i)
    }
}

धन्यवाद