To pytanie rozprzestrzenia się jak wirus w moim biurze. Istnieje wiele różnych podejść:

Wydrukuj następujące:

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

Odpowiedzi są punktowane w postaciach, przy czym mniej znaków jest lepszych.

J, 29 26 24 23 22 21 znaków

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

Dzięki FUZxxl za "+podstęp (nie sądzę, żebym kiedykolwiek używał u"v, heh).

Wyjaśnienie

                  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

Jeśli dozwolone są spacje oddzielające liczby (jak we wpisie Mathematica), można je skrócić do 28 26:

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

Wyjaśnienie:

• (Długi program :)
• ⍳9: lista cyfr od 1 do 9
• 1↓⎕D: ⎕Dto ciąg „0123456789”, 1↓usuwa pierwszy element
• ⍴∘(1↓⎕D)¨⍳9: dla każdego elementu N z ⍳9, weź pierwsze N ​​elementów z 1↓⎕D. Daje to listę: [„1”, „12”, „123”, ... „123456789”] jako ciągi znaków

• ⌽¨: odwróć każdy element tej listy. [„1”, „21”, „321” ...]

• (Krótki program :)

• ⍳¨⍳9: lista 1 do N dla N [1..9]. Daje to listę [[1], [1,2], [1,2,3] ... [1,2,3,4,5,6,7,8,9]] jako liczby.
• ⌽∘⍕∘: odwrotność reprezentacji ciągu każdej z tych list. [„1”, „2 1” ...]
• (To samo od teraz :)
• A←⌽↑: tworzy macierz z listy list, dopełnia spacjami po prawej stronie, a następnie odwraca to. To daje górną ćwiartkę diamentu. Jest przechowywany w A.
• A←A,0 1↑⌽A: A, z odwrotnością A minus jego pierwsza kolumna przymocowana po prawej stronie. To daje górną połowę prostokąta. To jest następnie ponownie przechowywane w A.
• A⍪1↓⊖A: ⊖Ajest lustrzanym odbiciem w pionie (daje dolną połowę), 1↓usuwa górny rząd dolnej połowy i A⍪jest górną połową na górze 1↓⊖A.

Clojure, 191 179 bajtów

#(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 bajtów, zmieniając zewnętrzny doseqna a loop, co pozwoliło mi się pozbyć atom(yay).

Podwójna pętla „for-loop”. Zewnętrzna pętla ( loop) przechodzi nad każdym rzędem, podczas gdy wewnętrzna pętla ( doseq) przechodzi nad każdą liczbą w rzędzie, która jest w zakresie (concat (range 1 n) (range n 0 -1)), gdzie njest najwyższa liczba w rzędzie.

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

Z powodu błędu w logice przy pierwszej próbie (zamiast tego przypadkowo wstawiłem spację przed każdym numerem) udało mi się uzyskać:

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

Nawet nie zignoruj ​​oczywistego błędu, ale wyglądało fajnie.

Mathematica 83 49 43 54 51

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

Z 3 bajtami zaoszczędzonymi dzięki Kelly Lowder.

Analiza

Zasadniczą część kodu Sum[DiamondMatrix[k, 17], {k, 0, 8}]można sprawdzić na WolframAlpha .

Poniżej pokazano podstawową logikę podejścia na mniejszą skalę.

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

Nie sprytne:

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

C, 79 znaków

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)

Nadużywa zwrotów i repunits.

GolfScript, 33 31 30 znaków

Kolejne rozwiązanie GolfScript

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

Dziękuję @PeterTaylor za kolejny znak.

Poprzednie wersje:

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

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

Mój pierwszy wpis w 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}

Jeśli można to jeszcze bardziej skrócić, prosimy o komentarz :)

PHP, 92 90 znaków

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

Oblicza i drukuje odległość Manhattanu od centrum. Drukuje spację, jeśli jest mniejsza niż 1.

Anonimowy użytkownik zaproponował następujące ulepszenie (84 znaków):

<?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 znaków

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

Najpierw zauważyłem, że elementy diamentu można wyrazić w następujący sposób:

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

itp.

xrekurencyjnie oblicza podstawę (1, 11, 111 itd.), która jest kwadratowa, a następnie drukowana na środku format. Aby liczby wzrosły do ​​najwyższego terminu i ponownie spadły, (- 8 (abs (- n 8)))unikałem drugiej pętli

Węgiel (niekonkurujący), 13 bajtów

Nie konkuruje, ponieważ język jest (znacznie) nowszy niż pytanie.

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

Wypróbuj online!

W jaki sposób?

Rysuje na sobie dziewięć, kolejno mniejszych, koncentrycznych liczb-diamentów:

Ｆ⁹«   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 opcje): 92 84 45 bajtów

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

Dzięki Strigoides za podpowiedź do użycia 1 ^ 2,11 ^ 2,111 ^ 2 ...

Ogoliłem niektóre postacie przez:

• Wyeliminowanie $w.
• Zagnieżdżono definicję $xzamiast pierwszego użycia.
• Wziąłem kilka wskazówek z rozwiązania Rynant :
  • Połączone tablice liczb całkowitych, z którymi +zamiast tego ,pozwala wyeliminować nawiasy wokół tablic i warstwę zagnieżdżenia w pętlach.
  • Służy 9-$_do obliczania długości potrzebnych spacji, zamiast bardziej skomplikowanych obliczeń matematycznych i metod obiektowych. To również wyeliminowało potrzebę $y.

Wyjaśnienie:

1..8+9..1lub 1..9+8..1generuje tablicę liczb całkowitych rosnących od 1 do 9, a następnie malejących z powrotem do 1.

|%{... }potokuje tablicę liczb całkowitych w ForEach-Objectpętli za pomocą wbudowanego aliasu %.

' '*(9-$_)+ odejmuje bieżącą liczbę całkowitą od 9, a następnie tworzy ciąg tych tylu spacji na początku wyniku dla tego wiersza.

[int64]($x='1'*$_)*$xdefiniuje $xjako ciąg 1s, o ile bieżąca liczba całkowita jest duża. Następnie jest konwertowany na int64 (wymagany do poprawnego wyprowadzenia 111111111 ² bez użycia notacji E) i podniesiony do kwadratu.

Vim, 62 39 38 klawiszy

Dzięki @DJMcMayhem za oszczędność tony bajtów!

Moja pierwsza odpowiedź Vima, taka ekscytująca!

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

Próbowałem zapisać liczby za pomocą nagrania, ale jest to znacznie dłużej

Wypróbuj online!

Wyjaśnienie:

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

EDYTOWAĆ:

Użyłem Hzamiast ggi zapisałem 1 bajt

APL (Dyalog Classic) , 20 19 bajtów

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

Wypróbuj online!

⎕d są cyframi '0123456789'

1↓upuść pierwszy ( '0')

,⍨\ swap catenate scan, tj. odwrócone prefiksy '1' '21' '321' ... '987654321'

↑ wymieszać w matrycę wypełnioną spacjami:

1
21
321
...
987654321

⌽ odwróć matrycę w poziomie

(... )⍣2zrób to dwa razy:

⍉⊢⍪1↓⊖transpozycja ( ⍉) samej macierzy ( ⊢) połączonej pionowo ( ⍪) z pionowo odwróconą macierzą ( ⊖) bez jej pierwszego rzędu ( 1↓)

R, 71 znaków

Do dokumentacji:

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 znaków)

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

Stara metoda:

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

CJam, 31 27 bajtów

CJam jest znacznie nowszy od tego wyzwania, więc ta odpowiedź nie kwalifikuje się do zaakceptowania. Było to jednak miłe, małe wyzwanie w sobotni wieczór. ;)

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

Sprawdź to tutaj.

Chodzi o to, aby najpierw utworzyć lewy górny kwadrant. Oto jak to działa:

Najpierw utwórz ciąg " 123456789", używając 8S*9,:)+. Ten ciąg ma 17 znaków. Teraz powtarzamy ciąg 9 razy, a następnie dzielimy na podciągi o długości 9 za pomocą 9/. Niedopasowanie między 9 a 17 zrównoważy co drugi wiersz jeden znak w lewo. Drukując każdy podciąg na własnej linii otrzymujemy:

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

Jeśli więc po prostu upuszczamy co drugi rząd (co wygodnie działa, robiąc 2%), otrzymujemy jeden kwadrant zgodnie z potrzebami:

        1
       12
      123
     1234
    12345
   123456
  1234567
 12345678
123456789

Na koniec odbijamy to dwukrotnie, przenosząc siatkę pomiędzy, aby zapewnić, że dwie operacje odbicia będą przebiegać wzdłuż różnych osi. Samo odbicie lustrzane jest sprawiedliwe

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

Wreszcie, po prostu łączymy wszystkie linie z nowymi liniami, z N*.

GolfScript, 36 znaków

Zakładając, że jest to wyzwanie polegające na kodzie golfowym , oto podstawowe rozwiązanie GolfScript:

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

Ruby, 76 znaków

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

Ulepszenia mile widziane. :)

Befunge-93 , 155 znaków

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

Wypróbuj online!

Zdecydowanie można by go bardziej zagrać w golfa, ale to mój pierwszy program Funge i głowa już mnie boli. Ale dobrze się bawiłem

JavaScript, 170 bajtów

Mój pierwszy golf golfowy :)

Grał w golfa

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

Nie golfił

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 znaków

Dodano 1 znak dla -pprzełącznika.

Używa kwadratowych powtórzeń do wygenerowania sekwencji.

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

Perl, 43 + 1

dodanie +1, dla -Ektórego jest wymaganesay

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

edycja: nieco skrócona

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

stara wersja:

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

Scala - 86 znaków

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

JavaScript, 137

Z rekurencją:

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

Pierwszy raz na CG :)

Lub 118

Jeśli mogę znaleźć implementację JS, która działa 111111111**2z większą precyzją.
(Tutaj: 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)