Zrób mi do góry nogami choinkę!

15

Wyzwanie

Wszyscy wiemy o normalnych choinkach - ale co powiesz na odwróconą choinkę ! To dość łatwe, świąteczne wyzwanie. Celem tego wyzwania jest uczynienie mnie do góry nogami choinką ASCII. Oto zasady tego wyzwania:

  1. Zaakceptuj nieparzystą liczbę całkowitą dodatnią. Możesz założyć, że zawsze będzie pomiędzy 7i 51.

  2. Podstawa drzewa będzie złożona z postaci:

    ___
\ /
 |

  3. Wierzchołek drzewa (gwiazda) będzie składał się z jednego *.

  4. Każda linia drzewa zostanie zbudowana w formacie, w <?>którym ?jest dowolna liczba -s. Na przykład, jeśli tworzysz linię długości 5, linia powinna być <--->. Lub jeśli tworzysz linię długości 8, linia powinna być <------>.

  5. Oto, jak należy zbudować ciało drzewa:

    1. Weź liczbę nieparzystą npodaną jako dane wejściowe i utwórz linię drzewa o tej długości.

    2. Odjąć 4od ni utworzyć linię drzewa tej długości.

    3. Odjąć 2od ni utworzyć linię drzewa tej długości.

    4. Zmniejszenie nprzez 2. Następnie, chyba że njest równy5 , wróć do kroku 2.

  6. Baza (patrz krok 2.) gwiazda (patrz krok 3.) i każda linia drzewa (patrz kroki 4. i 5.) powinny być wyśrodkowane przy użyciu oryginału liczby nieparzystej (patrz krok 1.) jako maksimum szerokość.

Przykłady / przypadki testowe

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
        *

Zasady

code-golf  string  ascii-art 
— Christian Dean
źródło
3
Widząc, że wejście jest gwarantowane jako liczba nieparzysta, czy możemy wziąć jego indeks w sekwencji liczb nieparzystych?
— FlipTack,
Również - repeat the above steps until the odd number minus 2 equals 5- na pierwszym wejściu liczba nieparzysta to 7, a 7-2 = 5, dlatego drzewo powinno się natychmiast zakończyć (wiem, co masz na myśli, ale wymaga przeformułowania)
— FlipTack
@FlipTack Nie jestem do końca pewien, co masz na myśli. Jeśli liczba nieparzysta jest 7minimalną wartością wejściową, najpierw należy utworzyć trzy linie drzewa (pod-kroki .1.1, .1.2, .1.3), a następnie odjąć 2od liczby nieparzystej i sprawdzić, czy jest ona równa 5. Instrukcja sprawdzenia, czy „liczba nieparzysta minus 2 równa się 5” znajduje się na końcu, pozostałe trzy kroki należy wykonać w pierwszej kolejności. Ale odpowiedź na twój pierwszy komentarz byłaby w porządku.
— Christian Dean,
1
@FlipTack Myślę, że pyta, czy musisz zaakceptować 7dane wejściowe, czy możesz je zaakceptować 4, jak w czwartej liczbie nieparzystej (lub 3czy jest to indeks 0).
— DonielF,
4
Z tytułu: „Ok, jesteś teraz do góry nogami choinką”.
— dkudriavtsev

Odpowiedzi:

10

Python 3 , 127 121 105 103 100 98 bajtów

To jest nienazwana funkcja lambda, która zwraca listę linii:

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

Wypróbuj online!

Główną częścią tej odpowiedzi jest (o-i+2-i%2*3)określenie liczby myślników na linii. Resztą odpowiedzi jest po prostu przekształcenie tego w pożądaną sztukę ASCII.

Ogromne podziękowania dla pana Xcodera za golenie 6 bajtów i omawianie ze mną golfa na czacie.

Dziękujemy także Lynn za zauważenie, że 3*(i%2)może być i%2*3, 2 bajty krótsze!

— FlipTack
źródło
— Mr. Xcoder,
2
Ilekroć zamieszczam odpowiedź w języku Python, bez względu na porę dnia i jego bieżącą lokalizację, @ ​​Mr.Xcoder ma golfa do przekazania :)
— FlipTack
Welp , to z łatwością pokonuje moje 250 bajtów + rozwiązanie Python. Dobra robota! +1
— Christian Dean,
o-i+2-i%2*3oszczędza dwa bajty.
— Lynn
@ Lynn Dobre miejsce, zaktualizowane.
— FlipTack,
7

