एक्सवाईजेड के साथ एक क्यूब के चेहरे को सममित रूप से बाहर निकालें

Question

सैंडबॉक्स

वर्तमान कार्य के प्रयोजनों के लिए, इकाई लंबाई का एक घन इस प्रकार के रूप में ASCII प्रतीकों के साथ परोक्ष प्रक्षेपण में प्रस्तुत किया गया है:

  +-----+
 /     /|
+-----+ |
|     | +
|     |/
+-----+

• + कोने के लिए।
• -एक्स किनारों के लिए। X के साथ इकाई की लंबाई -को दो कोने के बीच पांच द्वारा दर्शाया गया है ।
• |Y किनारों के लिए। Y के साथ इकाई की लंबाई |दो कोने के बीच दो द्वारा दर्शाई गई है।
• /जेड किनारों के लिए। Z के साथ इकाई की लंबाई /दो कोने के बीच एक से दर्शाया गया है ।
• वर्टिकल केवल ऐसे ही खींचे जाते हैं जहां तीनों प्लेन प्रतिच्छेद करते हैं।
• किनारों को केवल वहीं खींचा जाता है, जहां दो प्लेन प्रतिच्छेद करते हैं।

जब एक इकाई चेहरा बाहर निकाला जाता है, तो इसकी मूल स्थिति से एक इकाई की लंबाई की भरपाई होती है और प्रत्येक दिशा (सकारात्मक और नकारात्मक) के लिए चार नए किनारों का निर्माण किया जाता है।

आप एक 3 डी कार्टेशियन कोऑर्डिनेट सिस्टम के अक्षों को खींचने के बारे में सोच सकते हैं, जहां प्रत्येक अक्ष को क्रॉस सेक्शन 1x1 और लंबाई nसे घनाभ के रूप में दर्शाया गया है (0,0,0)

एक्स के साथ 1 से बहिष्कृत:

  +-----------------+
 /                 /|   
+-----------------+ |
|                 | +
|                 |/
+-----------------+

कार्य

XYZ कुल्हाड़ियों के लिए तीन संख्याओं को देखते हुए, संकेतित मात्राओं के अनुसार एक इकाई घन के चेहरों को सममित रूप से बाहर निकालें और परिणाम को ऊपर बताए अनुसार ASCII प्रतीकों के साथ प्रस्तुत करें।

इनपुट

एक्स, वाई, जेड - गैर-नकारात्मक संख्या - संबंधित अक्षों के लिए एक्सट्रूज़न लंबाई। 0 का मतलब है कोई बाहर निकालना। इनपुट तीन नंबर, तीन नंबर की सूची, एक ट्रिपल, एक स्ट्रिंग या कुछ भी हो सकता है जो आपके लिए सुविधाजनक हो।

उत्पादन

बाहर निकलने के बाद घन का ASCII ड्राइंग। लीडिंग और ट्रेलिंग wihtespaces की अनुमति है।

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

X Y Z
0 0 0

  +-----+
 /     /|
+-----+ |
|     | +
|     |/
+-----+

1 0 0

  +-----------------+
 /                 /|   
+-----------------+ |
|                 | +
|                 |/
+-----------------+


0 0 1   
        +-----+
       /     /|
      /     / |
     /     /  +
    /     /  /
   /     /  /
  +-----+  /
  |     | / 
  |     |/
  +-----+


1 1 0

        +-----+
       /     /|      
      +-----+ |
  +---|     | +-----+
 /    |     |/     /|
+-----+     +-----+ |
|                 | +
|                 |/
+-----+     +-----+
      |     | +
      |     |/
      +-----+

2 0 1

                +-----+
               /     /|
  +-----------+     +-----------+
 /                             /|
+-----------+     +-----------+ |
|          /     /|           | +
|         +-----+ |           |/
+---------|     | +-----------+
          |     |/
          +-----+

1 1 1 

        +-----+
       /     /|-+   
      +-----+ |/|
  +---|     | +-----+
 /    |     |/     /|
