Wydrukuj choinkę

26

Wyzwanie

Wydrukuj ładną choinkę z własną gwiazdą u góry, używając możliwie najkrótszego kodu. Gwiazda drzewa jest gwiazdką ( *), a bryła drzewa jest wykonana z 0drzewa Drzewo musi mieć 10 rzędów wysokości. Każdy wiersz powinien być odpowiednio wcięty w taki sposób, aby poprzedni wiersz był wyśrodkowany na następnym. Każdy wiersz musi mieć 2 więcej zer od poprzedniego, z wyjątkiem pierwszego, który jest gwiazdą, i drugiego, który ma tylko jedno 0. Wynik jest mniej więcej taki:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Zerwanie remisu dla drzew o zmiennej wysokości bez zmian oprogramowania (z wyjątkiem zmiany parametru wysokości)

Wklej również powstałe drzewo kodu!

Tabela liderów

Pokaż fragment kodu

code-golf ascii-art kolmogorov-complexity Averroes
źródło
3
Nie do końca duplikat, ale jest taki w SO: Code Golf Christmas Edition: Jak wydrukować choinkę wysokości N
Hasturkun

Odpowiedzi:

17

Golfscript, 27 znaków

" "9*"*"9,{n\.4$>\.+)"0"*}%

Wynikowe drzewo wygląda następująco:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Wersja, która używa parametru wysokości tylko raz, jest o jeden znak dłuższa:

9." "*"*"@,{n\.4$>\.+)"0"*}%

Odczyt wysokości ze standardowego wejścia (z wejściem „10” w celu wygenerowania drzewa przykładów) zajmuje taką samą liczbę znaków (28):

~,)" "*"*"@{n\.4$>\.+)"0"*}%
Ventero
źródło
56

Wiem, że to nie jest zgodne ze specyfikacją, ale pomyślałem, że spróbuję dodać trochę różnorodności drzewom, imitując tę klasyczną scenę świąteczną ASCII autorstwa Joan G. Stark .

Nie próbowałem odtworzyć całego obrazu - byłoby to trochę za dużo - ale tylko drzewo, dla którego przedstawiam ten 138-bajtowy program Perl:

$_=join$/,qw'11| 8\2_2/ 9(\o/) 5---2/1\2--- 10>*<',map(11-$_.A.AA x$_,2..11),'9\|H|/';s/\d+/$"x$&/eg,s/A/substr">>>@*O<<<",rand 9,1/eg,say

I, oczywiście, oto próbka danych wyjściowych:

           |
        \  _  /
         (\o/)
     ---  / \  ---
          >*<
         >O><@
        <><<>><
       @><><>@<<
      @<O><*@*>>O
     OO@@*O<<<*<OO
    ><<>@><<>@<><><
   >><O<>>><@*>>><<O
  *<>*<><<>@><O*>><*<
 O><><<@<*>><O*@>O><>*
O<><<><@O>>*O*OO<><<>O>
         \|H|/

Wypróbuj online!

Kod korzysta z funkcji Perl 5.10+ say, dlatego należy go uruchomić za pomocą przełącznika wiersza polecenia -M5.010(lub -E). (Właściwie samo zastąpienie sayna końcu printuniknęłoby tego, kosztem dwóch kolejnych bajtów i utraty nowej linii po ostatnim wierszu danych wyjściowych.)

Zauważ, że większość drzewa jest generowana losowo, więc rozmieszczenie ozdób będzie się różnić w zależności od serii. Anioł, stojak i górny rząd drzewa są jednak nieruchome.

Aby ta popularna odpowiedź nie została szybko usunięta zgodnie z polityką ustanowioną po jej opublikowaniu , oto również rozwiązanie zgodne ze specyfikacją tokena (45 bajtów, również Perl 5):

$_=$"x10 ."*";say,s/ 0/00/,s/\*?$/0/ while/ /

Wypróbuj online!

