एक ASCII घनाकार ड्रा

Question

तीन पूर्णांक> = 2 को देखते हुए, एक ऑर्थोगोनल (कैबिनेट) प्रक्षेपण में एक ASCII घन बनाएं। तीन पूर्णांक कोनों सहित ऊंचाई, चौड़ाई और गहराई (दृश्यमान वर्णों में मापा गया) का प्रतिनिधित्व करते हैं। कोनों को 'ओ'स या' + ', फ्री चॉइस होना चाहिए।

डब्ल्यू: १०, एच: ५, डी: ४ इस प्रकार देता है:

   o--------o
  /        /|
 /        / |
o--------o  |
|        |  o
|        | /
|        |/
o--------o

अब, इसे थोड़ा कठिन बनाने के लिए, सभी चेहरे या तो ठोस, पारदर्शी या गायब हो सकते हैं। हम इस तरह चेहरे का आदेश देते हैं:

   o--------o
  /        /|
 /    2   / |
o--------o 3|
|        |  o
|   1    | /
|        |/
o--------o

  ---
  |2|
-------
|5|1|3|
-------
  |4|
  ---
  |6|
  ---

और टोकन, एस, टी या एम की सूची की आपूर्ति करें। मूल उदाहरण इस प्रकार है:

w 10
h 5
d 4
S S S S S S

   o--------o
  /        /|
 /        / |
o--------o  |
|        |  o
|        | /
|        |/ 
o--------o

यदि एक चेहरा पारदर्शी है, तो हम उसके पीछे कुछ भी देख सकते हैं:

T S S S S S

   o--------o
  /        /|
 /        / |
o--------o  |
|  o-----|  o
| /      | /
|/       |/
o--------o


T T T T T T

   o--------o
  /|       /|
 / |      / |
o--------o  |
|  o-----|--o
| /      | /
|/       |/
o--------o

लापता चेहरे के जोड़े के लिए, आसन्न किनारे या कोने अब दिखाई नहीं देते हैं:

M M S S S S

   o--------o
  /|       /|
 / |      / |
o  |     o  |
|  o-----|  o
| /      | /
|/       |/
o--------o

M M S S M S

   o--------o
   |       /|
   |      / |
   |     o  |
   o-----|  o
  /      | /
 /       |/
o--------o

कोड गोल्फ, सबसे छोटा कोड जीतता है! ट्रेलिंग स्पेस और न्यूलाइन्स ठीक हैं, आप इनपुट विधि और इनपुट ऑर्डर चुनने के लिए स्वतंत्र हैं।

Comments

आपका इनपुट प्रारूप कितना सख्त है? क्या मैं 9 मापदंडों के साथ एक फ़ंक्शन बना सकता हूं?

— लिफडेविन

@LiefdeWen you're free to choose input method and input order। और जैसा कि कुछ भी नहीं कहता अन्यथा, किसी भी डिफ़ॉल्ट इनपुट / आउटपुट विधियों का उपयोग किया जा सकता है।

— द्विजिमा

क्या मैं पारदर्शी / ठोस झंडे के लिए बिटमैप के रूप में पूर्णांक ले सकता हूं?

— टाइटस

@ ठीक है .. ठीक है। मुझे लगता है कि यह थोड़ा अधिक मनोरंजक है यदि आप वास्तव में अपने स्वयं के मूल्यों का परीक्षण कर सकते हैं।

— निकोलस

Answer 1

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

