Code Golf Christmas Edition: So drucken Sie einen Weihnachtsbaum der Größe N aus


89

NWie kann ich bei einer gegebenen Zahl einen hohen Weihnachtsbaum Nmit der geringsten Anzahl von Codezeichen ausdrucken ? Nwird auf einen Minimalwert von 3und einen Maximalwert von beschränkt angenommen 30(Grenzen und Fehlerprüfung sind nicht erforderlich). Nwird als einziges Befehlszeilenargument für Ihr Programm oder Skript angegeben.

Alle Sprachen sind willkommen, wenn Sie eine bereits implementierte Sprache sehen und sie kürzer machen können. Bearbeiten Sie sie, wenn möglich. Kommentieren Sie sie anders und hoffen Sie, dass jemand das Chaos beseitigt. Fügen Sie der Klarheit halber Zeilenumbrüche und Leerzeichen hinzu, aber schließen Sie sie nicht in die Zeichenanzahl ein.

Ein Weihnachtsbaum wird als solcher erzeugt, dessen "Stamm" nur aus einem zentrierten "*" besteht.

N = 3:

   *
  ***
 *****
   *

N = 4:

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

N = 5:

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

N definiert die Höhe der Zweige ohne den einzeiligen Stamm.

Frohe Weihnachten PPCG!

Antworten:


46

J , 24 Zeichen

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

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

Erläuterung:

'*'$~5
*****

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

Dann }:@|."1kehrt jede Zeile und streift die letzte Spalte aus, und ,.Heftklammern es ].

