Code Golf Christmas Edition: Jak wydrukować choinkę wysokości N.

89

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!

TheSoftwareJedi
źródło

Odpowiedzi:

46

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
  *
 ***
*****
  *
efemeryczny
źródło
Jeszcze tylko 9 znaków może nadać tej funkcji nazwę:c=:[:((\:i.@#),}.)"1[:$&'*'"0[:>:0,~i.
ephemient
11
Co, czy używacie jakiejś biblioteki dokumentacji J, aby zrozumieć kod? :)
92

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 =)
jrtapsell
źródło
1
mój mózg jest chory ... chory
3
O mój Boże.
anonimowy tchórz
63

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. 
MkV
źródło
25
Cholera jasna ... perl naprawdę jest nieczytelny.
8
@zenazn, należy również zauważyć, że większość golfa jest kodem BAD w dowolnym języku. Gdyby to był konkurs na najczystszy kod, moglibyśmy również wygrać.
Kent Fredric,
5
@zenazn: dowód można zobaczyć nam współpracę i poprawę każdego kodu innych użytkowników powyżej, dowodzi to MY może odczytać nawzajem kod perfekcyjnie.
Kent Fredric,
1
PS: Dzięki za wyjaśnienie dla programistów spoza Perla. Nadal jest dość nieczytelny, ale przynajmniej ma sens. Chyba przyzwyczaiłeś się do tego po chwili.
2
@RobH: J jest dzieckiem APL. W pewnym sensie jest bardziej nieczytelny, ponieważ nie używa zestawu znaków APL ze specjalnym symbolem dla każdej operacji - zamiast tego przeciąża znaki ASCII wieloma znaczeniami. stackoverflow.com/questions/392788/1088931#1088931
ephemient
26

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
           *
          ***
         *****
        *******
       *********
      ***********
     *************
    ***************
   *****************
  *******************
 *********************
           *
tzot
źródło
8
to, co najbardziej podoba mi się w tym rozwiązaniu, to to, że Python naprawdę utrudnia pisanie niejasnego kodu, jest to jedno z najbardziej czytelnych rozwiązań
Używasz powłoki do przetworzenia argumentu, co nie jest zgodne z duchem kodu golfowego IMO. Używając „import sys” i „n = w = int (sys.argv [1])” i wcięcia 1 znaku dla treści pętli, wymyślam 89 znaków dla tej wersji.
4
Tak to robiłem wcześniej. Duch tego pytania polega na dobrej zabawie, a ponadto nie określono specyfikacji używania tylko jednego języka :) Zobacz na przykład odpowiedź na pieprzenie mózgu; bez argumentów.
26

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

Jonas Gulle
źródło
24

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

źródło
masochista! Podoba mi się
Bardzo dobrze ... dostajesz +1
2
Opóźnione rozszerzanie zmiennych można włączyć za pomocą setlocal enabledelayedexpansionpolecenia.
Helen
koleś. poważnie?
Nie mogę tego zrobić. Pierwszy raz jednak próbuję.
Fabinout,
21

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

jrtapsell
źródło
cholera, miałem nadzieję, że nikt jeszcze nie próbował tego w rubinie. dobra robota.
To bardzo fajna linia Ruby.
Czy wydawało mi się, że jestem zbyt sprośny? Przepraszam, nie moja intencja! Wesołych Świąt! :)
Nie chciałem też być wredny i oczywiście miałeś rację! Wesołych Świąt!
1
W wersji 1.9 możesz zapisać więcej znaków: n=$*[0].to_i;puts [*1..n,1].map{|i|" "*(n-i)+"*"*(2*i-1)}obniża to do 58.
14

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:

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

źródło
13

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 $

Hynek-Pichi- Vychodil
źródło
11
Dobry Boże, co to do cholery jest?
1
Wystarczy przeczytać stronę
12

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

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

źródło
W rzeczywistości jest to 57 znaków, tylko spacja jest znacząca zgodnie ze specyfikacją pytania.
10

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


