Desafío

Todos sabemos acerca de los árboles de Navidad normales, ¡pero qué tal un árbol de Navidad al revés ! Este es un desafío bastante fácil con temas navideños. El objetivo de este desafío es hacerme un árbol de Navidad invertido ASCII. Aquí están las reglas para este desafío:

1. Acepta un número entero extraño y positivo. Puede suponer que siempre estará entre 7y 51.

2. La base del árbol estará compuesta por los personajes:

   ___
   \ /
    |
   

3. La parte superior del árbol (la estrella) estará compuesta por una sola *.

4. Cada línea del árbol se construirá utilizando el formato <?>donde ?hay cualquier número de -s. Por ejemplo, si hace una línea de longitud 5, la línea debería ser <--->. O si hace una línea de longitud 8, la línea debería ser <------>.

5. Así es como se debe construir el cuerpo del árbol:

   1. Tome el número impar ndado como entrada y cree una línea del árbol de esa longitud.

   2. Restar 4de ny crear una línea del árbol de esa longitud.

   3. Restar 2de ny crear una línea del árbol de esa longitud.

   4. Decremento npor 2. Después de eso, a menos que sea nigual5 , regrese al paso 2.

6. La base (consulte el paso 2), la estrella (consulte el paso 3) y cada línea del árbol (consulte los pasos 4 y 5) deben centrarse utilizando la entrada de número impar original (consulte el paso 1) como máximo anchura.

Ejemplos / Casos de prueba

odd number inputed: 7
  ___
  \ /
   |
<----->      line length -> 7
  <->        line length -> 7 - 4 = 3
 <--->       line length -> 7 - 2 = 5
   *


odd number inputed: 13
     ___
     \ /
      |
<----------->      line length -> 13
  <------->        line length -> 13 - 4 = 9
 <--------->       line length -> 13 - 2 = 11
   <----->         line length -> 11 - 4 = 7
  <------->        line length -> 11 - 2 = 9
    <--->          line length -> 9 - 4 = 5
   <----->         line length -> 9 - 2 = 7
     <->           line length -> 7 - 4 = 3 
    <--->          line length -> 7 - 2 = 5
      *


odd number inputed: 9
   ___
   \ /
    |
<------->      line length -> 9
  <--->        line length -> 9 - 4 = 5
 <----->       line length -> 9 - 2 = 7
   <->         line length -> 7 - 4 = 3
  <--->        line length -> 7 - 2 = 5
    *


odd number inputed: 17
       ___
       \ /
        |
<--------------->      line length -> 17
  <----------->        line length -> 17 - 4 = 13
 <------------->       line length -> 17 - 2 = 15
   <--------->         line length -> 15 - 4 = 11
  <----------->        line length -> 15 - 2 = 13
    <------->          line length -> 13 - 4 = 9
   <--------->         line length -> 13 - 2 = 11
     <----->           line length -> 11 - 4 = 7
    <------->          line length -> 11 - 2 = 9
      <--->            line length -> 9 - 4 = 5
     <----->           line length -> 9 - 2 = 7
       <->             line length -> 7 - 4 = 3
      <--->            line length -> 7 - 2 = 5
        *    

Reglas

• Se aplican lagunas estándar .
• Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Python 3 , 127 121 105 103 100 98 bytes

Esta es una función lambda sin nombre que devuelve una lista de líneas:

lambda o:[s.center(o)for s in['___','\ /','|',*[f'<{"-"*(o-i+2-i%2*3)}>'for i in range(4,o)],'*']]

Pruébalo en línea!

La parte principal de esta respuesta es (o-i+2-i%2*3), que calcula el número de guiones para tener en una línea. El resto de la respuesta es simplemente convertir esto en el arte ASCII deseado.

Muchas gracias al Sr. Xcoder , por recortar 6 bytes y hablar de golf conmigo en el chat.

¡Gracias también a Lynn por notar que 3*(i%2)puede ser i%2*3, 2 bytes más corto!

C, 163 bytes

#define P;printf(
i;g(l){P"%*c",1+i-l--/2,60);for(;--l P"-"))P">\n");}f(n){i=n/2 P"%*c__\n%*c /\n%*c|\n",i,95,i,92,i,32);for(g(n);n>5;g(n-=2))g(n-4)P" %*c",i,42);}

Pruébalo en línea!

Desenrollado:

#define P;printf(

i;
g(l)
{
    P"%*c", 1+i-l--/2, 60);
    for (; --l P"-"))
    P">\n");
}

f(n)
{
    i=n/2
    P"%*c__\n%*c /\n%*c|\n", i, 95, i, 92, i, 32);

    for(g(n); n>5; g(n-=2))
        g(n-4)

    P" %*c", i, 42);
}

Protón , 83 bytes

Gracias a FlipTack por guardar 4 bytes y por colaborar en el chat (en realidad formamos un gran equipo). Indirectamente guardado 2 bytes gracias a Lynn .

o=>[s.center(o)for s:['___','\ /','|']+['<'+"-"*(o-i+2-i%2*3)+'>'for i:4..o]+['*']]

Pruébalo en línea!

Carbón , 28 bytes

__⸿ /⸿|Ｆ⮌…¹⊘Ｎ«⸿⊕ι>⸿⊖ι>»‖Ｂ← *

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

__⸿ /⸿|

Imprime la base.

Ｆ⮌…¹⊘Ｎ«

Pase de la mitad del número de entrada a 1.

⸿⊕ι>⸿⊖ι>»

Imprima dos líneas, la primera con una más -que el índice de bucle, la segunda con una menos.

‖Ｂ←

Espejo para completar el árbol.

 *

Coloca la estrella.

SOGL V0.12 , 35 30 bytes

┌* <++L
%⁽⁄6‘√.⁾δ№{⁽LFL}j *+§Γ

Pruébalo aquí!

Utiliza el algoritmo de carbón de Neil , toma la entrada como índice en los números impares, por lo que 13 correspondería a la entrada 7

Retina , 89 bytes

.+
$*->
^--
<
+`( *<)----(-+>)$
$&¶  $1$2¶ $1--$2
s`.*¶( +)<->.*
$1___¶$1\ /¶$1 |¶$&¶$1 *

Pruébalo en línea! Explicación: La primera etapa convierte la entrada en unaria y agrega a >. La segunda etapa reemplaza dos -s con a <para corregir la longitud de la línea. Luego, la tercera etapa replica la rama, pero cada vez un poco más corta hasta que la rama no se puede acortar más. La etapa final agrega la base y la estrella.

Javascript 506 bytes

Versión de golf:

function tree(i){const mid=(i+1)/2;const leg1=' '.repeat((mid-2))+`___
`;const leg2=' '.repeat((mid-2))+`\\ \/
`;const leg3=' '.repeat((mid-1))+`|
`;let xmasTree=leg1+leg2+leg3;for(let j=0;j<(i-4);j++){if(j%2===0){let v=j/2;let t=i-2*v-2;let body1=" ".repeat(j/2)+"<"+"-".repeat(t)+">"+`
`;xmasTree=xmasTree+body1}else{let k=1+Math.ceil(j/2);let h=i-2*k-2;let body2=' '.repeat(k)+'<'+'-'.repeat(h)+">"+`
`;xmasTree=xmasTree+body2}}
const head=' '.repeat((mid-1))+'*'
xmasTree=xmasTree+head;return xmasTree}

Versión Ungolf:

function tree(i){
  const mid = (i+1)/2;
  const leg1 = ' '.repeat((mid-2)) + `___
`;
  const leg2 = ' '.repeat((mid-2)) + `\\ \/
`;
  const leg3 = ' '.repeat((mid-1)) + `|
`;
  let xmasTree = leg1 + leg2 + leg3;
  for (let j = 0; j<(i-4); j++) {
    if (j%2===0) {
      let v = j/2;
      let t = i-2*v-2;
      let body1 = " ".repeat(j/2)+"<"+"-".repeat(t) +">"+`
`;
      xmasTree = xmasTree + body1;
    } else {
      let k = 1 + Math.ceil(j/2);
      let h = i-2*k-2;
      let body2 = ' '.repeat(k)+ '<'+ '-'.repeat(h) + ">"+`
`;
      xmasTree = xmasTree + body2;
    }
  }
  const head = ' '.repeat((mid-1)) + '*'
  xmasTree = xmasTree + head;
  return xmasTree;
}

Uso: console.log(tree(13)), console.log(tree(17)),

ES6 165 bytes (de mi amigo)

Versión de golf:

p=n=>{l=_=>console.log(`${' '.repeat((n-_.length)/2)}${_}`);t=_=>_==1?'*':'<'+'-'.repeat(_-2)+'>';x=n;l('___');l('\\ /');l('|');for(;x!==3;){l(t(x));l(t(x-4));x-=2}}

Versión Ungolf:

p = n => {
  l = _ => console.log(`${' '.repeat((n-_.length)/2)}${_}`);
  t = _ => _ == 1 ? '*' : '<' + '-'.repeat(_-2)+'>';
  x = n;
  l('___');l('\\ /');l('|');
  for(;x!==3;) {
    l(t(x)); l(t(x-4));x-=2;
  }
}

Uso: p(31); p(17);

PowerShell , 131 bytes

$i=2;$x="$args"..5|%{' '*($j=if($_%2){$i-2}else{($i++)})+'<'+'-'*($_-(5,2)[$_%2])+'>'};($y=' '*++$j)+"___";"$y\ /";"$y |";$x;"$y *"

Pruébalo en línea!

Bueno, este es un desastre para cualquiera que no esté familiarizado con PowerShell ... así que, veamos qué tan bien puedo explicar cómo funciona.

Para la explicación, usaré input = 17 .

Comenzamos de manera bastante simple, con la configuración de la variable auxiliar $i=2y la configuración $xde <something>, con el <something>inicio como un rango desde la entrada $argshasta 5, así que17,16,15,...,6,5 . Ese rango se bombea en un bucle for.

Cada iteración, que se inicia con el establecimiento de la variable de ayuda $jpara ser el resultado de un ifcomunicado, if($_%2){$i-2}else{($i++)}. Si es extraño $j=$i-2, de lo contrario $j=($i++). Esto, junto con $i=2al principio, nos da la secuencia0, 2, 1, 3, 2, 4, 3, 5... que, por casualidad, corresponde exactamente a cuántos espacios necesitamos anteponer a nuestra línea de árbol. ;-) Lo tomamos ' 'y multiplicamos por cadenas por ese número.

A continuación necesitamos nuestras ramas. Esto se hace con '<'más la parte media '-'multiplicada, más el final '>'. La multiplicación se realiza reconociendo que la -alternativa en un 2, 5, 2, 5, 2...patrón basado en el número de entrada$_ , por lo que estamos seleccionando de un pseudoternario basado en ese patrón.

Para mayor aclaración, aquí están los primeros dos términos en cada sección:

$_ = 17 16 15 14 13 12 11 10
$j =  0  2  1  3  2  4  3  5
mid=  2  5  2  5  2  5  2  5
'-'= 15 11 13  9 11  7  9  5

Así que ahora hemos establecido $xser una matriz de ramas (es decir, cadenas). Fuera del ciclo, ahora construimos nuestro árbol "arriba" con el número apropiado de espacios guardados $y, luego mostramos nuestras ramas $x, y luego el árbol "abajo" con el *. Cada uno de ellos se deja en la tubería y la salida está implícita con una nueva línea entre los elementos.

JavaScript (ES6), 150 147 bytes

N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,n=N,l=n=>' '[r](N/2-n/2)+(n-1?`<${'-'[r](n-2)}>
`:'*');n-3;n-=2)s+=l(n)+l(n-4)
return s}

f=

N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,n=N,l=n=>' '[r](N/2-n/2)+(n-1?`<${'-'[r](n-2)}>
`:'*');n-3;n-=2)s+=l(n)+l(n-4)
return s}

console.log(f(7))
console.log(f(9))
console.log(f(13))
console.log(f(17))

Lienzo , 28 bytes.

-×>＋∔
__¶ /¶|╶┤ｒ⇵｛├⁸¹⁸｝ｋ*∔↔│

Pruébalo aquí!

Un puerto de mi respuesta SOGL que es un puerto de la respuesta de Neil's Charcoal.

N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,l=n=>' '[r](N/2-n/2)+n-1?`<${'-'[r](n-2)}>
`:'*');N-=2;s+=l(N)+l(N-4);return s}

Mi intento de JS ESGoogoltriplex.

f=

N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,l=n=>' '[r](N/2-n/2)+n-1?`<${'-'[r](n-2)}>
`:'*');N-=2;s+=l(N)+l(N-4);return s}

console.log(f(7))
console.log(f(9))
console.log(f(13))
console.log(f(17))