Questa domanda si è diffusa come un virus nel mio ufficio. Esistono diversi approcci:

Stampa quanto segue:

        1
       121
      12321
     1234321
    123454321
   12345654321
  1234567654321
 123456787654321
12345678987654321
 123456787654321
  1234567654321
   12345654321
    123454321
     1234321
      12321
       121
        1

Le risposte sono segnate in caratteri con un minor numero di caratteri migliori.

J, 29 26 24 23 22 21 caratteri

,.(0&<#":)"+9-+/~|i:8

Grazie a FUZxxl per il "+trucco (non credo di aver mai usato u"vprima, eh).

Spiegazione

                  i:8  "steps" vector: _8 _7 _6 ... _1 0 1 ... 7 8
                 |     magnitude
              +/~      outer product using +
            9-         inverts the diamond so that 9 is in the center
  (      )"+           for each digit:
      #                  copy
   0&<                   if positive then 1 else 0
       ":                copies of the string representation of the digit
                         (in other words: filter out the strictly positive
                          digits, implicitly padding with spaces)
,.                     ravel each item of the result of the above
                       (necessary because the result after `#` turns each
                        scalar digit into a vector string)

APL ( 33 31)

A⍪1↓⊖A←A,0 1↓⌽A←⌽↑⌽¨⍴∘(1↓⎕D)¨⍳9

Se sono consentiti spazi che separano i numeri (come nella voce Mathematica), è possibile accorciarli a 28 26:

A⍪1↓⊖A←A,0 1↓⌽A←⌽↑⌽∘⍕∘⍳¨⍳9

Spiegazione:

• (Programma lungo :)
• ⍳9: un elenco dei numeri da 1 a 9
• 1↓⎕D: ⎕Dè la stringa '0123456789', 1↓rimuove il primo elemento
• ⍴∘(1↓⎕D)¨⍳9: per ogni elemento N di ⍳9, prendi i primi N elementi da 1↓⎕D. Questo dà un elenco: ["1", "12", "123", ... "123456789"] come stringhe

• ⌽¨: inverte ogni elemento di questo elenco. ["1", "21", "321" ...]

• (Programma corto :)

• ⍳¨⍳9: l'elenco da 1 a N, per N [1..9]. Ciò fornisce un elenco [[1], [1,2], [1,2,3] ... [1,2,3,4,5,6,7,8,9]] come numeri.
• ⌽∘⍕∘: il contrario della rappresentazione in formato stringa di ciascuna di queste liste. ["1", "2 1" ...]
• (Lo stesso d'ora in poi :)
• A←⌽↑: crea una matrice dall'elenco degli elenchi, riempiendo a destra con spazi, quindi invertendolo. Questo dà il quadrante superiore del diamante. È memorizzato in A.
• A←A,0 1↑⌽A: A, con il rovescio di A meno la sua prima colonna attaccata a destra. Questo dà la metà superiore del rettangolo. Questo viene quindi memorizzato di nuovo in A.
• A⍪1↓⊖A: ⊖Aè A specchiato verticalmente (dando la metà inferiore), 1↓rimuove la riga superiore della metà inferiore ed A⍪è la metà superiore in cima 1↓⊖A.

Clojure, 191 179 byte

#(loop[[r & s](range 18)h 1](print(apply str(repeat(if(< r 8)(- 8 r)(- r 8))\ )))(doseq[m(concat(range 1 h)(range h 0 -1))](print m))(println)(if s(recur s((if(< r 8)inc dec)h))))

-12 byte cambiando l'esterno doseqin a loop, che mi ha permesso di sbarazzarmi di atom(yay).

Un doppio "for-loop". Il ciclo esterno ( loop) passa sopra ogni riga, mentre il ciclo interno ( doseq) supera ogni numero nella riga, che è nell'intervallo (concat (range 1 n) (range n 0 -1)), dove nè il numero più alto nella riga.

(defn diamond []
  (let [spaces #(apply str (repeat % " "))] ; Shortcut function that produces % many spaces
    (loop [[row-n & r-rows] (range 18) ; Deconstruct the row number from the range
           high-n 1] ; Keep track of the highest number that should appear in the row
      (let [top? (< row-n 8) ; Are we on the top of the diamond?
            f (if top? inc dec) ; Decided if we should increment or decrement
            n-spaces (if top? (- 8 row-n) (- row-n 8))] ; Calculate how many prefix-spaces to print
        (print (spaces n-spaces)) ; Print prefix-spaces
        (doseq [m (concat (range 1 high-n) (range high-n 0 -1))] ; Loop over the row of numbers
          (print m)) ; Print the number
        (println)

        (if r-rows
          (recur r-rows (f high-n)))))))

A causa di un bug nella logica nel mio primo tentativo (inserendo accidentalmente gli spazi prefisso tra ogni numero), sono riuscito a ottenere questo:

1
1       2       1
1      2      3      2      1
1     2     3     4     3     2     1
1    2    3    4    5    4    3    2    1
1   2   3   4   5   6   5   4   3   2   1
1  2  3  4  5  6  7  6  5  4  3  2  1
1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
12345678987654321
1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1
1  2  3  4  5  6  7  8  9  8  7  6  5  4  3  2  1
1   2   3   4   5   6   7   8   7   6   5   4   3   2   1
1    2    3    4    5    6    7    6    5    4    3    2    1
1     2     3     4     5     6     5     4     3     2     1
1      2      3      4      5      4      3      2      1
1       2       3       4       3       2       1
1        2        3        2        1
1         2         1

Nemmeno corretto ignorando l'ovvio errore, ma sembrava bello.

Mathematica 83 49 43 54 51

Print@@#&/@(Sum[k~DiamondMatrix~17,{k,0,8}]/.0->" ")

Con 3 byte salvati grazie a Kelly Lowder.

Analisi

La parte principale del codice Sum[DiamondMatrix[k, 17], {k, 0, 8}], può essere verificata su WolframAlpha .

Quanto segue mostra la logica di base dell'approccio, su scala minore.

a = 0~DiamondMatrix~5;
b = 1~DiamondMatrix~5;
c = 2~DiamondMatrix~5;
d = a + b + c;
e = d /. 0 -> "";
Grid /@ {a, b, c, d, e}

Python 2, 72 69 67 61

Non intelligente:

s=str(111111111**2)
for i in map(int,s):print'%8s'%s[:i-1]+s[-i:]

C, 79 caratteri

v;main(i){for(;i<307;putchar(i++%18?v>8?32:57-v:10))v=abs(i%18-9)+abs(i/18-8);}

Python 2, 60 59

for n in`111111111**2`:print`int('1'*int(n))**2`.center(17)

Abusa backtick e ricongiungimenti.

GolfScript, 33 31 30 caratteri

Un'altra soluzione GolfScript

17,{8-abs." "*10@-,1>.-1%1>n}%

Grazie a @PeterTaylor per un altro personaggio .

Versioni precedenti:

17,{8-abs" "*9,{)+}/9<.-1%1>+}%n*

( correre online )

17,{8-abs" "*9,{)+}/9<.-1%1>n}%

