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!

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

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

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. 

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

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

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

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

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:

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

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

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

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

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

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

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

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)

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

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, ΤΖΩΤΖ.

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

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

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

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

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

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.

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.

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

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

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

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

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

Kohle , 9 Bytes (nicht konkurrierend)

Ｇ↗↘←Ｎ*Ｍ↓*

Probieren Sie es online!

Ausführlich

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

Probieren Sie es online!

Gelee , 12 Bytes

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

Probieren Sie es online!

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

?>