+-----+-----+-----+ |
|    /     /|     | +
|   +-----+ |     |/
+---|     | +-----+
    |     |/| +
    +-----+ |/
      +-----+

मानदंड जीतना

हर भाषा में बाइट्स में सबसे छोटा समाधान जीतता है। कृपया उपयोग की गई विधि और अपने कोड का संक्षिप्त विवरण जोड़ें।

Comments

क्या प्रत्येक प्रत्यर्पण के लिए एक ऊपरी सीमा है?

— अज्ञानता का प्रतीक

@ इम्बोडेंस ऑफ इग्नोरेंस - 9 पर्याप्त होना चाहिए

— गैलेन इवानोव

Answer 1

जावास्क्रिप्ट (ईएस 6),  525 ... 475 471  459 बाइट्स

13 बाइट्स @Neil की बदौलत सहेजे गए

एक सरणी के रूप में इनपुट लेता है [X,Y,Z]। वर्णों का एक मैट्रिक्स लौटाता है।

a=>([X,Y,Z]=a,m=[],W=X*6+Z*2,'1uol9h824lsqpq17de52u1okgnv21dnjaww111qmhx1gxf4m50xg6pb42kzijq21xyh34t0h2gueq0qznnza2rrimsg3bkrxfh3yrh0em').replace(/.{7}/g,s=>[[c,x,A,y,B,w,C,h,D,t]=parseInt(s,36)+s,Y*W,Z,X,Y|!W,Z*X,X*Y*!Z,X*Z*!Y,Y*Z*!X][c]&&(g=H=>V<h&&((m[r=y-(3-B)*p+(t>1?H-V:V)+Y*3+Z*2]=m[r]||Array(W*2+9).fill` `)[x-2*(3-A)*p+(t>1?V:H-V*t)+W]=` ${c>5?'  + ':t>1?'|-':'-|'}+/+`[(H%~-w?0:+t?4:2)|!(V%~-h)],g(++H<w?H:!++V)))(V=0,p=a[c%3],w-=-3*C*p,h-=-D*p))&&m

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

कैसे?

ड्राइंग कदम

आउटपुट में 15 पक्ष होते हैं, एक विशिष्ट क्रम में खींचा जाता है।

कार्यान्वयन

ड्राइंग फ़ंक्शन $g$ । यह निम्नलिखित मापदंडों के साथ काम करता है:

• $(x, y)$ : जहां ड्राइंग शुरू करना है
• $w$ : चौड़ाई
• $h$ : ऊंचाई
• $t$ : साइड का प्रकार

कोने हमेशा खींचे जाते हैं। एक और पैरामीटर $c$ के मूल्य के आधार पर , किनारों को या तो खींचा जाता है या मिटा दिया जाता है।

यदि $t=0$ , तो फ़ंक्शन एक सामने की ओर खींचता है:

...........      ...........
..+-----+..      ..+     +..
..|     |..  or  ..       ..
..|     |..      ..       ..
..+-----+..      ..+     +..
...........      ...........

यदि $t=1$ , तो यह ऊपर की ओर खींचता है:

...........      ...........
...+-----+.      ...+     +.
../     /..  or  ..       ..
.+-----+...      .+     +...
...........      ...........

यदि $t=2$

......+....      ......+....
...../|....      .....  ....
....+ |....  or  ....+  ....
....| +....      ....  +....
....|/.....      ....  .....
....+......      ....+......

निर्देशांक $(x,y)$ और प्रत्येक पक्ष का आकार $(w,h)$ या तो एक स्थिर मान है या इनपुट चर में से एक पर निर्भर है: $X$ , $Y$ या$Z$

दोनों इनपुट चर का उपयोग करने के लिए और जांच करने के लिए शर्त पैरामीटर के साथ की पहचान कर रहे $c \in[1..8]$

संक्षेप में, एक पक्ष पूरी तरह से इसके साथ वर्णित है:

