Imprimer un arbre de Noël

26

Le défi

Imprimez un joli sapin de Noël avec sa propre étoile en haut en utilisant le code le plus court possible. L'étoile de l'arbre est un astérisque ( *) et le corps de l'arbre est composé de 0L'arbre doit avoir 10 lignes de haut. Chaque ligne doit être correctement indentée de la façon dont la ligne précédente est centrée sur la suivante. Toute ligne donnée doit avoir 2 0 de plus que la précédente, à l'exception de la première qui est l'étoile et la seconde, qui n'a qu'un 0. Le résultat est quelque chose comme ceci:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Cravate pour les arbres de hauteur redimensionnables sans modifications logicielles (sauf modification du paramètre de hauteur)

Veuillez également coller l'arborescence résultante de votre code!


Classement

Averroes
la source
3
Pas exactement un double mais il y en a un sur SO: Code Golf Christmas Edition: Comment imprimer un sapin de Noël de hauteur N
Hasturkun

Réponses:

17

Golfscript, 27 caractères

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

L'arbre résultant ressemble à ceci:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Une version qui n'utilise le paramètre de hauteur qu'une seule fois a un caractère de plus:

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

La lecture de la hauteur à partir de stdin (avec l'entrée "10" pour générer l'arbre d'exemple) prend la même quantité de caractères (28):

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

Je sais que cela ne correspond pas aux spécifications, mais j'ai pensé que j'essaierais d'ajouter de la diversité aux arbres ici en imitant cette scène de Noël classique ASCII de Joan G. Stark .

Je n'ai pas essayé de reproduire l'image entière - cela aurait été un peu trop - mais juste l'arbre, pour lequel je présente ce programme Perl de 138 octets:

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

Et, bien sûr, voici un échantillon de la sortie:

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

Essayez-le en ligne!

Le code utilise la fonctionnalité Perl 5.10+ say, et doit donc être exécuté avec le commutateur de ligne de commande -M5.010(ou -E). (En fait, le simple fait de remplacer le sayà la fin par printéviterait cela, au prix de deux octets de plus et la perte de la nouvelle ligne après la dernière ligne de sortie.)

Notez que la majeure partie de l'arbre est générée de manière aléatoire, de sorte que le placement des ornements variera d'une série à l'autre. L'ange, le support et la rangée supérieure de l'arbre sont cependant fixes.


Pour éviter que cette réponse populaire ne soit supprimée sommairement dans le cadre d' une stratégie instituée après sa publication , voici également une solution conforme aux spécifications des jetons (45 octets, également Perl 5):

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

Essayez-le en ligne!

Comme le programme ci-dessus, celui-ci doit également être exécuté sur Perl 5.10+ avec le -M5.010commutateur pour activer la sayfonctionnalité. De toute évidence (ceci étant un ), il produit exactement la même sortie ennuyeuse que toutes les autres entrées conformes, que je ne prendrai pas la peine de répéter ici. (Il est également facilement redimensionnable en changeant le nombre 10en toute autre valeur.)

Ilmari Karonen
la source
1
Génial! Pas selon les spécifications mais je pense que le prix spécial des juges est pour vous! :)
Averroes
6
cela donne un coup de pied au proverbial des spécifications, +2 si je le pouvais.
Kris
3
Désolé, mais selon les règles, les réponses qui ne répondent pas aux spécifications doivent être supprimées.
mbomb007
1
Pourriez-vous s'il vous plaît déplacer la réponse valide vers le haut et ajouter un en-tête?
Dennis
13

GolfScript (33 caractères)

Version à hauteur fixe:

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

Ou pour exactement la même longueur

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

L'arbre ressemble remarquablement à tout le monde:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Version qui prend de la hauteur de stdin:

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

Le début de la ligne précédente est l'un des meilleurs smileys que j'ai faits dans un programme GolfScript "utile".

Peter Taylor
la source
10

Script shell, 44 caractères

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

Imprime cet arbre:

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

Érable, 30/37 caractères

Inspiré par l'entrée Mathematica de Mr.Wizard , je présente cette commande Maple 12 de 30 caractères:

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

Sortie:

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

Je peux également me débarrasser des crochets au prix de sept caractères supplémentaires:

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

Sortie omise - elle ressemble à celle ci-dessus, mais sans les crochets. Malheureusement, je ne connais aucun moyen d'empêcher Maple d'insérer des lignes vides entre les lignes de sortie en mode texte. Il semble meilleur en mode feuille de calcul classique. Je suppose que je pourrais inclure une capture d'écran ...

capture d'écran

