3 डी ASCII ब्लॉक बिल्डिंग

82

चुनौती

एक प्रोग्राम लिखें जो 11x11 सरणी के पूर्णांक लेता है, और एक 3 डी ASCII ब्लॉक बिल्डिंग का निर्माण करता है, जहां सरणी में प्रत्येक मान सरणी स्थिति से मेल खाने वाले निर्देशांक पर ब्लॉक के एक स्तंभ की ऊंचाई का प्रतिनिधित्व करता है। एक नकारात्मक ऊंचाई "फ्लोटिंग" कॉलम है - केवल शीर्ष ब्लॉक दिखाई देता है।

उदाहरण

                                                        __________________
                                        ___            /\__\__\__\__\__\__\
 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,      /\__\          /\/\__\__\__\__\__\__\
 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,     /\/__/         /\/\/__/__/__/__/__/__/
 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /\/\__\        /\/\/\__\      /\/\/__/
 1, 0, 0, 7,-7,-7,-7,-7, 7, 0, 0,    \/\/\__\      /\/\/\/__/     /\/\/__/
 0, 0, 0, 7,-7,-7,-7,-7, 7, 0, 0,     \/\/__/     /\/\/\/\__\    /\/\/__/
 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0,      \/\__\    /\/\/\/\/__/   /\/\/__/
 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0,       \/__/    \/\/\/\/\__\_  \/\/__/
 1, 0, 0, 4, 3, 2, 1, 0, 0, 0, 1,                 \/\/\/\/__/_\_ \/__/
 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,            ___   \/\/\/__/__/_\_         ___
 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,           /\__\   \/\/__/__/__/_\       /\__\
 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,           \/\__\   \/__/__/__/__/       \/\__\
                                             \/\__\_________         ______\/\__\
                                              \/\__\__\__\__\       /\__\__\__\__\
                                               \/__/__/__/__/       \/__/__/__/__/

इनपुट

इनपुट 121 पूर्णांकों की एक सूची होगी, या तो स्टडिन (विभाजक का विकल्प आप पर निर्भर है) से पढ़ा जाता है, या एक सरणी (1 डी या 2 डी हो सकता है) के रूप में पारित किया गया है।

ऊंचाई -11 से 11 के बीच होगी।

उत्पादन

उत्पन्न इमारत को stdout को लिखा जा सकता है, स्क्रीन पर सीधे प्रदर्शित किया जा सकता है, या एक नई-लाइन-अलग स्ट्रिंग के रूप में वापस आ सकता है।

अग्रणी और अनुगामी व्हाट्सएप की अनुमति है।

भवन नियम

एक व्यक्ति 3D ब्लॉक का आकार इस तरह दिखता है:

 ___
/\__\
\/__/

और ब्लॉकों का एक 2x2x2 घन इस तरह दिखता है:

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

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

कॉलम हाइट्स की व्याख्या को एक ओर से 2 डी प्रतिनिधित्व को देखकर समझाया जा सकता है।

HEIGHT:  1    2    3   -3   -2   -1
                  __   __
             __  |__| |__|  __
        __  |__| |__|      |__|  __
       |__| |__| |__|           |__|

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

यदि आप कुछ और इनपुट्स पर अपने समाधान की कोशिश करना चाहते हैं, तो मैंने कुछ परीक्षण मामलों को एक साथ रखा है ।

जीतना

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