$$\begin{cases} c\\ t\\ x=o_x+m_x\times P\\ y=o_y+m_y\times P\\ w=o_w+m_w\times P\\ h=o_h+m_h\times P \end{cases}$$

$P$$c$

इसलिए, हमें प्रत्येक पक्ष के लिए निम्नलिखित 10 मापदंडों को संग्रहीत करने की आवश्यकता है:

$$[c, o_x, m_x, o_y, m_y, o_w, m_w, o_h, m_h, t]$$

नीचे दिए गए 15 पक्षों के पैरामीटर दिए गए हैं:

$$\begin{array}{|c|c|} \hline \text{side} & c & o_x & m_x & o_y & m_y & o_w & m_w & o_h & m_h & t\\ \hline 0 & 4 & 0 & 0 & 2 & -3 & 7 & 0 & 4 & 6 & 0\\ 1 & 4 & 6 & 0 & 2 & -3 & 4 & 6 & 3 & 0 & 2\\ 2 & 2 & 6 & -2 & 2 & 2 & 4 & 0 & 3 & 4 & 2\\ 3 & 3 & 6 & 6 & 2 & 0 & 4 & 0 & 3 & 0 & 2\\ 4 & 3 & 0 & -6 & 2 & 0 & 7 & 12 & 4 & 0 & 0\\ 5 & 2 & 2 & 2 & 0 & -2 & 7 & 0 & 3 & 4 & 1\\ 6 & 3 & 2 & -6 & 0 & 0 & 7 & 12 & 3 & 0 & 1\\ 7 & 2 & 0 & -2 & 2 & 2 & 7 & 0 & 4 & 0 & 0\\ 8 & 5 & 6 & -2 & 2 & 2 & 4 & 0 & 1 & 2 & 2\\ 9 & 4 & 2 & 0 & 0 & -3 & 7 & 0 & 3 & 0 & 1\\ 10 & 1 & 0 & 0 & 2 & -3 & 7 & 0 & 1 & 3 & 0\\ 11 & 1 & 6 & 0 & 2 & -3 & 1 & 3 & 3 & 0 & 2\\ 12 & 6 & 0 & 0 & 2 & 0 & 7 & 0 & 4 & 0 & 0\\ 13 & 7 & 2 & 0 & 0 & 0 & 7 & 0 & 3 & 0 & 1\\ 14 & 8 & 6 & 0 & 2 & 0 & 4 & 0 & 3 & 0 & 2\\ \hline \end{array}$$

$[0..9]$

$$m_x\gets (m_x+6)/2\\ m_y\gets m_y+3\\ m_w\gets m_w/3$$

इसका परिणाम ठीक 10 दशमलव अंकों की 15 संख्याओं में होता है, जिन्हें आधार 36 में 7 अंकों के 15 समूहों के रूप में संग्रहीत किया जाता है।

उदाहरण के लिए, पहले पक्ष को एन्कोड किया गया है 4032070460और जैसे ही संग्रहीत किया गया है 1uol9h8।

Comments

मुझे लगता Array(W*2+9).fill` ` है कि एक बाइट बचाता है।

— नील

उफ़, क्षमा करें, मेरा बुरा, मुझे इसे गलत या कुछ और देखना चाहिए। उपेक्षा।

— अज्ञानता का प्रतीक

@EododimentofIgnorance कोई चिंता नहीं। :)

— अरनौल

आपके पारंपरिक रूप से शांत विवरण के अलावा शानदार दृश्य! आदर करना!

— गैलेन इवानोव

@GalenIvanov धन्यवाद! मुझे वास्तव में इस चुनौती पर काम करने में बहुत मजा आया।

— अरनौल

Answer 2

एपीएल (डायलॉग क्लासिक) , 162 161 132 130 बाइट्स