Podobnie jak powyższy program, ten należy również uruchomić na Perlu 5.10+ z -M5.010przełącznikiem, aby włączyć tę sayfunkcję. Oczywiście (jest to wyzwanie złożoności Kołmogorowa ) daje dokładnie takie same nudne wyniki, jak wszystkie inne zgodne wpisy, których tutaj nie zawracam sobie głowy. (Można także w niewielkim stopniu zmienić rozmiar, zmieniając liczbę 10na dowolną inną wartość).

Ilmari Karonen
źródło
1
Świetny! Nie według specyfikacji, ale myślę, że specjalna nagroda dla sędziów jest dla Ciebie! :)
Averroes
6
powoduje to przysłowiową specyfikację, +2, gdybym mógł.
Kris,
3
Przepraszamy, ale zgodnie z zasadami odpowiedzi, które nie spełniają specyfikacji, muszą zostać usunięte.
mbomb007,
Usuwam ten post zgodnie z naszymi zasadami dotyczącymi odpowiedzi niespełniających specyfikacji wyzwania .
Dennis
1
Czy możesz przenieść prawidłową odpowiedź na górę i dodać nagłówek?
Dennis
13

GolfScript (33 znaki)

Wersja o stałej wysokości:

;8:^' '*.'*'+\'0'+^{.(;'00'+}*]n*

Lub dla dokładnie tej samej długości