Dann ,{.fügt man die erste Spalte unten ein.

Vorherige Einträge :

29 Zeichen, überhaupt keine Leerzeichen.

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

   NB. Zähle von 1 bis n , dann wieder 1
   >: 0, ~ i.3
1 2 3 1
   NB. repliziere '*' x mal
   $ & '*' "0>: 0, ~ i.3
*
**
***
*
   NB. kehren Sie jede Reihe um
   (\: i. @ #) 1 $ & '*' 0>: 0, ~ i.3
  *
 **
***
  *
   NB. führende Säule abstreifen
   }. "1 $ & '*'" 0>: 0, ~ i.3

*
**

   NB. zusammenfügen
   ((\: i. @ #),}.) 1 $ & '*' 0>: 0, ~ i.3
  *
 ***
*****
  *

Mit nur 9 weiteren Zeichen können Sie dieser Funktion einen Namen geben:c=:[:((\:i.@#),}.)"1[:$&'*'"0[:>:0,~i.
ephemient 06.07.09

11
Was, benutzt ihr eine Art J-Dokumentationsbibliothek, um den Code verständlich zu machen? :)

92

Brainfuck, 240 Zeichen

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

Noch nicht fertig. Es funktioniert, aber nur mit einstelligen Zahlen.

EDIT: Fertig! Funktioniert für Dolmetscher, die 0 als EOF verwenden. Siehe NOTEs in der kommentierten Quelle für diejenigen mit -1.

Erneut BEARBEITEN: Da es in Brainfuck keine Standardmethode zum Lesen von Befehlszeilenargumenten gibt, habe ich stattdessen stdin (Standardeingabe) verwendet. ASCII natürlich.

Ein drittes Mal BEARBEITEN: Oh je, es scheint, als hätte ich .beim Verdichten des Codes Zeichen entfernt (ausgegeben). Fest...

Hier ist die grundlegende Speicherverwaltung der Hauptschleife. Ich bin sicher, es kann stark optimiert werden, um die Anzahl der Zeichen um 30 oder so zu reduzieren.

  1. Befristet
  2. Kopie des Zählers
  3. Zähler (zählt bis 0)
  4. Leerzeichen (Dezimalzahl 32)
  5. Sternchen (Dezimalzahl 42)
  6. Anzahl der Sternchen in der aktuellen Zeile (1 + 2 * Zähler)
  7. Befristet
  8. Neues Zeilenzeichen
  9. Befristet?
  10. Gesamtzahl der Zeilen (dh Eingabewert; wird beim Drucken des Trunks bis zum Ende gespeichert)

Kondensierte Version:

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

Und die hübsche Version:

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

1
Mein Gehirn fühlt sich f ..... krank

3
Oh mein Gott.
Anonymer Feigling

63

Perl, 50 Zeichen

(1 relevante Leerzeichen)

Perl: einzeilige Version:

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

und jetzt mit mehr whitesapce:

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

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

Erweiterte Erklärung für Nicht-Perl-Benutzer.

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

25
Heiliger Mist ... Perl ist wirklich unlesbar.

8
@Zenazn, auch sollte beachtet werden, dass das meiste Golfen BAD Code in jeder Sprache ist. Wenn dies ein Wettbewerb für den saubersten Code wäre, könnten wir das auch gewinnen.
Kent Fredric

5
@zenazn: Beweis, Sie können sehen, wie wir zusammenarbeiten und uns gegenseitig verbessern. Dies beweist, dass WIR JEDEN ANDEREN Code perfekt lesen können .
Kent Fredric

1
PS: Danke für die Erklärung für Nicht-Perl-Programmierer. Es ist immer noch ziemlich unlesbar, aber zumindest macht es Sinn. Ich nehme an, Sie gewöhnen sich nach einer Weile daran.

2
@RobH: J ist das Kind von APL. In gewisser Hinsicht ist es unlesbarer, da der APL-Zeichensatz nicht für jede Operation mit einem speziellen Symbol versehen wird. Stattdessen werden ASCII-Zeichen mit mehreren Bedeutungen überladen. stackoverflow.com/questions/392788/1088931#1088931
ephemient

26

Sprache: Python (durch Shell), Zeichenanzahl: 64 (2 signifikante Leerzeichen)

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

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

8
Was mir an dieser Lösung am besten gefällt, ist, dass es mit Python wirklich schwierig ist, obskuren Code zu schreiben. Es ist eine der am besten lesbaren Lösungen

Sie verwenden die Shell, um das Argument zu verarbeiten, was nicht im Sinne von Code Golf IMO ist. Unter Verwendung von "import sys" und "n = w = int (sys.argv [1])" und einem Einzug von 1 Zeichen für den Schleifenkörper habe ich für diese Version 89 Zeichen gefunden.

4
So habe ich es vorher gemacht. Der Sinn dieser Frage ist, Spaß zu haben, und außerdem gab es keine Spezifikation, nur eine Sprache zu verwenden :) Siehe beispielsweise die Antwort auf den Brainfuck. keine argumente.

26

x86 asm 16-Bit, 50 Bytes

Noch keine Montageversion? :)

    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

(Hinweis: N ist in dieser Version auf 1 - 9 begrenzt.)

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

Hier herunterladen


24

Sprache: Windows Batch Script ( schockierend! )

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

Masochist! Ich mag es

Sehr schön ... Sie erhalten +1

2
Die verzögerte Variablenerweiterung kann mit dem setlocal enabledelayedexpansionBefehl aktiviert werden .
Helen

Kumpel. Ernsthaft?

Ich kann es nicht zum Laufen bringen. Zum ersten Mal versuche ich es aber.
Fabinout

21

Ruby, 64 Bytes

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

Frohe Weihnachten euch allen!

Bearbeiten: Verbesserungen hinzugefügt, wie von Joshua Swink vorgeschlagen


Scheiße, ich hatte gehofft, dass es noch niemand in Rubin probiert hat. gute Arbeit.

Dies ist eine sehr schöne Linie von Ruby.

Habe ich zu abrubt gewirkt? Entschuldigung, nicht meine Absicht! Frohe Weihnachten! :)

Wollte auch nicht gemein sein, und natürlich hattest du recht! Frohe Weihnachten!

1
Am 1.9 können Sie weitere Zeichen speichern: n=$*[0].to_i;puts [*1..n,1].map{|i|" "*(n-i)+"*"*(2*i-1)}

14

Sprache: C #, Zeichenzahl: 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));
    }
}

