Défi

Nous connaissons tous les arbres de Noël normaux - mais que diriez-vous d'un arbre de Noël à l'envers ! C'est un défi assez facile sur le thème de Noël. L'objectif de ce challenge est de faire de moi un sapin de Noël à l'envers ASCII. Voici les règles de ce défi:

1. Acceptez un entier impair et positif. Vous pouvez supposer que ce sera toujours entre 7et 51.

2. La base de l'arbre sera composée des personnages:

   ___
   \ /
    |
   

3. Le sommet de l'arbre (l'étoile) sera composé d'un seul *.

4. Chaque ligne de l'arbre sera construite en utilisant le format <?>où ?est un nombre quelconque de -s. Par exemple, si vous créez une ligne de longueur 5, la ligne devrait l'être <--->. Ou si vous faites une ligne de longueur 8, la ligne devrait l'être <------>.

5. Voici comment le corps de l'arbre doit être construit:

   1. Prenez le nombre impair ndonné en entrée et créez une ligne de l'arbre de cette longueur.

   2. Soustraire 4de ncréer une ligne de l'arbre de cette longueur.

   3. Soustraire 2de ncréer une ligne de l'arbre de cette longueur.

   4. Décrémenter nde 2. Après cela, sauf négal5 , revenez à l'étape 2.

6. La base (voir étape 2.), l'étoile (voir étape 3.) et chaque ligne de l'arbre (voir étapes 4. et 5.) doivent toutes être centrées en utilisant le nombre impair d' origine (voir étape 1.) comme maximum largeur.

Exemples / cas de test

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
        *    

Règles

• Des échappatoires standard s'appliquent .
• C'est le code-golf , donc la réponse la plus courte en octets l'emporte!

Python 3 , 127 121 105 105 103 100 98 octets

Il s'agit d'une fonction lambda sans nom qui renvoie une liste de lignes:

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

Essayez-le en ligne!

La partie principale de cette réponse est (o-i+2-i%2*3) , qui calcule le nombre de tirets à avoir sur une ligne. Le reste de la réponse consiste simplement à convertir cela en art ASCII souhaité.

Un grand merci à M. Xcoder , d'avoir rasé 6 octets et d'avoir discuté du golf avec moi dans le chat.

Merci également à Lynn d' avoir remarqué que cela 3*(i%2)peut être i%2*32 octets plus court!

C, 163 octets

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

Essayez-le en ligne!

Déroulé:

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

Proton , 83 octets

Merci à FlipTack pour avoir économisé 4 octets et pour avoir collaboré au chat (nous formons en fait une excellente équipe). Indirectement enregistré 2 octets grâce à Lynn .

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

Essayez-le en ligne!

Fusain , 28 octets

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

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

__⸿ /⸿|

Imprimez la base.

Ｆ⮌…¹⊘Ｎ«

Boucle de la moitié du numéro d'entrée à 1.

⸿⊕ι>⸿⊖ι>»

Imprimez deux lignes, la première avec une de plus -que l'index de boucle, la seconde avec une de moins.

‖Ｂ←

Miroir pour compléter l'arbre.

 *

Placez l'étoile.

SOGL V0.12 , 35 30 octets

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

Essayez-le ici!

Utilise l'algorithme de charbon de Neil , prend l'entrée comme indice dans les nombres impairs - donc 13 correspondrait à l'entrée 7

Rétine , 89 octets

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

Essayez-le en ligne! Explication: La première étape convertit l'entrée en unaire et ajoute a >. La deuxième étape remplace deux -s par un <pour corriger la longueur de ligne. La troisième étape reproduit ensuite la branche mais légèrement plus courte à chaque fois jusqu'à ce que la branche ne puisse plus être raccourcie. L'étape finale ajoute la base et l'étoile.

Javascript 506 octets

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

Version 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;
}

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

ES6 165 octets (de mon ami)

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

Version 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;
  }
}

Usage: p(31); p(17);

PowerShell , 131 octets

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

Essayez-le en ligne!

Eh bien, c'est un vrai gâchis pour quiconque ne connaît pas PowerShell ... alors, voyons comment je peux expliquer comment cela fonctionne.

Pour l'explication, je vais utiliser input = 17.

Nous commençons assez simplement, avec la définition de la variable d'assistance $i=2et la définition $xde <something>, avec le <something>démarrage comme une plage de l'entrée $argsvers le bas 5, donc 17,16,15,...,6,5. Cette plage est pompée dans une boucle for.

Chaque itération, nous commençons avec réglage variable d'aide $jpour être le résultat d'une ifdéclaration, if($_%2){$i-2}else{($i++)}. Si c'est bizarre $j=$i-2, sinon $j=($i++). Ceci, couplé avec $i=2au début, nous donne la séquence 0, 2, 1, 3, 2, 4, 3, 5...qui correspond exactement au nombre d'espaces dont nous avons besoin pour ajouter à notre ligne d'arbre. ;-) Nous prenons ' 'et multiplions les chaînes par ce nombre.

Ensuite, nous avons besoin de nos succursales. Cela se fait avec '<'plus la partie centrale '-'multipliée, plus la fin '>'. La multiplication se fait en reconnaissant que l' -alternative dans un 2, 5, 2, 5, 2...modèle basé sur le numéro d'entrée $_, nous sélectionnons donc à partir d'un pseudo-ternaire basé sur ce modèle.

Pour plus de précisions, voici les deux premiers termes de chaque section:

$_ = 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

Alors maintenant, nous avons défini $xun tableau de branches (c'est-à-dire des chaînes). En dehors de la boucle, nous construisons maintenant notre arbre "en haut" avec le nombre approprié d'espaces enregistrés dans $y, puis affichons nos branches $x, puis l'arbre "en bas" avec le *. Chacun d'eux est laissé sur le pipeline et la sortie est implicite avec une nouvelle ligne entre les éléments.

JavaScript (ES6), 150 147 octets

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

Toile , 28 octets

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

Essayez-le ici!

Un port de ma réponse SOGL qui est un port de la réponse 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}

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