Code Golf Christmas Edition: Comment imprimer un sapin de Noël de hauteur N

89

Étant donné un numéro N, comment puis-je imprimer un sapin de Noël de hauteur en Nutilisant le moins de caractères de code? Nest supposé contraint à une valeur minimale de 3, et à une valeur maximale de 30(les bornes et la vérification des erreurs ne sont pas nécessaires). Nest le seul et unique argument de ligne de commande de votre programme ou de votre script.

Toutes les langues sont appréciées, si vous voyez une langue déjà implémentée et que vous pouvez la raccourcir, modifiez-la si possible - commentez sinon et espérez que quelqu'un nettoie les dégâts. Incluez des nouvelles lignes et des espaces blancs pour plus de clarté, mais ne les incluez pas dans le nombre de caractères.

Un arbre de Noël est généré en tant que tel, avec son "tronc" composé uniquement d'un "*" centré

N = 3:

   *
  ***
 *****
   *

N = 4:

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

N = 5:

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

N définit la hauteur des branches, sans compter le tronc d'une ligne.

Joyeux Noël PPCG!

Le logicielJedi
la source

Réponses:

46

J , 24 caractères

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

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

Explication:

'*'$~5
*****

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

}:@|."1Inverse ensuite chaque ligne, enlève la dernière colonne et ,.agrafe ].

Puis ,{.colle la première colonne sur le bas.

Entrées précédentes :

29 caractères, pas d'espaces du tout.

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

   NB compter de 1 à n , puis à nouveau 1
   >: 0, ~ i.3
1 2 3 1
   NB répliquer '*' x fois chaque
   $ & '*' "0>: 0, ~ i.3
*
**
***
*
   NB inverser chaque rangée
   (\: i. @ #) "1 $ & '*'" 0>: 0, ~ i.3
  *
 **
***
  *
   NB enlever la colonne de tête
   }. "1 $ & '*'" 0>: 0, ~ i.3

*
**

   NB coller ensemble
   ((\: i. @ #),}.) "1 $ & '*'" 0>: 0, ~ i.3
  *
 ***
*****
  *
éphémère
la source
Avec seulement 9 caractères supplémentaires, vous pouvez attribuer un nom à cette fonction:c=:[:((\:i.@#),}.)"1[:$&'*'"0[:>:0,~i.
éphémiente le
11
Quoi, utilisez-vous une sorte de bibliothèque de documentation J pour comprendre le code? :)
92

Brainfuck, 240 caractères

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

Pas encore fait. Cela fonctionne, mais seulement avec des nombres à un chiffre.

EDIT: fait! Fonctionne pour les interprètes utilisant 0 comme EOF. Voir NOTEs dans la source commentée pour ceux avec -1.

EDIT à nouveau: je dois noter que, comme Brainfuck n’a pas de méthode standard pour lire les arguments en ligne de commande, j’ai utilisé stdin (entrée standard). ASCII, bien sûr.

EDIT une troisième fois: Oh mon Dieu, il semble que j’ai enlevé .des caractères lors de la condensation du code. Fixé...

Voici la gestion de base de la mémoire de la boucle principale. Je suis sûr que cela peut être fortement optimisé pour réduire le nombre de personnages de 30 ou plus.

  1. Temporaire
  2. Copie de compteur
  3. Compteur (compte jusqu'à 0)
  4. Caractère d'espace (décimal 32)
  5. Caractère astérisque (décimal 42)
  6. Nombre d'astérisques sur la ligne en cours (compteur 1 + 2 *)
  7. Temporaire
  8. Nouveau caractère de ligne
  9. Temporaire?
  10. Nombre total de lignes (c.-à-d. Valeur d'entrée; stockées jusqu'à la toute fin lors de l'impression du tronc)

Version condensée:

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

Et la jolie 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 =)
jrtapsell
la source
1
mon cerveau se sent f ..... malade
3
Oh mon Dieu.
lâche anonyme
63

Perl, 50 caractères

(1 espaces pertinents)

perl: version une ligne:

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

et maintenant avec plus de blanc:

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

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

Explication développée pour les utilisateurs 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. 
MkV
la source
25
Holy Crap ... Perl est vraiment illisible.
8
@zenazn, il faut aussi noter que la plupart des golfeurs utilisent un code BAD dans toutes les langues. S'il s'agissait d'une compétition pour le code le plus propre, nous pourrions également gagner.
Kent Fredric
5
@zenazn: preuve, vous pouvez nous voir collaborer et améliorer le code de chacun des autres joueurs ci-dessus, cela prouve que nous pouvons lire le code de CHAQUE AUTRE parfaitement.
Kent Fredric
1
PS: Merci pour l'explication pour les programmeurs non-Perl. C'est toujours assez illisible, mais au moins c'est logique. Je suppose que vous vous y habituez après un moment.
2
@RobH: J est l'enfant de APL. À certains égards, il est plus illisible, car il n'utilise pas le jeu de caractères de APL avec un symbole spécial pour chaque opération. Il surcharge les caractères ASCII ayant plusieurs significations. stackoverflow.com/questions/392788/1088931#1088931
ephemient
26

Langue: Python (par le biais de shell), Nombre de caractères: 64 (2 espaces significatifs)

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

$ sh ax6 11
           *
          ***
         *****
        *******
       *********
      ***********
     *************
    ***************
   *****************
  *******************
 *********************
           *
tzot
la source
8
Ce que j'aime le plus dans cette solution est que python rend très difficile l'écriture de code obscur, c'est l'une des solutions les plus lisibles
Vous utilisez le shell pour traiter l'argument, ce qui n'est pas dans l'esprit de code golf IMO. Avec "import sys" et "n = w = int (sys.argv [1])" et un retrait de 1 caractère pour le corps de la boucle, je présente 89 caractères pour cette version.
4
C'est comme ça que je l'avais fait avant. L’esprit de cette question est de s’amuser et, en outre, il n’était pas prévu d’utiliser une seule langue :) Voir la réponse sournoise, par exemple; pas d'arguments.
26

x86 asm 16 bits, 50 octets

Pas encore de version d'assemblage? :)

    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

(Remarque: N est limité à 1 - 9 dans cette version)

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

Télécharger ici

Jonas Gulle
la source
24

Langue: Script batch Windows ( choquant! )

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

la source
masochiste! Je l'aime bien
Très bien ... vous obtenez +1
2
Le développement des variables différées peut être activé à l'aide de la setlocal enabledelayedexpansioncommande.
Helen
mec. sérieusement?
Je ne peux pas le faire fonctionner. C'est la première fois que j'essaye.
Fabinout
21

Ruby, 64 octets

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

Joyeux Noël à tous!

Edit: Améliorations ajoutées comme suggéré par Joshua Swink

jrtapsell
la source
J'espérais que personne ne l'avait encore essayé en rubis. Bon travail.
C'est une très belle ligne de Ruby.
Ai-je semblé trop abrupte? Désolé, pas mon intention! Joyeux Noël! :)
Je ne voulais pas être méchant non plus, et bien sûr vous aviez raison! Joyeux Noël!
1
Sur 1.9, vous pouvez économiser encore plus de caractères: n=$*[0].to_i;puts [*1..n,1].map{|i|" "*(n-i)+"*"*(2*i-1)}
14

Langue: C #, Nombre de personnages: 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));
    }
}

Juste le code, sans formatage (120 caractères):

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 avec 109 caractères (juste le 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)));

