Dato un numero N, come posso stampare un albero di Natale di altezza Nusando il minor numero di caratteri di codice? Nviene assunto vincolato a un valore minimo di 3e un valore massimo di 30(non sono necessari limiti e controllo degli errori). Nviene fornito come l'unico e unico argomento della riga di comando per il programma o lo script.

Sono apprezzate tutte le lingue, se vedi una lingua già implementata e puoi accorciarla, modifica se possibile - commenta diversamente e spera che qualcuno ripulisca il disordine. Includi nuove righe e spazi bianchi per maggiore chiarezza, ma non includerli nel conteggio dei personaggi.

Un albero di Natale viene generato come tale, con il suo "tronco" costituito solo da un "*" centrato

N = 3:

   *
  ***
 *****
   *

N = 4:

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

N = 5:

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

N definisce l'altezza dei rami escluso il tronco di una linea.

Buon Natale PPCG!

J , 24 caratteri

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

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

Spiegazione:

'*'$~5
*****

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

Quindi }:@|."1inverte ogni riga e rimuove l'ultima colonna e la ,.pinza su ].

Quindi ,{.incolla la prima colonna sul fondo.

Voci precedenti :

29 caratteri, nessuno spazio.

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

   NB. conta da 1 a n , quindi di nuovo 1
   >: 0, ~ I.3
1 2 3 1
   NB. replicare '*' x volte ciascuno
   $ & '*' "0>: 0, ~ I.3
*
**
***
*
   NB. invertire ogni riga
   (\:. I @ #) "1 $ & '*'" 0>: 0, ~ I.3
  *
 **
***
  *
   NB. togliere la colonna principale
   } "1 $ & '*'" 0>:. 0, ~ I.3

*
**

   NB. incollare insieme
   ((\:. I @ #),}.) "1 $ & '*'" 0>: 0, ~ I.3
  *
 ***
*****
  *

Brainfuck, 240 caratteri

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

Non ancora fatto. Funziona, ma solo con numeri a una cifra.

EDIT: Fatto! Funziona con interpreti che usano 0 come EOF. Vedi NOTEs nella fonte commentata per quelli con -1.

EDIT di nuovo: dovrei notare che poiché Brainfuck non ha un metodo standard per leggere gli argomenti della riga di comando, ho usato invece stdin (input standard). ASCII, ovviamente.

MODIFICA una terza volta: oh mio Dio, mi sembra di aver rimosso i caratteri .(in uscita) durante la condensazione del codice. Fisso...

Ecco la gestione di base della memoria del loop principale. Sono sicuro che può essere fortemente ottimizzato per ridurre il numero di caratteri di circa 30.

1. Temporaneo
2. Copia del contatore
3. Contatore (conta fino a 0)
4. Carattere spaziale (decimale 32)
5. Carattere asterisco (decimale 42)
6. Numero di asterischi sulla riga corrente (contatore 1 + 2 *)
7. Temporaneo
8. Carattere di nuova riga
9. Temporaneo?
10. Numero totale di righe (ovvero valore di input; memorizzato fino alla fine, durante la stampa del trunk)

Versione condensata:

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

E la versione carina:

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 caratteri

(1 spazi pertinenti)

perl: versione a una riga:

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

e ora con più spazi bianchi:

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

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

Spiegazione estesa per utenti non 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. 

Lingua: Python (tramite shell), Conteggio caratteri: 64 (2 spazi significativi)

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

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

x86 asm 16 bit, 50 byte

Nessuna versione dell'assembly ancora? :)

    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 è limitato a 1 - 9 in questa versione)

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

Scarica qui

Lingua: Windows Batch Script ( scioccante! )

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

Rubino, 64 byte

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

Buon Natale a tutti!

Modifica: miglioramenti aggiunti come suggerito da Joshua Swink

Lingua: C #, Conteggio caratteri: 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));
    }
}

Solo il codice, senza formattazione (120 caratteri):

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

Versione con 109 caratteri (solo il codice):

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

Risultato per altezza = 10:

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

Lingua: cc (tramite shell) Conteggio caratteri: 83

Versione cc leggermente più corta:

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

EDIT: ha cambiato la costante 10 in $ 1

python, trucco "-c" ... @ 61 caratteri (e una riga)

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

Ecco una versione di Haskell ragionevolmente efficiente in termini di spazio, con 107 caratteri:

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

eseguendolo:

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

Buon Natale a tutti :)

Lingua: cc (tramite shell), Conteggio caratteri: 119 (1 spazio significativo)

Solo per l'oscurità di esso :)

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

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

Meglio C ++, circa 210 caratteri:

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

Ridotto a 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;}

Lingua: pitone, nessun trucco, 78 caratteri

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

Miglioramento della risposta di ΤΖΩΤΖΙΟΥ. Non posso commentare, quindi ecco un nuovo post. 72 caratteri.

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

Usando il trucco "python -c", 61 caratteri.

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

Ho imparato la funzione centrale e che "python -c" può accettare più di un codice di linea. Grazie, ΤΖΩΤΖΙΟΥ.

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

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 caratteri su una riga.

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

Lingua: Java, Conteggio caratteri: 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");}}

Per riferimento, sono stato in grado di radere la precedente soluzione Java, usando la ricorsione, fino a 231 caratteri, dal precedente minimo di 269. Anche se un po 'più a lungo, mi piace questa soluzione perché Tè veramente orientata agli oggetti. È possibile creare una piccola foresta di Tistanze di dimensioni casuali . Ecco l'ultima evoluzione di quella virata:

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

Lingua: PowerShell, Conteggio caratteri: 41 (incluso 1 spazio)

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

21 personaggi con dyalog APL.

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

⍳ fornisce un vettore di numeri interi che iniziano con 1.

1, ⍨ aggiunge uno alla fine del vettore. Questo sarà il piede dell'albero.

'*' \ ¨⍨ fornisce un vettore di * -strings con lunghezze fornite dal vettore precedente.

↑ trasforma il vettore in una matrice e aggiunge spazi a destra.

m ← memorizza la matrice in m.

0 1 ↓ elimina zero righe e la prima colonna.

⌽ inverte la matrice.

m, ⍨ concatena con m sul lato destro.

Lingua: C, Numero di caratteri: 133

Miglioramento della versione 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);
}

Funziona e prende anche l'altezza dell'albero come argomento. Ha bisogno di un compilatore che tolleri il codice in stile K & R.

Mi sento così sporco ora .. Questo codice è brutto.

R (62 byte)

Non ho ancora visto la soluzione R. Correggimi se l'ho perso.

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

Produzione:

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

Lingua: C, Numero di caratteri: 176 (2 spazi pertinenti)

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

Versione shell, 134 caratteri:

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

Lingua: Python, Conteggio significativo dei caratteri: 90

È brutto ma funziona:

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

Dato che si tratta di un CW: non mi piace che i golf di codice siano sempre organizzati in termini di "numero di caratteri" o qualcosa del genere. Non potrebbero essere organizzati in termini di numero di istruzioni per il compilatore / interprete (o qualche criterio simile)? Ecco di nuovo la soluzione Ruby , ed è sostanzialmente la stessa, ma ora anche per il consumo umano:

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

Carbone , 9 byte (non competitivo)

Ｇ↗↘←Ｎ*Ｍ↓*

Provalo online!

verboso

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

Provalo online!

Gelatina , 12 byte

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

Provalo online!

PHP, 111 caratteri

(L'ultimo carattere dovrebbe essere una nuova riga.)

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

Versione leggibile:

<?php

$n = $argv[1];

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

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

?>