;8:^' '*.'*'+n@'0'+^{.n\(;'00'+}*

Drzewo wygląda niezwykle podobnie do wszystkich innych:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Wersja, która pobiera wysokość ze standardowego wejścia:

~((:^' '*.'*'+\'0'+^{.(;'00'+}*]n*

Początek poprzedniej linii jest jednym z lepszych uśmieszek, które zrobiłem w „przydatnym” programie GolfScript.

Peter Taylor
źródło
10

Skrypt powłoki, 44 znaki

printf %9c\\n \* 0|sed ':x
p;s/ 0/000/;tx
d'

Drukuje to drzewo:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Evan Krall
źródło
9

Klon, 30/37 znaków

Zainspirowany wpisem Matematyki Wizarda , przedstawiam to 30- znakowe polecenie Maple 12:

<`*`,('cat(0$2*i+1)'$i=0..8)>;

Wydajność:

                              [        *        ]
                              [                 ]
                              [        0        ]
                              [                 ]
                              [       000       ]
                              [                 ]
                              [      00000      ]
                              [                 ]
                              [     0000000     ]
                              [                 ]
                              [    000000000    ]
                              [                 ]
                              [   00000000000   ]
                              [                 ]
                              [  0000000000000  ]
                              [                 ]
                              [ 000000000000000 ]
                              [                 ]
                              [00000000000000000]

Mogę również pozbyć się nawiasów kosztem siedmiu dodatkowych znaków:

`*`;for i in$0..8 do;cat(0$2*i+1);od;

Wyjście pominięte - wygląda tak jak powyżej, tylko bez nawiasów. Niestety nie znam żadnego sposobu, aby powstrzymać Maple przed wstawieniem pustych linii między wierszami wyjściowymi w trybie tekstowym. Wygląda lepiej w klasycznym trybie arkusza roboczego. Chyba mogę dołączyć zrzut ekranu ...

zrzut ekranu

(Zrzut ekranu pokazuje wcześniejszą 44-znakową wersję polecenia, ale jestem zbyt leniwy, aby ją powtórzyć. Wynik jest nadal taki sam.)

No i tak, rozmiar jest w pełni regulowany: wystarczy zastąpić 8 z n -2 dla drzewa n- rzędowego. W pierwszym rozwiązaniu przejście powyżej 25 wierszy (lub 10 w GUI) wymaga jednak również ustawienia interfejsu (rtablesize = n ).

(Ps. Myślałem, że udało mi się pokonać GolfScript w najnowszej wersji, ale niestety ... )

Ilmari Karonen
źródło
8

Perl, 42 znaki

say$"x9,"*";say$"x(9-$_),"00"x$_,0for 0..8

Wydajność:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Wysokość drzewa można zmienić między 1 a 11 rzędami, zastępując 8na końcu wartościami od -1do 9. Wyjście powyżej 11 wierszy wymaga również zwiększenia dwóch 9s wcześniej w kodzie, które kontrolują, jak daleko od lewej strony ekranu jest wcięte drzewo.

Ilmari Karonen
źródło
Ten ma 11 rzędów: Chyba drobne zmiany
Averroes
@Averroes: Tak, najpierw założyłem, że powinno to być 10 rzędów plus gwiazda, ale potem policzyłem wiersze w próbce i naprawiłem to.
Ilmari Karonen,
8

Groovy, 65

(p={c,r->println' '*(9-r)+(c*(r*2-1))})'*',1;(1..9).each{p'0',it}

Zaskakująco, drzewo wygląda następująco:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Armand
źródło
Część „post the tree output” służy wprowadzeniu świątecznego nastroju na tę stronę: P
Averroes,
Twoje też mają 11 rzędów!
Averroes,
Mogę to naprawić, dostosowując parametry wysokościowe!
Armand,
8

Ruby, 46 znaków

puts" "*8+?*;9.times{|i|puts"%8s0"%(v=?0*i)+v}

Aby zmienić wysokość, musiałbyś zmienić zarówno 8s, jak i oczywiście 9. Wyjście programu jest następujące:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Edycja : Niewykluczone, że pominąłem dane wyjściowe w pierwszym przesłaniu.

Howard
źródło
1
Zapomniałeś opublikować wynik. :)
Ilmari Karonen,
7

PowerShell, 41

" "*8+"*";0..8|%{" "*(8-$_)+"0"+"0"*$_*2}

Nic dziwnego, że wyświetla to samo drzewo, co drzewo wszystkich innych :-p

Jeśli sparametryzujesz to 8, to da ci rozmiar do twojej konsoli, powiedzmy, 48 znaków :

" "*($w=8)+"*";0..$w|%{" "*($w-$_)+"0"+"0"*$_*2}

Lub, jako pełny skrypt, który wymaga argumentu, 53 znaki :

param($w)" "*$w+"*";0..$w|%{" "*($w-$_)+"0"+"0"*$_*2}

Nazywany wygląda następująco:

PS>: Get-Tree.ps1 8
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Jaykul
źródło
7

Python 3: 62 znaki

print(' '*9+'*',*('\n'+' '*(9-i)+'0'*(i*2+1)for i in range(9)))

Wydajność:

        * 
        0 
       000 
      00000 
     0000000 
    000000000 
   00000000000 
  0000000000000 
 000000000000000
00000000000000000

Zauważ, że to zasadniczo bije odpowiedź @ Ante o 11 znaków, ponieważ ta odpowiedź, po konwersji do Pythona 3, używa 73 znaków.

Zmień każdą 9wartość na inną dla innej wysokości.

Kazark
źródło
3
Myślę, że możesz wcześniej stracić miejsce for.
badp
@badp Thanks - zmieniono z 63 na 62!
Kazark,
6

Python, 59

print' '*9+'*'
for i in range(9):print' '*(9-i)+'0'*(i*2+1)
Patrick
źródło
Dobra robota - to pokazuje, że chociaż odpowiedź @Ante wydłuża się w Pythonie 3, moja odpowiedź w Pythonie 3 jest krótsza w Pythonie 2 ( printnie jest funkcją).
Kazark,
6

Prolog: 183 lub 186

r(0,_,L,L).
r(N,C,L,[C|T]):-N>0,M is N-1,r(M,C,L,T).
y(S,T,C):-r(T,C,[10],X),r(S,32,X,Y),atom_codes(A,Y),write(A).
x(A,B):-A>0,y(A,B,48),C is A-1,D is B+2,x(C,D).
x(N):-y(N,1,42),x(N,1).

Wydruki:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
false.

Może być ściśnięty w przypadku niektórych tłumaczy (np. Używając tab / 1 na SWI)

Wywołaj za pomocą x (N). Gdzie N to liczba wierszy w rzeczywistym drzewie (bez gwiazdy). Nadanie mu stałej wysokości obniżyłoby ją do 183

Paul Butcher
źródło
6

do

To jest wersja C Wade Tandy, ale nieco zmodyfikowana:

           ;
          int
         main(
        ){int i
       =-1,j=0,c
      =10;while(j
     ++<c){printf(
    " ");}{;printf(
   "*");}while(++i<c
  ){for(j=-2;++j<c-i;
 )printf(" ");for(j=0;
++j<2*i;){printf("0");}
          ;;;
        printf(
         "\n")
          ;}}
Skizz
źródło
5

Mathematica, 50

MatrixForm@Prepend[Row/@Table[0,{n,9},{2n-1}],"*"]
Mr.Wizard
źródło
5

Applesoft BASIC, 143 znaki

Ponieważ to pytanie przypomina mi zadanie domowe, które miałem w szkole średniej (kiedy uczyli na Apple // e):

1INPUTH:X=(H*2)-2:C=(X/2):S$="*":O=0:GOSUB2:S$="0":FORO=0TOX-2STEP2:GOSUB2:NEXT:END
2FORS=0TOC-(O/2):?" ";:NEXT:FORI=0TOO:?S$;:NEXT:?"":RETURN

Użyłem JavaScript Applesoft BASIC znalezionego tutaj: http://www.calormen.com/applesoft/

WYDAJNOŚĆ:

?10
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000
sirchristian
źródło
5

Prolog: 127 znaków

p:-write('        *'),h(1).
h(L):-(L<10,nl,w(L,-8),h(L+1));!.
w(L,N):-(N<9,N<L,(L>abs(N)->write('0');write(' ')),w(L,N+1));!.

Wydajność:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true

Używane, Prologponieważ nie byłem w stanie pobić Groovyrekordu bez obejrzenia jego kodu :(.

Rob Fox
źródło
5

PostScript (ze sparametryzowaną wysokością), 114 znaków

/h 9 def/b{{( )=print}repeat}def
h -1 0{dup h eq{dup b(*)=}if dup b h sub neg 2 mul 1 add{(0)=print}repeat()=}for

Wydajność:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

Co chciałeś, żeby to wydrukowało?

MrMRDubya
źródło
4

JavaScript (Rhino: 108, węzeł: 114, konsola programistyczna Webkit: 119, wtyczka jQuery: 132)


Nosorożec jest najkrótszy (ma 108 znaków), ponieważ (a) jego printfunkcja ma krótką nazwę i (b) pozwoli ci przypisać funkcje wbudowane do krótszej nazwy zmiennej. Więc:

h=10,p=print,m='0',a=Array(h-1),s=a.join(' ');p(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);}


Node.js pojawia się w console.logkrótkim momencie (przy 114 znakach), ponieważ jego funkcja drukowania ma dłuższą nazwę, ale pozwoli nam również przypisać ją do krótkiej zmiennej:

h=10,p=console.log,m='0',a=Array(h-1),s=a.join(' ');p(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);}


Jednak konsola deweloperska Webkit (i prawdopodobnie również Firebug) uważa, że p=console.logjest to zbyt podstępne (gdy spróbujesz zadzwonić p(), narzeka na ciebie). Musimy więc wydłużyć czas do 119 znaków:

h=10,m='0',a=Array(h-1),s=a.join(' ');with(console){log(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();log(a.join(' ')+m);}}

(Co ciekawe, withratuje nas tylko postać).


Wreszcie ... wtyczka jQuery (wciąż tweetowana przy 132 znakach!):

$.fn.xms=function(h){var m='0',w=2,l=['*',m];while(w++<h)l.push(m+='00');$(this).css({textAlign:'center'}).html(l.join('\n<br/>'));}

I możesz ją wywołać w stopce tej samej strony: $('#footer').xms(3)

Oczywiście nie musi to być wtyczka ... ponieważ prawdopodobnie musielibyśmy użyć konsoli JavaScript, aby dodać ją do strony i wywołać, mogliśmy po prostu zrobić fragment jQuery :

h=10,m='0',w=2,l=['*',m];while(w++<h)l.push(m+='00');$('#footer').css({textAlign:'center'}).html(l.join('\n<br/>'));

który waży 116 bardziej konkurencyjnych znaków - w rzeczywistości przewyższa inne implementacje konsoli programistów. Ale znowu użycie jQuery i / lub silnika układu przeglądarki można uznać za oszustwo. :)

Weston C.
źródło
4

C, 67

Wiem, że to już dawno minęło, ale to moja pierwsza próba gry w golfa kodowego i myślę, że mam całkiem niezłe rozwiązanie w języku C.

Co ciekawe, wymyśliłem to niezależnie od bardzo podobnego rozwiązania @ Patrick.

I tak, nie wygrywam żadnych więzi z moimi zakodowanymi wartościami;) W każdym razie jestem całkiem zadowolony.