Nur der Code ohne Formatierung (120 Zeichen):

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

Version mit 109 Zeichen (nur der Code):

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

Ergebnis für Höhe = 10:

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

13

Sprache: dc (durch Shell) Zeichenanzahl: 83

Ein bisschen kürzere DC-Version:

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

BEARBEITEN: Konstante 10 in $ 1 geändert


11
Guter Herr, was zum Teufel ist das?

1

12

Python, "-c" Trick ... bei 61 Zeichen (und einer Zeile)

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

Tatsächlich sind es 57 Zeichen, nur das Leerzeichen ist gemäß den Fragenspezifikationen von Bedeutung.

10

Hier ist eine einigermaßen platzsparende Haskell-Version mit 107 Zeichen:

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

Laufen es:

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

Frohe Weihnachten euch allen :)


10

Sprache: dc (durch Shell), Zeichenanzahl: 119 (1 signifikantes Leerzeichen)

Nur für die Dunkelheit davon :)

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

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

Ähm im Ernst, wtf? Ich verstehe keine einzige Zeile davon: P

dc ist ein Umkehrpoliturrechner. 'man dc' ist der naheliegende Weg :)

6

Besser C ++, ca. 210 Zeichen:

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

Auf 179 minimiert:

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

mit std; jemand?

strager - als ich anfing gab es nur ein paar std :: 's und' using namespace std; ' war viel text. Ich nehme an, das wären jetzt weniger Zeichen.

Ihre Version ist ineffizienter als meine, da sie Zeichenfolgen erstellen muss. Meine Version gibt nur die Zeichen aus, die sie benötigt. :)
Pyon

6

Sprache: Python, keine Tricks, 78 Zeichen

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

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

5

Die Antwort von ΤΖΩΤΖ verbessern. Ich kann keinen Kommentar abgeben. Hier ist ein neuer Beitrag. 72 Zeichen.

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

Mit dem Trick "python -c" 61 Zeichen.

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

Ich habe die Center-Funktion gelernt und festgestellt, dass "python -c" mehr als einen Zeilencode akzeptieren kann. Danke, ΤΖΩΤΖ.


5

C # mit 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 Zeichen.

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

5

AWK, 86 Zeichen in einer Zeile.

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

5

Sprache: Java, Zeichenzahl: 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");}}

Als Referenz konnte ich die vorherige Java-Lösung mit einer Rekursion von bis zu 231 Zeichen von dem vorherigen Minimum von 269 rasieren. Obwohl diese Lösung etwas länger ist, gefällt sie mir, weil sie Twirklich objektorientiert ist. Sie könnten einen kleinen Wald von TInstanzen in zufälliger Größe erstellen . Hier ist die neueste Entwicklung auf diesem Gebiet:

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

Ihre neue Zeichenanzahl ist 251 (1 relevantes Leerzeichen)

"public static void main" loswerden, einen statischen Block verwenden und mit Java 6 kompilieren;)
Fabinout 15.11.13

Ich weiß, es ist fast 9 Jahre her (lol ..), aber Sie können einige Dinge Golf spielen: 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 Zeichen / Bytes)
Kevin Cruijssen

5

Sprache: PowerShell, Zeichenanzahl: 41 (einschließlich 1 Leerzeichen)

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

5

21 Zeichen mit dyalog APL.

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

⍳ gibt einen Vektor von ganzen Zahlen an, der mit 1 beginnt.

1, ⍨ fügt am Ende des Vektors eine Eins hinzu. Dies wird der Fuß des Baumes sein.

'*' \ ¨⍨ gibt einen Vektor von * -Strings mit Längen an, die durch den vorherigen Vektor gegeben sind.

