Drucken Sie einen Weihnachtsbaum

26

Die Herausforderung

Drucken Sie einen schönen Weihnachtsbaum mit seinem eigenen Stern oben mit dem kürzestmöglichen Code. Der Baumstern ist ein Stern ( *) und der Baumkörper besteht aus 0Der Baum muss 10 Reihen hoch sein. Jede Zeile sollte ordnungsgemäß so eingerückt sein, dass die vorherige Zeile über der nächsten zentriert ist. Jede angegebene Zeile muss zwei weitere Nullen als die vorherige haben, mit Ausnahme der ersten, bei der es sich um den Stern handelt, und der zweiten, bei der es sich nur um eine 0 handelt. Das Ergebnis sieht ungefähr so ​​aus:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Tie - Break für veränderbare Höhe Bäume ohne Software - Änderungen (außer wechselnden Höhenparameter)

Bitte fügen Sie auch den resultierenden Baum Ihres Codes ein!

Bestenliste

Code-Snippet anzeigen

code-golf ascii-art kolmogorov-complexity Averroes
quelle
3
Nicht gerade ein Duplikat, aber es gibt dieses auf SO: Code Golf Christmas Edition: So drucken Sie einen Weihnachtsbaum der Größe N
Hasturkun

Antworten:

17

Golfscript, 27 Zeichen

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

Der resultierende Baum sieht folgendermaßen aus:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Eine Version, die den Parameter height nur einmal verwendet, ist ein Zeichen länger:

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

Das Lesen der Höhe von stdin (mit der Eingabe "10", um den Beispielbaum zu erzeugen) benötigt die gleiche Anzahl von Zeichen (28):

~,)" "*"*"@{n\.4$>\.+)"0"*}%
Ventero
quelle
56

Ich weiß, dass dies nicht der Spezifikation entspricht, aber ich dachte, ich würde versuchen, den Bäumen hier etwas Abwechslung zu verleihen, indem ich diese klassische ASCII-Kunst-Weihnachtsszene von Joan G. Stark imitiere .

Ich habe nicht versucht, das ganze Bild zu reproduzieren - das wäre ein bisschen zu viel gewesen -, sondern nur den Baum, für den ich dieses 138-Byte-Perl-Programm präsentiere:

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

Und hier ist natürlich ein Beispiel für die Ausgabe:

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

Probieren Sie es online!

Der Code verwendet die Perl 5.10+ say-Funktion und muss daher mit der Befehlszeilenoption -M5.010(oder -E) ausgeführt werden. (Tatsächlich würde nur das Ersetzen des sayam Ende durch das printdas vermeiden, auf Kosten von zwei weiteren Bytes und dem Verlust der Newline nach der letzten Ausgabezeile.)

Beachten Sie, dass der Großteil des Baums zufällig generiert wird, sodass die Platzierung der Ornamente zwischen den Läufen variiert. Der Engel, der Ständer und die oberste Baumreihe sind jedoch fixiert.

Um zu verhindern, dass diese beliebte Antwort im Rahmen einer Richtlinie gelöscht wird , die nach dem Posten eingerichtet wurde , finden Sie hier auch eine Lösung, die den Tokenspezifikationen entspricht (45 Byte, auch Perl 5):

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

Probieren Sie es online!

Wie das obige Programm muss auch dieses unter Perl 5.10+ mit dem -M5.010Schalter ausgeführt werden, um die sayFunktion zu aktivieren . Offensichtlich (dies ist eine Herausforderung der Kolmogorov-Komplexität ) erzeugt es genau die gleiche langweilige Ausgabe wie alle anderen kompatiblen Einträge, die ich hier nicht wiederholen werde. (Die Größe kann auch geringfügig geändert werden, indem die Zahl 10in einen anderen Wert geändert wird .)

Ilmari Karonen
quelle
1
Groß! Nicht von der Spezifikation, aber ich denke, der Judges Special Award ist für Sie! :)
Averroes
6
das wirft die sprichwörtliche spekulation hinter sich, +2 wenn ich könnte.
Kris
3
Tut mir leid, aber gemäß den Regeln müssen Antworten, die die Spezifikation nicht erfüllen, gelöscht werden.
mbomb007
Ich lösche diesen Beitrag in Übereinstimmung mit unserer Richtlinie zu Antworten, die nicht der Herausforderungsspezifikation entsprechen .
Dennis
1
Könnten Sie bitte die gültige Antwort nach oben verschieben und eine Überschrift hinzufügen?
Dennis
13