C, 163 bajty

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

Wypróbuj online!

Rozwinięty:

#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);
}
— Steadybox
źródło
6

Proton , 83 bajty

Dzięki FlipTack za zaoszczędzenie 4 bajtów i za współpracę na czacie (tak naprawdę tworzymy świetny zespół). Pośrednio zapisane 2 bajty dzięki Lynn .

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

Wypróbuj online!

— Pan Xcoder
źródło
5

Węgiel drzewny , 28 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

__⸿ /⸿|

Wydrukuj bazę.

Ｆ⮌…¹⊘Ｎ«

Pętla od połowy liczby wejściowej do 1.

⸿⊕ι>⸿⊖ι>»

Wydrukuj dwa wiersze, pierwszy z jednym większym -niż indeks pętli, drugi z jednym mniejszym.

‖Ｂ←

Lustro, aby ukończyć drzewo.

 *

Umieść gwiazdę.

— Neil
źródło
3

Siatkówka , 89 bajtów

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

Wypróbuj online! Objaśnienie: Pierwszy etap konwertuje dane wejściowe na jednoargumentowe i dołącza znak >. Drugi etap zastępuje dwa -s przez, <aby skorygować długość linii. Trzeci etap replikuje gałąź, ale za każdym razem nieco krótszy, dopóki gałąź nie może być dalej skracana. Ostatni etap dodaje podstawę i gwiazdę.

— Neil
źródło
2

JavaScript 506 bajtów

Wersja golfowa:

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}

Wersja bez golfa:

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

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

ES6 165 bajtów (od mojego przyjaciela)

Wersja golfowa:

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

Wersja bez golfa:

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

Stosowanie: p(31); p(17);

— NTCG
źródło
1
Możesz dużo grać w golfa, używając tylko 1-literowych nazw zmiennych, usuwając constsłowa kluczowe itp.
— FlipTack
1

PowerShell , 131 bajtów

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

Wypróbuj online!

Cóż, jest to dobry bałagan dla każdego, kto nie zna się w PowerShell ... więc zobaczmy, jak dobrze mogę wyjaśnić, jak to działa.

Dla wyjaśnienia użyję input = 17.

Zaczynamy dość prosto, z ustawieniem zmiennej pomocniczej $i=2i ustawieniem $xna <something>, z <something>początkiem jako zakres od wejścia $argsdo 5, więc 17,16,15,...,6,5. Ten zakres jest pompowany do pętli for.

Każda iteracja, zaczynamy z ustawieniem zmiennej pomocnika $jbyć wynikiem ifoświadczeniu if($_%2){$i-2}else{($i++)}. Jeśli to dziwne, $j=$i-2w przeciwnym razie $j=($i++). To, w połączeniu z $i=2początkiem, daje nam sekwencję, 0, 2, 1, 3, 2, 4, 3, 5...która akurat dokładnie odpowiada liczbie spacji, które musimy przyłożyć do naszej linii drzewa. ;-) Bierzemy ' 'i mnożymy to przez ten numer.

Następnie potrzebujemy naszych oddziałów. Odbywa się to poprzez pomnożenie '<'środkowej części '-'plus koniec '>'. Mnożenie odbywa się przez rozpoznanie, że -zmienna we 2, 5, 2, 5, 2...wzorcu na podstawie liczby wejściowej $_, więc wybieramy z pseudo-trójki na podstawie tego wzorca.

Aby uzyskać dodatkowe wyjaśnienia, oto kilka pierwszych terminów w każdej sekcji:

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

Więc teraz ustawiliśmy $xsię na tablicę rozgałęzień (tj. Łańcuchów). Poza pętlą budujemy teraz nasze „górne” drzewo z zachowaną odpowiednią liczbą spacji $y, a następnie wyświetlamy nasze gałęzie $x, a następnie „dolne” drzewo za pomocą *. Każdy z nich pozostaje w potoku, a wynik jest domyślnie z nową linią między elementami.

— AdmBorkBork
źródło
1

JavaScript (ES6), 150 147 bajtów

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}

Pokaż fragment kodu

— darrylyeo
źródło
1

Płótno , 28 bajtów

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

Wypróbuj tutaj!

Port mojej odpowiedzi SOGL, która jest odpowiedzią na węgiel drzewny Neila.

— dzaima
źródło
0 
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}

Moja próba na JS ESGoogoltriplex.

Pokaż fragment kodu

— użytkownik75200
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.