Meydan okuma

Bir 11x11 tamsayı dizisi alan bir program yazın ve dizideki her değerin, dizinin konumu ile eşleşen koordinatlardaki bir blok sütununun yüksekliğini temsil ettiği bir 3D ASCII blok yapısı oluşturur. Negatif yükseklik "kayan" bir sütundur - yalnızca üst blok görünür.

Örnek

                                                        __________________
                                        ___            /\__\__\__\__\__\__\
 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,           \/\__\   \/__/__/__/__/       \/\__\
                                             \/\__\_________         ______\/\__\
                                              \/\__\__\__\__\       /\__\__\__\__\
                                               \/__/__/__/__/       \/__/__/__/__/

Giriş

Giriş, ya stdin'den okunan (ayırıcı seçimi size bağlıdır) ya da bir dizi olarak iletilen (1D veya 2D olabilir) bir 121 tamsayı listesi olacaktır.

Yükseklikler -11 ile 11 arasında olacaktır.

Çıktı

Üretilen bina stdout'a yazılabilir, doğrudan ekranda görüntülenebilir veya yeni satırlarla ayrılmış bir dizge olarak döndürülebilir.

Lider ve takip eden boşluklara izin verilir.

Bina Kuralları

Tek tek bir 3D bloğun şekli şöyle görünür:

 ___
/\__\
\/__/

Ve 2x2x2'lik blok küpler şöyle görünür:

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

Bloklar üst üste geldiğinde, daha yüksek bir blok daha alçak olandan öncelikli olur, öndeki bloklar arkadakilerden daha önceliklidir ve sola doğru olan bloklar sağdan daha önceliklidir. Tek özel durum, bir bloğun üst satırının arkasında hiçbir boşluk olmayan karakterin üzerine yazmaması gerektiğidir.

Sütun yüksekliklerinin yorumlanması en iyi, yandan bir 2D gösterime bakarak açıklanabilir.

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

Test Kılıfları

Eğer birkaç tane daha girdilere çözümünüzü denemek isterseniz, ben birlikte test durumları bir çift koyduk burada .

Kazanan

Bu kod-golf , bu yüzden en kısa teslim (bayt cinsinden) kazanır.

Kömür , 70 69 68 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

≔Ｅ¹¹⮌Ｉ⪪Ｓ,θ

Diziyi okuyun, her satırı virgülle ayırın ve tamsayıya dönüştürün, ancak aynı zamanda her satırı tersine çevirin; çünkü sağdan sola çizmek istiyoruz; (Diğer boyutlar zaten üzerine yazma davranışı istedi.)

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

İ) üst çizgileri ve gövdeleri k) yükseklik l) satırlar m) sütunlardan geçirin. (Önce üst satırlarda ve sonra gövdelerde döngü, üst satırlarda gövdelerin üzerine yazmaktan kaçınır.)

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

Küp konumuna atla.

≔§§θλμη

Yüksekliği geçerli satır ve sütunda al.

¿∨⁼±η⊕κ‹κη

Bir küpün bu satır ve sütun için bu yükseklikte çizilmesi gerekip gerekmediğini test edin.

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

Küpün gövdesini veya üstünü çizin.

C,  376   350   313   309  285 bayt

Dört byte tasarrufu için @ Jonathan Frech'e teşekkürler!

#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);}

Çevrimiçi deneyin!

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);
}

JavaScript (ES6), 277 251 bayt

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`
`)

f=

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`
`)

console.log(f([
	[3, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11],
	[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, 11]
]))

@ Neil'in önerisinden 26 bayt kaydedildi .

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`
)

Python 2,243 bayt

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)

Çevrimiçi deneyin!

Neil'in Kömür Yaklaşımı yaklaşımının Python çevirisi.

APL (Dyalog Unicode) , 117 116 112 bayt ^SBCS

a←23 55⍴0⋄{i←11 0+⍵+.×3 2⍴3-7897⊤⍨6⍴5⋄(,2 5↑i↓a)←745366⊤⍨10⍴4⋄(3⍴i↓1⌽¯1⊖a)⌈←1}¨j[⍋-/↑j←⍸↑⎕↑¨⊂⌽1,11/⍳2]⋄' _/\'[a]

Çevrimiçi deneyin!

Tcl, 380 409 bayt

Kullanıcı sergiol bu çok güzel aşağı kırma meşguldü:

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]]]

Çevrimiçi deneyin!

Orijinal İçerik

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]]]

Çevrimiçi deneyin!

Ne yazık ki, budur. “Bağlanamadığında” sadece gözler için biraz daha kolay

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

Gereksinimlere göre bir dize oluşturur. Diziyi stdin'den alır. Dize verileri üzerinde aşağıdan yukarıya, önden arkaya, sağdan sola gider. İki seferde, bir kez üst kenar için ve yine her bir küpün gövdesinin geri kalanı için.

Bazı tatlı fonksiyonel lambda mojo'yu kullanarak daha küçük yapmaya çalıştım, ama ne yazık ki, onu büyütdü.