Résultat pour height = 10:

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

la source
13

Langue: dc (via shell) Nombre de personnages: 83

Version dc un peu plus courte:

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

EDIT: changé constante 10 en 1 $

Hynek-Pichi- Vychodil
la source
11
Bon dieu, qu'est-ce que c'est que ça?
1
Il suffit de lire la page de manuel ;-)
12

Python, astuce "-c" ... @ 61 caractères (et une ligne)

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

la source
En fait, il s’agit de 57 caractères. Seul l’espace "" est significatif conformément aux spécifications de la question.
10

Voici une version de Haskell raisonnablement peu encombrante, avec 107 caractères:

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

le lancer:

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

Joyeux Noël à tous :)


la source
10

Langue: dc (via shell), Nombre de personnages: 119 (1 espace significatif)

Juste pour l'obscurité de celui-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
la source
Uhm sérieusement, wtf? Je ne comprends pas une seule ligne: P
dc est une calculatrice à polissage inverse. 'homme dc' est le moyen évident d'aller :)
6

Meilleur C ++, environ 210 caractères:

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

Réduit à 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;}

la source
en utilisant std; n'importe qui?
strager - quand j'ai commencé, il n'y avait que quelques std :: 'et' using namespace std; ' était beaucoup de texte. Je suppose que maintenant ce serait moins de caractères.
Votre version est plus inefficace que la mienne, car elle doit créer des chaînes, ma version n’imprime que les caractères dont elle a besoin. :)
Pyon
6

Langue: python, pas d'astuce, 78 caractères

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

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

la source
5

Améliorer la réponse de Ω. Je ne peux pas commenter, alors voici un nouveau post. 72 caractères.

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

Utilisation de l'astuce "python -c", 61 caractères.

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

J'ai appris la fonction de centre et que "python -c" peut accepter plus d'un code de ligne. Merci, ΩΤΖΙΟΥ.


