Imprimir uma árvore de Natal

26

O desafio

Imprima uma bela árvore de Natal com sua própria estrela no topo usando o código mais curto possível. A estrela da árvore é um asterisco ( *) e o corpo da árvore é formado por 0A árvore deve ter 10 linhas de altura. Cada linha deve ser recuada adequadamente da maneira que a linha anterior é centralizada na próxima. Qualquer linha deve ter 2 mais 0s que a anterior, exceto a primeira que é a estrela e a segunda, que possui apenas um 0. O resultado é algo como isto:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Laço de ruptura para árvores de altura redimensionável sem mudanças de software (excepto mudando parâmetro altura)

Por favor, cole a árvore resultante do seu código também!

Entre os melhores

Mostrar snippet de código

code-golf ascii-art kolmogorov-complexity Averroes
fonte
3
Não é exatamente um duplicado, mas não há esta no SO: Código Golf Christmas Edition: Como imprimir uma árvore de Natal da altura N
Hasturkun

Respostas:

17

Golfscript, 27 caracteres

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

A árvore resultante é assim:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Uma versão que usa o parâmetro height apenas uma vez tem mais um caractere:

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

A leitura da altura do stdin (com a entrada "10" para gerar a árvore de exemplo) requer a mesma quantidade de caracteres (28):

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

Sei que isso não está de acordo com as especificações, mas pensei em tentar adicionar um pouco de diversidade às árvores aqui imitando essa cena clássica de Natal de arte ASCII de Joan G. Stark .

Não tentei reproduzir a imagem inteira - isso teria sido um pouco demais -, mas apenas a árvore, para a qual apresento este programa Perl de 138 bytes:

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

E, claro, aqui está uma amostra da saída:

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

Experimente online!

O código usa o sayrecurso Perl 5.10+ e, portanto, precisa ser executado com a opção de linha de comando -M5.010(ou -E). (Na verdade, apenas substituir o sayno final por printevitaria isso, ao custo de mais dois bytes e a perda da nova linha após a última linha de saída.)

Observe que a maior parte da árvore é gerada aleatoriamente, portanto a colocação dos ornamentos varia entre as corridas. O anjo, o suporte e a fileira superior da árvore são fixos.

Para impedir que essa resposta popular seja sumariamente excluída em uma política instituída após a publicação , aqui está uma solução compatível com especificações de token (45 bytes, também Perl 5):

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

Experimente online!

Como o programa acima, este também precisa ser executado no Perl 5.10+ com a -M5.010opção para ativar o sayrecurso. Obviamente (esse é um desafio de complexidade kolmogorov ), ele produz exatamente a mesma saída chata que todas as outras entradas compatíveis, que eu não vou nem repetir aqui. (Também é redimensionável trivialmente, alterando o número 10para qualquer outro valor.)

Ilmari Karonen
fonte
1
Ótimo! Não pela especificação, mas acho que o prêmio especial dos juízes é para você! :)
Averroes
6
isso retrocede o proverbial das especificações, +2 se eu pudesse.
Kris
3
Desculpe, mas pelas regras, as respostas que não atendem às especificações devem ser excluídas.
mbomb007
Estou excluindo esta postagem em conformidade com nossa política sobre respostas que não atendem à especificação de desafio .
Dennis
1
Você poderia mover a resposta válida para o topo e adicionar um cabeçalho?
Dennis
13

GolfScript (33 caracteres)

Versão de altura fixa:

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

Ou exatamente pelo mesmo comprimento

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

A árvore é notavelmente semelhante à de todos os outros:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Versão que tira a altura do stdin:

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

O início da linha anterior é um dos melhores smilies que fiz em um programa GolfScript "útil".

Peter Taylor
fonte
10

Script de shell, 44 caracteres

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

Imprime esta árvore:

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

Maple, 30/37 caracteres

Inspirado na entrada Mathematica de Mr.Wizard , apresento este comando Maple 12 de 30 caracteres:

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

Saída:

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

Também posso me livrar dos colchetes ao custo de mais sete caracteres:

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

Saída omitida - parece exatamente como acima, apenas sem os colchetes. Infelizmente, não sei como impedir o Maple de inserir linhas em branco entre as linhas de saída no modo de texto. Parece melhor no modo de planilha clássico. Acho que poderia incluir uma captura de tela ...

captura de tela

(A captura de tela mostra uma versão anterior de 44 caracteres do comando, mas estou com preguiça de refazê-lo. A saída ainda é a mesma.)

Ah, e sim, o tamanho é totalmente ajustável: basta substituir o 8 por n -2 para uma árvore com n linhas. Com a primeira solução, ir acima de 25 linhas (ou 10 na GUI) também requer a configuração da interface (rtablesize = n ).

(Ps. Pensei ter conseguido vencer o GolfScript com a versão mais recente, mas infelizmente ... )

Ilmari Karonen
fonte
8

Perl, 42 caracteres

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

Saída:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

A altura da árvore pode ser alterada entre 1 e 11 linhas, substituindo 8no final pelos valores de -1para 9. Ir acima das 11 linhas requer também o aumento dos dois 9s anteriores no código, que controlam a que distância do lado esquerdo da tela a árvore é recuada.

Ilmari Karonen
fonte
Este tem 11 linhas: P Alterações menores, eu acho
Averroes
@Averroes: Sim, eu primeiro assumi que deveria ter 10 linhas mais a estrela, mas depois contei as linhas na saída de amostra e a corrigi.
Ilmari Karonen
8

Groovy, 65

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

Surpreendentemente, a árvore fica assim:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Armand
fonte
A parte 'post the tree output' é para trazer um pouco de espírito natalino para este site: P
Averroes
Além disso, o seu também possui 11 linhas!
Averroes
Eu posso consertar isso ajustando os parâmetros de altura!
Armand
8

Ruby, 46 caracteres

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

Para alterar a altura, você teria que alterar os 8s e, claro, também os 9. A saída do programa é a seguinte:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Edit : Indesculpável eu omiti a saída na primeira submissão.

Howard
fonte
1
Você esqueceu de postar a saída. :)
Ilmari Karonen
7

PowerShell, 41

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

Sem surpresa, gera a mesma árvore que a de todos os outros :-p

Se você parametrizar esse 8, ele produzirá até o tamanho do seu console, digamos, 48 caracteres :

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

Ou, como um script completo que usa um argumento, 53 caracteres :

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

Chamado, parece com:

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

Python 3: 62 caracteres

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

Saída:

        * 
        0 
       000 
      00000 
     0000000 
    000000000 
   00000000000 
  0000000000000 
 000000000000000
00000000000000000

Observe que isso basicamente supera a resposta de @ Ante em 11 caracteres, porque essa resposta, quando convertida em Python 3, usa 73 caracteres.

Altere cada um 9para outro valor para uma altura diferente.

Kazark
fonte
3
Eu acho que você também pode perder o espaço antes for.
badp 6/12/11
@badp Thanks - alterado de 63 para 62!
Kazark 6/12/11
6

Python, 59

print' '*9+'*'
for i in range(9):print' '*(9-i)+'0'*(i*2+1)
Patrick
fonte
Bom trabalho - isso demonstra que, embora a resposta do @Ante fique mais longa no Python 3, minha resposta do Python 3 é mais curta no Python 2 ( printnão é uma função).
Kazark 6/12/11
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).

Impressões:

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

Pode ser espremido ainda mais para certos intérpretes (por exemplo, usando tab / 1 no SWI)

Invoque com x (N). Onde N é o número de linhas na árvore real (excluindo estrela). Dando-lhe uma altura fixa, o número desceria para 183

Paul Butcher
fonte
6

C

Esta é a versão C de Wade Tandy, mas modificada um pouco:

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

Mathematica, 50

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

Applesoft BASIC, 143 caracteres

Como essa pergunta me lembra uma tarefa de casa que eu tinha no ensino médio (quando eles ensinavam em uma 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

Usei o JavaScript Applesoft BASIC encontrado aqui: http://www.calormen.com/applesoft/

SAÍDA:

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

Prolog: 127 caracteres

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

Saída:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true

Usado Prologporque eu não consegui bater o Groovyrecorde sem olhar para o código dele :(.

Rob Fox
fonte
5

PostScript (com altura parametrizada), 114 caracteres

/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

Saída:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

O que você queria imprimir?

MrMRDubya
fonte
4

JavaScript (Rhino: 108, Nó: 114, Console de desenvolvimento da Webkit: 119, Plug-in do jQuery: 132)


O Rhino é o mais curto (com 108 caracteres) porque (a) sua printfunção tem um nome abreviado e (b) permite atribuir funções internas a um nome de variável mais curto. Tão:

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


O Node.js chega em um segundo próximo (a 114 caracteres) porque sua função de impressão console.logtem um nome mais longo, mas nos permitirá atribuir isso a uma variável curta:

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


No entanto, o Webkit Dev Console (e provavelmente o Firebug também) acha que p=console.logé um pouco furtivo (quando você tenta ligar p(), ele reclama com você). Então, temos que estender as coisas para 119 caracteres:

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

(Curiosamente, withapenas nos salva um personagem).


Finalmente ... um plugin jQuery (ainda twittável em 132 caracteres!):

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

E você pode invocá-lo no rodapé desta página: $('#footer').xms(3)

Claro, ele não precisa ser um plug-in ... já que provavelmente teríamos que usar um console JavaScript para adicioná-lo a uma página e invocá-lo, poderíamos ter feito apenas um trecho 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/>'));

que pesa 116 caracteres mais competitivos - na verdade, supera a outra implementação do console de desenvolvedor. Mas, novamente, usar o jQuery e / ou o mecanismo de layout do navegador pode ser considerado trapaça. :)

Weston C
fonte
4

C, 67

Sei que isso acabou há muito tempo, mas é minha primeira tentativa de código de golfe e acho que tenho uma solução C muito boa.

Curiosamente, eu vim com isso independentemente da solução muito semelhante da @ Patrick.

E sim, não vou ganhar nenhum vínculo com meus valores codificados;) Estou bastante satisfeito, de qualquer maneira.

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

        *
        0 0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Pressione qualquer tecla para continuar . . .
JoeFish
fonte
4

Oráculo

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

PHP, 106 caracteres

7 menos que o anterior:

<?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
fonte
2
ative tags curtas e economize 3 caracteres, ou use <?=e salve outros 5 no "eco".
Brombomb
Eu sei que eu sou 8 meses de atraso, mas 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

Experimente online!

Saída:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kevin Traver
fonte
1
Isso é código-golfe , então adicione a contagem de bytes do seu envio ao cabeçalho.
Lirtosiast
4

Python, 70 caracteres

Solução não tão curta, mas recursiva :-)

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

Mude 8 para definir a altura.

Ante
fonte
4

Javascript, 119 caracteres

Saídas para o console do 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
fonte
2
Na verdade, são 120 caracteres.
Rob Fox
3

PHP 113

Achei que eu gritei com uma versão php:

113 caracteres (ajuste $hpara alterar a altura, o número de linhas inclui a estrela):

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

Eu tentei torná-lo curto, não legível e já sabíamos que o php não pode competir com concisão, então isso não vai ganhar nada, ainda é um pequeno quebra-cabeça divertido.

saída é como spec:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kris
fonte
Codificando um pouco mais, 103 caracteres, (você não pode ver os espaços no primeiro eco dentro deste comentário) $ n = 0; eco "* \ n"; for ($ i = 9; $ i> 0; $ i -, imprime str_repeat ('', $ i) .str_repeat ('0', $ n + 9- $ i). "\ n", $ n ++);
6117 Lucia
sua primeira linha codificada ficaria desequilibrada se você alterar a altura da árvore 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);}

Antes de ler a especificação printf com mais cuidado, eu tinha esse número bonitinho até 138 caracteres:

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

Java, 192 (198 com 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 a árvore solicitada:

        *           
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Para altura variável, um pouco mais:

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

O comprimento da lista de argumentos da linha de comando determina a altura (por exemplo java W a a a a a, fornecerá a altura 5).

(Esta é basicamente a versão Java da solução C de Wade Tandy.)

Daniel Schneller
fonte
Eu sei que isso foi postado há um tempo atrás :), mas aqui estão duas coisas que eu vejo: 1. você pode usar uma interface em vez de uma classe no java 8 2. para salvar dois caracteres, while (++i < c) {-> for (s += "*";++i < c;s = "") {, e remover o s += "*";es = "";
Reinis Mazeiks 02/02
3

Vim, 18 bytes

17i0<esc>qqYPxr q8@qa*

Experimente on-line no interpretador V compatível com versões anteriores!

Embora essa seja uma abordagem muito semelhante à minha resposta em V, essa não é competitiva, pois o vim é velho e louco. :)

Explicação:

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

Scala, 74 bytes

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

h - altura da árvore

Saída

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

Inicialize k para a altura da árvore, i para k-1. F é o sinalizador de primeira linha. Se não houver argumento, F deve ser 1 na entrada.

Uma versão ligeiramente mais longa (81) em que f não é um sinalizador de primeira linha:

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
fonte