Stampa un albero di Natale


26

La sfida

Stampa un bell'albero di Natale con la sua stella in alto usando il codice più corto possibile. La stella dell'albero è un asterisco ( *) e il corpo dell'albero è composto da 0L'albero deve essere alto 10 file. Ogni riga deve essere correttamente rientrata nel modo in cui la riga precedente è centrata su quella successiva. Ogni riga specifica deve avere 2 0 in più rispetto alla precedente, fatta eccezione per la prima che è la stella e la seconda, che ha solo uno 0. Il risultato è qualcosa del genere:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Tie break per alberi di altezza ridimensionabili senza modifiche al software (tranne la modifica del parametro di altezza)

Per favore, incolla anche l'albero risultante del tuo codice!


Classifica


3
Non esattamente un duplicato, ma ce n'è uno su SO: Code Golf Edizione natalizia: Come stampare un albero di Natale di altezza N
Hasturkun,

Risposte:


17

Golfscript, 27 caratteri

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

L'albero risultante è simile al seguente:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Una versione che utilizza il parametro height solo una volta è più lunga di un carattere:

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

La lettura dell'altezza dallo stdin (con input "10" per generare l'albero di esempio) richiede la stessa quantità di caratteri (28):

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

56

So che questo non è conforme alle specifiche, ma ho pensato di provare ad aggiungere un po 'di diversità agli alberi qui imitando questa classica scena natalizia in arte ASCII di Joan G. Stark .

Non ho provato a riprodurre l'intera immagine - sarebbe stato un po 'troppo - ma solo l'albero, per il quale presento questo programma Perl a 138 byte:

$_=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, naturalmente, ecco un esempio dell'output:

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

Provalo online!

Il codice utilizza la sayfunzione Perl 5.10+ e quindi deve essere eseguito con l' opzione -M5.010(o -E) della riga di comando. (In realtà, la semplice sostituzione saydi alla fine con printlo eviterebbe, al costo di altri due byte e la perdita della nuova riga dopo l'ultima riga di output.)

Si noti che la maggior parte dell'albero viene generata casualmente, quindi il posizionamento degli ornamenti varierà tra le serie. L'angelo, il supporto e la fila superiore dell'albero sono fissi, però.


Per evitare che questa risposta popolare venga eliminata sommariamente in base a una politica istituita dopo la sua pubblicazione , ecco anche una soluzione conforme alle specifiche del token (45 byte, anche Perl 5):

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

Provalo online!

Come il programma sopra, anche questo deve essere eseguito su Perl 5.10+ con l' -M5.010interruttore per abilitare la sayfunzione. Ovviamente (trattandosi di una ) produce esattamente lo stesso noioso output di tutte le altre voci conformi, che non mi preoccuperò di ripetere qui. (È anche banalmente ridimensionabile cambiando il numero 10in qualsiasi altro valore.)


1
Grande! Non secondo le specifiche, ma penso che il premio speciale dei giudici sia per te! :)
Averroè il

6
questo dà un calcio al proverbiale dietro le specifiche, +2 se potessi.
Kris il

3
Siamo spiacenti, ma secondo le regole, le risposte che non soddisfano le specifiche devono essere eliminate.
mbomb007,


1
Potresti spostare la risposta valida in alto e aggiungere un'intestazione?
Dennis,

13

GolfScript (33 caratteri)

Versione ad altezza fissa:

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

O esattamente per la stessa lunghezza

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

L'albero sembra notevolmente simile a quello di tutti gli altri:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Versione che prende altezza dallo stdin:

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

L'inizio della riga precedente è una delle faccine migliori che ho realizzato in un "utile" programma GolfScript.


10

Script di shell, 44 caratteri

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

Stampa questo albero:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

9

Acero, 30/37 caratteri

Ispirato dalla voce Mathematica di Mr.Wizard , vi presento questo comando Maple 12 da 30 caratteri:

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

Produzione:

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

Posso anche sbarazzarmi delle parentesi al costo di altri sette caratteri:

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

Uscita omessa: sembra proprio come sopra, solo senza parentesi. Sfortunatamente, non conosco alcun modo per impedire a Maple di inserire righe vuote tra le righe di output in modalità testo. Sembra migliore nella classica modalità foglio di lavoro. Immagino di poter includere uno screenshot ...

immagine dello schermo

