Це питання поширюється як вірус у моєму кабінеті. Існує досить багато підходів:

Роздрукуйте наступне:

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

Відповіді набираються символами, на яких менше символів.

J, 29 26 24 23 22 21 символів

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

Завдяки FUZxxl за "+трюк (я не думаю, що я ніколи раніше не використовував u"v, так).

Пояснення

                  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

Якщо дозволено пробіли, що розділяють числа (як у записі Mathematica), його можна скоротити до 28 26:

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

Пояснення:

• (Тривала програма :)
• ⍳9: список цифр від 1 до 9
• 1↓⎕D: ⎕Dє рядок '0123456789', 1↓видаляє перший елемент
• ⍴∘(1↓⎕D)¨⍳9: для кожного елемента N ⍳9, візьміть перші N елементів з 1↓⎕D. Це дає список: ["1", "12", "123", ... "123456789"] як рядки

• ⌽¨: повернути назад кожен елемент цього списку. ["1", "21", "321" ...]

• (Коротка програма :)

• ⍳¨⍳9: список від 1 до N, для N [1..9]. Це дає список [[1], [1,2], [1,2,3] ... [1,2,3,4,5,6,7,8,9]] як числа.
• ⌽∘⍕∘: зворотний рядковий рядок кожного з цих списків. ["1", "2 1" ...]
• (Те саме відтепер :)
• A←⌽↑: робить матрицю зі списку списків, прошиваючи праворуч із пробілами, а потім переверніть її. Це дає верхній квадрант алмазу. Він зберігається в А.
• A←A,0 1↑⌽A: A, із зворотним боком A мінус його перший стовпець праворуч. Це дає верхню половину прямокутника. Потім він знову зберігається в A.
• A⍪1↓⊖A: ⊖Aє Дзеркальним відображенням вертикально (надає нижню половину), 1↓видаляє верхній ряд нижньої половини і A⍪є верхньою половиною зверху 1↓⊖A.

Clojure, 191 179 байт

#(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 байт, змінивши зовнішній doseqна a loop, що дозволило мені позбутися atom(yay).

Подвійний "для-петлі". Зовнішня петля ( loop) переходить над кожним рядом, тоді як внутрішня петля ( doseq) переходить через кожне число у рядку, яке знаходиться в діапазоні (concat (range 1 n) (range n 0 -1)), де nнайбільше число у рядку.

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

Через помилку в логіці в першій моїй спробі (випадково вставивши префікс-пробіли між кожним номером замість цього), мені вдалося отримати таке:

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

Навіть не правильно ігноруючи очевидну помилку, але це виглядало круто.

Математика 83 49 43 54 51

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

З 3 байтами збережено завдяки Келлі Лоудер.

Аналіз

Основну частину коду Sum[DiamondMatrix[k, 17], {k, 0, 8}]можна перевірити на WolframAlpha .

Далі показано основні логіки підходу в меншому масштабі.

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}

Пітон 2, 72 69 67 61

НЕ розумний:

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

C, 79 символів

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

Пітон 2, 60 59

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

Зловживає заднім числом і повторним підключенням.

GolfScript, 33 31 30 символів

Ще одне рішення GolfScript

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

Дякуємо @PeterTaylor за ще одну прихильність .

Версії Previos:

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

( запустити онлайн )

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

Математика 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

Мій перший запис на 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}

Якщо це можна скоротити далі, будь ласка, прокоментуйте :)

PHP, 92 90 символів

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

Обчислює та друкує відстань Манхеттена від позиції від центру. Друкує пробіл, якщо він менше 1.

Анонімний користувач запропонував таке вдосконалення (84 символи):

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

Лист звичайний, 113 символів

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

Спочатку я помітив, що елементи алмазу можна виразити так:

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

тощо.

xрекурсивно обчислює основу (1, 11, 111 тощо), яка розміщується в квадраті, а потім друкується по центру format. Щоб змусити цифри піднятися до найвищого терміну та знову знизитись, я намагався (- 8 (abs (- n 8)))уникати другого циклу

Вугілля (без конкуренції), 13 байт

Не змагається, оскільки мова (набагато) новіша, ніж питання.

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

Спробуйте в Інтернеті!

Як?

Намалює дев'ять послідовно менших концентричних цифр-діамантів один на одного:

Ｆ⁹«   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 варіанти): 92 84 45 байт

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

Завдяки Strigoides за підказку використовувати 1 ^ 2,11 ^ 2,111 ^ 2 ...