{' |+/+ +-? ??? ++'[⍉(⊃~∘0)⍤1⍣3⍉↑a↑¨⍨↓(--1-⌊/∘,)2-/1⌽↑⍳⍴a←16|29|1+{2⊥+/¨∊¨=⌿¨⍵(⍉⍵)(⍉↓⍵)}⌺2 2 2{⍉⍤2⍉⌽0,⍵}⍣6↑3/↓2/6⌿1<⍵+.=⍨↑⍳1+2×⍵]}

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

• इकाई क्यूबियों की एक 3 डी बूल सरणी उत्पन्न करते हैं
• प्रत्येक क्यूबी को 3 3 बार xyz के साथ दोहराएं
• शून्य के साथ चारों ओर
• प्रत्येक 2 × 2 × 2 सबर्रे के लिए 0 और 16 के बीच एक संख्या की गणना करें जो संबंधित आउटपुट चार को निर्धारित करता है: (1 + 4*cx + 2*cy + cz) mod 16जहां cx,cy , czधुरी एक्स, वाई, जेड के साथ एक ही मूल्य "छड़" की संख्या कर रहे हैं, यानी वैक्टर कि धुरी है कि मिलकर साथ समान मान: 0 0 या 1 1. हम एक अपवाद बनाते हैं यदि सबअरेअर शून्य-(या सभी-एक - जो कोई फर्क नहीं पड़ता) और हम 28 के बजाय इसकी संख्या 0 मानते हैं।
• प्रत्येक सेल गणना के लिए जहां स्क्रीन पर संबंधित चार को खींचा जाना चाहिए
• प्रत्येक सेल के लिए एक पारदर्शी (0-पैडेड) मैट्रिक्स का निर्माण करें जिसमें केवल एक अपारदर्शी "पिक्सेल" हो
• मेट्रिसेस को मिलाएं - इस बिंदु पर हमारे पास 5x सरणी है जिसमें आयाम inx, iny, inz, outx, outy है
• उनके साथ केवल पहली गैर-पारदर्शी (item 0) आइटम रखते हुए, पहले तीन अक्षों को कम करें
• संख्याओं में बदलने के लिए लुकअप टेबल (एक स्ट्रिंग) का उपयोग करें -|/+

धन्यवाद स्कॉट मिलनर खोलना है कि कुछ के लिए +रों के रूप में प्रदान ?रों

Comments

आप वास्तव में इसका परीक्षण कैसे करते हैं? मैं उदाहरण के लिए 2,3,4 के प्रत्यर्पण की कोशिश करना चाहता था, लेकिन कुछ भी स्पष्ट नहीं लग रहा था।

— नील

एल्गो बहुत बेकार है, इसलिए 2 3 4 स्मृति से बाहर चलाता है, लेकिन 2 3 3 पहुंच के भीतर है

— ngn

@ नील मैंने एक छोटा सा सुधार किया और अब 2 3 4 काम करता है। एक पक्ष प्रभाव :) के रूप में एक बाइट खो

— NGN

एक एपीएल समाधान है कि एक ascii- कला चुनौती पर चारकोल के रूप में आधा है ?! क्या चल रहा है?!

— झबरा

100% निश्चित नहीं है, लेकिन मुझे पूरा यकीन है कि यह 0 1 1

— स्कॉट मिलनर

Answer 3

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