(La capture d'écran montre une version antérieure de 44 caractères de la commande, mais je suis trop paresseux pour la reprendre. La sortie est toujours la même.)

Oh, et oui, la taille est entièrement réglable: remplacez simplement le 8 par n -2 pour un arbre à n- flèches. Avec la première solution, aller au-dessus de 25 lignes (ou 10 dans l'interface graphique) nécessite également de définir l'interface (rtablesize = n ).

(Ps. Je pensais avoir réussi à battre GolfScript avec la dernière version, mais hélas ... )

Ilmari Karonen
la source
8

Perl, 42 caractères

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

Sortie:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

La hauteur de l'arbre peut être modifiée entre 1 et 11 lignes en remplaçant le 8à la fin par les valeurs de -1à 9. Aller au-dessus de 11 lignes nécessite également d'augmenter les deux 9s plus tôt dans le code, qui contrôlent la distance entre le côté gauche de l'écran et l'arborescence.

Ilmari Karonen
la source
Celui-ci a 11 rangées: P changements mineurs je suppose
Averroes
@Averroes: Oui, j'ai d'abord supposé qu'il était censé être 10 lignes plus l'étoile, mais j'ai ensuite compté les lignes dans la sortie de l'échantillon et l'ai corrigé.
Ilmari Karonen
8

Groovy, 65

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

Étonnamment, l'arbre ressemble à ceci:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Armand
la source
La partie 'poster la sortie de l'arbre' est pour apporter un peu d'esprit de Noël à ce site: P
Averroes
De plus, la vôtre a aussi 11 rangées!
Averroes
Je peux résoudre ce problème en ajustant le ou les paramètres de hauteur!
Armand
8

Ruby, 46 caractères

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

Afin de changer la hauteur, vous devez changer les deux 8 et bien sûr aussi le 9. La sortie du programme est la suivante:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Edit : Inexcusably j'ai omis la sortie dans la première soumission.

Howard
la source
1
Vous avez oublié de publier la sortie. :)
Ilmari Karonen
7

PowerShell, 41

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

Sans surprise, génère la même arborescence que celle de tout le monde :-p

Si vous paramétrez ce 8, cela donnera jusqu'à la taille de votre console, en disons 48 caractères :

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

Ou, comme un script complet qui prend un argument, 53 caractères :

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

Appelé, il ressemble à:

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

Python 3: 62 caractères

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

Sortie:

        * 
        0 
       000 
      00000 
     0000000 
    000000000 
   00000000000 
  0000000000000 
 000000000000000
00000000000000000

Notez que cela dépasse essentiellement la réponse de @ Ante de 11 caractères, car cette réponse, lorsqu'elle est convertie en Python 3, utilise 73 caractères.

Remplacez chacun 9par une autre valeur pour une hauteur différente.

Kazark
la source
3
Je pense que vous pouvez également perdre de l'espace avant for.
badp
@badp Merci - changé de 63 à 62!
Kazark
6

Python, 59

print' '*9+'*'
for i in range(9):print' '*(9-i)+'0'*(i*2+1)
Patrick
la source
Beau travail - cela démontre que bien que la réponse de @Ante s'allonge en Python 3, ma réponse Python 3 est plus courte en Python 2 ( printpas une fonction).
Kazark
6

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

Tirages:

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

Pourrait être resserré davantage pour certains interprètes (par exemple en utilisant tab / 1 sur SWI)

Appelez avec x (N). Où N est le nombre de lignes dans l'arbre réel (à l'exclusion de l'étoile). Lui donner une hauteur fixe le ramènerait à 183

Paul Butcher
la source
6

C

Ceci est la version C de Wade Tandy mais modifiée un peu:

           ;
          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
la source
5

Mathematica, 50

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

Applesoft BASIC, 143 caractères

Étant donné que cette question me rappelle un devoir que j'avais de retour au lycée (quand ils enseignaient sur un 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

J'ai utilisé le JavaScript Applesoft BASIC trouvé ici: http://www.calormen.com/applesoft/

SORTIE:

?10
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000
sirchristian
la source
5

Prolog: 127 caractères

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

Sortie:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true 

Utilisé Prologcar je n'ai pas pu battre le Groovyrecord sans regarder son code :(.

Rob Fox
la source
5

PostScript (avec hauteur paramétrée), 114 caractères

/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

Sortie:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

Quoi, vous vouliez l'imprimer?

MrMRDubya
la source
4

JavaScript (Rhino: 108, Node: 114, Webkit Dev Console: 119, plugin jQuery: 132)


Rhino est le plus court (à 108 caractères) car (a) sa printfonction a un nom court et (b) il vous permettra d'assigner des fonctions intégrées dans un nom de variable plus court. Alors:

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 vient juste après (à 114 caractères) parce que sa fonction d'impression console.loga un nom plus long, mais cela nous permettra également d'assigner cela à une courte variable:

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


Cependant, la console de développement Webkit (et probablement Firebug aussi) pense que p=console.logc'est un peu trop sournois (lorsque vous essayez d'appeler p(), cela va vous plaindre). Donc, nous devons allonger les choses à 119 caractères:

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

