Code Golf Christmas Edition: come stampare un albero di Natale di altezza N


89

Dato un numero N, come posso stampare un albero di Natale di altezza Nusando il minor numero di caratteri di codice? Nviene assunto vincolato a un valore minimo di 3e un valore massimo di 30(non sono necessari limiti e controllo degli errori). Nviene fornito come l'unico e unico argomento della riga di comando per il programma o lo script.

Sono apprezzate tutte le lingue, se vedi una lingua già implementata e puoi accorciarla, modifica se possibile - commenta diversamente e spera che qualcuno ripulisca il disordine. Includi nuove righe e spazi bianchi per maggiore chiarezza, ma non includerli nel conteggio dei personaggi.

Un albero di Natale viene generato come tale, con il suo "tronco" costituito solo da un "*" centrato

N = 3:

   *
  ***
 *****
   *

N = 4:

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

N = 5:

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

N definisce l'altezza dei rami escluso il tronco di una linea.

Buon Natale PPCG!

Risposte:


46

J , 24 caratteri

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

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

Spiegazione:

'*'$~5
*****

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

Quindi }:@|."1inverte ogni riga e rimuove l'ultima colonna e la ,.pinza su ].

Quindi ,{.incolla la prima colonna sul fondo.

Voci precedenti :

29 caratteri, nessuno spazio.

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

   NB. conta da 1 a n , quindi di nuovo 1
   >: 0, ~ I.3
1 2 3 1
   NB. replicare '*' x volte ciascuno
   $ & '*' "0>: 0, ~ I.3
*
**
***
*
   NB. invertire ogni riga
   (\:. I @ #) "1 $ & '*'" 0>: 0, ~ I.3
  *
 **
***
  *
   NB. togliere la colonna principale
   } "1 $ & '*'" 0>:. 0, ~ I.3

*
**

   NB. incollare insieme
   ((\:. I @ #),}.) "1 $ & '*'" 0>: 0, ~ I.3
  *
 ***
*****
  *

Con solo altri 9 personaggi puoi dare un nome a questa funzione:c=:[:((\:i.@#),}.)"1[:$&'*'"0[:>:0,~i.
effimero

11
Ragazzi, usate una sorta di libreria di documentazione J per capire il codice? :)

92

Brainfuck, 240 caratteri

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

Non ancora fatto. Funziona, ma solo con numeri a una cifra.

EDIT: Fatto! Funziona con interpreti che usano 0 come EOF. Vedi NOTEs nella fonte commentata per quelli con -1.

EDIT di nuovo: dovrei notare che poiché Brainfuck non ha un metodo standard per leggere gli argomenti della riga di comando, ho usato invece stdin (input standard). ASCII, ovviamente.

MODIFICA una terza volta: oh mio Dio, mi sembra di aver rimosso i caratteri .(in uscita) durante la condensazione del codice. Fisso...

Ecco la gestione di base della memoria del loop principale. Sono sicuro che può essere fortemente ottimizzato per ridurre il numero di caratteri di circa 30.

  1. Temporaneo
  2. Copia del contatore
  3. Contatore (conta fino a 0)
  4. Carattere spaziale (decimale 32)
  5. Carattere asterisco (decimale 42)
  6. Numero di asterischi sulla riga corrente (contatore 1 + 2 *)
  7. Temporaneo
  8. Carattere di nuova riga
  9. Temporaneo?
  10. Numero totale di righe (ovvero valore di input; memorizzato fino alla fine, durante la stampa del trunk)

Versione condensata:

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

E la versione carina:

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
il mio cervello si sente male .....

3
Dio mio.
codardo anonimo il

63

Perl, 50 caratteri

(1 spazi pertinenti)

perl: versione a una riga:

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

e ora con più spazi bianchi:

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

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

Spiegazione estesa per utenti 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. 

25
Santa merda ... perl è davvero illeggibile.

8
@zenazn, inoltre, dovrebbe essere notato che la maggior parte del golf è il codice BAD in qualsiasi lingua. Se questa fosse una competizione per il codice più pulito, potremmo vincere anche quello.
Kent Fredric,

5
@zenazn: la prova, si può vedere noi collaborare e migliorare ogni codice sopra gli altri, questo dimostra WE in grado di leggere ogni altro codice perfettamente bene.
Kent Fredric,

1
PS: Grazie per la spiegazione per i programmatori non Perl. È ancora piuttosto illeggibile, ma almeno ha senso. Immagino che ti abitui dopo un po '.

2
@RobH: J è il figlio di APL. In alcuni sensi, è più illeggibile perché non utilizza il set di caratteri APL con un simbolo speciale per ogni operazione, ma sovraccarica i caratteri ASCII con significati multipli. stackoverflow.com/questions/392788/1088931#1088931
ephemient

26

Lingua: Python (tramite shell), Conteggio caratteri: 64 (2 spazi significativi)

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

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

8
quello che mi piace di più di questa soluzione è che Python rende davvero difficile scrivere codice oscuro, è una delle soluzioni più leggibili

Stai usando la shell per elaborare l'argomento, che non è nello spirito del codice golf IMO. Usando "import sys" e "n = w = int (sys.argv [1])" e un rientro di 1 carattere per il corpo del loop, ho trovato 89 caratteri per questa versione.

4
È così che l'ho fatto prima. Lo spirito di questa domanda è divertirsi e inoltre non è stato specificato l'utilizzo di una sola lingua :) Vedi la risposta brainfuck, per esempio; nessun argomento.

26

x86 asm 16 bit, 50 byte

Nessuna versione dell'assembly ancora? :)

    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

(Nota: N è limitato a 1 - 9 in questa versione)

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

Scarica qui


24

Lingua: Windows Batch Script ( scioccante! )

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

masochista! Mi piace

Molto bello ... ottieni +1

2
L'espansione ritardata delle variabili può essere abilitata usando il setlocal enabledelayedexpansioncomando.
Helen,

tipo. sul serio?

Non riesco a farlo funzionare. Prima volta ci provo comunque.
Fabinout,

21

Rubino, 64 byte

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

Buon Natale a tutti!

Modifica: miglioramenti aggiunti come suggerito da Joshua Swink


dang Speravo che nessuno lo avesse ancora provato in ruby. bel lavoro.

Questa è una linea molto bella di Ruby.

Mi è sembrato troppo brusco? Scusa, non è mia intenzione! Merry XMas! :)

Non intendevo nemmeno essere cattivo, e ovviamente avevi ragione! Buon Natale!

1
Con 1.9, puoi salvare altri caratteri: lo n=$*[0].to_i;puts [*1..n,1].map{|i|" "*(n-i)+"*"*(2*i-1)}porta a 58.

14

Lingua: C #, Conteggio caratteri: 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));
    }
}

Solo il codice, senza formattazione (120 caratteri):

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

Versione con 109 caratteri (solo il codice):

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

Risultato per altezza = 10:

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

13

Lingua: cc (tramite shell) Conteggio caratteri: 83

Versione cc leggermente più corta:

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

EDIT: ha cambiato la costante 10 in $ 1


11
Buon Dio, che diavolo è quello?

1
Basta leggere la pagina man ;-)