i;main(){for(;i<10;++i)printf("%*s%0*c\n",i?9-i:8,"",i*2,i?32:42);}

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Naciśnij dowolny klawisz, aby kontynuować . . .
JoeFish
źródło
4

Wyrocznia

select lpad('*', 11) from dual
union all
select rpad(' ', 10 - level) || rpad(' ', level * 2, '0') from dual
connect by level <= 9;


          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

10 rows selected.
Phan
źródło
4

PHP, 106 znaków

7 mniej niż poprzednie:

<?php echo str_pad(' ',9)."*\n";for($i=0;$i<9;$i++){echo str_pad("",9-$i).str_pad("",($i*2)+1,"0")."\n";}
Graham Christensen
źródło
2
włącz krótkie tagi i zapisz sobie 3 znaki, lub użyj <?=i zapisz kolejne 5 z „echa”.
Brombomb,
Wiem, że jestem spóźniony o 8 miesięcy, ale codegolf.stackexchange.com/a/6783/4967 :)
Leigh
4

LOLCODE, 527 bajtów

CAN HAS STDIO?
HAI 1.2
IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 8
    VISIBLE " "!
IM OUTTA YR LOOP
VISIBLE "*"
I HAS A SPACES
SPACES R 8
I HAS A ZEROS
ZEROS R 1
IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 9
    IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN SPACES
        VISIBLE " "!
    IM OUTTA YR LOOP
    IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN ZEROS 
        VISIBLE "0"!
    IM OUTTA YR LOOP
    VISIBLE ""
    SPACES R DIFF OF SPACES AN 1
    ZEROS R SUM OF ZEROS AN 2