la source
5

C # en utilisant 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 caractères.

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

la source
5

AWK, 86 caractères sur une ligne.

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

la source
5

Langue: Java, Nombre de personnages: 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");}}

Pour référence, j'ai pu réduire la précédente solution Java en utilisant la récursivité, passant du minimum précédent à 231 caractères à 239 caractères T. Vous pouvez créer une petite forêt d' Tinstances de taille aléatoire . Voici la dernière évolution sur ce point:

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
la source
Le nombre de vos nouveaux personnages est 251 (1 espace correspondant)
se débarrasser de "public static void main", utiliser un bloc statique et compiler avec java 6;)
Fabinout
Je sais que ça fait presque 9 ans (lol ..) mais vous pouvez 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+"*");}}
jouer au
5

Langue: PowerShell, Nombre de personnages: 41 (incluant 1 espace)

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

21 caractères avec APL dyalog.

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

Donne un vecteur d'entiers commençant par 1.

1, ⍨ ajoute un un à la fin du vecteur. Ce sera le pied de l'arbre.

'*' \ ¨⍨ donne un vecteur de * chaînes de longueurs données par le vecteur précédent.

↑ transforme le vecteur en matrice et ajoute des espaces à droite.

m ← stocke la matrice dans m.

0 1 ↓ supprime zéro ligne et la première colonne.

⌽ inverse la matrice.

m, ⍨ concatène avec m sur le côté droit.

utilisateur10639
la source
m,⍨⌽0 1↓m←->(⌽,0 1↓⊢)
NDGF le
4

Langue: C, Nombre de personnages: 133

Amélioration de la version 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);
}

Fonctionne et prend même la hauteur de l’arbre comme argument. Besoin d'un compilateur qui tolère le code de style K & R.

Je me sens tellement sale maintenant .. Ce code est moche.


la source
Cela pose le même problème que lors de ma première version en Java; ce n'est pas un programme complet avec l'utilisation d'un argument de ligne de commande!
Oh? Est-ce nécessaire? Aucun problème. Je vais arranger ça.
Il s’agit de 138 caractères lorsque toutes les nouvelles lignes inutiles sont supprimées.
Peut Berk Güder
Je compte 133 (vient de supprimer tous les espaces et vérifier la taille du fichier)
4

R (62 octets)

Je n'ai pas encore vu de solution R. Corrigez-moi si je l'ai raté.

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

Sortie:

> 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
la source
3

Langue: C, Nombre de personnages: 176 (2 espaces pertinents)

#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");}
Peut Berk Güder
la source
3

Version shell, 134 caractères:

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

la source
3

Langue: Python, Nombre de personnages significatifs: 90

C'est moche mais ça marche:

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

la source
Votre nombre de personnages est de 98 (2 espaces significatifs, ceux entre guillemets)
3

Comme il s’agit d’un CW: Je n’aime pas que le code soit toujours organisé en termes de "nombre de caractères" ou d’autres. Ne pourraient-ils pas être organisés en termes de nombre d'instructions pour le compilateur / interprète (ou un critère similaire)? Voici à nouveau la solution Ruby , et elle est fondamentalement la même, mais maintenant pour la consommation humaine:

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
Communauté
la source
Je suis d'accord avec la première déclaration. En ce sens, les langues telles que perl ont un avantage de départ. Devrait être quelque chose comme le nombre de statemetns ou similaires.
merci ... j'ai posé une question sur le golf hier et sur la façon de le faire avec des "jetons" ... de cette façon, la longueur du nom, etc., n'est pas pénalisée.
2

PHP, 111 caractères

(Le tout dernier caractère devrait être une nouvelle ligne.)

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

Version lisible:

<?php

$n = $argv[1];

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

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

?>

la source
Vous pouvez enregistrer plusieurs caractères en construisant la chaîne, puis en la répercutant. Je pense. Essayez ça.
Bonne idée, mais j'ai essayé et ça ne fait que prolonger. '$ t. = (...)' est seulement un caractère plus court que 'echo (...)', et vous devrez alors aussi 'echo $ t' à la fin.
Raccourcissez-le de 4 caractères en supprimant le '$ i = 0;' première partie de la déclaration for. PHP suppose que les variables inexistantes utilisées dans un contexte entier sont déjà à 0! : P
Sauvegardé un caractère en mettant $ r = .. à l'intérieur du for. En outre, je dis que les caractères de nouvelle ligne devraient être un octet, pas deux. =]
Oui, je viens de me rendre compte que je me suis trompé de compte parce que j'ai compté en utilisant le numéro de colonne dans mon éditeur de texte. J'utilise linux donc le caractère de nouvelle ligne est un octet.