La Triforce est un artefact fictif dans The Legend of Zelda , composé de trois triangles équilatéraux d'aspect identique représentant la puissance, la sagesse et le courage. Plusieurs jeux de la saga incluent une animation lorsque les trois parties se rejoignent enfin.

Le but de ce défi est de dessiner une seule image 2D d'une telle animation simplifiée, avec une largeur donnée pour les triangles et un espacement donné entre les pièces.

Contribution

L'entrée se compose de deux nombres entiers: une largeur et une valeur d'espacement .s ≥ $w\ge1$$s\ge0$

Sortie

Le cadre doit être dessiné selon les spécifications suivantes:

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

Dans l'exemple ci-dessus, nous avons et .s = $w=3$$s=2$

Plus d'exemples

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

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

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

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

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

          /\          
         /  \         
        /    \        
       /______\       



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

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

          /\          
         /  \         
        /    \        
       /      \       
      /________\      

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

Règles

• Les espaces de fin sur chaque ligne sont facultatifs.
• Les espaces de tête supplémentaires sur chaque ligne ne sont pas autorisés.
• Vous pouvez sortir une seule nouvelle ligne supplémentaire et / ou une seule nouvelle ligne supplémentaire.
• C'est du code-golf .

Python 2 , 197 194 169 169 167 155 144 octets

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)

Essayez-le en ligne!

Enregistré:

• -3 octets, merci à M. Xcoder

Fusain , 25 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

←×_Ｎ

Entrer wet dessiner w _s.

↗⊕θ

Dessinez w+1 /s.

‖Ｍ

Réfléchissez pour terminer le premier triangle.

≔⁺⊕θＮη

Saisissez set calculez le décalage entre les triangles gauche et central.

Ｃη±η

Copiez le triangle gauche au milieu.

‖ＢＯ⊗⊕θ

Réfléchissez autour du triangle central pour compléter la triforce.

Python 2 , 127 124 octets

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

Essayez-le en ligne!

Toile , 20 19 16 octets

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

Essayez-le ici!

Explication:

+├                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

note: en faisant cela, j'ai corrigé une erreur dans le code, sans ce correctif, ce serait 18 octets .

R , 225 , 224 , 214 , 211 , 208 octets

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

Essayez-le en ligne!

• -1 octet grâce à Giuseppe
• -10 octets après changement d'approche
• -3 octets expliquant le code ASCII
• -3 octets grâce à JayCe

Pascal (FPC) , 296 264 octets

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.

Essayez-le en ligne!

Python 2 , 256 248 240 228 199 195 195 octets

Un programme plus long, mais une approche légèrement différente:

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

Essayez-le en ligne!

économisé beaucoup d'octets grâce à l'ignorance des espaces de fin et à l'incorporation de quelques astuces de @ovs
encore plus en définissant une variable plus tôt

Rubis , 126 octets

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

Essayez-le en ligne!

Retina 0.8.2 , 141 octets

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

Essayez-le en ligne! Remarque: certains espaces en fin de sortie. Explication:

\d+
$* 

Convertissez les entrées en espaces. (La deuxième ligne se termine par un espace.)

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

Créez les côtés des deux triangles inférieurs avec l'espacement approprié.

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

Remplissez la base des triangles.

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

Dupliquez les triangles avec l'espacement vertical approprié.

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

Convertissez les triangles supérieurs en un seul triangle centré.

C (gcc), 404 389 octets

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

Essayez-le en ligne!

-14 octets de Rodolvertice

-1 octet en fixant une décrémentation variable de boucle

_{barré 404 est presque toujours 404}

Non golfé:

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

Gelée , 51 octets

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

Essayez-le en ligne!