IM OUTTA YR LOOP
KTHXBYE

Wypróbuj online!

Wydajność:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kevin Traver
źródło
1
To jest kod-golf , więc proszę dodać liczbę bajtów twojego przesłania do nagłówka.
lirtosiast
4

Python, 70 znaków

Nie tak krótkie, ale rekurencyjne rozwiązanie :-)

def a(s):
 print s
 if s<"0":a(s[1:]+"00")
print" "*8+"*"
a(" "*8+"0")

Zmień 8, aby ustawić wysokość.

Ante
źródło
4

JavaScript, 119 znaków

Wyjścia do konsoli Firebug

i=h=9;a=new Array(h);a[0]=a.join(' ');b=a.join('000');a[0]+='*';while(i)a[i--]=b.substr(i,h+i);console.log(a.join('\n'))


        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Jozuego
źródło
2
To właściwie 120 znaków.
Rob Fox
3

PHP 113

Pomyślałem, że włączyłem wersję php:

113 znaków (dostosuj, $haby zmienić wysokość, liczba linii obejmuje gwiazdkę):

$h=10;for($n=0;$n<$h;$n++){$i=$n>0?$n:1;$c=$n<1?"*":"0";echo str_repeat(" ",$h-$i).str_repeat($c,($i*2)-1)."\n";}

