Diese Frage hat sich wie ein Virus in meinem Büro verbreitet. Es gibt verschiedene Ansätze:

Drucken Sie Folgendes aus:

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

Antworten werden in Zeichen gewertet, wobei weniger Zeichen besser sind.

J, 29 26 24 23 22 21 Zeichen

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

Danke an FUZxxl für den "+Trick (ich glaube nicht, dass ich ihn jemals benutzt habe u"v, heh).

Erläuterung

                  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

Wenn Leerzeichen zwischen den Zahlen zulässig sind (wie im Mathematica-Eintrag), kann dies auf 28 26 verkürzt werden :

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

Erläuterung:

• (Langes Programm :)
• ⍳9: eine Liste der Nummern 1 bis 9
• 1↓⎕D: ⎕DIst die Zeichenfolge '0123456789', 1↓wird das erste Element entfernt
• ⍴∘(1↓⎕D)¨⍳9: ⍳9Nimm für jedes Element N von die ersten N Elemente von 1↓⎕D. Dies gibt eine Liste: ["1", "12", "123", ... "123456789"] als Zeichenfolgen

• ⌽¨: kehrt jedes Element dieser Liste um. ["1", "21", "321" ...]

• (Kurzprogramm :)

• ⍳¨⍳9: die Liste von 1 bis N, für N [1..9]. Dies ergibt eine Liste [[1], [1,2], [1,2,3] ... [1,2,3,4,5,6,7,8,9]] als Zahlen.
• ⌽∘⍕∘: die Umkehrung der Zeichenfolgendarstellung jeder dieser Listen. ["1", "2 1" ...]
• (Das selbe von jetzt an :)
• A←⌽↑: Erstellt eine Matrix aus der Liste der Listen, füllt sie rechts mit Leerzeichen auf und kehrt diese um. Dies ergibt den oberen Quadranten des Diamanten. Es ist in A gespeichert.
• A←A,0 1↑⌽A: A, wobei die Rückseite von A minus der ersten Spalte rechts angehängt ist. Dies ergibt die obere Hälfte des Rechtecks. Dies wird dann wieder in A gespeichert.
• A⍪1↓⊖A: ⊖Aist A vertikal gespiegelt (wobei die untere Hälfte angegeben wird), 1↓entfernt die obere Reihe der unteren Hälfte und A⍪liegt die obere Hälfte darüber 1↓⊖A.

Clojure, 191 179 Bytes

#(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 Bytes durch Ändern des äußeren doseqin ein loop, wodurch ich das atom(yay) loswerden konnte .

Eine doppelte "for-Schleife". Die äußere Schleife ( loop) geht über jede Zeile, während die innere Schleife ( doseq) über jede Nummer in der Zeile geht, die sich in dem Bereich befindet (concat (range 1 n) (range n 0 -1)), in dem nsich die höchste Nummer in der Zeile befindet.

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

Aufgrund eines Fehlers in der Logik bei meinem ersten Versuch (das versehentliche Einfügen der Präfix-Leerzeichen zwischen den einzelnen Nummern) gelang mir Folgendes:

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

Nicht einmal richtig ignoriert den offensichtlichen Fehler, aber es sah cool aus.

Mathematica 83 49 43 54 51

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

Mit 3 Bytes dank Kelly Lowder gespart.

Analyse

Der Hauptteil des Codes Sum[DiamondMatrix[k, 17], {k, 0, 8}]kann auf WolframAlpha überprüft werden .

Das Folgende zeigt die zugrunde liegende Logik des Ansatzes in kleinerem Maßstab.

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

Nicht schlau:

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

C 79 Zeichen

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)

Missbrauch von Backticks und Repunits.

GolfScript, 33 31 30 Zeichen

Eine weitere GolfScript-Lösung

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

Vielen Dank an @PeterTaylor für einen weiteren Char.

Vorherige Versionen:

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

( online laufen )

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

Mein erster Eintrag bei 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}

Wenn dies noch weiter gekürzt werden kann, bitte kommentieren :)

PHP, 92 90 Zeichen

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

Berechnet und druckt die Manhattan-Entfernung der Position vom Zentrum. Gibt ein Leerzeichen aus, wenn es kleiner als 1 ist.

Ein anonymer Benutzer schlug die folgende Verbesserung vor (84 Zeichen):

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

Common Lisp, 113 Zeichen

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

Zuerst bemerkte ich, dass die Elemente des Diamanten so ausgedrückt werden konnten:

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

usw.

xBerechnet rekursiv die Basis (1, 11, 111 usw.), die im Quadrat angegeben und dann zentriert durch gedruckt wird format. Damit die Zahlen zum höchsten Term auf- und wieder absteigen, habe ich (- 8 (abs (- n 8)))eine zweite Schleife vermieden

Holzkohle (nicht konkurrierend), 13 Bytes

Nicht konkurrieren, weil die Sprache (viel) neuer ist als die Frage.

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

Probieren Sie es online!

Wie?

Zeichnet neun aufeinanderfolgend kleinere konzentrische Diamanten übereinander:

Ｆ⁹«   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

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 Optionen): 92 84 45 Byte

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

Danke an Strigoides für den Hinweis, 1 ^ 2,11 ^ 2,111 ^ 2 zu verwenden ...

Einige Charaktere rasiert von:

• Eliminieren $w.
• Verschachtelt die Definition von $xanstelle seiner ersten Verwendung.
• Nahm einige Hinweise aus Rynants Lösung :
  • Kombiniert man die Integer-Arrays mit, können +stattdessen ,die Klammern um die Arrays und eine Ebene zum Verschachteln in den Schleifen entfernt werden.
  • Wird verwendet 9-$_, um die Länge der benötigten Leerzeichen zu berechnen, anstatt kompliziertere Mathematik- und Objektmethoden. Damit entfällt auch die Notwendigkeit $y.

Erläuterung:

1..8+9..1oder 1..9+8..1generiert ein Array von ganzen Zahlen, die von 1 bis 9 aufsteigen und dann wieder auf 1 absteigen.

|%{... }leitet das Integer-Array ForEach-Objectüber den eingebauten Alias in eine Schleife %.

' '*(9-$_)+ subtrahiert die aktuelle Ganzzahl von 9 und erstellt am Anfang der Ausgabe für diese Zeile eine Zeichenfolge mit so vielen Leerzeichen.

[int64]($x='1'*$_)*$xDefiniert $xals Zeichenfolge von 1s, solange die aktuelle Ganzzahl groß ist. Dann wird es in int64 konvertiert (zur korrekten Ausgabe von 111111111 ² ohne Verwendung der E-Notation erforderlich ) und quadriert.

Vim, 62 39 38 Tastenanschläge

Vielen Dank an @DJMcMayhem für das Speichern einer Menge Bytes!

Meine erste Vim-Antwort, so aufregend!

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

Ich habe versucht, die Zahlen über eine Aufnahme zu schreiben, aber es ist viel länger

Probieren Sie es online!

Erläuterung:

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

BEARBEITEN:

Ich habe Hstattdessen gg1 Byte gespeichert

APL (Dyalog Classic) , 20 bis 19 Byte

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

Probieren Sie es online!

⎕d sind die Ziffern '0123456789'

1↓lass das erste fallen ( '0')

,⍨\ Catenate Scan vertauscht, dh die umgekehrten Präfixe '1' '21' '321' ... '987654321'

↑ mischen in eine Matrix mit Leerzeichen:

1
21
321
...
987654321

⌽ kehren Sie die Matrix horizontal um

(... )⍣2mach das zweimal:

⍉⊢⍪1↓⊖die Transposition ( ⍉) der Matrix selbst ( ⊢), die vertikal ( ⍪) mit der vertikal invertierten Matrix ( ⊖) ohne ihre erste Zeile ( 1↓) verkettet ist

R, 71 Zeichen

Für die Aufzeichnungen:

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

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

Alte Methode:

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

CJam, 31 27 Bytes

CJam ist viel neuer als diese Herausforderung, daher kann diese Antwort nicht akzeptiert werden. Dies war jedoch eine nette kleine Herausforderung am Samstagabend. ;)

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

Teste es hier.

Die Idee ist, zuerst den oberen linken Quadranten zu bilden. So funktioniert das:

Bilden Sie zunächst die Zeichenfolge " 123456789"mit 8S*9,:)+. Diese Zeichenfolge ist 17 Zeichen lang. Nun wiederholen wir den String 9 mal und teilen ihn dann mit in Teilstrings der Länge 9 auf 9/. Die Nichtübereinstimmung zwischen 9 und 17 versetzt jede zweite Zeile um ein Zeichen nach links. Wenn wir jeden Teilstring in einer eigenen Zeile drucken, erhalten wir:

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

Wenn wir also einfach jede zweite Zeile fallen lassen (was bequemerweise so funktioniert 2%), erhalten wir einen Quadranten wie gewünscht:

        1
       12
      123
     1234
    12345
   123456
  1234567
 12345678
123456789

Zum Schluss spiegeln wir dies zweimal und transponieren das Raster dazwischen, um sicherzustellen, dass die beiden Spiegelvorgänge entlang unterschiedlicher Achsen verlaufen. Die Spiegelung selbst ist gerecht

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

Zuletzt verbinden wir alle Zeilen mit Zeilenumbrüchen, mit N*.

GolfScript, 36 Zeichen

Angenommen, dies ist eine Code-Golf- Herausforderung. Hier ist eine grundlegende GolfScript-Lösung:

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

Ruby, 76 Zeichen

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

Verbesserungen sind willkommen. :)

Befunge-93 , 155 Zeichen

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-#$:_^

Probieren Sie es online!

Es könnte definitiv mehr Golf gespielt werden, aber es ist mein erstes Funge-Programm und mein Kopf tut schon weh. Hatte aber viel Spaß

JavaScript, 170 Byte

Mein erster Code Golf :)

Golf gespielt

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 Zeichen

1 Zeichen für den -pSchalter hinzugefügt .

Verwendet quadratische Repunits, um die Sequenz zu generieren.

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

Perl, 43 + 1

Addieren von +1, -Ewofür erforderlich istsay

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

edit: etwas gekürzt

Python, 65

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

alte Version:

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

Scala - 86 Zeichen

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

Javascript, 137

Mit Rekursion:

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,""))

Zum ersten Mal auf CG :)

Oder 118

Wenn ich eine JS-Implementierung finde, die 111111111**2mit höherer Präzision ausgeführt wird.
(Hier: 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)