≔×⁶Ｎθ≔׳Ｎη≔⊗Ｎζ¿‹¹№⟦θηζ⟧⁰«Ｂ⁺⁷⊗θ⁺⁴⊗η↗↗⊕⊗ζ+⁺⁵⊗θＰ↙⊗⊕ζ↓+↓⁺²⊗η↙+↙⊕⊗ζ»«Ｆ‹⁰θ«↗+↗←+←⊖θ↙+/Ｐ→θ↓+↓²+⊖θ+»Ｆ‹⁰η«Ｊ⁶¦³↗+↗↓+↓⊖η↙+/Ｐ↑η←+←⁵↑+↑⊖η+»Ｆ‹⁰ζ«Ｊ⁸±²↓+↓↓↗+↗⊖ζ↑+↑²Ｐ↙ζ←+←⁵↙+↙⊖ζ+»Ｊ⁶¦⁰Ｆ‹⁰ζ«Ｇ↓³↙⊕ζ←⁷↑³↗⊕ζ ↙+↙⊖ζ↓+↓²+→⁵Ｐ↗ζ↑+↑²Ｐ←⁶↗+↗⊖ζ»Ｆ‹⁰η«Ｇ←⁶↑⊕η↗³→⁶↓⊕η ↑+↑⊖η←+←⁵↙+/Ｐ↓η+⁵Ｐ↗²↓+↓⊖η»Ｆ‹⁰θ«Ｇ↗²→⊕θ↓⁴↙²←⊕θ →+⊖θ↗+/↑+↑²Ｐ←θ↙+/Ｐ↓³←+←⊖θ»Ｐ↗∧∧θη²Ｐ↓∧∧ζθ³Ｐ←∧∧ηζ⁶+

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔×⁶Ｎθ≔׳Ｎη≔⊗Ｎζ

एक्सट्रूज़न इनपुट करें, लेकिन बाइट्स को बचाने के लिए उन्हें मुख्य रूप से।

¿‹¹№⟦θηζ⟧⁰«Ｂ⁺⁷⊗θ⁺⁴⊗η↗↗⊕⊗ζ+⁺⁵⊗θＰ↙⊗⊕ζ↓+↓⁺²⊗η↙+↙⊕⊗ζ»«

यदि एक्सट्रूज़न में से कम से कम दो शून्य हैं, तो बस आयामों का एक क्यूबॉइड (2x + 1, 2y + 1, 2z + 1) खींचें। अन्यथा:

Ｆ‹⁰θ«↗+↗←+←⊖θ↙+/Ｐ→θ↓+↓²+⊖θ+»

यदि कोई हो, तो बायाँ एक्सट्रूज़न प्रिंट करें।

Ｆ‹⁰η«Ｊ⁶¦³↗+↗↓+↓⊖η↙+/Ｐ↑η←+←⁵↑+↑⊖η+»

यदि कोई हो, तो डाउन एक्सट्रूज़न प्रिंट करें।

Ｆ‹⁰ζ«Ｊ⁸±²↓+↓↓↗+↗⊖ζ↑+↑²Ｐ↙ζ←+←⁵↙+↙⊖ζ+»

यदि कोई हो, तो बैक एक्सट्रूज़न प्रिंट करें।

Ｊ⁶¦⁰

शेष अतिरिक्त सभी इस बिंदु पर मिलते हैं (जो बहुत अंत तक तैयार नहीं होते हैं!)

Ｆ‹⁰ζ«Ｇ↓³↙⊕ζ←⁷↑³↗⊕ζ ↙+↙⊖ζ↓+↓²+→⁵Ｐ↗ζ↑+↑²Ｐ←⁶↗+↗⊖ζ»

फ्रंट एक्सट्रूज़न प्रिंट करें, यदि कोई हो, तो ओवरलैप के बाईं और नीचे के हिस्सों को हटाने के लिए देखभाल करना।

Ｆ‹⁰η«Ｇ←⁶↑⊕η↗³→⁶↓⊕η ↑+↑⊖η←+←⁵↙+/Ｐ↓η+⁵Ｐ↗²↓+↓⊖η»

ऊपर की ओर और बाईं ओर के विस्तार को मिटाने के लिए देखभाल करते हुए, यदि कोई हो, तो बाहर निकालना प्रिंट करें।

Ｆ‹⁰θ«Ｇ↗²→⊕θ↓⁴↙²←⊕θ →+⊖θ↗+/↑+↑²Ｐ←θ↙+/Ｐ↓³←+←⊖θ»

सही एक्सट्रूज़न प्रिंट करें, यदि कोई हो, तो नीचे और पीछे के एक्सट्रूज़न के हिस्सों को मिटाने के लिए देखभाल करना।