↑ transformiert den Vektor in eine Matrix und fügt rechts Leerzeichen ein.

m ← speichert die Matrix in m.

0 1 ↓ löscht null Zeilen und die erste Spalte.

⌽ kehrt die Matrix um.

m, ⍨ verkettet sich mit m auf der rechten Seite.


m,⍨⌽0 1↓m←->(⌽,0 1↓⊢)
ngn

4

Sprache: C, Zeichenzahl: 133

Verbesserung der C-Version.

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

Funktioniert und nimmt sogar die Baumhöhe als Argument. Benötigt einen Compiler, der K & R-Code toleriert.

Ich fühle mich jetzt so schmutzig. Dieser Code ist hässlich.


Dies hat das gleiche Problem wie mein erster Schnitt in Java; Es ist kein vollständiges Programm mit einem Befehlszeilenargument!

Oh? Ist das erforderlich? Kein Problem. Ich werde das reparieren.

Es sind 138 Zeichen, wenn alle unnötigen Zeilenumbrüche entfernt wurden.
Can Berk Güder

Ich zähle 133 (habe gerade alle Leerzeichen entfernt und die Dateigröße überprüft)

4

R (62 Bytes)

Ich habe die R-Lösung noch nicht gesehen. Korrigieren Sie mich, wenn ich es verpasst habe.

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

Ausgabe:

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

3

Sprache: C, Zeichenanzahl: 176 (2 relevante Leerzeichen)

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

3

Shell-Version, 134 Zeichen:

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


3

Sprache: Python, Signifikante Zeichenanzahl: 90

Es ist hässlich, aber es funktioniert:

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

Ihre Zeichenanzahl beträgt 98 (2 signifikante Leerzeichen, die in Anführungszeichen stehen)

3

Da dies ein CW ist: Ich mag es nicht, dass Codegolfs immer nach "Anzahl der Zeichen" oder ähnlichem organisiert sind. Könnten sie nicht in Bezug auf die Anzahl der Anweisungen für den Compiler / Interpreter (oder ein ähnliches Kriterium) organisiert werden? Hier ist wieder die Ruby-Lösung , und sie ist im Grunde die gleiche, aber jetzt auch für den menschlichen Verzehr:

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

Ich stimme der ersten Aussage zu. In dieser Hinsicht haben Sprachen wie Perl einen entscheidenden Vorteil. Sollte so etwas wie Anzahl der Statemetns oder ähnliches sein.

danke ... Ich habe gestern eine Frage zum Thema Golf gestellt und die Art und Weise, dies zu tun, könnte mit "Token" sein ... auf diese Weise wird die Länge des Namens usw. nicht bestraft.



2

PHP, 111 Zeichen

(Das allerletzte Zeichen sollte ein Zeilenumbruch sein.)

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

Lesbare Version:

<?php

$n = $argv[1];

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

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

?>

Sie können mehrere Zeichen speichern, indem Sie die Zeichenfolge erstellen und anschließend wiederholen. Ich denke. Probieren Sie das aus.

Gute Idee, aber ich habe es versucht und es macht es nur länger. '$ t. = (...)' ist nur ein Zeichen kürzer als 'echo (...)', und am Ende müsste auch 'echo $ t' stehen.

Verkürzt um 4 Zeichen durch Entfernen von '$ i = 0;' erster Teil der for-Anweisung. PHP geht davon aus, dass nicht existierende Variablen, die in einem Integer-Kontext verwendet werden, bereits 0 sind! : P

Ein Zeichen wurde gespeichert, indem $ r = .. in das for gesetzt wurde. Außerdem sage ich, dass Newline-Zeichen ein Byte und nicht zwei sein sollten. =]

Ja, ich habe gerade gemerkt, dass ich um eins falsch gezählt habe, weil ich mit der Spaltennummer in meinem Texteditor gezählt habe. Ich benutze Linux, also ist das Newline-Zeichen ein Byte.
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.