code-golf  ascii-art 
— जेम्स होल्डरनेस
स्रोत
9
ओह लड़का, 300+ बाइट समाधान के लिए तैयार हो जाओ। अच्छी चुनौती। +1
— पूरी तरह से
7
@totallyhuman नाह, डेनिस 20 मिनट में इसके लिए 9-बाइट समाधान करने जा रहा है।
— डीकन
3
क्या परिप्रेक्ष्य को अग्रभूमि में इनपुट डेटा के नीचे बाईं ओर दिखाया गया है? तथ्य यह है कि यह डेटा का पहला या अंतिम तत्व नहीं है। क्या यह या तो 1. स्वीकार्य है और मानचित्रण को बनाए रखें और अग्रभूमि में नीचे दाएं स्तंभ के साथ आउटपुट खींचें या 2. दर्पण छवि या डेटा के 90 नीचे रोटेशन को आकर्षित करें? इनमें से कोई भी अंतिम डेटा तत्व अग्रभूमि में कॉलम के साथ मेल खाएगा, जो आसान होगा।
— लेवल रिवर सेंट
3
मैं एक वास्तविक गेम इंजन (या उसके हिस्से का) का उपयोग करने के लिए एक तस्वीर रेंडर करने और ASCII में बदलने के लिए इच्छुक महसूस करता हूं
— स्टेन स्ट्रम
@LevelRiverSt जो एक उचित अनुरोध की तरह लगता है - आप 121 इनपुट तत्वों के क्रम को चुन सकते हैं कि आपके समाधान के लिए सबसे अधिक समझ में आता है, जब तक कि आपका आदेश सुसंगत है। प्रत्येक प्रकार के लेआउट का उत्पादन करना संभव है जो डिफ़ॉल्ट आदेश के साथ उत्पादित किया जा सकता है।
— जेम्स होल्डरनेस

जवाबों:

25

चारकोल , 70 69 68 बाइट्स

≔Ｅ¹¹⮌Ｉ⪪Ｓ,θＦ²Ｆ¹¹Ｆ¹¹Ｆ¹¹«Ｊ⁻⁻⁺λκ×μ³ι⁻λκ≔§§θλμη¿∨⁼±η⊕κ‹κη¿ι“↗⊟&⁹κＵhnI”___

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

≔Ｅ¹¹⮌Ｉ⪪Ｓ,θ

एरे को पढ़ें, प्रत्येक लाइन को कॉमा पर विभाजित करें और पूर्णांक पर कास्ट करें, लेकिन प्रत्येक पंक्ति को भी उल्टा करें, क्योंकि हम दाएं-से-बाएं आकर्षित करना चाहते हैं ताकि बाएं कॉलम दाएं कॉलम को अधिलेखित कर दें। (अन्य आयामों में पहले से ही अधिलेखित व्यवहार है।)

Ｆ²Ｆ¹¹Ｆ¹¹Ｆ¹¹«

I लूप के माध्यम से) शीर्ष रेखाएँ और निकायों k) ऊँचाई l) पंक्तियाँ m) कॉलम। (पहले शीर्ष लाइनों के माध्यम से लूपिंग और फिर निकाय शीर्ष लाइनों के साथ ओवरराइटिंग बॉडी से बचते हैं।)

Ｊ⁻⁻⁺λκ×μ³ι⁻λκ

घन की स्थिति के लिए कूदो।

≔§§θλμη

वर्तमान पंक्ति और स्तंभ पर ऊँचाई प्राप्त करें।

¿∨⁼±η⊕κ‹κη

परीक्षण करें कि क्या इस पंक्ति और स्तंभ के लिए इस ऊंचाई पर एक क्यूब खींचा जाना चाहिए।

¿ι“↗⊟&⁹κＵhnI”___

शरीर या क्यूब के ऊपर ड्रा करें।

— नील
स्रोत
जब मैं पहली बार 3ए में बदलता हूं 33, तो मुझे टॉवर में केवल 11 ब्लॉक मिलते हैं। सामान्य टावरों में 11 पर छाया हुआ लगता है। यह कैसे होता है?
— फाबियान रोलिंग
@ फ़ेबियन मैं थोड़ा उलझन में हूँ कि Ｆ¹¹Ｆ¹¹Ｆ¹¹एक सुराग नहीं था ...
— नील
मैं इस प्रोग्रामिंग भाषा को नहीं जानता, मैंने टीआईओ लिंक के साथ बस थोड़ा सा खेला।
— फाबियान रोलिंग
30