Ｐ↗∧∧θη²Ｐ↓∧∧ζθ³Ｐ←∧∧ηζ⁶+

बाद वाले एक्सट्रूज़न के बीच में जोड़ लें।

Comments

चारकोल में 325 बाइट्स ?! एक पर ascii अत्याधुनिक चुनौती ?! यह इतना है कि मुझे Ja (vaScri) pt में भी यह प्रयास करने के लिए पर्याप्त नहीं है!

— झबरा

@ शैग्गी यह एक इष्टतम दृष्टिकोण नहीं हो सकता है, और इसे गोल्फ के तरीके हो सकते हैं जो मैंने वैसे भी अनदेखी की है। हालांकि मुझे यह कहना है कि ngn का तरीका पेचीदा लग रहा है, ऐसा लगता है जैसे वह आकार को एक आंतरिक सरणी में खींचता है और फिर अपने आउटपुट को उत्पन्न करने के लिए किनारे का पता लगाता है।

— नील

@ शैगी मैं 195 बाइट समाधान के साथ आया हूं, जिसे मैंने अलग-अलग पोस्ट किया है क्योंकि यह पूरी तरह से अलग दृष्टिकोण है। हालांकि एपीएल की अभी भी कमी है।

— नील

Answer 4

चारकोल , 195 164 144 बाइट्स

≔⁺³×⁶Ｎθ≔⁺²×³Ｎη≔⊕⊗ＮζＦ…·±ζζＦ…·±ηηＦ…·±θθ«Ｊ⁻λι⁺κι≔⟦⟧δＦＥ²↔⁻⁺ιμ·⁵ＦＥ²↔⁻κνＦＥ²↔⁻⁺λξ·⁵⊞δ⌊⟦‹μζ‹νη‹ξθ‹¹№Ｅ⟦μνξ⟧‹π⊕ρ¹⟧≡Σδ¹+²§ |-/⁺⌕δ¹⌕⮌δ¹¦³+⁴§ +Σ…δ⁴¦⁶§ |-/⌕δ⁰

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मैं इसे एक अलग उत्तर के रूप में पोस्ट कर रहा हूं क्योंकि यह एक्सट्रूज़न को खींचने के लिए एक पूरी तरह से अलग दृष्टिकोण का उपयोग करता है। स्पष्टीकरण:

≔⁺³×⁶Ｎθ≔⁺²×³Ｎη≔⊕⊗Ｎζ

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

Ｆ…·±ζζＦ…·±ηηＦ…·±θθ«

सभी सीमाओं पर लूप भीतर (सीमा सहित) बाहर निकालना युक्त घनाभ है।

Ｊ⁻λι⁺κι

उन निर्देशांक के अनुरूप आउटपुट स्थिति पर जाएं।

≔⟦⟧δＦＥ²↔⁻⁺ιμ·⁵ＦＥ²↔⁻κνＦＥ²↔⁻⁺λξ·⁵⊞δ⌊⟦‹μζ‹νη‹ξθ‹¹№Ｅ⟦μνξ⟧‹π⊕ρ¹⟧

दिए गए निर्देशांक से, सभी आठ विकर्ण दिशाओं में झांकना यह निर्धारित करने के लिए कि बाहर निकालना उस दिशा में ओवरलैप करता है या नहीं। झांकने वाले निर्देशांक की जाँच की जाती है कि वे अभी भी घनाभ के भीतर स्थित हैं, और फिर कुल्हाड़ियों की संख्या जिसमें मूल घन के भीतर समन्वित झूठ होना चाहिए 1 से अधिक होना चाहिए। ध्यान दें कि क्यूब के पास एक विषम प्रदर्शन ऊंचाई है, वाई-अक्ष मान जबकि अन्य अक्षों भिन्नात्मक निर्देशांक का उपयोग करते हैं, झांकते हैं पूर्णांक होते हैं।

≡Σδ

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

¹+