Mathematica 55 50 45 41 38

(10^{9-Abs@Range[-8,8]}-1)^2/81//Grid

Grid[(10^Array[{9}-Abs[#-9]&,17]-1)^2/81]

Javascript, 114

La mia prima voce su Codegolf!

for(l=n=1;l<18;n-=2*(++l>9)-1,console.log(s+z)){for(x=n,s="";x<9;x++)z=s+=" ";for(x=v=1;x<2*n;v-=2*(++x>n)-1)s+=v}

Se questo può essere ulteriormente abbreviato, si prega di commentare :)

PHP, 92 90 caratteri

<?for($a=-8;$a<9;$a++){for($b=-8;$b<9;){$c=abs($a)+abs($b++);echo$c>8?" ":9-$c;}echo"\n";}

Calcola e stampa la distanza di Manhattan della posizione dal centro. Stampa uno spazio se è inferiore a 1.

Un utente anonimo ha suggerito il seguente miglioramento (84 caratteri):

<?for($a=-8;$a<9;$a++,print~õ)for($b=-8;$b<9;print$c>8?~ß:9-$c)$c=abs($a)+abs($b++);

Carbone (non concorrenziale), 13 byte

Non competere perché la lingua è (molto) più recente della domanda.

Ｆ⁹«ＧX⁻⁹ιＩ⁺ι¹→

Provalo online!

Come?

Disegna nove diamanti numerici concentrici, successivamente più piccoli, uno sopra l'altro:

Ｆ⁹«   Loop ι from 0 to 8:
ＧX     Draw a (filled) polygon with four equilateral diagonal sides
⁻⁹ι      of length 9-ι
Ｉ⁺ι¹    using str(ι+1) as the character
→       Move right one space before drawing the next one

Lisp comune, 113 caratteri

(defun x(n)(if(= n 0)1(+(expt 10 n)(x(1- n)))))(dotimes(n 17)(format t"~17:@<~d~>~%"(expt(x(- 8(abs(- n 8))))2)))

Innanzitutto ho notato che gli elementi del diamante potevano essere espressi in questo modo:

  1   =   1 ^ 2
 121  =  11 ^ 2
12321 = 111 ^ 2

eccetera.

xcalcola ricorsivamente la base (1, 11, 111, ecc.), che viene quadrata e quindi stampata centrata da format. Per fare in modo che i numeri salgano al termine più alto e tornino indietro, ho usato (- 8 (abs (- n 8)))per evitare un secondo ciclo

JavaScript, 81

for(i=9;--i+9;console.log(s))for(j=9;j;s=j--^9?k>0?k+s+k:" "+s:k+"")k=i<0?j+i:j-i

PowerShell (2 opzioni): 92 84 45 byte

1..8+9..1|%{' '*(9-$_)+[int64]($x='1'*$_)*$x}
1..9+8..1|%{' '*(9-$_)+[int64]($x='1'*$_)*$x}

Grazie a Strigoides per il suggerimento di utilizzare 1 ^ 2,11 ^ 2,111 ^ 2 ...

Hai rasato alcuni personaggi di:

• Eliminando $w.
• Annidata la definizione di $xal posto del suo primo utilizzo.
• Ho preso alcuni indizi dalla soluzione di Rynant :
  • Combina le matrici intere con le quali +invece ,consente l'eliminazione della parentesi attorno alle matrici e uno strato di annidamento nei loop.
  • Utilizzato 9-$_per calcolare la lunghezza degli spazi necessari, anziché metodi matematici e oggetti più complicati. Ciò ha anche eliminato la necessità di $y.

Spiegazione:

1..8+9..1o 1..9+8..1genera un array di numeri interi che salgono da 1 a 9, quindi scendono di nuovo a 1.

|%{... }convoglia l'array di numeri interi in un ForEach-Objectloop tramite l'alias incorporato %.

' '*(9-$_)+ sottrae il numero intero corrente da 9, quindi crea una stringa di tanti spazi all'inizio dell'output per questa linea.

[int64]($x='1'*$_)*$xdefinisce $xcome una stringa di 1s purché il numero intero corrente sia grande. Quindi viene convertito in int64 (necessario per generare correttamente 111111111 ² senza usare la notazione E) e quadrato.

Vim, 62 39 38 sequenze di tasti

Grazie a @DJMcMayhem per aver salvato un sacco di byte!

La mia prima risposta Vim, così eccitante!

i12345678987654321<ESC>qqYP9|xxI <ESC>YGpHq7@q

Ho provato a scrivere i numeri tramite una registrazione, ma è molto più lungo

Provalo online!

Spiegazione:

i123 ... 321<ESC>                   Write this in insert mode and enter normal mode
qq                                  Start recording into register q
  YP                                Yank this entire line and Paste above
    9|                              Go to the 9th column
      xx                            Delete character under cursor twice
        I <ESC>                     Go to the beginning of the line and insert a space and enter normal mode
               Y                    Yank this entire line
                G                   Go to the last line
                 p                  Paste in the line below
                  H                 Go to the first line
                   q                End recording
                    7@q             Repeat this 7 times

MODIFICARE:

Ho usato Hinvece gge salvato 1 byte

APL (Dyalog Classic) , 20 19 byte

(⍉⊢⍪1↓⊖)⍣2⌽↑,⍨\1↓⎕d

Provalo online!

⎕d sono le cifre '0123456789'

1↓rilascia il primo ( '0')

,⍨\ scansione catenata scambiata, ovvero i prefissi invertiti '1' '21' '321' ... '987654321'

↑ mescolare in una matrice imbottita con spazi:

1
21
321
...
987654321

⌽ invertire la matrice in senso orizzontale

(... )⍣2fallo due volte:

⍉⊢⍪1↓⊖la trasposizione ( ⍉) della matrice stessa ( ⊢) concatenata verticalmente ( ⍪) con la matrice invertita verticalmente ( ⊖) senza la sua prima riga ( 1↓)

R, 71 caratteri

Per i record:

s=c(1:9,8:1);for(i in s)cat(rep(" ",9-i),s[0:i],s[(i-1):0],"\n",sep="")

k ( 64 50 caratteri)

-1'(::;1_|:)@\:((|!9)#'" "),'$i*i:"J"$(1+!9)#'"1";

Vecchio metodo:

-1',/(::;1_|:)@\:((|!9)#\:" "),',/'+(::;1_'|:')@\:i#\:,/$i:1+!9;

CJam, 31 27 byte

CJam è molto più recente di questa sfida, quindi questa risposta non può essere accettata. Questa è stata una bella sfida sabato sera, comunque. ;)

8S*9,:)+9*9/2%{_W%1>+z}2*N*