GolfScript (33 Zeichen)

Version mit fester Höhe:

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

Oder für genau die gleiche Länge

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

Der Baum sieht allen anderen bemerkenswert ähnlich:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Version welche die Höhe von stdin annimmt:

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

Der Anfang der vorherigen Zeile ist einer der besseren Smilies, die ich in einem "nützlichen" GolfScript-Programm gemacht habe.

Peter Taylor
quelle
10

Shell-Skript, 44 Zeichen

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

Druckt diesen Baum:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Evan Krall
quelle
9

Ahorn, 30/37 Zeichen

Inspiriert von Mr.Wizard's Mathematica-Eintrag präsentiere ich diesen Maple 12-Befehl mit 30 Zeichen:

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

Ausgabe:

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

Ich kann die Klammern auch auf Kosten von sieben weiteren Zeichen loswerden:

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

Ausgabe weggelassen - es sieht genauso aus wie oben, nur ohne die Klammern. Leider kann ich Maple nicht davon abhalten, im Textmodus Leerzeilen zwischen die Ausgabezeilen einzufügen. Im klassischen Arbeitsblattmodus sieht es besser aus. Ich denke, ich könnte einen Screenshot hinzufügen ...

Bildschirmfoto

(Der Screenshot zeigt eine frühere 44-Zeichen-Version des Befehls, aber ich bin zu faul, um sie erneut auszuführen. Die Ausgabe ist immer noch dieselbe.)

Oh, und ja, die Größe ist vollständig einstellbar: Ersetzen Sie einfach die 8 durch n -2 für einen n- Zeilen-Baum. Bei der ersten Lösung muss für mehr als 25 Zeilen (oder 10 in der GUI) auch die Schnittstelle festgelegt werden (rtablesize = n ).

(Ps. Ich dachte, ich hätte es geschafft, GolfScript mit der neuesten Version zu schlagen , aber leider ... )

Ilmari Karonen
quelle
8

Perl, 42 Zeichen

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

Ausgabe:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Die Höhe des Baums kann zwischen 1 und 11 Zeilen geändert werden, indem 8am Ende die Werte von -1bis angegeben werden 9. Wenn Sie über 11 Zeilen hinausgehen, müssen Sie auch die zwei 9Sekunden früher im Code erhöhen , um zu steuern, wie weit der Baum von der linken Seite des Bildschirms eingerückt ist.

Ilmari Karonen
quelle
Dieser hat 11 Zeilen: P Kleinere Änderungen, denke ich
Averroes
@Averroes: Ja, ich habe zuerst angenommen, dass es 10 Zeilen plus Stern sein sollen, aber dann habe ich die Zeilen in der Beispielausgabe gezählt und korrigiert.
Ilmari Karonen
8

Groovy, 65 Jahre alt

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

Überraschenderweise sieht der Baum so aus:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Armand
quelle
Der Teil 'Post the Tree Output' ist dafür gedacht, etwas Weihnachtsstimmung auf diese Seite zu bringen: P
Averroes
Sie haben auch 11 Zeilen!
Averroes
Ich kann das beheben, indem ich die Höhenparameter anpasse!
Armand
8

Ruby, 46 Zeichen

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

Um die Höhe zu ändern, müssten Sie beide 8er und natürlich auch die 9er ändern. Die Ausgabe des Programms ist wie folgt:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Edit : Unentschuldlicherweise habe ich die Ausgabe in der ersten Einreichung weggelassen.

Howard
quelle
1
Sie haben vergessen, die Ausgabe zu posten. :)
Ilmari Karonen
7

PowerShell, 41

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

Es überrascht nicht, dass derselbe Baum ausgegeben wird wie der von allen anderen :-p

Wenn Sie diese 8 parametrisieren, ergibt sich eine Konsolengröße von bis zu 48 Zeichen :

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

Oder, als vollwertiges Skript, das ein Argument enthält, 53 Zeichen :

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

Genannt sieht es so aus:

PS>: Get-Tree.ps1 8
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Jaykul
quelle
7

Python 3: 62 Zeichen

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

Ausgabe:

        * 
        0 
       000 
      00000 
     0000000 
    000000000 
   00000000000 
  0000000000000 
 000000000000000