(Lo screenshot mostra una versione precedente del comando a 44 caratteri, ma sono troppo pigro per riprenderlo. L'output è sempre lo stesso.)

Oh, e sì, la dimensione è completamente regolabile: basta sostituire l'8 con n -2 per un albero n -row. Con la prima soluzione, andare oltre 25 righe (o 10 nella GUI) richiede anche l'impostazione dell'interfaccia (rtablesize = n ).

(Ps. Pensavo di essere riuscito a battere GolfScript con l'ultima versione, ma purtroppo ... )


8

Perl, 42 caratteri

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

Produzione:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

L'altezza dell'albero può essere modificata tra 1 e 11 righe sostituendo 8alla fine con i valori da -1a 9. Andare sopra le 11 righe richiede anche di aumentare le due 9s precedenti nel codice, che controllano la distanza dal rientro dell'albero dal lato sinistro dello schermo.


Questo ha 11 righe: P Modifiche minori suppongo
Averroè il

@Averroes: Sì, per prima cosa ho pensato che dovesse essere 10 righe più la stella, ma poi ho effettivamente contato le righe nell'output del campione e l'ho risolto.
Ilmari Karonen,

8

Groovy, 65

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

Sorprendentemente, l'albero appare così:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

La parte 'post the tree output' è per portare un po 'di spirito natalizio in questo sito: P
Averroes,

Inoltre, anche le tue hanno 11 file!
Averroè,

Posso risolverlo regolando i parametri di altezza!
Armand,

8

Rubino, 46 ​​caratteri

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

Per cambiare l'altezza dovresti cambiare sia 8s che ovviamente anche 9. L'output del programma è il seguente:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Modifica : Inescusabilmente ho omesso l'output nella prima presentazione.


1
Hai dimenticato di pubblicare l'output. :)
Ilmari Karonen il

7

PowerShell, 41

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

Non sorprende che produca lo stesso albero di tutti gli altri :-p

Se si parametrizza quell'8, si produrrà fino alla dimensione della console, ad esempio 48 caratteri :

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

Oppure, come uno script completo che accetta una discussione, 53 caratteri :

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

Chiamato, sembra:

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

7

Python 3: 62 caratteri

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

Produzione:

        * 
        0 
       000 
      00000 
     0000000 
    000000000 
   00000000000 
  0000000000000 
 000000000000000
00000000000000000

Nota che questo in sostanza batte la risposta di @ Ante di 11 caratteri, perché quella risposta, quando convertita in Python 3, usa 73 caratteri.

Cambia ciascuno 9con un altro valore per un'altezza diversa.


3
Penso che tu possa anche perdere lo spazio prima for.
badp

Grazie @badp: modificato da 63 a 62!
Kazark

6

Python, 59

print' '*9+'*'
for i in range(9):print' '*(9-i)+'0'*(i*2+1)

Bel lavoro — questo dimostra che sebbene la risposta di @Ante si allunghi in Python 3, la mia risposta in Python 3 è più breve in Python 2 ( printnon una funzione).
Kazark

6

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

stampe:

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

Potrebbe essere ulteriormente compresso per alcuni interpreti (ad es. Usando tab / 1 su SWI)

Richiama con x (N). Dove N è il numero di righe nell'albero reale (esclusa la stella). Dare un'altezza fissa lo porterebbe a 183


6

C

Questa è la versione C di Wade Tandy ma è stata leggermente modificata:

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

Dato che questa domanda mi ricorda un compito a casa che avevo al liceo (quando insegnavano su 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

Ho usato JavaScript Applesoft BASIC trovato qui: http://www.calormen.com/applesoft/

PRODUZIONE:

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

5

Prolog: 127 caratteri

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

Produzione:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true 

Usato Prologperché non sono riuscito a battere il Groovyrecord senza guardare il suo codice :(.


5

PostScript (con altezza parametrizzata), 114 caratteri

/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

Produzione:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

Cosa, volevi che stampasse?


4

JavaScript (Rhino: 108, Nodo: 114, Webkit Dev Console: 119, jQuery Plugin: 132)


Rhino è il più breve (con 108 caratteri) perché (a) la sua printfunzione ha un nome breve e (b) ti permetterà di assegnare le funzioni integrate a un nome di variabile più breve. Così:

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 arriva al secondo posto (a 114 caratteri) perché la sua funzione di stampa console.logha un nome più lungo, ma ci permetterà di assegnarlo anche a una variabile breve:

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


Tuttavia, la console di sviluppo Webkit (e probabilmente anche Firebug) ritiene che p=console.logsia un po 'troppo subdolo (quando si tenta di chiamare p(), si lamenterà con te). Quindi, dobbiamo allungare le cose a 119 caratteri:

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

(È interessante notare withche ci salva solo un personaggio).


Finalmente ... un plugin jQuery (ancora tweetabile con 132 caratteri!):

$.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 puoi invocarlo sul piè di pagina di questa stessa pagina: $('#footer').xms(3)

Certo, non deve essere un plug-in ... dal momento che probabilmente dovremmo usare una console JavaScript per aggiungerlo a una pagina e invocarlo, avremmo potuto semplicemente fare uno snippet di 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/>'));

che pesa in 116 caratteri più competitivi - in effetti, batte l'altra implementazione della console di sviluppo. Ma, di nuovo, usare jQuery e / o il motore di layout del browser potrebbe essere considerato un imbroglio. :)


4

C, 67

So che è passato molto tempo, ma è il mio primo tentativo di code golf e penso di avere una soluzione C piuttosto carina.

È interessante notare che ho trovato questo indipendentemente dalla soluzione molto simile di @ Patrick.

E sì, non vincerò alcun legame con i miei valori hardcoded;) Sono comunque abbastanza contento.

i;main(){for(;i<10;++i)printf("%*s%0*c\n",i?9-i:8,"",i*2,i?32:42);}
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Premere un tasto qualsiasi per continuare . . .

4

Oracolo

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 byte

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

Provalo online!

Produzione:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

1
Questo è code-golf , quindi per favore aggiungi il conteggio dei byte della tua richiesta all'intestazione.
lirtosiast,

4

Python, 70 caratteri

Soluzione non così breve, ma ricorsiva :-)

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

Cambia 8 per impostare l'altezza.


4

Javascript, 119 caratteri

Output sulla console 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
In realtà sono 120 caratteri.
Rob Fox,

3

PHP 113

Ho pensato di entrare in una versione php:

113 caratteri (regolare $hper modificare l'altezza, il numero di linee include la stella):

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

Ho cercato di renderlo breve, non leggibile e sapevamo già che php non può competere sulla concisione, quindi questo non vincerà nulla, comunque un piccolo enigma divertente.

l'output è come spec:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Hardcoding un po 'di più, 103 caratteri, (non puoi vedere gli spazi nella prima eco all'interno di questo commento) $ n = 0; echo "* \ n"; per ($ i = 9; $ i> 0; $ i -, stampa str_repeat ('', $ i) .str_repeat ('0', $ n + 9- $ i). "\ n", $ n ++);
Lucia,

la tua prima riga codificata sarebbe sbilanciata se cambi l'altezza dell'albero 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);}

Prima di leggere le specifiche di printf più attentamente, avevo questo piccolo numero carino fino a 138 caratteri:

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

Stampa l'albero richiesto:

        *           
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Per altezza variabile, leggermente più lungo:

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 lunghezza dell'elenco degli argomenti della riga di comando determina l'altezza (ad es. java W a a a a aDarà l'altezza 5).

(Questa è fondamentalmente la versione Java della soluzione C di Wade Tandy.)


So che questo è stato pubblicato un po 'di tempo fa :), ma qui ci sono due cose che vedo: 1. puoi usare un'interfaccia invece di una classe in Java 8 2. per salvare due caratteri, while (++i < c) {-> for (s += "*";++i < c;s = "") {e rimuovere il s += "*";e ils = "";
Reinis Mazeiks,

3

Vim, 18 byte

17i0<esc>qqYPxr q8@qa*

Provalo online nell'interprete V compatibile con le versioni precedenti!

Anche se questo è un approccio molto simile alla mia risposta V, questo non è in competizione poiché Vim è pazzo vecchio. :)

Spiegazione:

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 byte

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

h - altezza dell'albero

Produzione

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

Inizializza k all'altezza dell'albero, da i a k-1. F è la bandiera della prima linea. Dato nessun argomento, allora F dovrebbe essere 1 all'entrata.

Una versione leggermente più lunga (81) in cui f è un flag non di prima linea:

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));}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.