ＮωＡ⁻ω²ςＮηＡ⁻η²γＮδＡ⁻δ²χＡ⪪Ｓ αＦ›⊟αMＦ⟦ςγςγ⟧«oκ↶»Ｆ∧›⊟αM²«oς↷³oχ↷¹»Ｆ∧›⊟αM²«↷³oχ↷³oγ↶»Ｍ⁻ωδ⁻δηＦ⁼§α²SＧ↗δ↓η↙δ↑η Ｆ∧›⊟αM²«↶¹oχ↷³oγ↷»Ｆ⁼§α¹SＧ↗δ←ω↙δ→ω Ｆ∧›⊟αM²«↶¹oχ↶³oς»Ｆ⁼§α⁰SＵＯ±ωη ↷Ｆ›⊟αMＦ⟦γςγς⟧«oκ↷

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: मेरी स्थितियों का अनुकूलन करके 9 बाइट्स सहेजे गए। चारकोल का कोई elseटोकन नहीं है , इसलिए ifकमांड में हमेशा दो विकल्प होते हैं, जब तक कि वे एक ब्लॉक या प्रोग्राम के अंत में न हों। इससे बचने के लिए, मैं for (<bool>)इसके बजाय उपयोग करता हूं if (<bool>)जिसका एक समान प्रभाव पड़ता है जब अभिव्यक्ति केवल 0 या 1 मान हो सकती है, लेकिन एक बाइट बचाता है। (इसे प्राप्त करने के लिए मुझे अभिव्यक्तियों को बदलना पड़ा ताकि शरीर को निष्पादित करने की आवश्यकता होने पर वे हमेशा सही हों।) मैं भी अनुकूलन करने if (<bool>) for (<int>)में सक्षम था for (And(bool, int))।

Comments

पवित्र मसीह O_O। मैं यह भी पता नहीं लगा सका कि चारकोल का उपयोग करके क्यूब को कैसे खींचना है। क्या आप जीथब उदाहरण फोल्डर पर एक साधारण घन खींचने के लिए एक उदाहरण रख सकते हैं? एक है कि अनुकूलित किया गया है? मैं अपनी तरह की तुलना करना चाहता हूं ... 50 बाइट का जवाब है कि यह क्या होना चाहिए था।

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

@carusocomputing क्षमा करें, मैं स्पष्ट नहीं हूँ कि आप "सरल घन" से क्या मतलब है, और मैं खुद चारकोल का लेखक नहीं हूं, इसलिए मैं एक उदाहरण नहीं जोड़ सकता।

— नील

तुम नहीं कर रहे हैं ?! पवित्र बकवास, कौन है? मैंने ईमानदारी से सोचा था कि आप थे। इसके अलावा, मैं एक चारकोल योगदानकर्ता बनने के लिए कहूंगा। आप आसानी से जीथब पर एक बन सकते हैं :)। आप स्पष्ट रूप से भाषा में प्रतिभाशाली हैं। और "सरल घन" से मेरा मतलब चुनौती का पहला भाग है, बस एक X * Y * Z ASCII घन बना रहा है।

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

@carusocomputing ASCII- केवल मुख्य योगदानकर्ता है जहाँ तक मैं बता सकता हूँ, हालांकि एसोलंग विकी एक दूसरे योगदानकर्ता को श्रेय देता है।

— नील

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

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

Answer 2

जावास्क्रिप्ट (ईएस 6), 318 314 308 बाइट्स

चौड़ाई, ऊंचाई और गहराई को पूर्णांक और वर्णों के एक सरणी के रूप में लेता है।

(w,h,d,l,M=(n,F)=>[...Array(n+1).keys()].map(F),a=M((L=w--+d)*(h--+--d),i=>++i%L?' ':`
`),D=(t,Y=0,X=d,W=t&1?d:w,H=t&2?d:h,F=l[t>>2])=>F>'R'&&M(W,i=>M(H,j=>a[p=L*(Y+j-i*(t&1))+X+i-(t&2?j:0)]=(x=!(i&&i-W)|2*!(j&&j-H))?' |-o|/o/-o'[t%4*3+x]:a[F>'S'?p:0])))=>D(20)&D(D(14,h)&D(17,d,0),d,D(9,d,w)&D(6))||a.join``

कैसे?

फ़ंक्शन M () किसी दिए गए रेंज पर दिए गए कॉलबैक F को प्रोसेस करता है [0 ... n] ।

M = (n, F) => [...Array(n + 1).keys()].map(F)

चर एक एक फ्लैट सरणी आकार का एक ग्रिड का प्रतिनिधित्व रखती है (w + घ) एक्स (ज + डी -1) । यह आरंभ में रिक्त स्थान की पंक्तियों से भरा हुआ है जिसे नई-नई लाइनों के साथ समाप्त किया गया है।

a = M((L = w-- + d) * (h-- + --d), i => ++i % L ? ' ' : '\n')