Provalo qui.

L'idea è di formare prima il quadrante in alto a sinistra. Ecco come funziona:

Innanzitutto, forma la stringa " 123456789", usando 8S*9,:)+. Questa stringa è lunga 17 caratteri. Ora ripetiamo la stringa 9 volte e poi la dividiamo in sottostringhe di lunghezza 9 con 9/. La mancata corrispondenza tra 9 e 17 compenserà ogni altra riga di un carattere a sinistra. Stampando ogni sottostringa sulla sua stessa linea otteniamo:

        1
23456789 
       12
3456789  
      123
456789   
     1234
56789    
    12345
6789     
   123456
789      
  1234567
89       
 12345678
9        
123456789

Quindi se lasciamo cadere ogni altra riga (che funziona convenientemente facendo 2%), otteniamo un quadrante come desiderato:

        1
       12
      123
     1234
    12345
   123456
  1234567
 12345678
123456789

Infine, eseguiamo il mirroring due volte, trasponendo la griglia in mezzo per garantire che le due operazioni di mirroring passino lungo assi diversi. Il mirroring stesso è giusto

_      "Duplicate all rows.";
 W%    "Reverse their order.";
   1>  "Discard the first row (the centre row).";
     + "Add the other rows.";

Infine, uniamo tutte le linee con le nuove linee, con N*.

