Imprimir un árbol de navidad

26

El reto

Imprima un bonito árbol de Navidad con su propia estrella en la parte superior utilizando el código más corto posible. La estrella del árbol es un asterisco ( *) y el cuerpo del árbol está hecho de 0El árbol debe tener 10 filas de alto. Cada fila debe tener una sangría adecuada en la forma en que la fila anterior se centra en la siguiente. Cualquier fila dada debe tener 2 ceros más que la anterior, excepto la primera que es la estrella y la segunda, que solo tiene un 0. El resultado es algo como esto:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Tie break para árboles de altura redimensionables sin cambios de software (excepto cambiar el parámetro de altura)

¡Por favor, pegue el árbol resultante de su código también!


Tabla de clasificación

Averroes
fuente
3
No es exactamente un duplicado, pero hay este en SO: Code Golf Christmas Edition: Cómo imprimir un árbol de Navidad de altura N
Hasturkun

Respuestas:

17

Golfscript, 27 caracteres

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

El árbol resultante se ve así:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Una versión que usa el parámetro de altura solo una vez es un carácter más largo:

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

Leer la altura de stdin (con la entrada "10" para generar el árbol de ejemplo) requiere la misma cantidad de caracteres (28):

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

Sé que esto no cumple con las especificaciones, pero pensé que trataría de agregar algo de diversidad a los árboles aquí imitando esta clásica escena navideña de arte ASCII de Joan G. Stark .

No traté de reproducir la imagen completa, hubiera sido demasiado, sino solo el árbol, para lo cual presento 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

Y, por supuesto, aquí hay una muestra de la salida:

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

Pruébalo en línea!

El código usa la función Perl 5.10+ say, por lo que debe ejecutarse con el -M5.010(o -E) interruptor de línea de comando. (En realidad, solo reemplazando sayal final con printevitaría eso, a costa de dos bytes más y la pérdida de la nueva línea después de la última línea de salida).

Tenga en cuenta que la mayor parte del árbol se genera aleatoriamente, por lo que la colocación de los adornos variará entre las ejecuciones. Sin embargo, el ángel, el soporte y la fila superior del árbol están fijos.


Para evitar que esta respuesta popular se elimine sumariamente bajo una política instituida después de su publicación , aquí también hay una solución que cumple con las especificaciones de token (45 bytes, también Perl 5):

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

Pruébalo en línea!

Al igual que el programa anterior, este también debe ejecutarse en Perl 5.10+ con el -M5.010interruptor para habilitar la sayfunción. Obviamente (esto es un ) produce exactamente el mismo resultado aburrido que todas las otras entradas compatibles, que no me molestaré en repetir aquí. (También es trivialmente redimensionable cambiando el número 10a cualquier otro valor).

Ilmari Karonen
fuente
1
¡Excelente! ¡No según las especificaciones, pero creo que el premio especial de los jueces es para ti! :)
Averroes
66
esto patea el proverbial de las especificaciones, +2 si pudiera.
Kris
3
Lo sentimos, pero según las reglas, las respuestas que no cumplan con la especificación deben eliminarse.
mbomb007
Estoy eliminando esta publicación en cumplimiento de nuestra política sobre respuestas que no cumplen con la especificación de desafío .
Dennis
1
¿Podría mover la respuesta válida al principio y agregar un encabezado?
Dennis
13

GolfScript (33 caracteres)

Versión de altura fija:

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

O exactamente por la misma longitud

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

El árbol se ve notablemente similar al de todos los demás:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Versión que toma altura de stdin:

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

El comienzo de la línea anterior es una de las mejores caritas que hice en un programa "útil" de GolfScript.

Peter Taylor
fuente
10

Script de shell, 44 caracteres

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

Imprime este árbol:

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

Arce, 30/37 caracteres

Inspirado por la entrada de Mr.Wizard en Mathematica , presento este comando Maple 12 de 30 caracteres:

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

Salida:

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

También puedo deshacerme de los corchetes a costa de siete caracteres más:

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

Salida omitida: se ve igual que arriba, solo sin los corchetes. Desafortunadamente, no conozco ninguna forma de evitar que Maple inserte líneas en blanco entre las filas de salida en modo de texto. Se ve mejor en el modo clásico de hoja de trabajo. Supongo que podría incluir una captura de pantalla ...

captura de pantalla

(La captura de pantalla muestra una versión anterior de 44 caracteres del comando, pero soy demasiado vago para volver a tomarlo. La salida sigue siendo la misma).