सी,  376   350   313   309  285 बाइट्स

चार बाइट बचाने के लिए @ जोनाथन फ्रीच को धन्यवाद!

#define F for(
char*t,G[26][67],*s;i,j,e,k,v,x,y;b(){F s="\\/__//\\__\\ ___ ";*s;--y,s+=5)F e=5;e--;*t=*s<33&*t>32?*t:s[e])t=G[y]+x+e;}f(int*M){F;e<1716;++e)G[e/66][e%66]=32;F k=0;++k<12;)F i=0;i<11;++i)F j=11;j--;v+k||b())x=i+j*3+k,y=14+i-k,(v=M[i*11+j])>=k&&b();F;++e<26;)puts(G+e);}

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

unrolled:

#define F for(

char *t, G[26][67], *s;
i, j, e, k, v, x, y;

b()
{
    F s="\\/__//\\__\\ ___ "; *s; --y, s+=5)
        F e=5; e--; *t=*s<33&*t>32?*t:s[e])
            t = G[y]+x+e;
}

f(int*M)
{
    F; e<1716; ++e)
        G[e/66][e%66] = 32;

    F k=0; ++k<12;)
        F i=0; i<11; ++i)
            F j=11; j--; v+k||b())
                x = i+j*3+k,
                y = 14+i-k,
                (v=M[i*11+j])>=k && b();

    F; ++e<26;)
        puts(G+e);
}
— Steadybox
स्रोत
कर सकते हैं 26*66नहीं हो 1716?
— जोनाथन फ्रीच
@JonathanFrech ज़रूर, मैं उस बारे में भूल गया।
— स्टेडियोबॉक्स
*s==32-> *s<33।
— जोनाथन फ्रेच
for(e=k=1;e;++k)for(e=-> for(k=1;e;++k)for(e=।
— जोनाथन फ्रीच
#define B b(...)&++e-> #define B++e&b(...)(यह bनिर्भर नहीं करता है e, जो मुझे लगता है कि यह नहीं है)।
— जोनाथन फ्रीच
9

जावास्क्रिप्ट (ईएस 6), 277 251 बाइट्स

a=>(n=55,$=f=>[...Array(n)].map((_,i)=>f(i)),S=$(_=>$(_=>' ')),n=11,$(l=>$(z=>$(y=>$(x=>(x=10-x,X=x*3+y+z,Y=y-z+n,Z=a[y][x])<=z&&Z+z+1?0:l?['/\\__\\','\\/__/'].map(s=>S[++Y].splice(X,5,...s)):S[Y].splice(X+1,3,...'___'))))),S.map(r=>r.join``).join`
`)

कोड स्निपेट दिखाएं

@ नील के सुझाव से 26 बाइट्स बचाए ।

Ungolfed

a=>(
    n=55,
    $=f=>[...Array(n)].map((_,i)=>f(i)),
    S=$(_=>$(_=>' ')),
    n=11,
    $(l=>
        $(z=>$(y=>$(x=>(
            x=10-x,
            X=x*3+y+z,
            Y=y-z+n,
            Z=a[y][x],
            Z<=z && Z+z+1 || (
                l
                ? ['/\\__\\','\\/__/'].map(s=>S[++Y].splice(X,5,...s))
                : S[Y].splice(X+1,3,...'___')
            )
        ))))
    ),
    S.map(r=>r.join``).join`\n`
)
— darrylyeo
स्रोत
2
,$(w=>$(z=>$(y=>$(x=>(Z=a[y][x=10-x,X=x*3+y+z,Y=y-z+n,x])<=z&&Z+z+1?0:w?['/\\__\\','\\/__/'].map(s=>S[++Y].splice(X,5,...s)):S[Y].splice(X+1,3,...'___'))))),26 बाइट्स बचाने के लिए लगता है।
— नील
@ नील शानदार! पहले सभी शीर्ष रेखाओं को खींचना मुझे गैर-रिक्त स्थान के लिए जाँच करने की परेशानी से बचाता है।
— darrylyeo
6

पायथन 2 , 243 बाइट्स

a=input()
s=eval(`[[' ']*55]*23`)
for h in range(7986):
 k=h%3;x=h/3%11;y=h/33%11;z=h/363%11;i=h/3993;u=y+z-x*3+30;v=y-z+10
 if~-(z>=a[y][10-x]!=~z):
	if i*k:s[v+k][u:u+5]='\//\____/\\'[k%2::2]
	if~-i:s[v][u+1+k]='_'
for l in s:print''.join(l)

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

नील के चारकोल दृष्टिकोण का एक पायथन अनुवाद।

— लिन
स्रोत
इसके लिए एक गोल्फ वाले पायथन समाधान को देखकर अच्छा लगा। मेरा पायथन प्रूफ-ऑफ-कॉन्सेप्ट 900 से अधिक बाइट्स था!
— जेम्स होल्डरनेस
3
+1+k-> -~k।
— जोनाथन फ्रीच
5

Tcl, 380 409 बाइट्स

उपयोगकर्ता सेरगिओल को बहुत अच्छी तरह से नीचे गिराने में व्यस्त है:

set X [read stdin]
proc L {a b c d e s} {time {incr z
set y -1
time {incr y
set x -1
time {if {abs([set Z [lindex $::X [expr ($y+1)*11-[incr x]-1]]])==$z|$z<$Z} {set s [string repl [string repl $s [set i [expr -3*$x+57*$y-55*abs($z)+701]] $i+$b $a] [incr i $c] $i+$e $d]}} 11} 11} 12
set s}
puts [L /\\__\\ 4 56 \\/__/ 4 [L "" -1 -55 ___ 2 [string repe [string repe \  55]\n 23]]]

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

मूल सामग्री

set xs [read stdin]
proc L {a b c d e s} {set z 0
while {[incr z]<12} {set y -1
while {[incr y]<11} {set x -1
while {[incr x]<11} {set Z [lindex $::xs [expr ($y+1)*11-$x-1]]
if {abs($Z)==$z||$z<$Z} {set i [expr -3*$x+57*$y-55*abs($z)+701]
set s [string repl [string repl $s $i $i+$b $a] [incr i $c] $i+$e $d]}}}}
set s}
puts [L /\\__\\ 4 56 \\/__/ 4 [L "" -1 -55 ___ 2 [string repe [string repe \  55]\n 23]]]

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

काश, यह वही है जो यह है। यह आंखों पर केवल एक आसान है जब "ungolfed"

set s [string repeat [string repeat " " 55]\n 23]

proc loops {s0 i0 io s1 i1} {
  set z  0; while {[incr z] < 12} {
  set y -1; while {[incr y] < 11} {
  set x -1; while {[incr x] < 11} {
    set Z [lindex $::xs [expr {($y+1) * 11 - $x - 1}]]
    if {abs($Z) == $z || $z < $Z} {
        set i [expr {-3*$x + 57*$y - 55*abs($z) + 701}]
        set ::s [string replace $::s $i $i+$i0 $s0]
        incr i $io
        set ::s [string replace $::s $i $i+$i1 $s1]
    }
  } } }
}

loops ""      -1 -55 \
       ___     2
loops /\\__\\  4  56 \
      \\/__/   4

puts $s

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

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

— Dúthomhas
स्रोत
आप गोल्फ कर सकते हैं: tio.run/…
— सेरगिओल
अधिक गोल्फिंग: tio.run/…
— सर्गियोल
More: tio.run/…
— sergiol
फिर भी अधिक: tio.run/…
— सेरगिओल
अभी तक: tio.run/##lVHtboJAEPx/…
— सेरगिओल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.