Étant donné un numéro N, comment puis-je imprimer un sapin de Noël de hauteur en Nutilisant le moins de caractères de code? Nest supposé contraint à une valeur minimale de 3, et à une valeur maximale de 30(les bornes et la vérification des erreurs ne sont pas nécessaires). Nest le seul et unique argument de ligne de commande de votre programme ou de votre script.

Toutes les langues sont appréciées, si vous voyez une langue déjà implémentée et que vous pouvez la raccourcir, modifiez-la si possible - commentez sinon et espérez que quelqu'un nettoie les dégâts. Incluez des nouvelles lignes et des espaces blancs pour plus de clarté, mais ne les incluez pas dans le nombre de caractères.

Un arbre de Noël est généré en tant que tel, avec son "tronc" composé uniquement d'un "*" centré

N = 3:

   *
  ***
 *****
   *

N = 4:

    *
   ***
  *****
 *******
    *

N = 5:

     *
    ***
   *****
  *******
 *********
     *

N définit la hauteur des branches, sans compter le tronc d'une ligne.

Joyeux Noël PPCG!

J , 24 caractères

(,{.)(}:@|."1,.])[\'*'$~

   (,{.)(}:@|."1,.])[\'*'$~5
    *    
   ***   
  *****  
 ******* 
*********
    *    

Explication:

'*'$~5
*****

[\'*'$~5
*    
**   
***  
**** 
*****

}:@|."1Inverse ensuite chaque ligne, enlève la dernière colonne et ,.agrafe ].

Puis ,{.colle la première colonne sur le bas.

Entrées précédentes :

29 caractères, pas d'espaces du tout.

   ((\: i. @ #),}.) "1 $ & '*'" 0>: 0, ~ i.3
  *
 ***
*****
  *
   ((\: i. @ #),}.) "1 $ & '*'" 0>: 0, ~ i.11
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 ********************
**********************
          *

   NB compter de 1 à n , puis à nouveau 1
   >: 0, ~ i.3
1 2 3 1
   NB répliquer '*' x fois chaque
   $ & '*' "0>: 0, ~ i.3
*
**
***
*
   NB inverser chaque rangée
   (\: i. @ #) "1 $ & '*'" 0>: 0, ~ i.3
  *
 **
***
  *
   NB enlever la colonne de tête
   }. "1 $ & '*'" 0>: 0, ~ i.3

*
**

   NB coller ensemble
   ((\: i. @ #),}.) "1 $ & '*'" 0>: 0, ~ i.3
  *
 ***
*****
  *

Brainfuck, 240 caractères

              ,
             >++
            +++++
           +[-<---
          --->],[>+
         +++++++[-<-
        ----->]<<[->+
       +++++++++<]>>]<
      [->+>+>>>>>>>+<<<
     <<<<<<]>>>>++++++++
    [-<++++>]>++++++[-<++
   +++++>]+>>>++[-<+++++>]
  <<<<<<[-[>.<-]<[-<+>>+<]<
 [->+<]>>>>>[-<.>>+<]>[-<+>]
>.<<++<<<-<->]>>>>>>>-[-<<<<<
           <.>>>
           >>>]<
           <<<<.

Pas encore fait. Cela fonctionne, mais seulement avec des nombres à un chiffre.

EDIT: fait! Fonctionne pour les interprètes utilisant 0 comme EOF. Voir NOTEs dans la source commentée pour ceux avec -1.

EDIT à nouveau: je dois noter que, comme Brainfuck n’a pas de méthode standard pour lire les arguments en ligne de commande, j’ai utilisé stdin (entrée standard). ASCII, bien sûr.

EDIT une troisième fois: Oh mon Dieu, il semble que j’ai enlevé .des caractères lors de la condensation du code. Fixé...

Voici la gestion de base de la mémoire de la boucle principale. Je suis sûr que cela peut être fortement optimisé pour réduire le nombre de personnages de 30 ou plus.

1. Temporaire
2. Copie de compteur
3. Compteur (compte jusqu'à 0)
4. Caractère d'espace (décimal 32)
5. Caractère astérisque (décimal 42)
6. Nombre d'astérisques sur la ligne en cours (compteur 1 + 2 *)
7. Temporaire
8. Nouveau caractère de ligne
9. Temporaire?
10. Nombre total de lignes (c.-à-d. Valeur d'entrée; stockées jusqu'à la toute fin lors de l'impression du tronc)

Version condensée:

,>++++++++[-<------>],[>++++++++[-<------>]<<[->++++++++++<]>>]<[->+>+>>>>>>>+<<<<<<<<<]>>>>++++++++[-<++++>]>++++++[-<+++++++>]+>>>++[-<+++++>]<<<<<<[-[>.<-]<[-<+>>+<]<[->+<]>>>>>[-<.>>+<]>[-<+>]>.<<++<<<-<->]>>>>>>>-[-<<<<<<.>>>>>>]<<<<<.

Et la jolie version:

ASCII to number
,>
++++++++[-<------>]  = 48 ('0')

Second digit (may be NULL)
,
NOTE:   Add plus sign here if your interpreter uses negative one for EOF
[ NOTE: Then add minus sign here
 >++++++++[-<------>]
 <<[->++++++++++<]>>  Add first digit by tens
]

Duplicate number
<[->+>+>>>>>>>+<<<<<<<<<]>>

Space char
>>++++++++[-<++++>]

Asterisk char
>++++++[-<+++++++>]

Star count
+

New line char
>>>++[-<+++++>]<<<

<<<

Main loop
[
Print leading spaces
-[>.<-]

Undo delete
<[-<+>>+<]
<[->+<]
>>

Print stars
>>>[-<.>>+<]

Add stars and print new line
>[-<+>]
>.<
<++

<<<

-<->
End main loop
]

Print the trunk
>>>>>>>
-[-<<<<<<.>>>>>>]
<<<<<.

Merry Christmas =)

Perl, 50 caractères

(1 espaces pertinents)

perl: version une ligne:

print$"x($a-$_),'*'x($_*2+1),$/for 0..($a=pop)-1,0

et maintenant avec plus de blanc:

print $"  x ( $a - $_ ),             #"# Syntax Highlight Hacking Comment
      '*' x ( $_ * 2  + 1),
      $/
for 0 .. ( $a = pop ) - 1, 0;

$ perl tree.pl 3
   *
  ***
 *****
   *
$ perl tree.pl 11
           *
          ***
         *****
        *******
       *********
      ***********
     *************
    ***************
   *****************
  *******************
 *********************
           *
$ 

Explication développée pour les utilisateurs non-Perl.

# print $Default_List_Seperator ( a space )  
#     repeated ( $a - $currentloopiterationvalue ) times,
print $" x ( $a - $_ ), 
#"# print '*' repeated( $currentloopiteration * 2 + 1 ) times. 
  '*' x ( $_ * 2  + 1),
# print $Default_input_record_seperator ( a newline )
  $/
# repeat the above code, in a loop, 
#   iterating values 0 to ( n - 1) , and then doing 0 again
for 0 .. ( $a = pop ) - 1, 0;
# prior to loop iteration, set n to the first item popped off the default list, 
#   which in this context is the parameters passed on the command line. 

Langue: Python (par le biais de shell), Nombre de caractères: 64 (2 espaces significatifs)

python -c "
n=w=$1
s=1
while w:
    print' '*w+'*'*s
    s+=2
    w-=1
print' '*n+'*'"

$ sh ax6 11
           *
          ***
         *****
        *******
       *********
      ***********
     *************
    ***************
   *****************
  *******************
 *********************
           *

x86 asm 16 bits, 50 octets

Pas encore de version d'assemblage? :)

    bits 16
    org 100h

    mov si, 82h
    lodsb
    aaa
    mov cx, ax
    mov dx, 1
    push cx 
    mov al, 20h
    int 29h
    loop $-2
    push dx
    mov al, 2ah
    int 29h
    dec dx
    jnz $-3
    pop dx
    mov al, 0ah
    int 29h
    inc dx
    inc dx
    pop cx
    loop $-23
    shr dx, 1
    xchg cx, dx
    mov al, 20h
    int 29h
    loop $-2
    mov al, 2ah
    int 29h
    ret

(Remarque: N est limité à 1 - 9 dans cette version)

G:\>tree 9
         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
         *

Télécharger ici

Langue: Script batch Windows ( choquant! )

@echo off
echo Enable delayed environment variable expansion with CMD.EXE /V

rem Branches
for /l %%k in (1,1,%1) do (
set /a A=%1 - %%k
set /a B=2 * %%k - 1
set AA=
for /l %%i in (1,1,!A!) do set "AA=!AA! "
set BB=
for /l %%i in (1,1,!B!) do set BB=*!BB!
echo !AA!!BB!
)

rem Trunk
set /a A=%1 - 1
set AA=
for /l %%i in (1,1,!A!) do set "AA=!AA! "
echo !AA!*

Ruby, 64 octets

n=ARGV[0].to_i
((1..n).to_a+[1]).each{|i|puts' '*(n-i)+'*'*(2*i-1)}

n=$*[0].to_i
((1..n).to_a<<1).each{|i|puts' '*(n-i)+'*'*(2*i-1)}

Joyeux Noël à tous!

Edit: Améliorations ajoutées comme suggéré par Joshua Swink

Langue: C #, Nombre de personnages: 120

static void Main(string[] a)
{
    int h = int.Parse(a[0]);

    for (int n = 1; n < h + 2; n++)
        Console.WriteLine(n <= h ?
            new String('*', n * 2 - 1).PadLeft(h + n) :
            "*".PadLeft(h + 1));
    }
}

Juste le code, sans formatage (120 caractères):

int h=int.Parse(a[0]);for(int n=1;n<h+2;n++)Console.WriteLine(n<=h?new String('*',n*2-1).PadLeft(h+n):"*".PadLeft(h+1));

Version avec 109 caractères (juste le code):

for(int i=1,n=int.Parse(a[0]);i<n+2;i++)Console.WriteLine(new String('*',(i*2-1)%(n*2)).PadLeft((n+(i-1)%n)));

Résultat pour height = 10:

          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************
          *

Langue: dc (via shell) Nombre de personnages: 83

Version dc un peu plus courte:

dc -e '?d1rdsv[d32r[[rdPr1-d0<a]dsaxszsz]dsbx1-rd42rlbx2+r10Plv1-dsv0<c]dscxszsz32rlbx[*]p' <<<$1

EDIT: changé constante 10 en 1 $

Python, astuce "-c" ... @ 61 caractères (et une ligne)

python -c"for i in range($1)+[0]:print' '*($1-i)+'*'*(2*i+1)"

Voici une version de Haskell raisonnablement peu encombrante, avec 107 caractères:

main=interact$(\g->unlines$map(\a->replicate(g-a)' '++replicate(a*2-1)'*')$[1..g]++[1]).(read::[Char]->Int)

le lancer:

$ echo 6 | runhaskell tree.hs
     *
    ***
   *****
  *******
 *********
***********
     *

Joyeux Noël à tous :)

Langue: dc (via shell), Nombre de personnages: 119 (1 espace significatif)

Juste pour l'obscurité de celui-ci :)

dc -e "$1dsnsm"'
[[ ]n]ss
[[*]n]st
[[
]n]sl
[s2s1[l2xl11-ds10<T]dsTx]sR
[lndlslRxlcdltlRxllx2+sc1-dsn0<M]sM
1sclMxlmlslRxltxllx
'

$ sh ax3 10
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************
          *

Meilleur C ++, environ 210 caractères:

#include <iostream>
using namespace std;
ostream& ChristmasTree(ostream& os, int height) {
    for (int i = 1; i <= height; ++i) {
        os << string(height-i, ' ') << string(2*i-1, '*') << endl;
    }
    os << string(height-1, ' ') << '*' << endl;
    return os;
}

Réduit à 179:

#include <iostream>
using namespace std;ostream& xmas(ostream&o,int h){for(int i=1;i<=h;++i){o<<string(h-i,' ')<<string(2*i-1,'*')<<endl;}o<<string(h-1,' ')<<'*'<<endl;return o;}

Langue: python, pas d'astuce, 78 caractères

import sys
n=int(sys.argv[1])
for i in range(n)+[0]:print' '*(n-i)+'*'*(2*i+1)

Groovy 62B

n=args[0]as Long;[*n..1,n].any{println' '*it+'*'*(n-~n-it*2)}

_

n = args[0] as Long
[*n..1, n].any{ println ' '*it + '*'*(n - ~n - it*2) }

Améliorer la réponse de Ω. Je ne peux pas commenter, alors voici un nouveau post. 72 caractères.

import sys
n=int(sys.argv[1])
for i in range(n)+[0]:
   print ("*"*(2*i+1)).center(2*n)

Utilisation de l'astuce "python -c", 61 caractères.

python -c "
for i in range($1)+[0]:
   print ('*'*(2*i+1)).center(2*$1)
"

J'ai appris la fonction de centre et que "python -c" peut accepter plus d'un code de ligne. Merci, ΩΤΖΙΟΥ.

C # en utilisant Linq:

    using System;
    using System.Linq;
    class Program
        {
            static void Main(string[] args)
            {
                int n = int.Parse(args[0]);
                int i=0;
                Console.Write("{0}\n{1}", string.Join("\n", 
                   new int[n].Select(r => new string('*',i * 2 + 1)
                   .PadLeft(n+i++)).ToArray()),"*".PadLeft(n));
            }
       }

170 caractères.

int n=int.Parse(a[0]);int i=0;Console.Write("{0}\n{1}",string.Join("\n",Enumerable.Repeat(0,n).Select(r=>new string('*',i*2+1).PadLeft(n+i++)).ToArray()),"*".PadLeft(n));

AWK, 86 caractères sur une ligne.

awk '{s="#";for(i=0;i<$1;i++){printf"%"$1-i"s%s\n","",s;s=s"##"}printf"%"$1"s#\n",""}'

echo "8" | awk '{s="#";for(i=0;i<$1;i++){printf"%"$1-i"s%s\n","",s;s=s"##"}printf"%"$1"s#\n",""}'
        #
       ###
      #####
     #######
    #########
   ###########
  #############
 ###############
        #

cat tree.txt
3
5

awk '{s="#";for(i=0;i<$1;i++){printf"%"$1-i"s%s\n","",s;s=s"##"}printf"%"$1"s#\n",""}' tree.txt
   #
  ###
 #####
   #
     #
    ###
   #####
  #######
 #########
     #

Langue: Java, Nombre de personnages: 219

class T{ /* 219 characters */
  public static void main(String[] v){
    int n=new Integer(v[0]);
    String o="";
    for(int r=1;r<=n;++r){
      for(int s=n-r;s-->0;)o+=' ';
      for(int s=1;s<2*r;++s)o+='*';
      o+="%n";}
    while(n-->1)o+=' ';
    System.out.printf(o+"*%n");}}

Pour référence, j'ai pu réduire la précédente solution Java en utilisant la récursivité, passant du minimum précédent à 231 caractères à 239 caractères T. Vous pouvez créer une petite forêt d' Tinstances de taille aléatoire . Voici la dernière évolution sur ce point:

class T{ /* 231 characters */
  public static void main(String[] v){new T(new Integer(v[0]));}}
  String o="";
  T(int n){
    for(int r=1;r<=n;++r){
      x(' ',n-r);x('*',2*r-1);o+="%n";}
    x(' ',n-1);
    System.out.printf(o+"*%n");
  }
  void x(char c,int x){if(x>0){o+=c;x(c,x-1);}
 }

Langue: PowerShell, Nombre de personnages: 41 (incluant 1 espace)

1..$args[0]+1|%{" "*(30-$_)+"*"*($_*2-1)}

21 caractères avec APL dyalog.

m,⍨⌽0 1↓m←↑'*'\¨⍨1,⍨⍳

Donne un vecteur d'entiers commençant par 1.

1, ⍨ ajoute un un à la fin du vecteur. Ce sera le pied de l'arbre.

'*' \ ¨⍨ donne un vecteur de * chaînes de longueurs données par le vecteur précédent.

↑ transforme le vecteur en matrice et ajoute des espaces à droite.

m ← stocke la matrice dans m.

0 1 ↓ supprime zéro ligne et la première colonne.

⌽ inverse la matrice.

m, ⍨ concatène avec m sur le côté droit.

Langue: C, Nombre de personnages: 133

Amélioration de la version C

char s[61];

l(a,b){printf("% *.*s\n",a,b,s);}

main(int i,char**a){
  int n=atoi(a[1]);memset(s,42,61);
  for(i=0;i<n;i++)l(i+n,i*2+1);l(n,1);
}

Fonctionne et prend même la hauteur de l’arbre comme argument. Besoin d'un compilateur qui tolère le code de style K & R.

Je me sens tellement sale maintenant .. Ce code est moche.

R (62 octets)

Je n'ai pas encore vu de solution R. Corrigez-moi si je l'ai raté.

for(i in c(1:N,1))cat(rep(" ",N-i),rep("*",2*i-1),"\n",sep="")

Sortie:

> N <- 3
> for(i in c(1:N,1))cat(rep(" ",N-i),rep("*",2*i-1),"\n",sep="")
  *
 ***
*****
  *
> 
> N <- 4
> for(i in c(1:N,1))cat(rep(" ",N-i),rep("*",2*i-1),"\n",sep="")
   *
  ***
 *****
*******
   *
> 
> N <- 5
> for(i in c(1:N,1))cat(rep(" ",N-i),rep("*",2*i-1),"\n",sep="")
    *
   ***
  *****
 *******
*********
    *

Langue: C, Nombre de personnages: 176 (2 espaces pertinents)

#include <stdio.h>
#define P(x,y,z) for(x=0;x++<y-1;)printf(z);
main(int c,char **v){int i,j,n=atoi(v[1]);for(i=0;i<n;i++){P(j,n-i," ")P(j,2*i+2,"*")printf("\n");}P(i,n," ")printf("*\n");}

Version shell, 134 caractères:

#!/bin/sh
declare -i n=$1
s="*"
for (( i=0; i<$n; i++ )); do
    printf "%$(($n+$i))s\n" "$s"
    s+="**"
done
printf "%$(($n))s\n" "*"

Langue: Python, Nombre de personnages significatifs: 90

C'est moche mais ça marche:

import sys
n=int(sys.argv[1])
print"\n".join(" "*(n-r-1)+"*"*(r*2+1)for r in range(n)+[0])

...

$ python tree.py 13
            *
           ***
          *****
         *******
        *********
       ***********
      *************
     ***************
    *****************
   *******************
  *********************
 ***********************
*************************
            *

Comme il s’agit d’un CW: Je n’aime pas que le code soit toujours organisé en termes de "nombre de caractères" ou d’autres. Ne pourraient-ils pas être organisés en termes de nombre d'instructions pour le compilateur / interprète (ou un critère similaire)? Voici à nouveau la solution Ruby , et elle est fondamentalement la même, mais maintenant pour la consommation humaine:

SPACE = " "
ASTERISK = "*"
height_of_tree=ARGV[0].to_i
tree_lines = (1..height_of_tree).to_a
tree_lines.push 1 # trunk
tree_lines.each do | line |
   spaces_before = SPACE*(height_of_tree-line)
   asterisks = ASTERISK*(2*line-1) 
   puts spaces_before + asterisks
end

Fusain , 9 octets (sans compétition)

Ｇ↗↘←Ｎ*Ｍ↓*

Essayez-le en ligne!

Verbeux

Polygon(:UpRight, :DownRight, :Left, InputNumber(), "*")
Move(:Down)
Print("*")

Essayez-le en ligne!

Gelée , 12 octets

R”*ẋz⁶ṚŒBṁ‘Y

Essayez-le en ligne!

PHP, 111 caractères

(Le tout dernier caractère devrait être une nouvelle ligne.)

<?php $n=$argv[1];for($r='str_repeat';$i<$n;$i++)echo $r(' ',$n-$i).$r('*',$i*2+1)."\n";echo $r(' ',$n).'*' ?>

Version lisible:

<?php

$n = $argv[1];

for ($r = 'str_repeat'; $i < $n; $i++)
    echo $r(' ', $n - $i) . $r('*' , $i * 2 + 1) . "\n";

echo $r(' ', $n) . '*'

?>