00000000000000000

Beachten Sie, dass dies im Wesentlichen die Antwort von @ Ante um 11 Zeichen übertrifft, da diese Antwort bei der Konvertierung in Python 3 73 Zeichen verwendet.

Ändern Sie jeweils 9einen anderen Wert für eine andere Höhe.

Kazark
quelle
3
Ich denke du kannst auch den Platz vorher verlieren for.
badp
@badp Danke - von 63 auf 62 geändert!
Kazark
6

Python, 59

print' '*9+'*'
for i in range(9):print' '*(9-i)+'0'*(i*2+1)
Patrick
quelle
Gute Arbeit - dies zeigt, dass die Antwort von @Ante in Python 3 länger wird, meine Python 3-Antwort in Python 2 jedoch kürzer ist ( printkeine Funktion).
Kazark
6

Prolog: 183 oder 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).

Drucke:

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

Könnte für bestimmte Dolmetscher weiter gedrückt werden (z. B. mit Tabulator / 1 auf SWI)

Rufe mit x (N) auf. Wobei N die Anzahl der Zeilen im tatsächlichen Baum ist (ohne Stern). Eine feste Höhe würde es auf 183 senken

Paul Butcher
quelle
6

C

Dies ist die C-Version von Wade Tandy, die jedoch ein wenig modifiziert wurde:

           ;
          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
quelle
5

Mathematica, 50

MatrixForm@Prepend[Row/@Table[0,{n,9},{2n-1}],"*"]
Mr.Wizard
quelle
5

Applesoft BASIC, 143 Zeichen

Da diese Frage mich an eine Hausaufgabe erinnert, die ich in der High School hatte (als sie auf einem Apple // e unterrichteten):

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

Ich habe das JavaScript Applesoft BASIC verwendet, das hier zu finden ist: http://www.calormen.com/applesoft/

AUSGABE:

?10
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000
Sirchristian
quelle
5

Prolog: 127 Zeichen

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));!.

Ausgabe:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true

Verwendet, Prologweil ich den GroovyRekord nicht schlagen konnte, ohne auf seinen Code zu schauen :(.

Rob Fox
quelle
5

PostScript (mit parametrierter Höhe), 114 Zeichen

/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

Ausgabe:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

Was, Sie wollten, dass es ausgedruckt wird?

MrMRDubya
quelle
4

JavaScript (Rhino: 108, Knoten: 114, Webkit-Entwicklerkonsole: 119, jQuery-Plugin: 132)


Rhino ist das kürzeste (mit 108 Zeichen), da (a) seine printFunktion einen Kurznamen hat und (b) Sie integrierte Funktionen einem kürzeren Variablennamen zuordnen können. So:

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 kommt in einer knappen Sekunde (mit 114 Zeichen), weil seine Druckfunktion console.logeinen längeren Namen hat, aber wir können das auch einer kurzen Variablen zuweisen:

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


Die Webkit Dev Console (und wahrscheinlich auch Firebug) ist jedoch der Meinung, dass sie p=console.logetwas zu hinterhältig ist (wenn Sie versuchen anzurufen p(), wird sie sich über Sie beschweren). Also müssen wir die Länge auf 119 Zeichen verlängern:

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

(Interessanterweise withrettet uns nur ein Charakter).


Endlich ... ein jQuery-Plugin (noch tweetbar mit 132 Zeichen!):

$.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/>'));}

Und Sie können es in der Fußzeile dieser Seite aufrufen: $('#footer').xms(3)

Natürlich muss es kein Plugin sein ... da wir wahrscheinlich eine JavaScript-Konsole verwenden müssten, um es einer Seite hinzuzufügen und aufzurufen, hätten wir einfach einen Ausschnitt aus jQuery machen können :

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

Das entspricht 116 konkurrenzfähigeren Zeichen - in der Tat übertrifft es die andere Implementierung der Entwicklerkonsole. Andererseits kann die Verwendung von jQuery und / oder der Layout-Engine des Browsers als Betrug angesehen werden. :)

Weston C
quelle
4

C 67

Ich weiß, dass dies schon lange vorbei ist, aber es ist mein erster Versuch, Code Golf zu spielen, und ich denke, ich habe eine ziemlich gute C-Lösung.

