Sfida

Sappiamo tutti dei normali alberi di Natale, ma che ne dici di un albero di Natale capovolto ! Questa è una sfida a tema natalizio abbastanza semplice. L'obiettivo di questa sfida è di farmi un albero di Natale capovolto ASCII. Ecco le regole per questa sfida:

1. Accetta un numero intero dispari e positivo. Puoi presumere che sarà sempre tra 7e 51.

2. La base dell'albero sarà composta dai personaggi:

   ___
   \ /
    |
   

3. La parte superiore dell'albero (la stella), sarà composta da un singolo *.

4. Ogni linea dell'albero verrà costruita utilizzando il formato in <?>cui ?è presente un numero qualsiasi di -s. Ad esempio, se si crea una linea di lunghezza 5, la linea dovrebbe essere <--->. O se si crea una linea di lunghezza 8, la linea dovrebbe essere <------>.

5. Ecco come dovrebbe essere costruito il corpo dell'albero:

   1. Prendi il numero dispari nindicato come input e crea una linea dell'albero di quella lunghezza.

   2. Sottrarre 4da ne creare una linea dell'albero che lunghezza.

   3. Sottrarre 2da ne creare una linea dell'albero che lunghezza.

   4. Decremento ndi 2. Dopodiché, a meno che non sia nuguale5 , tornare al passaggio 2.

6. La base (vedi passaggio 2.) la stella (vedi passaggio 3.) e ogni linea dell'albero (vedi passaggi 4. e 5.) dovrebbero essere tutte centrate usando il numero dispari originale (vedi passaggio 1.) come massimo larghezza.

Esempi / casi di 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
        *    

Regole

• Si applicano scappatoie standard .
• Questo è code-golf , quindi vince la risposta più breve in byte!

Python 3 , 127 121 105 103 100 98 byte

Questa è una funzione lambda senza nome che restituisce un elenco di righe:

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

Provalo online!

La parte principale di questa risposta è (o-i+2-i%2*3) , che determina il numero di trattini da avere su una linea. Il resto della risposta sta semplicemente convertendo questo nell'arte ASCII desiderata.

Mille grazie a Mr. Xcoder , per aver rasato 6 byte e aver discusso di golf con me in chat.

Grazie anche a Lynn per aver notato che 3*(i%2)può essere i%2*3, 2 byte in meno!

C, 163 byte

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

Provalo online!

srotolato:

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

Grazie a FlipTack per aver salvato 4 byte e per aver collaborato alla chat (formiamo davvero una grande squadra). Risparmiato indirettamente 2 byte grazie a Lynn .

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

Provalo online!

Carbone , 28 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

__⸿ /⸿|

Stampa la base.

Ｆ⮌…¹⊘Ｎ«

Passa dalla metà del numero di input a 1.

⸿⊕ι>⸿⊖ι>»

Stampa due righe, la prima con una in più -rispetto all'indice del loop, la seconda con una in meno.

‖Ｂ←

Specchio per completare l'albero.

 *

Posiziona la stella.

SOGL V0.12 , 35 30 byte

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

Provalo qui!

Utilizza l'algoritmo Neil Charcoal , accetta input come indice nei numeri dispari, quindi 13 corrisponderebbe all'input 7

Retina , 89 byte

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

Provalo online! Spiegazione: Il primo stadio converte l'input in unario e aggiunge a >. Il secondo stadio sostituisce due -s con a <per correggere la lunghezza della linea. Il terzo stadio replica quindi il ramo ma ogni volta leggermente più corto fino a quando non è possibile accorciare ulteriormente il ramo. La fase finale aggiunge la base e la stella.

Javascript 506 byte

Golf-Versione:

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}

Ungolf-Versione:

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 byte (dal mio amico)

Golf-Versione:

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

Ungolf-Versione:

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 byte

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

Provalo online!

Bene, questo è un casino giusto per chiunque non sia esperto in PowerShell ... quindi, vediamo come posso spiegare come funziona.

Per la spiegazione, userò input = 17.

Iniziamo abbastanza semplice, con l'impostazione della variabile helper $i=2e l'impostazione $xsu <something>, con l' <something>inizio come un intervallo dall'input in $argsgiù a 5, quindi 17,16,15,...,6,5. Tale intervallo viene pompato in un ciclo for.

Ogni iterazione, si parte con impostando la variabile di supporto $jper essere il risultato di una ifdichiarazione, if($_%2){$i-2}else{($i++)}. Se è strano $j=$i-2, altrimenti $j=($i++). Questo, unito $i=2all'inizio, ci dà la sequenza 0, 2, 1, 3, 2, 4, 3, 5...che corrisponde esattamente a quanti spazi dobbiamo anteporre al nostro albero. ;-) Prendiamo' ' e moltipliciamo le stringhe per quel numero.

Quindi abbiamo bisogno dei nostri rami. Questo viene fatto con '<'più la parte centrale '-'moltiplicata, più l'estremità '>'. La moltiplicazione avviene riconoscendo che l' -alternanza in un 2, 5, 2, 5, 2...modello si basa sul numero di input $_, quindi stiamo selezionando da uno pseudo-ternario basato su quel modello.

Per ulteriori chiarimenti, ecco i primi due termini in ogni sezione:

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

Quindi ora abbiamo impostato $xun array di rami (cioè stringhe). Al di fuori del ciclo, ora costruiamo il nostro albero "in alto" con il numero appropriato di spazi in cui salvare $y, quindi visualizziamo i nostri rami $xe quindi l'albero "in basso" con il *. Ognuno di questi viene lasciato sulla pipeline e l'output è implicito con una nuova riga tra gli elementi.

JavaScript (ES6), 150 147 byte

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

Tela , 28 byte

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

Provalo qui!

Una porta della mia risposta SOGL che è una porta della risposta di Neil al carbone.

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}

Il mio tentativo di 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))