Ah, y sí, el tamaño es totalmente ajustable: simplemente reemplace el 8 con n -2 para un árbol n -row. Sin embargo, con la primera solución, superar las 25 filas (o 10 en la GUI) también requiere configurar la interfaz (rtablesize = n ).

(Ps. Pensé que había logrado vencer a GolfScript con la última versión, pero por desgracia ... )

Ilmari Karonen
fuente
8

Perl, 42 caracteres

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

Salida:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

La altura del árbol se puede cambiar entre 1 y 11 filas reemplazando 8al final con valores de -1a 9. Ir por encima de 11 filas también requiere aumentar las dos 9s anteriores en el código, que controlan qué tan lejos del lado izquierdo de la pantalla está sangrado el árbol.

Ilmari Karonen
fuente
Este tiene 11 filas: P Cambios menores, supongo
Averroes
@Averroes: Sí, primero supuse que se suponía que eran 10 filas más la estrella, pero luego conté las filas en la salida de muestra y lo arreglé.
Ilmari Karonen
8

Groovy, 65

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

Sorprendentemente, el árbol se ve así:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Armand
fuente
La parte 'publicar la salida del árbol' es para traer un poco de espíritu navideño a este sitio: P
Averroes
Además, ¡los tuyos también tienen 11 filas!
Averroes
¡Puedo arreglar eso ajustando los parámetros de altura!
Armand
8

Ruby, 46 caracteres.

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

Para cambiar la altura, tendría que cambiar los 8 y, por supuesto, también el 9. La salida del programa es la siguiente:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Editar : inexcusablemente omití la salida en el primer envío.

Howard
fuente
1
Olvidó publicar la salida. :)
Ilmari Karonen
7

PowerShell, 41

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

Como era de esperar, genera el mismo árbol que todos los demás :-p

Si parametriza ese 8, producirá hasta el tamaño de su consola, en, digamos, 48 caracteres :

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

O, como un guión completo que toma una discusión, 53 caracteres :

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

Llamado, se ve así:

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

Python 3: 62 caracteres

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

Salida:

        * 
        0 
       000 
      00000 
     0000000 
    000000000 
   00000000000 
  0000000000000 
 000000000000000
00000000000000000

Tenga en cuenta que esto esencialmente supera la respuesta de @ Ante en 11 caracteres, porque esa respuesta, cuando se convierte a Python 3, usa 73 caracteres.

Cambie cada uno 9a otro valor para una altura diferente.

Kazark
fuente
3
Creo que también puedes perder el espacio antes for.
badp
@badp Gracias, ¡cambió de 63 a 62!
Kazark
6

Python, 59

print' '*9+'*'
for i in range(9):print' '*(9-i)+'0'*(i*2+1)
Patricio
fuente
Buen trabajo: esto demuestra que aunque la respuesta de @Ante se alarga en Python 3, mi respuesta de Python 3 es más corta en Python 2 ( printno es una función).
Kazark
6

Prólogo: 183 o 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).

Huellas dactilares:

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

Podría exprimirse aún más para ciertos intérpretes (por ejemplo, usar tab / 1 en SWI)

Invocar con x (N). Donde N es el número de filas en el árbol real (excluyendo la estrella). Darle una altura fija lo reduciría a 183

Carnicero paul
fuente
6

do

Esta es la versión C de Wade Tandy pero modificada un poco:

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

Mathematica, 50

MatrixForm@Prepend[Row/@Table[0,{n,9},{2n-1}],"*"]
Señor mago
fuente
5

Applesoft BASIC, 143 caracteres

Como esta pregunta me recuerda una tarea que tenía en la escuela secundaria (cuando enseñaban en una 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

Usé JavaScript Applesoft BASIC que se encuentra aquí: http://www.calormen.com/applesoft/

SALIDA:

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

Prólogo: 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));!.

Salida:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true 