źródło
10

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
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************
          *
tzot
źródło
Uhm serio, wtf? Nie rozumiem ani jednej linijki: P
dc to kalkulator z odwrotnym polerowaniem. „man dc” to oczywisty sposób :)
6

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

źródło
przy użyciu std; ktoś?
strager - kiedy zaczynałem, było tylko kilka std :: 'i' using namespace std; ' było dużo tekstu. Przypuszczam, że teraz będzie mniej znaków.
Twoja wersja jest bardziej nieefektywna niż moja, ponieważ musi tworzyć ciągi, moja wersja drukuje tylko potrzebne znaki. :)
pyon
6

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)

źródło
6

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

źródło
5

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 ΤΖΩΤΖΙΟΥ.


źródło
5

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

źródło
5

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

źródło
5

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);}
 }
joel.neely
źródło
Twoja nowa liczba znaków to 251 (1 odpowiednie miejsce)
pozbyć się „public static void main”, użyj bloku statycznego i skompiluj z java 6;)
Fabinout
Wiem, że minęło prawie 9 lat (lol ..), ale możesz grać w golfa: class T{public static void main(String[]v){long n=new Long(v[0]),r=1,s;String o="";for(;r<=n;r++){for(s=n-r;s-->0;)o+=' ';for(;++s<2*r;)o+='*';o+="\n";}while(n-->1)o+=' ';System.out.println(o+"*");}}(199 znaków / bajty)
Kevin Cruijssen
5

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

1..$args[0]+1|%{" "*(30-$_)+"*"*($_*2-1)}
Jaykul
źródło
5

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.

użytkownik10639
źródło
m,⍨⌽0 1↓m←->(⌽,0 1↓⊢)
ngn
4

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ódło
Ma to ten sam problem, co moje pierwsze cięcie w Javie; nie jest to kompletny program z argumentem wiersza poleceń!
O? Czy to jest wymagane? Nie ma problemu. Naprawię to.
Ma 138 znaków, gdy wszystkie niepotrzebne znaki nowej linii zostaną usunięte.
Can Berk Güder,
Liczę 133 (właśnie usunąłem wszystkie białe spacje i sprawdziłem rozmiar pliku)
4

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="")
    *
   ***
  *****
 *******
*********
    *
djhurio
źródło
3

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");}
Czy Berk Güder
źródło
3

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

źródło
3

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

źródło
Liczba twoich postaci wynosi 98 (2 znaczące spacje, te w cudzysłowie)
3

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
Społeczność
źródło
Zgadzam się z pierwszym stwierdzeniem. W takich kategoriach języki takie jak Perl mają przewagę początkową. Powinno to być coś w rodzaju liczby statystyk lub podobnych.
dzięki ... zadałem wczoraj pytanie na temat golfa i sposób, w jaki można to zrobić za pomocą „tokenów” ... w ten sposób długość imienia i tak dalej nie są karane.
2

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

?>

źródło
Możesz zapisać kilka znaków, budując ciąg, a następnie powtarzając go. Myślę. Wypróbuj to.
Dobry pomysł, ale spróbowałem i to tylko wydłuża. „$ t. = (...)” jest tylko o jeden znak krótszy niż „echo (...)”, a na końcu musisz też „echo $ t”.
Skrócono go o 4 znaki, usuwając „$ i = 0;” pierwsza część instrukcji for. PHP zakłada, że ​​nieistniejące zmienne używane w kontekście liczb całkowitych mają już 0! : P
Zapisano znak, umieszczając $ r = .. wewnątrz for. Mówię też, że znaki nowego wiersza powinny mieć jeden bajt, a nie dwa. =]
Tak, właśnie zdałem sobie sprawę, że przeliczyłem się przez jeden, ponieważ policzyłem używając numeru kolumny w moim edytorze tekstu. Używam linuxa, więc znak nowej linii to jeden bajt.