Interessanterweise habe ich diese unabhängig von @ Patricks sehr ähnlicher Lösung gefunden.

Und ja, ich werde keine Verbindung mit meinen fest codierten Werten gewinnen;) Ich bin jedenfalls sehr zufrieden.

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
Drücken Sie eine beliebige Taste, um fortzufahren . . .
JoeFish
quelle
4

Orakel

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
quelle
4

PHP, 106 Zeichen

7 weniger als die vorherigen:

<?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
quelle
2
aktivieren Sie kurze Tags und speichern Sie sich 3 Zeichen, oder verwenden Sie die <?=und speichern Sie weitere 5 aus dem "Echo".
Brombomb
Ich weiß, ich bin 8 Monate zu spät, aber codegolf.stackexchange.com/a/6783/4967 :)
Leigh
4

LOLCODE, 527 Bytes

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

Probieren Sie es online!

Ausgabe:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kevin Traver
quelle
1
Dies ist Code-Golf , also fügen Sie bitte die Byteanzahl Ihrer Einreichung in den Header ein.
Lirtosiast
4

Python, 70 Zeichen

Nicht so kurz, aber rekursive Lösung :-)

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

Ändern Sie die 8, um die Höhe einzustellen.

Ante
quelle
4

Javascript, 119 Zeichen

Ausgaben an die Firebug-Konsole

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
Joshua
quelle
2
Das sind tatsächlich 120 Zeichen.
Rob Fox
3

PHP 113

Ich dachte, ich würde mit einer PHP-Version einsteigen:

113 Zeichen (anpassen $h, um die Höhe zu ändern, die Anzahl der Zeilen enthält den Stern):

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

Ich habe versucht, es kurz und nicht lesbar zu machen, und wir wussten bereits, dass PHP nicht konkurrieren kann, also wird dies nichts gewinnen, immer noch ein lustiges kleines Rätsel.

Die Ausgabe erfolgt wie folgt:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kris
quelle
Hardcodierung ein bisschen mehr, 103 Zeichen, (Sie können die Leerzeichen im ersten Echo in diesem Kommentar nicht sehen) $ n = 0; Echo "* \ n"; für ($ i = 9; $ i> 0; $ i -, print str_repeat ('', $ i) .str_repeat ('0', $ n + 9- $ i). "\ n", $ n ++);
Lucia
Ihre fest codierte erste Zeile würde aus dem Gleichgewicht geraten, wenn Sie die Höhe des Baums ändern,
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);}

Bevor ich die printf-Spezifikation genauer durchgelesen habe, hatte ich diese kleine Zahl mit 138 Zeichen:

#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
quelle
3

Java, 192 (198 mit Parameter)

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

Druckt den angeforderten Baum:

        *           
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Bei variabler Höhe etwas länger:

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

Die Länge der Befehlszeilenargumentliste bestimmt die Höhe (z. B. java W a a a a agibt Höhe 5 an).

(Dies ist im Grunde die Java-Version der C-Lösung von Wade Tandy.)

Daniel Schneller
quelle
Ich weiß, dass dies vor einiger Zeit gepostet wurde :), aber hier sind zwei Dinge, die ich sehe: 1. Sie können eine Schnittstelle anstelle einer Klasse in Java 8 verwenden 2. um zwei Zeichen zu speichern, while (++i < c) {-> for (s += "*";++i < c;s = "") {und das s += "*";und dass = "";
Reinis zu
3

Vim, 18 Bytes

17i0<esc>qqYPxr q8@qa*

Probieren Sie es online im abwärtskompatiblen V-Interpreter aus!

Obwohl dies ein sehr ähnlicher Ansatz wie meine V Antwort ist, dann ist dies eine nicht da vim nicht konkurrierenden verrückt alt ist. :)

Erläuterung:

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
quelle
3

Scala, 74 Bytes

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

h - Höhe des Baumes

Ausgabe

        *          
        0          
       000         
      00000        
     0000000       
    000000000      
   00000000000     
  0000000000000    
 000000000000000   
00000000000000000
Zvezdochet
quelle
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));}

Initialisiere k auf die Baumhöhe, i auf k-1. F ist das Flag der ersten Zeile. Ohne Argument sollte F bei der Eingabe 1 sein.

Eine etwas längere (81) Version, in der f kein Flag der ersten Zeile ist:

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));}
Litchie
quelle