Utilizado Prologporque no pude batir el Groovyrécord sin mirar su código :(.

Rob Fox
fuente
5

PostScript (con 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

Salida:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

¿Qué, querías que se imprimiera?

MrMRDubya
fuente
4

JavaScript (Rhino: 108, Nodo: 114, Consola de desarrollo de Webkit: 119, Complemento jQuery: 132)


Rhino es el más corto (con 108 caracteres) porque (a) su printfunción tiene un nombre corto y (b) le permitirá asignar funciones incorporadas en un nombre de variable más corto. Asi que:

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 viene en un segundo cercano (en 114 caracteres) porque su función de impresión console.logtiene un nombre más largo, pero también nos permitirá asignarlo a una variable corta:

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


Sin embargo, la consola de desarrollo de Webkit (y probablemente también Firebug) piensa que p=console.loges un poco astuto (cuando intentas llamar p(), se quejará de ti). Entonces, tenemos que alargar las cosas a 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, with solo nos ahorra un personaje).


Finalmente ... un plugin jQuery (¡todavía tweetable a 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/>'));}

Y puede invocarlo en el pie de página de esta misma página: $('#footer').xms(3)

Por supuesto, no tiene que ser un complemento ... ya que probablemente tendríamos que usar una consola de JavaScript para agregarlo a una página e invocarlo, podríamos haber hecho un fragmento 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 más competitivos; de hecho, supera a la otra implementación de la consola de desarrollo. Pero, una vez más, usar jQuery y / o el motor de diseño del navegador podría considerarse una trampa. :)

Weston C
fuente
4

C, 67

Sé que esto ha terminado hace mucho tiempo, pero es mi primer intento de golf de código, y creo que tengo una solución C bastante buena.

Curiosamente, se me ocurrió esto independientemente de la solución muy similar de @ Patrick.

Y sí, no ganaré ningún vínculo con mis valores codificados;) De todos modos, estoy bastante satisfecho.

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
Pulse cualquier tecla para continuar . . .
JoeFish
fuente
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
fuente
4

PHP, 106 caracteres

7 menos que el 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
fuente
2
habilite etiquetas cortas y ahórrese 3 caracteres, o use <?=y guarde otros 5 del "eco".
Brombomb
Sé que llego 8 meses tarde, pero 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

Pruébalo en línea!

Salida:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kevin Traver
fuente
1
Este es el código de golf , por lo tanto, agregue el recuento de bytes de su envío al encabezado.
lirtosiast
4

Python, 70 caracteres

No es tan corto, pero es una solución recursiva :-)

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

Cambiar 8 para establecer la altura.

Apuesta inicial
fuente
4

Javascript, 119 caracteres

Salidas a la consola 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
fuente
2
Esto es 120 caracteres en realidad.
Rob Fox
3

PHP 113

Imaginé que intercalaría con una versión de php:

113 caracteres (ajuste $hpara cambiar la altura, el número de líneas incluye la estrella):

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

Traté de hacerlo corto, no legible y ya sabíamos que php no puede competir en concisión, por lo que esto no va a ganar nada, aunque todavía es un pequeño rompecabezas divertido.

La salida es como especificaciones:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Kris
fuente
Codificando un poco más, 103 caracteres, (no puede ver los espacios en el primer eco dentro de este comentario) $ n = 0; echo "* \ n"; for ($ i = 9; $ i> 0; $ i -, imprime str_repeat ('', $ i) .str_repeat ('0', $ n + 9- $ i). "\ n", $ n ++);
Lucia
su primera línea codificada se saldría de balance si cambia la altura del árbol aunque :-(
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 leer las especificaciones de printf con más cuidado, tuve este pequeño y lindo número de 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);}
Patricio
fuente
3

Java, 192 (198 con 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 el árbol solicitado:

        *           
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Para altura variable, un poco más larga:

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 longitud de la lista de argumentos de la línea de comando determina la altura (por ejemplo java W a a a a a, dará la altura 5).

(Esta es básicamente la versión Java de la solución C de Wade Tandy).

Daniel Schneller
fuente
Sé que esto se publicó hace un tiempo :), pero aquí hay dos cosas que veo: 1. puede usar una interfaz en lugar de una clase en java 8 2. para guardar dos caracteres, while (++i < c) {-> for (s += "*";++i < c;s = "") {, y eliminar el s += "*";y els = "";
Reinis Mazeiks
3

Vim, 18 bytes

17i0<esc>qqYPxr q8@qa*

¡Pruébelo en línea en el intérprete de V compatible con versiones anteriores!

Aunque este es un enfoque muy similar a mi respuesta V, este no es no competitivo ya que vim es una locura. :)

Explicación:

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

Scala, 74 bytes

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

h - altura del árbol

Salida

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

Inicialice k a la altura del árbol, i a k-1. F es la bandera de primera línea. Sin ningún argumento, F debería ser 1 al ingresar.

Una versión un poco más larga (81) donde f no es un indicador de primera línea:

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
fuente