Поголив кілька персонажів:

• Усунення $w.
• Вкладено визначення $xзамість його першого використання.
• Взяв кілька підказок з рішення Рінанта :
  • Комбіновані цілі масиви, +замість ,яких дозволяє усунути круглі дужки навколо масивів і шар вкладення в петлі.
  • Використовується 9-$_для обчислення необхідної довжини просторів, замість складніших математичних та об’єктних методів. Це також усувало потребу в $y.

Пояснення:

1..8+9..1або 1..9+8..1генерує масив цілих чисел, що збільшуються від 1 до 9, потім опускаються назад до 1.

|%{... }передає цілий масив у ForEach-Objectцикл через вбудований псевдонім %.

' '*(9-$_)+ віднімає поточне ціле число з 9, а потім створює рядок з багатьох пробілів на початку виводу для цього рядка.

[int64]($x='1'*$_)*$xвизначає $xяк рядок 1s до тих пір, поки поточне ціле число є великим. Потім він перетворюється на int64 (необхідний для правильного виведення 111111111 ^2, не використовуючи позначення E) і розміщується у квадраті.

Вім, 62 39 38 натискань клавіш

Дякуємо @DJMcMayhem за економію тонни байтів!

Моя перша відповідь Віма, така захоплююча!

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

Я намагався записати цифри через запис, але це набагато довше

Спробуйте в Інтернеті!

Пояснення:

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

Редагувати:

Я використав Hзамість ggі зберег 1 байт

APL (Dyalog Classic) , 20 19 байт

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

Спробуйте в Інтернеті!

⎕d - це цифри '0123456789'

1↓упустити перший ( '0')

,⍨\ замінене сканування катенатів, тобто зворотні префікси '1' '21' '321' ... '987654321'

↑ змішайте в матрицю з пробілами:

1
21
321
...
987654321

⌽ повернути матрицю горизонтально

(... )⍣2зробіть це двічі:

⍉⊢⍪1↓⊖переміщення ( ⍉) самої матриці ( ⊢), з'єднане вертикально ( ⍪) з вертикально перевернутою матрицею ( ⊖), без першого рядка ( 1↓)

R, 71 символ

Для записів:

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 символів)

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

Старий метод:

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

CJam, 31 27 байт

CJam набагато новіший, ніж цей виклик, тому ця відповідь не може бути прийнятою. Це був охайний маленький суботній вечірній виклик. ;)

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

Тестуйте це тут.

Ідея полягає в тому, щоб сформувати спочатку верхній лівий квадрант. Ось як це працює:

Спочатку сформуйте рядок " 123456789", використовуючи 8S*9,:)+. Цей рядок має 17 символів. Тепер ми повторюємо рядок 9 разів, а потім розділяємо його на підрядки довжиною 9 с 9/. Невідповідність між 9 і 17 змістить кожен другий рядок по одному символу зліва. Друкуючи кожну підрядку в окремому рядку, ми отримуємо:

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

Тож якщо ми просто скинемо кожен інший рядок (який зручно працює 2%), отримаємо один квадрант за бажанням:

        1
       12
      123
     1234
    12345
   123456
  1234567
 12345678
123456789

Нарешті, ми відображаємо це дзеркально двічі, перекладаючи сітку між ними, щоб переконатися, що дві дзеркальні операції йдуть по різних осях. Саме дзеркальне відображення справедливе

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

Нарешті, ми просто з'єднуємо всі рядки з новими рядками, з N*.

GolfScript, 36 символів

Якщо припустити, що це мається на увазі як проблема з кодовим гольфом , ось базове рішення GolfScript:

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

Рубі, 76 символів

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

Поліпшення вітаються. :)

Befunge-93 , 155 символів

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

Спробуйте в Інтернеті!

Це, безумовно, можна було б пограти в гольф більше, але це моя перша програма Funge, і моя голова вже болить. Хоча було дуже весело

JavaScript, 170 байт

Мій перший гольф-код :)

Гольф

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

Безумовно

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 символи

Додано 1 знак для -pперемикача.

Для створення послідовності використовує квадратні повторні з'єднання.

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

Перл, 43 + 1

додавання +1, для -Eякого потрібноsay

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

редагувати: трохи скоротити

Пітона, 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""}

стара версія:

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

Scala - 86 символів

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

Javascript, 137

З рекурсією:

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

Перший раз на CG :)

Або 118

Якщо я можу знайти реалізацію JS, яка виконується 111111111**2з більшою точністю.
(Тут: 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)