Dibujemos la Trifuerza

29

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 .w1s0

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 = 0w=2 , :s=0

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

s = 3w=3 , :s=3

          /\          
         /  \         
        /    \        
       /______\       



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

s = 1w=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 .
Arnauld
fuente

Respuestas:

10

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
TFeld
fuente
8

Carbón de leña , 25 bytes

←×_N↗⊕θ‖M≔⁺⊕θNηCη±η‖BO⊗⊕θ

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

←×_N

Entrada wy sorteo w _s.

↗⊕θ

Draw w+1 /s.

‖M

Reflexiona para completar el primer triángulo.

≔⁺⊕θNη

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

Cη±η

Copia el triángulo izquierdo al medio.

‖BO⊗⊕θ

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

Neil
fuente
Uh, revisa tus matemáticas en esto. Puede tener 25 caracteres , pero es de 50 a 65 bytes (dependiendo de si usa la representación UTF-16 o UTF-8, respectivamente).
Stuart P. Bentley
Mi error; aparentemente, Charcoal y Canvas tienen sus propios mapeos de personajes , lo que me parece un poco tonto (si vas a usar símbolos arbitrarios, por qué no usar una selección existente), pero lo que sea.
Stuart P. Bentley
@ StuartP.Bentley El objetivo de este sitio es el tamaño del programa de golf. Muchos idiomas (hay muchos, muchos más que solo Canvas & Charcoal) optaron por utilizar los 8 bits por byte, ya que es una muy buena manera de acercarse al máximo golf. El bonito Unicode es solo para hacer que el código sea más fácil de leer y escribir (intenta programar en C escribiendo bytecode; nosotros también somos humanos)
dzaima
8

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!

ovs
fuente
7

Lienzo , 20 19 16 bytes

+├:⁸╵\L_×;∔║ω╋║↕

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 .

dzaima
fuente
Al igual que la respuesta de Neil , puede tener 16 caracteres , pero en términos Unicode, puede ser de 32 o 44 bytes, dependiendo de qué UTF use. (Pensé que podría ser representable en un conjunto de caracteres heredado de un solo byte como la página de códigos 437 , pero no hay ω o ⁸ disponible allí, por lo que me parece que tendría que ir con un formato de transformación Unicode).
Stuart P. Bentley
@ StuartP.Bentley Canvas utiliza una página de códigos personalizada, como se vincula en el título de mi publicación. El wiki de github para Charcoal también contiene su página de códigos. Se acordó en PPCG que está bien responder con respuestas con formato unicode si hay una página de códigos / convertidor que lo respalde.
dzaima
Tcsh, está bien (aunque en el momento en que está utilizando convertidores arbitrarios, me parece que también podría estar escribiendo en un idioma con nombres completos y midiendo la longitud de una instrucción de código de bytes VM compilada).
Stuart P. Bentley
@ StuartP.Bentley Verifique el enlace de respuestas de Carbón: ¡contiene código legible por humanos! (así que sí, 2 transpilaciones: p) Las personas aquí responden en la puntuación de ensamblaje como código de máquina, por lo que no hay razón para responder también en máquinas virtuales
dzaima
7

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
digEmAll
fuente
Como no pude encontrar nada que agregar a esto ... acabo de cambiar el nombre de las variables y también sugiero otra vía para regresar en silencio ... que no estoy completamente satisfecho con TBH. ¡Seguiremos buscando! TIO
JayCe
oh espera ... if(F)0es aceptable seguro y ahorra un byte. O incluso mejor rm()para 3 bytes.
JayCe
Mi sugerencia para usar q()en mi primer comentario no es válida según este meta
JayCe
@ JayCe: ¡gran truco usando rm ()!
digEmAll
4

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!

AlexRacer
fuente
4

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

micsthepick
fuente
Tendré que arreglar esto mañana (funciona, pero puedo hacerlo mejor)
micsthepick
218 bytes .
Jonathan Frech
216 bytes
ovs
eso fue un subproducto de cuando había dos
micsthepick
3

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!

Level River St
fuente
2

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.

Neil
fuente
2

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
}

pizzapants184
fuente
1
#define f para
guardar
¿No puedes hacer #define p putchar?
RK.
1
@RK. Si lo hiciera, entonces tendría que usar en p(x);lugar de p(x), para (+26, -6) = +20 bytes. El punto y coma se incluye cuando la macro se expande.
pizzapants184
284 bytes
ceilingcat
1

Jalea , 51 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente