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


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"*}%

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 ), 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.)


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


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".


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

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


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.


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

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.


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

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.


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)

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


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

5

Mathematica, 50

MatrixForm@Prepend[Row/@Table[0,{n,9},{2n-1}],"*"]

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

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 :(.


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?


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. :)


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

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.


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

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.


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

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

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

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


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

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  

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));}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.