Triforce kurgusal eserdir Legend of Zelda gücü, bilgelik ve cesaret temsil eden üç-özdeş görünümlü eşkenar üçgen yapılmış. Efsanedeki birkaç oyun, üç bölüm nihayet bir araya geldiğinde bir animasyon içeriyor.

Bu zorluğun amacı, üçgenler için belirli bir genişliğe ve parçalar arasında belirli bir boşluğa sahip, bu tür basitleştirilmiş bir animasyonun tek bir 2B karesini çizmektir.

Giriş

Giriş iki tamsayıdan oluşur: genişliği ve boşluk değeri .s ≥ $w\ge1$$s\ge0$

Çıktı

Çerçeve aşağıdaki özelliklere göre çizilmelidir:

         /\
        /  \____________ this part is horizontally centered
       /    \
      /______\
                    \___ s empty lines
                    /
   /\          /\
  /  \        /  \______ w+1 backslashes
 /    \      /    \
/______\    /______\
                \_______ 2w underscores
        |__|
          \_____________ 2s spaces

Yukarıdaki örnekte, ve .s = $w=3$$s=2$

Daha fazla örnek

$w=1$ , :$s=0$

   /\   
  /__\  
 /\  /\ 
/__\/__\

s = $w=2$ , :$s=0$

     /\     
    /  \    
   /____\   
  /\    /\  
 /  \  /  \ 
/____\/____\

s = $w=3$ , :$s=3$

          /\          
         /  \         
        /    \        
       /______\       



   /\            /\   
  /  \          /  \  
 /    \        /    \ 
/______\      /______\

s = $w=4$ , :$s=1$

          /\          
         /  \         
        /    \        
       /      \       
      /________\      

    /\          /\    
   /  \        /  \   
  /    \      /    \  
 /      \    /      \ 
/________\  /________\

kurallar

• Her satırdaki arka boşluklar isteğe bağlıdır.
• Her satırda fazladan boşluk olması yasaktır.
• Tek bir ekstra öncü yeni hat ve / veya bir tane ekstra sondaki yeni hat çıkartabilirsiniz.
• Bu kod golfü .

Python 2 , 197 194 169 167 155 144 bayt

w,s=input()
l=['']*(2*-~w+s)
for i in range(-~w):W=w-i;b='/'+'_ '[i<w]*2*i+'\\';l[i::w-~s]=' '*(w+s-~W)+b,' '*W+b+'  '*(W+s)+b
print'\n'.join(l)

Çevrimiçi deneyin!

Kaydedilen:

• Bay Xcoder sayesinde -3 bayt

Kömür , 25 bayt

←×_Ｎ↗⊕θ‖Ｍ≔⁺⊕θＮηＣη±η‖ＢＯ⊗⊕θ

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

←×_Ｎ

Girdi wve w _s çizin .

↗⊕θ

S çiz w+1 /.

‖Ｍ

İlk üçgeni tamamlamayı düşünün.

≔⁺⊕θＮη

sSol ve orta üçgenler arasındaki dengeyi girin ve hesaplayın.

Ｃη±η

Sol üçgeni ortasına kopyalayın.

‖ＢＯ⊗⊕θ

Triforu tamamlamak için orta üçgenin çevresini yansıtın.

Python 2 , 127 124 bayt

w,s=input()
n=2*-~w+s
while n:n-=1;I=w-n+(n>w)*(w-~s);print' '*n+('  '*(n+s)).join(['/'+I*2*' _'[I>=w]+'\\'][I>w:]*-~(n<=w))

Çevrimiçi deneyin!

Tuval , 20 19 16 bayt

＋├：⁸╵＼Ｌ_×；∔║ω╋║↕

Burada dene!

Açıklama:

+├                s + w + 2
  :               duplicated (for both X & Y)
   ⁸╵\            w+1 sized diagonal
      L_×         "_"*width of the diagonal
         ;∔       prepended before the diagonal
           ║      palindromize that
            ω     and push the argument of ║ (aka the unpalindromized version)
             ╋    overlap the upside down half-triangle over the upside down triangle at (s+w+2; s+w+2)
              ║   and palindromize the whole thing
               ↕  reverse everything vertically

not: Bunu yaparken kodunda bir hata düzelttim, Bu düzeltme olmadan, bu 18 bayt olurdu .

R , 225 , 224 , 214 , 211 , 208 bayt

function(w,s){M=matrix
C=cbind
h=w+1
k=C(apply(m<-diag(h)*60,1,rev)/4,m)
k[row(k)==h&!k]=63
z=rbind(C(a<-M(0,h,h+s),k,a),M(0,s,h*4+2*s),C(k,M(0,h,2*s),k))
z[]=intToUtf8(z+32,T)
apply(z,1,cat,sep='','
')
rm()}

Çevrimiçi deneyin!

• Giuseppe sayesinde -1 bayt
• - Yaklaşım değişikliğinden sonra 10 bayt
• ASCII kodunu açıklayan -3 bayt
• JayCe sayesinde -3 bayt

Pascal (FPC) , 296 264 bayt

const A='/';B='\';var w,s,i:word;u:string;begin read(w,s);u:=StringOfChar('_',2*w);for i:=1to w do writeln(A:w+3+s+w-i,B:i*2-1);writeln(A:w+2+s,u,B);for i:=1to s do writeln;for i:=1to w do writeln(A:w+2-i,B:i*2-1,A:2*(s+w-i)+3,B:i*2-1);write(A,u,B,A:2*s+1,u,B)end.

Çevrimiçi deneyin!

Python 2 , 256 248 240 228 199 195 bayt

Daha uzun bir program, ancak biraz farklı bir yaklaşım:

f,b,o='/\ '
O=o*2
w,s=input()
l=f+'__'*w+b
a=l+O*s+l
m=n=[]
p=lambda g:(len(a)-len(g))/2*o+g
for i in range(w):m=m+[p(f+O*i+b)];t=f+O*i+b;n+=p(t+O*(w-i+s)+t),
print'\n'.join(m+[p(l)]+[o]*s+n+[a])

Çevrimiçi deneyin!

Sondaki boşlukları görmezden gelip, @ovs'dan bazı hileler ekleyerek
daha önce bir değişkeni tanımlayarak daha fazla tasarruf sağladı.

Ruby , 126 bayt

->w,s{(-v=w+1).upto(v){|i|j= ~-i%-~v;$><<[$/*s,$/+' '*(v+s)+t="/#{(j<w ?' ':?_)*j*2}\\".center(w*2+2)+' '*s*2,$/+t*2][0<=>i]}}

Çevrimiçi deneyin!

Retina 0.8.2 , 141 bayt

\d+
$* 
(?=( *),( *))
¶$1/$`$`\$1$2$2$1/$`$`\
T` `\_`/ *\\(?=.*,)
s`¶(.*),( *)
$1¶$.2$*¶$1
\G(( *)/(  |__)*\\)\2(  )*\1 *¶
$2 $#3$* $#4$* $1¶

Çevrimiçi deneyin! Not: Çıktıdaki bazı sondaki boşluklar. Açıklama:

\d+
$* 

Girişleri boşluklara dönüştürün. (İkinci satır boşlukla bitiyor.)

(?=( *),( *))
¶$1/$`$`\$1$2$2$1/$`$`\

Alttaki iki üçgenin kenarlarını uygun aralıklarla oluşturun.

T` `\_`/ *\\(?=.*,)

Üçgenlerin tabanını doldurun.

s`¶(.*),( *)
$1¶$.2$*¶$1

Üçgenleri uygun dikey aralıklarla çoğaltın.

\G(( *)/(  |__)*\\)\2(  )*\1 *¶
$2 $#3$* $#4$* $1¶

Üstteki üçgenleri tek merkezli bir üçgene dönüştürün.

C (gcc), 404 389 bayt

#define p(x)putchar(x);
#define F for
W;S;i;a=32;b=47;c=92;f(w,s){W=w,S=s;F(;w;--w){F(i=W+w+s+1;i--;)p(a)p(b)F(i=w*2;i++-2*W;)p(a)p(c)p(10)}F(i=W+s+1;i--;)p(a)p(b)F(i=0;i++-2*W;)p(95)p(c)F(;s--+1;)p(10)F(w=W;w;--w){F(i=w;i--;)p(a)p(b)F(i=w*2;i++-2*W;)p(a)p(c)F(i=w*2+S*2;i--;)p(a)p(b)F(i=w*2;i++-2*W;)p(a)p(c)p(10)}p(b)F(i=0;i++-2*W;)p(95)p(c)F(i=S*2;i--;)p(a)p(b)F(i=0;i++-2*W;)p(95)p(c)}

Çevrimiçi deneyin!

-Rololvertice'den 14 bayt

Döngü değişkeni azaltımını sabitleyerek -1 bayt

_{404 çarpı neredeyse 404}

Ungolfed:

#define p(x)putchar(x); // save 7 bytes per putchar call (+24, -182)
#define F for // save 2 bytes per for loop (+14, -28)
int W, S, i; // W is w backup, S is s backup, i is an counter variable;
int a = ' '; // save 1 byte per space printed (+5, -8) (use a instead of 32)
int b = '/'; // save 1 byte per slash printed (+5, -6) (use b instead of 47)
int c = '\\'; // save 1 byte per backslash printed (+5, -6) (use c instead of 92)
// This isn't worth it for '\n' (-5, +3) (10), or '_' (-5, +3) (95)
int f(int w, int s) {
    W = w; // Backup w and s, as we will modify them later, 
    S = s; // but will need their original values
    for(; w != 0; --w) { // Top triangle (not the bottom line)
        for(i = W+w+s+1; i != 0; --i) // leading spaces
            putchar(' ');
        putchar('/'); // left side of triangle
        for(i = 2*w; i != 2*W; ++i) // inner spaces
            putchar(' ');
        putchar('\\'); // right side of triangle
        putchar('\n'); // newline
    }
    for(i = W+s+1; i != 0; --i)
        putchar(' '); // leading spaces for the bottom line
    putchar('/'); // left side
    for(i = 0; i != 2*W; ++i)
        putchar('_'); // the bottom line
    putchar('\\'); // right side
    for(; s-- + 1 != 0;)
        putchar('\n'); // newline after the bottom line and S empty lines
    for(w = W; w != 0; --w) { // Bottom triangles
        for(i = w; i != 0; --i)
            putchar(' '); // leading spaces
        putchar('/'); // left of left triangle
        for(i = w*2; i != 2*W; ++i)
            putchar(' '); // inside of left triangle
        putchar('\\'); // right of left triangle
        for(i = w*2+S*2; i != 0; --i)
            putchar(' '); // spaces between left and right triangles
        putchar('/');
        for(i = w*2; i != 2*W; ++i)
            putchar(' '); // inside of right triangle
        putchar('\\'); // right of right triangle
        putchar('\n'); // newline
    }
    putchar('//'); // left of left
    for(i = 0; i != 2*W; ++i)
        putchar('_'); // bottom of left triangle
    putchar('\\'); // right of left
    for(i = S*2; i != 0; --i)
        putchar(' '); // space between triangles
    putchar('/'); // left of right
    for(i = 0; i != 2*W; ++i)
        putchar('_'); // bottom of left triangle
    putchar('\\'); // right of right
}

Jöle , 51 bayt

+‘⁶ẋ;Ɱ®Y
‘⁼þ`a”/o"”_o⁶Ṛ;ṚØ^yƊ$€©ż`j€Ḥ⁶ẋƊ}Y,@çj‘⁷ẋƊ}

Çevrimiçi deneyin!