कालकोठरी क्रॉलर

Question

इनपुट

• एक बाइनरी मैट्रिक्स एक तहखाने की दीवारों का प्रतिनिधित्व करता है।$M$
• कालकोठरी के भीतर खिलाड़ी की स्थिति ।$(x,y)$
• दिशा जो खिलाड़ी वर्तमान में सामना कर रहा है (0 = उत्तर, 1 = पूर्व, 2 = दक्षिण, 3 = पश्चिम)$d$

उत्पादन

दीवारों का एक छद्म-3 डी प्रतिनिधित्व जो खिलाड़ी के देखने के क्षेत्र में है, वर्णों के ASCII कला के रूप में ।$30\times 10$

नीचे कई संभावित आउटपुट फ़्रेम दिए गए हैं, इसके साथ ही इसे लटकने में मदद करने के लिए संबंधित मानचित्र और कम्पास के साथ (लेकिन नक्शा और कम्पास को चित्रित करना चुनौती का हिस्सा नहीं है)।

विशिष्टता

देखने के क्षेत्र

खिलाड़ी के पास अपने दृश्य के क्षेत्र में दीवारें हैं, जिन्हें से तक लेबल किया गया है । नीचे सभी संभव दिशाओं में खिलाड़ी (पीले रंग में) के सापेक्ष दीवारों की स्थिति है।$13$$A$$M$

दीवारों को खींचना

दीवारों को इस सटीक क्रम में से तक खींचा जाना चाहिए , यह देखते हुए कि पहले से खींचा गया कोई भी हिस्सा करीब की दीवारों से अलग हो सकता है। आप निश्चित रूप से इसे अलग तरह से लागू कर सकते हैं जब तक कि अंतिम परिणाम समान हो।$A$$M$

पूरे उत्पादन 7 अलग पात्रों के साथ तैयार की है: " ", "'", ".", "|", "-", "_"और ":"।

क्योंकि इस चुनौती के शरीर में दीवारों के आकार का विस्तार करना इसे बहुत लंबा कर देगा, वे इसके बजाय निम्नलिखित TIO लिंक में प्रदान किए गए हैं:

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

वर्ण जो किसी दीवाल का हिस्सा नहीं हैं, "?"इन आरेखों में चिह्नित हैं । उन्हें 'पारदर्शी' पात्रों के रूप में माना जाना चाहिए जो बिल्कुल भी नहीं खींचे जाते हैं। दूसरी ओर, एक दीवार के भीतर सभी रिक्त स्थान 'ठोस' हैं और किसी भी अन्य वर्णों को अधिलेखित करना चाहिए जो पहले वहां खींचे गए थे।

नियम

इनपुट के बारे में

• आप किसी भी उचित प्रारूप में , , और ले सकते हैं ।$M$$x$$y$$d$
• आप 0-अनुक्रमित या 1-अनुक्रमित निर्देशांक का उपयोग कर सकते हैं।
• आप निर्देशों के लिए अपनी पसंद के 4 विशिष्ट मूल्यों का उपयोग कर सकते हैं।
• मैट्रिक्स को कम से कम होने की गारंटी है ।$3\times 3$
• आप मान सकते हैं कि किनारों पर हमेशा आसपास की दीवारें होंगी।
• खिलाड़ी को एक खाली वर्ग पर स्थित होने की गारंटी है।
• इनपुट मान्य होने की गारंटी है।

आउटपुट के बारे में

• दीवारों को बिल्कुल वर्णित रूप से खींचा जाना चाहिए।
• हालांकि, आउटपुट स्वरूप भी लचीला है: एकल स्ट्रिंग, स्ट्रिंग के सरणी, वर्णों के मैट्रिक्स आदि।
• जब तक यह सुसंगत है लीडिंग और अनुगामी व्हाट्सएप स्वीकार्य है।

यह कोड-गोल्फ है ।

परीक्षण के मामलों

सभी परीक्षण मामले निम्नलिखित मैट्रिक्स का उपयोग कर रहे हैं:

[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 1, 0, 1, 1, 1, 0, 0, 0, 0, 1 ],
  [ 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 ],
  [ 1, 0, 0, 0, 0, 0, 1, 1, 0, 1 ],
  [ 1, 0, 0, 1, 0, 0, 0, 1, 0, 1 ],
  [ 1, 0, 0, 1, 1, 0, 1, 1, 0, 1 ],
  [ 1, 1, 1, 1, 0, 0, 0, 0, 0, 1 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ]

निम्न इनपुट 0-अनुक्रमित निर्देशांक का उपयोग कर रहे हैं, शीर्ष-बाएँ कोने की ओर इशारा करते हुए।$(0,0)$

x=3, y=3, d=0
x=6, y=4, d=3
x=4, y=4, d=1
x=1, y=5, d=2
x=7, y=7, d=3
x=6, y=6, d=1
x=8, y=1, d=2
x=7, y=6, d=1

अपेक्षित आउटपुट:

------------------------------    ------------------------------
 x=3, y=3, d=0:                    x=6, y=4, d=3:
------------------------------    ------------------------------
__                          __    '.                          .'
  |'.                    .'|        |                        |  
  |   '.--------------.'   |        |----.                   |  
  |    |              |    |        |    | '.--------.       |  
  |    |              |    |        |    |  |        |       |  
  |    |              |    |        |    |  |        |       |  
  |    |              |    |        |    | .'--------'       |  
  |   .'--------------'.   |        |----'                   |  
__|.'                    '.|__      |                        |  
                                  .'                          '.
------------------------------    ------------------------------
 x=4, y=4, d=1:                    x=1, y=5, d=2:
------------------------------    ------------------------------
                            .'    __ ________________________ .'
                           |        |                        |  
-------.              .----|        |                        |  
       | '.--------.' |    |        |                        |  
       |  |        |  |    |        |                        |  
       |  |        |  |    |        |                        |  
       | .'--------'. |    |        |                        |  
-------'              '----|        |                        |  
                           |      __|________________________|  
                            '.                                '.
------------------------------    ------------------------------
 x=7, y=7, d=3:                    x=6, y=6, d=1:
------------------------------    ------------------------------
'.                                '.                            
  |'.                               |'.                         
  |   '.                            |   '.                      
  |    | '.                 .-      |    |--.--------.--------.-
  |    |  |:               :|       |    |  |        |        | 
  |    |  |:               :|       |    |  |        |        | 
  |    | .'                 '-      |    |--'--------'--------'-
  |   .'                            |   .'                      
  |.'                               |.'                         
.'                                .'                            
------------------------------    ------------------------------
 x=8, y=1, d=2:                    x=7, y=6, d=1:
------------------------------    ------------------------------
'.                          __    '.                            
  |'.                    .'|        |                           
  |   '.              .'   |        |----.--------------.-------
  |    | '.        .' |    |        |    |              |       
  |    |  |:      :|  |    |        |    |              |       
  |    |  |:      :|  |    |        |    |              |       
  |    | .'        '. |    |        |    |              |       
  |   .'              '.   |        |----'--------------'-------
  |.'                    '.|__      |                           
.'                                .'                            

---

संबंधित चुनौती:

2013 से यह चुनौती निकट से संबंधित है। लेकिन इसकी एक अलग जीत मानदंड (कोड-चुनौती) है, जो आउटपुट के बहुत कम विनिर्देश हैं, और इंटरैक्टिव I / O की आवश्यकता है।

Comments

यह तुरंत मुझे 3 डी मॉन्स्टर भूलभुलैया की याद दिलाता है, हालांकि यह निश्चित रूप से ब्लॉक ग्राफिक्स का उपयोग करता है।

— नील

आपकी चुनौतियां कितनी मजेदार और अच्छी हैं!

— ओलिवर

Minecraft में एक समाधान की प्रतीक्षा कर रहा है ...

क्या किसी और को विंडो स्क्रीन सेवर याद है? जब मैं 5 या 6 साल का था तो ऐसा ही एक मजेदार खेल था ...

— मैजिक ऑक्टोपस Urn

Answer 1