यदि एक्सट्रूज़न केवल एक दिशा में ओवरलैप होता है तो यह एक बाहरी कोने है और हमें आउटपुट करने की आवश्यकता है +।

²§ |-/⁺⌕δ¹⌕⮌δ¹¦

यदि एक्सट्रूज़न दो दिशाओं में ओवरलैप होता है तो यह एक बाहरी किनारा है। किस तरह का किनारा दो ओवरलैप्स के बीच अलगाव से निर्धारित होता है; 6 और 7 पीछे के किनारों हैं और ओवरराइट हो जाएंगे, 4 एक विकर्ण किनारे है, 2 एक ऊर्ध्वाधर किनारा है और 1 एक क्षैतिज किनारा है। (मैं वास्तव में 7 मिनट की जुदाई की गणना करता हूं क्योंकि ऐसा करना आसान लगता है।)

³+

यदि एक्सट्रूज़न तीन दिशाओं में ओवरलैप होता है, तो यह उस मामले में एक आंतरिक कोने है जहां एक्सट्रूज़न में से एक शून्य है और हमें उत्पादन करने की आवश्यकता है +।

⁴§ +Σ…δ⁴¦

यदि एक्सट्रूज़न चार दिशाओं में ओवरलैप होता है, तो दो मामले हैं: चेहरे (किसी भी दिशा), और तीन सकारात्मक विस्तार के साथ मामले में आंतरिक कोने। बाद के मामले में दर्शक की ओर विषम संख्या में ओवरलैप होते हैं।

⁶§ |-/⌕δ⁰

यदि एक्सट्रूज़न छह दिशाओं में ओवरलैप होता है तो यह एक आंतरिक किनारा है। यह बाहरी छोर के पूरक की तरह काम करता है, सिवाय इसके कि हम केवल तब रुचि रखते हैं जब दो खाली स्थानों में से एक आंख बिंदु (सरणी में अंतिम प्रविष्टि) की दिशा हो।

Answer 5

के (ngn / k) , 172 बाइट्स

{s:1+|/'i-:&//i:1_--':1_4#!#'2*:\a:16!29!1+2/(!3){+'+x}/'{2+':''1+':'0=':x}'{++'x}\6{+'+0,|x}/{6}#{3}#'{2}#''s#1<+/x=!s:1+2*x;" |+/+ +-? ??? ++"s#@[&*/s;s/i;{x+y*~x};,//a]}

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

अनिवार्य कश्मीर मेरे apl समाधान के फिर से लिखना

समान एल्गोरिथ्म, सिवाय इसके कि 3 डी-> 2 डी रेंडरिंग (के बराबर के साथ) तितर अनुक्रमणिका असाइनमेंट के बजाय प्रत्येक 3 डी तत्व के लिए 2 डी मैट्रिसेस बनाने और उन्हें मिश्रण करने के लिए किया जाता है।

Comments

ngn/aplआपके Dyalog APLसमाधान की तुलना में आपका इत्र कैसे होगा ?

— गैलेन इवानोव

@GalenIvanov यह एक निष्पक्ष तुलना नहीं होगी, क्योंकि मेरी एपीएल समाधान में मैं स्मृति का एक बहुत बर्बाद कुछ बाइट्स को बचाने के लिए, और कश्मीर में कम तेजी से इस मामले में होता है

— NGN

मैंने दो APL समाधानों के बीच तुलना के बारे में पूछा - तुम्हारा APL / Dyalog एक और ngn / apl में एक काल्पनिक समाधान

— Galen Ivanov

उफ़, मुझे नहीं पता कि मैंने क्यों पढ़ा कि "ngn / k" के रूप में ... यह फिर से अनुचित है - ngn / apl hobbyist जावास्क्रिप्ट है, dyalog पेशेवर है c

— ngn

@GalenIvanov शायद नहीं। ngn / apl हाल ही में भाषा को रैंक ऑपरेटर ( ⍤) और स्टैंसिल ( ⌺) की तरह याद कर रहा है

— ngn