Dado um número N, como posso imprimir uma árvore de Natal de altura Nusando o menor número de caracteres de código? Né assumido restrito a um valor mínimo de 3e um valor máximo de 30(limites e verificação de erros não são necessários). Né fornecido como o único argumento de linha de comando para seu programa ou script.

Todos os idiomas são apreciados, se você vir um idioma já implementado e poderá reduzi-lo, edite-o se possível - comente de outra forma e espere que alguém limpe a bagunça. Inclua novas linhas e Espaços em branco para maior clareza, mas não as inclua na contagem de caracteres.

Uma árvore de Natal é gerada como tal, com seu "tronco" consistindo apenas de um "*" centralizado

N = 3:

   *
  ***
 *****
   *

N = 4:

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

N = 5:

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

N define a altura dos galhos, sem incluir o tronco de uma linha.

Feliz Natal PPCG!

J , 24 caracteres

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

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

Explicação:

'*'$~5
*****

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

Em seguida, }:@|."1inverte cada linha e retira a última coluna e ,.grampeia-a para ].

Em seguida, ,{.cola a primeira coluna na parte inferior.

Entradas anteriores :

29 caracteres, sem espaços.

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

   NB. conte de 1 a n , depois 1 novamente
   >: 0, ~ i.3
1 2 3 1
   NB. replicar '*' x vezes cada
   $ & '*' "0>: 0, ~ i.3
*
**
***
*
   NB. inverta cada linha
   (\: i. @ #) "1 $ & '*'" 0>: 0, ~ i.3
  *
 **
***
  *
   NB. tira a coluna principal
   }. "1 $ & '*'" 0>: 0, ~ i.3

*
**

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

Brainfuck, 240 caracteres

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

Ainda não está pronto. Funciona, mas apenas com números de um dígito.

EDIT: Feito! Funciona para intérpretes usando 0 como EOF. Veja NOTEs na fonte comentada para aqueles com -1.

EDITAR novamente: devo observar que, como o Brainfuck não possui um método padrão para ler argumentos de linha de comando, usei stdin (entrada padrão). ASCII, é claro.

EDITE uma terceira vez: Oh, querida, parece que eu retirei .os caracteres (de saída) ao condensar o código. Fixo...

Aqui está o gerenciamento básico de memória do loop principal. Tenho certeza de que pode ser altamente otimizado para reduzir a contagem de caracteres em 30 ou mais.

1. Temporário
2. Cópia do contador
3. Contador (conta até 0)
4. Caractere de espaço (decimal 32)
5. Caractere asterisco (decimal 42)
6. Número de asteriscos na linha atual (1 + 2 * contador)
7. Temporário
8. Caractere de nova linha
9. Temporário?
10. Número total de linhas (ou seja, valor de entrada; armazenado até o final, ao imprimir o tronco)

Versão condensada:

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

E a versão bonita:

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 caracteres

(1 espaços relevantes)

perl: versão de uma linha:

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

e agora com mais espaço em branco:

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

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

Explicação expandida para usuários não-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. 

Idioma: Python (através do shell), Contagem de caracteres: 64 (2 espaços significativos)

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

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

x86 asm de 16 bits, 50 bytes

Ainda não há uma versão de montagem? :)

    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

(Nota: N está limitado a 1 - 9 nesta versão)

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

Baixe aqui

Idioma: Script em lote do Windows ( chocante! )

@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 bytes

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

Feliz Natal a todos!

Edit: Melhorias adicionadas como sugerido por Joshua Swink

Idioma: C #, Contagem de caracteres: 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));
    }
}

Apenas o código, sem formatação (120 caracteres):

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

Versão com 109 caracteres (apenas o código):

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

Resultado da altura = 10:

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

Idioma: dc (através do shell) Contagem de caracteres: 83

Uma versão dc um pouco mais curta:

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

EDIT: mudou a constante 10 para $ 1

python, truque "-c" ... @ 61 caracteres (e uma linha)

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

Aqui está uma versão Haskell razoavelmente eficiente em termos de espaço, com 107 caracteres:

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

executando:

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

Feliz Natal, todos :)

Idioma: dc (através do shell), Contagem de caracteres: 119 (1 espaço significativo)

Apenas pela obscuridade :)

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

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

Melhor C ++, cerca de 210 caracteres:

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

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

Idioma: python, sem truques, 78 caracteres

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

Melhorando a resposta de ΤΖΩΤΖΙΟΥ. Não posso comentar, então aqui está um novo post. 72 caracteres.

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

Usando o truque "python -c", 61 caracteres.

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

Aprendi a função central e que "python -c" pode aceitar mais de um código de linha. Obrigado ΤΖΩΤΖΙΟΥ.

C # usando 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 charcters.

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 caracteres em uma linha.

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

Idioma: Java, Número de caracteres: 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");}}

Para referência, consegui depilar a solução Java anterior, usando recursão, até 231 caracteres, do mínimo anterior de 269. Embora um pouco mais, eu gosto dessa solução porque Té realmente orientada a objetos. Você pode criar uma pequena floresta de Tinstâncias de tamanho aleatório . Aqui está a evolução mais recente dessa abordagem:

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

Idioma: PowerShell, Número de caracteres: 41 (incluindo 1 espaço)

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

21 caracteres com APL dyalog.

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

⍳ fornece um vetor de números inteiros começando com 1.

1, ⍨ adiciona um ao final do vetor. Este será o pé da árvore.

'*' \ ¨⍨ fornece um vetor de * -strings com comprimentos dados pelo vetor anterior.

↑ transforma o vetor em uma matriz e adiciona espaços à direita.

m ← armazena a matriz em m.

0 1 ↓ descarta zero linhas e a primeira coluna.

⌽ inverte a matriz.

m, ⍨ concatena com m no lado direito.

Idioma: C, Char charter: 133

Melhoria da versão 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);
}

Funciona e até leva a altura da árvore como argumento. Precisa de um compilador que tolere código no estilo K&R.

Eu me sinto tão sujo agora .. Esse código é feio.

R (62 bytes)

Ainda não vi a solução R. Corrija-me se eu perdi.

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

Resultado:

> 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="")
    *
   ***
  *****
 *******
*********
    *

Idioma: C, Número de caracteres: 176 (2 espaços relevantes)

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

Versão do shell, 134 caracteres:

#!/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" "*"

Idioma: Python, Contagem significativa de caracteres: 90

É feio, mas funciona:

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

Como esta é uma CW: não gosto que o código de golfe seja sempre organizado em termos de "número de caracteres" ou algo assim. Eles não poderiam ser organizados em termos de número de instruções para o compilador / intérprete (ou algum critério semelhante)? Aqui está a solução Ruby novamente , e é basicamente a mesma, mas agora também para consumo humano:

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

Carvão , 9 bytes (não competitivo)

Ｇ↗↘←Ｎ*Ｍ↓*

Experimente online!

Verbose

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

Experimente online!

Gelatina , 12 bytes

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

Experimente online!

PHP, 111 caracteres

(O último caractere deve ser uma nova linha.)

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

Versão legível:

<?php

$n = $argv[1];

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

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

?>