(Fait intéressant, withne nous sauve qu'un personnage).


Enfin ... un plugin jQuery (toujours tweetable à 132 caractères!):

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

Et vous pouvez l'invoquer en pied de page de cette même page: $('#footer').xms(3)

Bien sûr, il n'est pas nécessaire que ce soit un plugin ... puisque nous aurions probablement à utiliser une console JavaScript pour l'ajouter à une page et l'invoquer, nous aurions pu juste faire un extrait de 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/>'));

qui pèse 116 caractères plus compétitifs - en fait, il bat l'autre implémentation de la console de développement. Mais, encore une fois, l'utilisation de jQuery et / ou du moteur de mise en page du navigateur peut être considérée comme de la triche. :)

Weston C
la source
4

C, 67

Je sais que c'est fini depuis longtemps, mais c'est ma première tentative de golf de code, et je pense que j'ai une assez belle solution C.

Fait intéressant, j'ai trouvé cela indépendamment de la solution très similaire de @ Patrick.

Et oui, je ne gagnerai aucun lien avec mes valeurs codées en dur;) Je suis quand même très content.

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
Appuyez sur n'importe quelle touche pour continuer . . .
JoeFish
la source
4

Oracle

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
la source
4

PHP, 106 caractères

7 de moins que le précédent:

<?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
la source
2
activez les balises courtes et enregistrez-vous 3 caractères, ou utilisez le <?=et enregistrez 5 autres dans "l'écho".
Brombomb
Je sais que j'ai 8 mois de retard, mais codegolf.stackexchange.com/a/6783/4967 :)
Leigh
4

LOLCODE, 527 octets

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

Essayez-le en ligne!

Sortie:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kevin Traver
la source
1
Il s'agit de code-golf , veuillez donc ajouter le nombre d'octets de votre soumission à l'en-tête.
lirtosiast
4

Python, 70 caractères

Pas si court, mais solution récursive :-)

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

Changez les 8 pour régler la hauteur.

Ante
la source
4

Javascript, 119 caractères

Sorties vers la console 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
Joshua
la source
2
Il s'agit en fait de 120 caractères.
Rob Fox
3

PHP 113

J'ai pensé que je jouerais avec une version php:

113 caractères (ajustez $hpour changer la hauteur, le nombre de lignes inclut l'étoile):

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

J'ai essayé de le rendre court, non lisible et nous savions déjà que php ne peut pas rivaliser sur la concision, donc cela ne va rien gagner, encore un petit puzzle amusant.

la sortie est comme spec:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kris
la source
Codage en dur un peu plus, 103 caractères, (vous ne pouvez pas voir les espaces dans le premier écho à l'intérieur de ce commentaire) $ n = 0; echo "* \ n"; for ($ i = 9; $ i> 0; $ i -, affichez str_repeat ('', $ i) .str_repeat ('0', $ n + 9- $ i). "\ n", $ n ++);
Lucia
votre première ligne codée en dur se déséquilibrerait si vous modifiez la hauteur de l'arbre tho :-(
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);}

Avant de lire la spécification printf plus attentivement, j'avais ce joli petit numéro à 138 caractères:

#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
la source
3

Java, 192 (198 avec 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="";}}}

Imprime l'arborescence demandée:

        *           
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Pour une hauteur variable, légèrement plus longue:

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

La longueur de la liste des arguments de la ligne de commande détermine la hauteur (par exemple java W a a a a a , donnera la hauteur 5).

(Il s'agit essentiellement de la version Java de la solution C de Wade Tandy.)

Daniel Schneller
la source
Je sais que cela a été publié il y a quelque temps :), mais voici deux choses que je vois: 1. vous pouvez utiliser une interface au lieu d'une classe en java 8 2. pour enregistrer deux caractères, while (++i < c) {-> for (s += "*";++i < c;s = "") {, et supprimer le s += "*";et les = "";
Reinis Mazeiks
3

Vim, 18 octets

17i0<esc>qqYPxr q8@qa*

Essayez-le en ligne dans l'interpréteur V rétrocompatible!

Bien que ce soit une approche très similaire à ma réponse en V, celle-ci est pas non concurrente car vim est un vieux fou. :)

Explication:

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
la source
3

Scala, 74 octets

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

h - hauteur de l'arbre

Sortie

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

Initialisez k à la hauteur de l'arbre, i à k-1. F est le drapeau de première ligne. Étant donné aucun argument, alors F devrait être 1 à l'entrée.

Une version légèrement plus longue (81) où f n'est pas le drapeau de première ligne:

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
la source