这个问题像病毒一样在我的办公室中传播。有很多方法：

打印以下内容：

        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)

杀伤人员地雷（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←A,0 1↑⌽A：A，A的倒数减去右边的第一列。这给出了矩形的上半部分。然后将其再次存储在A中。
• A⍪1↓⊖A：⊖A是A垂直镜像（给出下半部分），1↓删除下半部分的第一行，并且A⍪是的顶部的上半部分1↓⊖A。

Clojure，191179字节

#(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的loop，这让我摆脱了atom（耶）。

双“ for-loop”。外循环（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

甚至没有忽略明显的错误，但看起来很酷。

Mathematica 83 49 43 54 51

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

借助Kelly Lowder，节省了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);}

Python 2中，60 59

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

滥用反引号和repunits。

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

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

我在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++);

普通Lisp，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代替了第一次使用。
• 从Rynant的解决方案中获得了一些线索：
  • 合并的整数阵列，+而不是,其允许消除阵列周围的括号和在环的嵌套的层。
  • 用于9-$_计算所需空间的长度，而不是更复杂的数学和对象方法。这也消除了对的需要$y。

说明：

1..8+9..1或1..9+8..1生成从1到9升序再降到1的整数数组。

|%{... 通过内置别名}将整数数组传递到ForEach-Object循环中%。

' '*(9-$_)+ 从9中减去当前整数，然后在此行的输出开头创建一个包含多个空格的字符串。

[int64]($x='1'*$_)*$x只要当前整数较大，就定义$x为1s 的字符串。然后将其转换为int64（要求在不使用E表示法的情况下正确输出111111111 ²）并平方。

Vim，62 39 38次击键

感谢@DJMcMayhem节省了大量的字节！

我的第一个Vim回答，真令人兴奋！

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

Ruby，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个字符

为-p开关添加了1个字符。

使用平方单位表示序列。

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

Perl，43 + 1

加+1 -E所需say

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

编辑：缩短了一点

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

旧版本：

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

如果我能找到执行111111111**2精度更高的JS实现。
（此处：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)