Biorąc pod uwagę liczbę N, jak mogę wydrukować choinkę wysokości, Nużywając najmniejszej liczby znaków kodu? Nprzyjmuje się, że jest ograniczony do minimalnej wartości 3i do maksymalnej wartości 30(ograniczenia i sprawdzanie błędów nie są konieczne). Njest podawany jako jedyny argument wiersza poleceń dla twojego programu lub skryptu.

Wszystkie języki są mile widziane, jeśli widzisz język już zaimplementowany i możesz go skrócić, edytuj, jeśli to możliwe - skomentuj inaczej i mam nadzieję, że ktoś posprząta bałagan. Dodaj znaki nowej linii i białe spacje dla przejrzystości, ale nie uwzględniaj ich w liczbie znaków.

Choinka jest generowana jako taka, a jej „pień” składa się tylko z wyśrodkowanego „*”

N = 3:

   *
  ***
 *****
   *

N = 4:

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

N = 5:

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

N określa wysokość gałęzi, nie licząc pnia jednej linii.

Wesołych Świąt PPCG!

J , 24 znaki

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

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

Wyjaśnienie:

'*'$~5
*****

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

Następnie }:@|."1odwraca każdy wiersz i usuwa ostatnią kolumnę i ,.zszywa ją ].

Następnie ,{.wkleja pierwszą kolumnę na spód.

Poprzednie wpisy :

29 znaków, bez spacji.

   ((\: i. @ #),}.) „1 $ & '*'” 0>: 0, ~ i.3
  *
 ***
*****
  *
   ((\: i. @ #),}.) „1 $ & '*'” 0>: 0, ~ i.11
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************
*********************
          *

   NB. policz od 1 do n , a następnie ponownie 1
   >: 0, ~ i.3
1 2 3 1
   NB. powtórz „*” x razy
   $ & '*' "0>: 0, ~ i.3
*
**
***
*
   NB. odwróć każdy rząd
   (\: i. @ #) „1 $ i '*'” 0>: 0, ~ i.3
  *
 **
***
  *
   NB. zdjąć kolumnę prowadzącą
   }. „1 $ & '*'” 0>: 0, ~ i.3

*
**

   NB. wklej razem
   ((\: i. @ #),}.) „1 $ & '*'” 0>: 0, ~ i.3
  *
 ***
*****
  *

Brainfuck, 240 znaków

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

Jeszcze nie skończone. Działa, ale tylko z liczbami jednocyfrowymi.

EDYCJA: Gotowe! Działa dla tłumaczy używających 0 jako EOF. Zobacz NOTEs w skomentowanym źródle dla tych z -1.

Znowu EDYTUJ: Powinienem zauważyć, że ponieważ Brainfuck nie ma standardowej metody odczytu argumentów wiersza poleceń, zamiast tego użyłem stdin (standardowe wejście). Oczywiście ASCII.

EDYCJA po raz trzeci: Ojej, wygląda na to, że usunąłem .(wyjściowe) znaki podczas zagęszczania kodu. Naprawiony...

Oto podstawowe zarządzanie pamięcią głównej pętli. Jestem pewien, że można go znacznie zoptymalizować, aby zmniejszyć liczbę postaci o około 30.

1. Chwilowy
2. Kopia licznika
3. Licznik (liczy się do 0)
4. Znak spacji (dziesiętnie 32)
5. Znak gwiazdki (dziesiętnie 42)
6. Liczba gwiazdek w bieżącej linii (licznik 1 + 2 *)
7. Chwilowy
8. Nowy znak linii
9. Chwilowy?
10. Całkowita liczba wierszy (tj. Wartość wejściowa; przechowywana do samego końca, podczas drukowania pnia)

Wersja skrócona:

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

I ładna wersja:

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 znaków

(1 odpowiednie miejsca)

perl: wersja jednoliniowa:

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

a teraz z większą ilością bieli:

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

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

Rozszerzone objaśnienie dla użytkowników innych niż 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. 

Język: Python (przez powłokę), Liczba znaków: 64 (2 znaczące spacje)

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

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

x86 asm 16-bitowy, 50 bajtów

Nie masz jeszcze wersji zestawu? :)

    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

(Uwaga: N jest ograniczony do 1 - 9 w tej wersji)

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

Pobierz tutaj

Język: skrypt wsadowy systemu Windows ( szokujący! )

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

Rubinowy, 64 bajty

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

Wesołych Świąt wszystkim!

Edycja: ulepszenia dodane zgodnie z sugestią Joshua Swink

Język: C #, Liczba znaków: 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));
    }
}

Tylko kod bez formatowania (120 znaków):

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

Wersja ze 109 znakami (tylko kod):

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

Wynik dla wysokości = 10:

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

Język: dc (przez powłokę) Liczba znaków: 83

Trochę krótsza wersja DC:

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

EDYCJA: zmieniono stałą 10 na 1 $

python, trick „-c” ... @ 61 znaków (i jeden wiersz)

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

Oto rozsądnie zajmująca mało miejsca wersja Haskell, o 107 znakach:

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

uruchomienie:

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

Wesołych Świąt wszystkim :)

Język: dc (przez powłokę), Liczba znaków: 119 (1 znacząca spacja)

Tylko dla niejasności :)

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

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

Lepsze C ++, około 210 znaków:

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

Zminimalizowane do 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;}

Język: python, bez lew, 78 znaków

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

Poprawa odpowiedzi ΤΖΩΤΖΙΟΥ. Nie mogę komentować, więc oto nowy post. 72 znaki.

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

Przy użyciu lewy „python -c” 61 znaków.

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

Nauczyłem się funkcji środkowej i że „python -c” może zaakceptować więcej niż jeden kod linii. Dzięki ΤΖΩΤΖΙΟΥ.

C # przy użyciu 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 znaków.

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 znaków w jednym wierszu.

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

Język: Java, liczba znaków: 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");}}

Dla porównania, byłem w stanie ogolić poprzednie rozwiązanie Java, używając rekurencji, do 231 znaków, z poprzedniego minimum 269. Chociaż nieco dłużej, podoba mi się to rozwiązanie, ponieważ Tjest naprawdę zorientowane obiektowo. Możesz utworzyć mały las Tinstancji o losowej wielkości . Oto najnowsza ewolucja tego rozwiązania:

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

Język: PowerShell, liczba znaków: 41 (w tym 1 spacja)

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

21 znaków z dyalogem APL.

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

⍳ daje wektor liczb całkowitych zaczynających się od 1.

1, ⍨ dodaje jeden na końcu wektora. To będzie stopa drzewa.

„*” \ ¨⍨ daje wektor ciągów * o długościach podanych przez poprzedni wektor.

↑ przekształca wektor w macierz i dodaje spacje po prawej stronie.

m ← przechowuje macierz wm.

0 1 ↓ upuszcza zero wierszy i pierwszą kolumnę.

⌽ odwraca matrycę.

m, ⍨ łączy się z m po prawej stronie.

Język: C, liczba znaków: 133

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

Działa, a nawet przyjmuje wysokość drzewa jako argument. Potrzebuje kompilatora, który toleruje kod w stylu K&R.

Czuję się teraz taki brudny .. To jest kod brzydki.

R (62 bajty)

Nie widziałem jeszcze rozwiązania R. Popraw mnie, jeśli mi tego brakowało.

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

Wynik:

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

Język: C, liczba znaków: 176 (2 odpowiednie spacje)

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

Wersja powłoki, 134 znaki:

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

Język: Python, Znacząca liczba znaków: 90

Jest brzydki, ale działa:

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

Ponieważ jest to CW: Nie podoba mi się, że golfy kodowe są zawsze zorganizowane pod względem „liczby znaków” lub czegoś takiego. Czy nie można ich zorganizować pod względem liczby instrukcji dla kompilatora / tłumacza (lub innego podobnego kryterium)? Oto znowu rozwiązanie Ruby i jest w zasadzie takie samo, ale teraz również do spożycia przez ludzi:

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

Węgiel , 9 bajtów (niekonkurencyjny)

Ｇ↗↘←Ｎ*Ｍ↓*

Wypróbuj online!

Gadatliwy

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

Wypróbuj online!

Galaretka , 12 bajtów

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

Wypróbuj online!

PHP, 111 znaków

(Ostatni znak powinien być znakiem nowej linii.)

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

Wersja do odczytu:

<?php

$n = $argv[1];

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

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

?>