क्लीन ( स्नैपी के साथ ), 800 785 670 644 बाइट्स

460 402 कोड के बाइट + 360 242-बाइट स्ट्रिंग शाब्दिक
(यहाँ और TIO पर बच गए क्योंकि यह मान्य UTF-8 नहीं है)

आप शाब्दिक की लंबाई सत्यापित कर सकते हैं यहाँ।

import StdEnv,Data.List,Data.Maybe,Codec.Compression.Snappy,Text
@a b|b<'~'=b=a
$m x y d=map(@' ')(foldl(\a b=[@u v\\u<-a&v<-b])['~~'..][join['
']k\\Just(Just 1)<-[mapMaybe(\e=e!?(x+[u,v,~u,~v]!!d))(m!?(y+[~v,u,v,~u]!!d))\\u<-[-2,2,-1,1,0,-1,1,0,-1,1,0,-1,1]&v<-[3,3,3,3,3,2,2,2,1,1,1,0,0]]&k<-nub[q\\w<-split"#"(snappy_uncompress"\211\6\44\41\41\41\55\56\40\41\40\174\72\5\4\60\55\47\40\41\41\41\43\41\41\41\176\56\55\r\1\24\56\40\41\176\174\40\r\1\4\174\72\72\r\0\0\47\r\46\35\72\25\1\31\103\0\41\25\24\35\113\176\25\0\31\133\11\224\r\152\20\56\40\40\40\41\21\217\10\40\47\56\31\14\4\40\174\126\14\0\4\56\47\21\74\0\47\1\74\1\340\r\220\25\242\11\1\25\250\25\360\11\1\25\253\376\30\0\21\30\25\333\11\1\24\47\41\41\43\137\137\11\154\20\41\40\40\174\47\r\344\1\157\5\341\1\11\5\336\172\11\0\34\56\47\41\137\137\174\56\47\1\347\20\43\176\176\40\137\132\1\0\4\40\41\75\211\76\1\0\1\356\5\150\116\1\0\376\35\0\376\35\0\126\35\0\132\347\0\20\137\174\41\43\47\101\337\51\74\41\133\122\4\0\10\56\47\40"),q<-let l=[[c\\c<-:rpad s 30'~']\\s<-split"!"w]in[l,map reverse l]]])

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

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

असम्पीडित स्ट्रिंग ( स्पष्टता के साथ #प्रतिस्थापित \n) है:

!!!-. ! |:! |:!-' !!!
!!!~.--------. !~|        |:!~|        |:!~'--------' !!!
!!!~~~~~~~~~~.--------.!~~~~~~~~~~|        |!~~~~~~~~~~|        |!~~~~~~~~~~'--------'!!!
!!-------.   !       | '.!       |  |!       |  |!       | .'!-------'   !!
!!~~~~~~~.--------------.!~~~~~~~|              |!~~~~~~~|              |!~~~~~~~|              |!~~~~~~~|              |!~~~~~~~'--------------'!!
__      !  |'.   !  |   '.!  |    |!  |    |!  |    |!  |    |!  |   .'!__|.'   !
~~ ________________________ !~~|                        |!~~|                        |!~~|                        |!~~|                        |!~~|                        |!~~|                        |!~~|                        |!~~|________________________|!
'. !  |!  |!  |!  |!  |!  |!  |!  |!.' 

यह अलग-अलग स्क्रीन घटकों के बाईं ओर के संस्करणों को !नई सुर्खियों के बजाय, और ~इसके बजाय 30-वर्णों के ?साथ दाएं-गद्देदार ~होने से पहले खुद को और उनके लाइन-रिवर्सल को लुकअप सूची में जोड़ देता है।

कोड के बाकी बस बाहर की सीमाओं के मामलों के साथ समन्वित देखने को नजरअंदाज कर दिया संभालती है।

Answer 2

पायथन 2 , 864 854 848 826 810 बाइट्स

L=[zip(*[iter(w)]*30)for w in zip(*[iter("eJzdllESgyAMRL+5Rf7yRQ7AZbhIDl9BwTqzSVtHrbKffR0Mm13HEM5SFHIoadpNI3snDyaS6NCknhU+JfZOvq8kLoIBU1oEI+RTbiePGzBa3QM0rf78TGl17+CZr5ZrUXBN+ECfY1GvGKEqtDsSI4s6xTn5jgqyqNcTTnUjTQO2FAEqTC0ngCrtpywenX5le6or1SsGi9ZLBKt0HuXtVEeUNGdzG6EsRNmo2EzLxuBbqFH8njmfwnqGcl+VY+s5+5ezSYXVel4dxaRK/6F15SatK1frvm//y4aoT4Ckj6XWfY2cbvz2fLSCPiiVvR+3ZuerzDwPSqeSvgAP9woa".decode('base64').decode('zip'))]*300)]
E=enumerate
def f(m,x,y,d):
 D=eval(`[[' ']*30]*10`);w,h=len(m[0]),len(m);a=[m,zip(*m)[::-1]][d%2];x,y=[x,y,w+~x,h+~y,y,w+~x,h+~y,x][d::4];X=sum([[0]*(x<2)+list(l)[x-2+(x<2):x+3]for l in[l*2for l in[a,[l[::-1]for l in a[::-1]]][d/2]*2][y:y+4]],[])
 for d,w in zip(L,'sropqmklhfgca'):
  for j,l in E(d):
   for i,q in E(l):
    if q*X[ord(w)%32]>=' ':D[j][i]=q
 for l in D:print''.join(l)

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

Answer 3

चारकोल , 500 332 बाइट्स

Ｆ⁴≔⮌Ｅ§θ⁰⁺00⭆θ§μλθ≔Ｅ✂θ⊖ζ⁺⁶ζ¹✂ι⊖η⁺⁶η¹θＦε≔⮌Ｅ§θ⁰⭆θ§μλθＢ³⁰χ Ｆ²«‖ＦΦ⪪⟦“ ｜0⟧Ｐ+Ｎ？⟧‹Ｇ”³¦⁰”{➙d⊟ＥＸ⍘k↧D({Ｖt⍘gＲd◨ⅉ^δ#T；”³¦¹“ ¶↖+9Ｇ₂pＦ^c1e⌈¬；”³χω⁰χ”{➙∧⊟∧◨ηü∧↖z↨⁸\G'λＩ∧¡∕⪫θＪoΣ³⊖Ｉ⊟ζ⊙”²¦⁰”{➙∧⊟∧◨ηü∨§·◧﹪d‹⟲ ＯzºκＦⅉＲï⎇”²¦⁷ω⁰χ”{➙∧⊟≔⊘⬤|↔3Ｚθ✂≔÷t⍘ε✂↨≔⧴×ld≕≡⌕m⟧6ψ=Ｚ”⁰¦⁰”}∧80ＫυgCAêＪm⟦↘/§‖Ｃk⮌Ｃ₂¡μ↗Ｗ”⁰¦²ω⁰χ”{⊟∨·◧¤∨¶⧴⬤2ＧＬ▷⁸ê5Ｇψ”⁰¦⁰⟧³Ｉ§⭆θ⭆³§μ⎇ι⊕ξ⁻⁵ξλ«Ｊ⁻⊟κײ⁹¬ι⊟κ⊟κ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। थोड़ा उबाऊ दृष्टिकोण, मुझे डर है; संकुचित स्ट्रिंग शाब्दिक मुद्रण के बहुत सारे। स्पष्टीकरण:

Ｆ⁴≔⮌Ｅ§θ⁰⁺00⭆θ§μλθ

0प्रत्येक तरफ दो अतिरिक्त एस के साथ सरणी पैड ।

≔Ｅ✂θ⊖ζ⁺⁶ζ¹✂ι⊖η⁺⁶η¹θ

7x7दिए गए निर्देशांक पर केंद्रित सरणी का एक उप-भाग स्लाइस करें ।

Ｆε≔⮌Ｅ§θ⁰⭆θ§μλθ

दी गई दिशा के लिए उपयुक्त के रूप में सरणी घुमाएँ।

Ｂ³⁰χ 

(नोट ट्रेलिंग स्पेस) एक खाली 30×10बॉक्स ड्रा करें ताकि आउटपुट हमेशा एक सुसंगत आकार का हो।

Ｆ²«‖

बीच में दर्शाते हुए प्रत्येक आधे को अलग से ड्रा करें।

ＦΦ⪪⟦...⟧³Ｉ§⭆θ⭆³§μ⎇ι⁻⁵ξ⊕ξλ«

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

Ｊ⁻⊟κײ⁹¬ι⊟κ⊟κ

दीवार के निर्देशांक पर जाएं और इसे प्रिंट करें। ध्यान दें कि एक्स-निर्देशांक को नकारात्मक रूप से प्रतिबिंबित करता [0, 30)है (-30, 0]ताकि एक पास पर कैनवास को प्रभावी रूप से 29 अक्षरों को बाईं ओर स्थानांतरित किया जा सके।

Comments

@ अर्नुलद वास्तव में, मैं समरूपता का कोई फायदा नहीं उठा रहा हूं, मुझे प्रत्येक आधे को अलग से एक तिहाई कटौती करने में सक्षम होना चाहिए।

— नील

168 बाइट गोल्फ स्ट्रोक के लिए +1। मुझे लगता है कि यह सबसे बड़ा एकल गोल्फ है जिसे मैंने यहां देखा है।

— एलपेड्रो

Answer 4

रूबी , 412 391 385 383 बाइट्स

->a,x,y,d{b=Array.new(97){[" "]*10}
e=[-1,0,1,0]
14.times{|i|m=-i%3-1
w=[31,25,15,9][n=i>2?4-i/3:(m*=2;3)]
(a*3)[y+n*e[d]+m*c=e[d-3]][x+n*c-m*e[d]]&&[p=w*(m*2-1)/2,r=[12,7,4,3][n]*m*m.abs+m/3].min.upto([q=w*(m*2+1)/2,r].max){|j|t=" .'"*9
b[j+15]=(p<j&&j<q ?%w{-%2s- -%4s- _%7s_}[-n]%"":t[k=(j^j>>9)%(36/-~n)]+"   :|  |    |"[k%13]*(k/3*2)+t[-k]).center(10).chars}}
b[0,30].transpose}

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

सत्य / मिथ्या मूल्यों की एक सरणी के रूप में इनपुट लेता है (नोट 0रूबी में सत्य है, लेकिन nilमिथ्या है।)

वर्णों की एक सरणी आउटपुट।

व्याख्या

ब्लॉक को पीछे की ओर, दाईं ओर, दाईं ओर मध्य के माध्यम से दूरी nकम करने और साइड साइड mसाइकिलिंग के साथ आगे की ओर खींचा जाता है -1,1,0। पांचवीं पंक्ति में मध्य ब्लॉक ई वास्तव में दो बार खींचा जाता है, क्योंकि हमें ए / बी और ब्लॉक सी / डी दोनों को जांचने की आवश्यकता है। n,mऔर सरणी को खोजने के लिए मूल्यों और मूल्यों को dसंशोधित करने के लिए उपयोग किया जाता है । अगर रेंज के बाहर सेल सेल के बाहर लौटाया जाता है और कोई त्रुटि नहीं डाली जाती है, लेकिन अगर रेंज से बाहर है तो पंक्ति के लिए वापस आ जाएगा और रूबी एक प्रकार की त्रुटि को फेंक देगा जब वह सेल की खोज करने की कोशिश करेगा। इससे बचने के लिए सरणी को खोज से पहले ऊर्ध्वाधर दिशा में तीन गुना किया जाता है। यदि एक सत्य मान पाया जाता है एक ब्लॉक तैयार किया गया है।xyaxnilynil

आउटपुट b10-तत्व सरणियों के एक सरणी में बनाया गया है जो आउटपुट के कॉलम का प्रतिनिधित्व करता है, और फ़ंक्शन के अंत में 10 पंक्तियों में ट्रांसपोज़ किया जाता है। सभी ब्लॉकों का पूरा सामने वाला चेहरा खींचा गया है (चाहे वह व्यूपोर्ट में दिखाई देता हो या नहीं) रेंज एरर से बचने के लिए एरे में अतिरिक्त जगह की जरूरत होती है। की सीमा jव्यूपोर्ट में मूल्यों से है -15करने के लिए +14, इस 15 द्वारा ऑफसेट है जब सरणी के लिए बचत की एक सीमा देने के लिए 0करने के लिए 29। प्रत्येक ब्लॉक के लिए तीन मानों की गणना की जाती है: pऔर qसामने की दीवार के बाएं और दाएं कोनों के लिए, और rसाइड की दीवार के पीछे के लिए। jबारी-बारी से कॉलम को आरेखित करने वाले इन तीन मूल्यों के न्यूनतम से अधिकतम तक पुनरावृत्त होता है।

3 प्रकार की लाइनें हैं: क्षैतिज -या _लंबवत |या :दोहराव " .'"पैटर्न के साथ विकर्ण । जहाँ p < j < qरिक्त स्थान वाले कॉलमों को सामने वाले के रूप में तैयार किया जाता है -या _खींचा जाता है। jइस सीमा के बाहर कहां है, अंतरिक्ष वाले कॉलम, |या किनारों से और / या साइड फेस बनाने के लिए :प्रतीकों के साथ छाया हुआ है t=" .'"। यह चर द्वारा प्रबंधित किया जाता है k=jजहां jसकारात्मक है या k=-j-1जहां jनकारात्मक है। ऊपर और नीचे के कैप के बीच वर्णों की संख्या है k/3*2। फरहस्ट ब्लॉक के बाहरी किनारों को सही ढंग से संभालने के लिए n=3, जहां kमोडुलो 9 लिया जाना चाहिए, लेकिन छोटे मूल्यों के लिए ऐसा नहीं किया जाना चाहिएn। kइसलिए मोडुलो लिया जाता है 36/-~n, जहां -~nमूल्यांकन किया जाता है n+1।

अघोषित कोड

->a,x,y,d{
  b=Array.new(97){[" "]*10}                                        #Set up array for output, allow space for plotting outside viewport
  e=[-1,0,1,0]                                                     #Direction offsets from player position
  14.times{|i|                                                     #Iterate through all blocks including block E twice 
    m=-i%3-1                                                       #Cycle -1,1,0 = left, right, centre
    n=i>2?4-i/3:(m*=2;3)                                           #Distance n=4-i/3. But if i/3==0 n=3 and double m for blocks A,B 
    w=[31,25,15,9][n]                                              #Width of front face of block
    r=[12,7,4,3][n]*m*m.abs+m/3                                    #Value of j for back edge of block. m/3 offsets by -1 when m negative 
    (a*3)[y+n*e[d]+m*c=e[d-3]][x+n*c-m*e[d]]&&(                    #If a block is present at the location then
      [p=w*(m*2-1)/2,r].min.upto([q=w*(m*2+1)/2,r].max){|j|        #Calculate left and right edges of front of block p,q and iterate
        t=" .'"*9                                                  #t=character constant for diagonal lines 
        k=(j^j>>9)%(36/-~n)                                        #k=j for positive j=distance from centre. For negative j, k=-1-j by XOR with j>>9=-1. If n=3 take modulo 9 for correct output of outer side of block. 
        b[j+15]=(p<j&&j<q ?%w{-%2s- -%4s- _%7s_}[-n]%"":           #If j between p&q, draw horizontal lines separated by 2,4 or 7 spaces depending on value of n
        t[k]+"   :|  |    |"[k%13]*(k/3*2)+t[-k]).center(10).chars #else draw space or vertical line capped by diagonal markers
      }
    )
  }
b[0,30].transpose}                                                 #Truncate values outside viewport, transpose, and return value.

Comments

अच्छा जवाब! मुझे पसंद है कि जिस तरह से सभी लाइनें प्रोग्रामेटिक रूप से उत्पन्न होती हैं, जिसमें विकर्ण शामिल हैं।

— अरनौलड