La Trifuerza es un artefacto ficticio en La leyenda de Zelda , hecha de tres triángulos equiláteros de aspecto idéntico que representan poder, sabiduría y coraje. Varios juegos de la saga incluyen una animación cuando las tres partes finalmente se unen.

El propósito de este desafío es dibujar un solo cuadro 2D de una animación tan simplificada, con un ancho dado para los triángulos y un espacio entre las partes.

Entrada

La entrada consta de dos enteros: un ancho y un valor de espaciado .$w\ge1$$s\ge0$

Salida

El marco debe dibujarse de acuerdo con las siguientes especificaciones:

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

En el ejemplo anterior, tenemos $w=3$ y $s=2$ .

Más ejemplos

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

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

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

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

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

          /\          
         /  \         
        /    \        
       /______\       



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

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

          /\          
         /  \         
        /    \        
       /      \       
      /________\      

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

Reglas

• Los espacios finales en cada línea son opcionales.
• No se permiten espacios iniciales adicionales en cada línea.
• Puede generar una nueva línea principal adicional y / o una línea nueva adicional adicional.
• Este es el código de golf .

Python 2 , 197 194 169 167 155 144 bytes

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)

Pruébalo en línea!

Salvado:

• -3 bytes, gracias al Sr. Xcoder

Carbón de leña , 25 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

←×_Ｎ

Entrada wy sorteo w _s.

↗⊕θ

Draw w+1 /s.

‖Ｍ

Reflexiona para completar el primer triángulo.

≔⁺⊕θＮη

Ingrese sy calcule el desplazamiento entre los triángulos izquierdo y medio.

Ｃη±η

Copia el triángulo izquierdo al medio.

‖ＢＯ⊗⊕θ

Reflexiona alrededor del triángulo del medio para completar la trifuerza.

Python 2 , 127124 bytes

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

Pruébalo en línea!

Lienzo , 20 19 16 bytes

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

Pruébalo aquí!

Explicación:

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

nota: al hacer esto, solucioné un error en el código. Sin esa solución, esto sería 18 bytes .

R , 225 , 224 , 214 , 211 , 208 bytes

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

Pruébalo en línea!

• -1 byte gracias a Giuseppe
• -10 bytes después del cambio de enfoque
• -3 bytes que explotan el código ASCII
• -3 bytes gracias a JayCe

Pascal (FPC) , 296 264 bytes

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.

Pruébalo en línea!

Python 2 , 256 248 240 228 199 195 bytes

Un programa más largo, pero un enfoque ligeramente diferente:

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

Pruébalo en línea!

ahorró muchos bytes gracias a ignorar el espacio en blanco al final e incorporar algunos trucos de @ovs
guardados aún más al definir una variable antes

Ruby , 126 bytes

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

Pruébalo en línea!

Retina 0.8.2 , 141 bytes

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

Pruébalo en línea! Nota: Algunos espacios en blanco finales en la salida. Explicación:

\d+
$* 

Convierte las entradas en espacios. (La segunda línea termina con un espacio).

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

Crea los lados de los dos triángulos inferiores con el espacio apropiado.

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

Completa la base de los triángulos.

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

Duplica los triángulos con el espacio vertical apropiado.

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

Convierte los triángulos superiores en un solo triángulo centrado.

C (gcc), 404 389 bytes

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

Pruébalo en línea!

-14 bytes de Rodolvertice

-1 byte arreglando una disminución de la variable de bucle

_{tachado 404 es casi todavía 404}

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

Jalea , 51 bytes

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

Pruébalo en línea!