12

python, trucco "-c" ... @ 61 caratteri (e una riga)

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

In realtà, ha 57 caratteri, solo lo spazio '' è significativo secondo le specifiche della domanda.

10

Ecco una versione di Haskell ragionevolmente efficiente in termini di spazio, con 107 caratteri:

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

eseguendolo:

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

Buon Natale a tutti :)


10

Lingua: cc (tramite shell), Conteggio caratteri: 119 (1 spazio significativo)

Solo per l'oscurità di esso :)

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

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

Uhm sul serio, wtf? Non capisco una sola riga di ciò: P

dc è un calcolatore per la lucidatura inversa. 'man dc' è il modo ovvio per andare :)

6

Meglio C ++, circa 210 caratteri:

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

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

usando std; chiunque?

strager - quando ho iniziato c'erano solo un paio di std :: 's e' using namespace std; ' era un sacco di testo. Suppongo che ora ci sarebbero meno personaggi.

La tua versione è più inefficiente della mia, perché deve creare stringhe, la mia versione stampa solo i caratteri di cui ha bisogno. :)
pyon il

6

Lingua: pitone, nessun trucco, 78 caratteri

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

Miglioramento della risposta di ΤΖΩΤΖΙΟΥ. Non posso commentare, quindi ecco un nuovo post. 72 caratteri.

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

Usando il trucco "python -c", 61 caratteri.

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

Ho imparato la funzione centrale e che "python -c" può accettare più di un codice di linea. Grazie, ΤΖΩΤΖΙΟΥ.


5

C # usando 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 caratteri.

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 caratteri su una riga.

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