फ़ंक्शन D () का उपयोग क्यूबॉइड के एक चेहरे को 'आकर्षित' करने के लिए किया जाता है।

दो पैरामीटर के कम से कम महत्वपूर्ण बिट टी चेहरा प्रकार पकड़:

• 0 = रियर / फ्रंट
• 1 = बाएं / दाएं
• 2 = नीचे / ऊपर

बिट्स # 2 से # 4 0-आधारित फेस इंडेक्स को धारण करते हैं।

D = (                                           // given:
  t, Y = 0, X = d,                              // - the type and the initial coordinates
  W = t & 1 ? d : w,                            // - the drawing width
  H = t & 2 ? d : h,                            // - the drawing height
  F = l[t >> 2]                                 // - the character representing the status
) =>                                            //
  F > 'R' &&                                    // provided that the face is not missing:
  M(W, i =>                                     // for each i in [0...W]:
    M(H, j =>                                   //  for each j in [0...H]:
      a[                                        //    update the output
        p = L * (Y + j - i * (t & 1)) +         //    at position p
            X + i - (t & 2 ? j : 0)             //
      ] =                                       //    with either:
      (x = !(i && i - W) | 2 * !(j && j - H)) ? //    - '|', '-' or '/' on edges
        ' |-o|/o/-o'[t % 4 * 3 + x]             //    - or 'o' on vertices
      :                                         //
        a[F > 'S' ? p : 0]                      //    - or a space on solid faces
    )                                           //    - or the current character on
  )                                             //      transparent faces

निम्नलिखित क्रम में चेहरे तैयार किए गए हैं:

D(5 * 4 + 0, 0, d)  // face #5 (rear)
D(3 * 4 + 2, h, d)  // face #3 (bottom)
D(4 * 4 + 1, d, 0)  // face #4 (left)
D(2 * 4 + 1, d, w)  // face #2 (right)
D(1 * 4 + 2, 0, d)  // face #1 (top)
D(0 * 4 + 0, d, 0)  // face #0 (front)

डेमो

let f =

(w,h,d,l,M=(n,F)=>[...Array(n+1).keys()].map(F),a=M((L=w--+d)*(h--+--d),i=>++i%L?' ':`
`),D=(t,Y=0,X=d,W=t&1?d:w,H=t&2?d:h,F=l[t>>2])=>F>'R'&&M(W,i=>M(H,j=>a[p=L*(Y+j-i*(t&1))+X+i-(t&2?j:0)]=(x=!(i&&i-W)|2*!(j&&j-H))?' |-o|/o/-o'[t%4*3+x]:a[F>'S'?p:0])))=>D(20)&D(D(14,h)&D(17,d,0),d,D(9,d,w)&D(6))||a.join``

let update = _ => O.innerHTML = f(W.value, H.value, D.value, [...F.value])
update()

<label>Width <input id="W" size="3" value="10" oninput="update()" /></label>
<label>Height <input id="H" size="3" value="5" oninput="update()" /></label>
<label>Depth <input id="D" size="3" value="4" oninput="update()" /></label>
<label>Faces <input id="F" size="6" value="MMSSMS" oninput="update()" /></label>
<pre id="O"></pre>

Answer 3

SOGL V0.11 , 200 194 193 192 190 बाइट्स

b³@*⁶
ž}1}X⁵
;aκ⁴
2-³
* o1Ο²
d=?a³:?∫:¹
be.Aā6∫D,ζLI%:C?abe"DCa∫:c+H⁴d+ /ž}{"a+Hy"e³┐²čž|"b³┌²žz"EBAøp”,ōkB°s9θW=*↑(⅜⅞~υ=\⁰ōwūΧ►ΣΤP░¶Ο⁽◄Φ7⅟▲s#‘┌Θdwι+#¶ŗ!!6c=?6d=?2aI⁶e³∙ž}5¹b+⁴Ie³@∙⁵}4¹2+⁴⁶⁵

आदेश में इनपुट लेता है

width
height
depth
down-face
left-face
back-face
top-face
right-face
front-face

बंधे!
यह कोशिश करो! (संपीडित मूल्य V0.12 संगत हो गया)