GolfScript, 36 caratteri

Supponendo che questo sia inteso come una sfida al golf del codice , ecco una soluzione GolfScript di base:

9,.);\-1%+:a{a{1$+7-.0>\" "if}%\;n}%

Rubino, 76 caratteri

def f(a)a+a.reverse[1..-1]end;puts f [*1..9].map{|i|f([*1..i]*'').center 17}

Miglioramenti benvenuti. :)

Befunge-93 , 155 caratteri

9:v:<,+55<v5*88<v-\9:$_68v
> v>     ^>3p2vpv  -1<!  *
, 1^  2p45*3+9<4:    ,:  +
g -^_75g94+4pg7^!    +^ ,<
1 : ^ `0    :-1$_:68*^$
^1_$:55+\-0\>:#$1-#$:_^

Provalo online!

Potrebbe sicuramente essere più giocato a golf, ma è il mio primo programma Funge e la mia testa fa già male. Mi sono divertito molto, comunque

JavaScript, 170 byte

Il mio primo codice golf :)

golfed

a="";function b(c){a+=" ".repeat(10-c);for(i=1;i<c;i++)a+=i;for(i=2;i<c;i++)a+=c-i;a+="\n";}for(i=2;i<11;i++)b(i);for(i=9;i>1;i--)b(i);document.write("<pre>"+a+"</pre>");

Ungolfed

var str = "";
function row(line) {
    str += " ".repeat(10 - line);
    for (var i = 1; i < line; i++) {
        str += i;
    }
    for (var i = 2; i < line; i++) {
        str += line - i;
    }
    str += "\n";
}
for (var line = 2; line < 11; line++) {
    row(line);
}
for (var line = 9; line > 1; line--) {
    row(line);
}
document.write("<pre>" + str + "</pre>");

Perl 56 54 caratteri

Aggiunto 1 carattere per lo -pswitch.

Utilizza le reimpostazioni quadrate per generare la sequenza.

s//12345678987654321/;s|(.)|$/.$"x(9-$1).(1x$1)**2|eg

Perl, 43 + 1

aggiungendo +1 per -Ecui è richiestosay

say$"x(9-$_).(1x$_)**2for 1..9,reverse 1..8

modifica: abbreviato un po '

Python, 65 anni

for i in map(int,str(int('1'*9)**2)):print' '*(9-i),int('1'*i)**2

Groovy 77 75

i=(-8..9);i.each{a->i.each{c=a.abs()+it.abs();print c>8?' ':9-c};println""}

vecchia versione:

(-8..9).each{a->(-8..9).each{c=a.abs()+it.abs();print c>8?' ':9-c};println""}

Scala - 86 caratteri

val a="543210/.-./012345";for(i<-a){for(j<-a;k=99-i-j)print(if(k<1)" "else k);println}

Javascript, 137

Con ricorsione:

function p(l,n,s){for(i=l;i;s+=" ",i--);for(i=1;i<=n;s+=i++);for(i-=2;i>0;s+=i--);return(s+="\n")+(l?p(l-1,n+1,"")+s:"")}alert(p(8,1,""))

Prima volta su CG :)

O 118

Se riesco a trovare un'implementazione JS che viene eseguita 111111111**2con maggiore precisione.
(Qui: 12345678987654320).

a="1",o="\n";for(i=0;i<9;i++,o+="         ".substr(i)+a*a+"\n",a+="1");for(i=8;i;i--)o+=o.split("\n")[i]+"\n";alert(o)