Starałem się, aby było to krótkie, nieczytelne i już wiedzieliśmy, że php nie może konkurować w zwięzłości, więc to nic nie wygra, wciąż zabawna łamigłówka.

dane wyjściowe są zgodne ze specyfikacją:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kris
źródło
Twarde kodowanie litlle nieco więcej, 103 znaków, (nie widzisz spacji w pierwszym echu w tym komentarzu) $ n = 0; echo "* \ n"; for ($ i = 9; $ i> 0; $ i -, wypisz str_repeat ('', $ i) .str_repeat ('0', $ n + 9- $ i). "\ n", $ n ++);
Lucia,
twoja zakodowana pierwsza linia straciłaby równowagę, gdybyś zmieniła wysokość drzewa :-(
Kris
3

C, 77

i;main(c){printf("%*c\n",c,42);while(i<c)printf("%*s%0*d\n",c-i,"",i++*2+1,0);}

Przed dokładniejszym przeczytaniem specyfikacji printf miałem tę uroczą małą liczbę do 138 znaków:

#define x sprintf(b,
#define y printf(b,
i;main(c){char b[9]="%%%dc\n",*t="%%%ds%%0%dd\n";x b,c);y 42);while(i<c)x t,c-i,i++*2+1),y "",0);}
Patrick
źródło
3

Java, 192 (198 z param)

class V{public static void main(String[]a){int c=10,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="*";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2*i;)s+="0";System.out.println(s);s="";}}}

Drukuje żądane drzewo:

        *           
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Dla zmiennej wysokości, nieco dłużej:

class W{public static void main(String[]a){int c=a.length,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="*";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2*i;)s+="0";System.out.println(s);s="";}}}

Długość listy argumentów wiersza poleceń określa wysokość (np. java W a a a a aDa wysokość 5).

(Jest to w zasadzie wersja Java rozwiązania Wade Tandy's C.)

Daniel Schneller
źródło
Znam ten został opublikowany jakiś czas temu :), ale tu są dwie rzeczy, które widzę: 1. można używać interfejsu zamiast klasy w Javie 8 2. Aby zapisać dwa znaki, while (++i < c) {-> for (s += "*";++i < c;s = "") {i usunąć s += "*";is = "";
Reinis Mazeiks
3

Vim, 18 bajtów

17i0<esc>qqYPxr q8@qa*

Wypróbuj online w kompatybilnym wstecznie tłumaczu V!

Chociaż jest to bardzo podobne podejście jak mój V odpowiedź, ten jest nie niekonkurującymi od vim fiksuje stary. :)

Wyjaśnienie:

17i0<esc>               " Insert 17 '0's
         qq     q       " Start recording into register 'q'
           YP           " Duplicate this line upwards
             x          " Delete one character
              r         " Replace this character with a space
                 8@q    " Playback macro 'q' 8 times
                    a*  " Append an asterisk
DJMcMayhem
źródło
3

Scala, 74 bajty

val h=10;println(" "*h+"*");for(i<-0 to h-2)println(" "*(h-i)+"0"*(i*2+1))

h - wysokość drzewa

Wydajność

        *          
        0          
       000         
      00000        
     0000000       
    000000000      
   00000000000     
  0000000000000    
 000000000000000   
00000000000000000
Zvezdochet
źródło
2

C, 80

i=9,k=10,j;main(F){while(i)putchar(++j<i?32:j<k?48-F*6:(i-=!F,k+=!F,F=j=0,10));}

Zainicjuj k do wysokości drzewa, i do k-1. F jest flagą pierwszego wiersza. Bez argumentu, F powinno wynosić 1 przy wejściu.

Nieco dłuższa (81) wersja, w której f nie jest flagą pierwszego wiersza:

i=9,k=10,j,f;main(){while(i)putchar(++j<i?32:j<k?42+f*6:(i-=f,k+=f,f=1,j=0,10));}
liczi
źródło