Lingua: Java, Conteggio caratteri: 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");}}

Per riferimento, sono stato in grado di radere la precedente soluzione Java, usando la ricorsione, fino a 231 caratteri, dal precedente minimo di 269. Anche se un po 'più a lungo, mi piace questa soluzione perché Tè veramente orientata agli oggetti. È possibile creare una piccola foresta di Tistanze di dimensioni casuali . Ecco l'ultima evoluzione di quella virata:

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

Il tuo nuovo numero di personaggi è 251 (1 spazio pertinente)

sbarazzarsi di "pubblico vuoto statico principale", utilizzare un blocco statico e compilare con Java 6;)
Fabinout

So che sono passati quasi 9 anni (lol ..) ma puoi giocare a golf alcune cose: 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 caratteri / byte)
Kevin Cruijssen,

5

Lingua: PowerShell, Conteggio caratteri: 41 (incluso 1 spazio)

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

5

21 personaggi con dyalog APL.

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

⍳ fornisce un vettore di numeri interi che iniziano con 1.

1, ⍨ aggiunge uno alla fine del vettore. Questo sarà il piede dell'albero.

'*' \ ¨⍨ fornisce un vettore di * -strings con lunghezze fornite dal vettore precedente.

↑ trasforma il vettore in una matrice e aggiunge spazi a destra.

m ← memorizza la matrice in m.

0 1 ↓ elimina zero righe e la prima colonna.

⌽ inverte la matrice.

m, ⍨ concatena con m sul lato destro.


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

4

Lingua: C, Numero di caratteri: 133

Miglioramento della versione 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);
}

Funziona e prende anche l'altezza dell'albero come argomento. Ha bisogno di un compilatore che tolleri il codice in stile K & R.

Mi sento così sporco ora .. Questo codice è brutto.


Questo ha lo stesso problema del mio primo taglio in Java; non è un programma completo con l'uso di un argomento da riga di comando!

Oh? È richiesto? Nessun problema. Lo aggiusterò.

Sono 138 caratteri quando vengono rimosse tutte le nuove righe non necessarie.
Can Berk Güder il

Conto 133 (ho appena rimosso tutti gli spazi bianchi e verificato la dimensione del file)

4

R (62 byte)

Non ho ancora visto la soluzione R. Correggimi se l'ho perso.

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

Produzione:

> 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

Lingua: C, Numero di caratteri: 176 (2 spazi pertinenti)

#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

Versione shell, 134 caratteri:

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

Lingua: Python, Conteggio significativo dei caratteri: 90

È brutto ma funziona:

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

Il conteggio dei personaggi è 98 (2 spazi significativi, quelli tra virgolette)

3

Dato che si tratta di un CW: non mi piace che i golf di codice siano sempre organizzati in termini di "numero di caratteri" o qualcosa del genere. Non potrebbero essere organizzati in termini di numero di istruzioni per il compilatore / interprete (o qualche criterio simile)? Ecco di nuovo la soluzione Ruby , ed è sostanzialmente la stessa, ma ora anche per il consumo umano:

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

Sono d'accordo con la prima affermazione. In tali termini, lingue come il perl hanno un vantaggio iniziale. Dovrebbe essere qualcosa di simile al numero di stati o simili.

grazie ... Ho fatto una domanda sul golf ieri e il modo di farlo potrebbe essere con "token" ... in questo modo la lunghezza del nome e così via non è penalizzata.



2

PHP, 111 caratteri

(L'ultimo carattere dovrebbe essere una nuova riga.)

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

Versione leggibile:

<?php

$n = $argv[1];

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

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

?>

È possibile salvare diversi caratteri creando la stringa e facendola eco. Penso. Provalo.

Buona idea, ma l'ho provato e lo rende solo più lungo. '$ t. = (...)' è solo un carattere più corto di 'echo (...)', e alla fine dovresti anche 'echo $ t'.

Ridotto di 4 caratteri rimuovendo '$ i = 0;' prima parte della dichiarazione for. PHP presuppone che le variabili inesistenti utilizzate in un contesto intero siano già 0! : P

Hai salvato un carattere inserendo $ r = .. all'interno di for. Inoltre, dico che i caratteri di nuova riga dovrebbero essere un byte, non due. =]

Sì, mi sono appena reso conto di aver contato male uno perché ho contato usando il numero di colonna nel mio editor di testo. Uso linux quindi il carattere newline è di un byte.
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.