[Question]
  [
Inspired by the bugged output in [*@Carcigenicate*'s Clojure answer](https://codegolf.stackexchange.com/a/109197/52210) for the [Print this diamond](https://codegolf.stackexchange.com/questions/8696/print-this-diamond) challenge.
## Print this exact text:
```
1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
```
(From the middle outward in both directions, each digit is separated by one more space than the previous line.)
## Challenge rules:
* There will be no input ([or an empty unused input](https://codegolf.meta.stackexchange.com/questions/12681/are-we-allowed-to-use-empty-input-we-wont-use-when-no-input-is-asked-regarding)).
* Trailing spaces are optional.
* A single trailing new-line is optional.
* Leading spaces or new-lines are not allowed.
* Returning a string-array isn't allowed. You should either output the text, or have a function which returns a single string with correct result.
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.  
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code.
* Also, please add an explanation if necessary.
  
[Answer]
# [Python 2](https://docs.python.org/2/),  ~~59 57 56~~ 55 bytes
```
i=8;exec"print(' '*abs(i)).join('1234567890');i-=1;"*17
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWwjq1IjVZqaAoM69EQ11BXSsxqVgjU1NTLys/M09D3dDI2MTUzNzC0kBd0zpT19bQWknL0Pz/fwA "Python 2 – Try It Online")
> 
> *@Leaky Nun helped golfing this a lot, @Praind Suggested a method to save 1 byte, which I formerly thought of, but forgot to edit, @CotyJohnathanSaxman suggested changing the loop.*
> 
> 
> 
---
# Explanation
* `i=8` - Assigns the value `8` to a variable called `i`.
* `exec"..."*17` - Execute that block of code (`...`) 17 times.
* `print(...)` - Output the result.
* `' '*abs(i)` - Create a String with a space repeated `|i|` times.
* `.join('1234567890')` - Interleave the string created above with `1234567890`, such that `|i|` spaces are inserted between the digits.
* `i-=1` - Decrement `i`, and by executing it 17 times, it reaches `-8`, which creates te repetitive pattern with the help of `abs()`.
[Answer]
# Vim, 35 bytes:
```
i1234567890<esc>qqYP:s/\d/& /g
YGp{q7@q
```
Explanation:
```
i1234567890<esc>    " insert '1234567890'
qq                  " Record the following into register 'q'
  Y                 "   Yank a line
   P                "   Paste it above us
    :s/\d/& /g      "   Put a space after each number
Y                   "   Yank this line
 G                  "   Move the end of the buffer
  p                 "   Paste the line
   {                "   Move the beginning of the buffer
    q               " Stop recording
     7@q            " Call macro 'q' 7 times
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~14~~ 13 bytes
```
17F9ÝÀN8αð×ý,
```
[Try it online!](https://tio.run/##AR0A4v8wNWFiMWX//zE3RjnDncOATjjOscOww5fDvSz//w "05AB1E – Try It Online")
**Explanation**
```
17F            # for N in [0 ... 16] do
   9Ý          # push [0 ... 9]
     À         # rotate left
      N8α      # compute the absolute difference between N and 8
         ð×    # push that many spaces
           ý   # merge the list of digits with the space string as separator
            ,  # print
```
[Answer]
# C64 ASM, 358 bytes (102 bytes compiled with basicstub)
This is the closest I could get due to obvious limitations:
[![C64](https://i.stack.imgur.com/GxFIX.png)](https://i.stack.imgur.com/GxFIX.png)
```
jsr $E544
lda #9
sta $FD
nl1: jsr dl
jsr il
dec $FD
bne nl1
inc $FD
nl2: ldy $FD
cpy #9
bne nt1
bl: jmp bl
nt1: iny
sty $FD
jsr dl
jsr il
jmp nl2
dl: clc
ldx #$31
ldy #0
lp: txa
sm: sta $0400, y
inx
cpx #$31
bne c1
rts
c1: cpx #$3A
bne nt2
ldx #$30
clc
nt2: tya
adc $FD
cmp #40
bcc c2
rts
c2: tay
jmp lp
il: lda sm+1
adc #39
bcc nc
inc sm+2
nc: sta sm+1
rts
```
(Could probably be optimized quite a bit)
[Answer]
# TSQL, 220 148 bytes
Improvement posted by ZLK:
```
DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1@2@3@4@5@6@7@8@9@0','@',SPACE(ABS(9-RANK()OVER(ORDER BY object_id))))+'
'FROM sys.objects PRINT @
```
Output:
```
1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
```
[Answer]
# [Haskell](https://www.haskell.org/), 58 55 bytes
```
unlines["1234567890">>=(:(' '<$[1..abs n]))|n<-[-8..8]]
```
[Try it online!](https://tio.run/##y0gszk7Nyflfraus4OPo5x7q6O6q4BwQoKCsW8tVYRvzvzQvJzMvtThaydDI2MTUzNzC0kDJzs5Ww0pDXUHdRiXaUE8vMalYIS9WU7Mmz0Y3WtdCT88iNvZ/bmJmnoKtQkFpSXBJkU@eQsV/AA "Haskell – Try It Online")
This is basically @nimi 's solution :)
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 22 bytes
```
↑∊¨(1+|¯9+⍳17)↑¨¨⊂1⌽⎕D
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKPdqRRItU181NF1aIWGoXbNofWW2o96NxuaawJFD604tOJRV5Pho569j/qmuoDU/wdqAAA "APL (Dyalog Unicode) – Try It Online")
`⎕D` **D**igits from zero to nine
`1⌽` rotate one step right (puts zero at end)
`⊂` enclose (to treat as unit)
`(`…`)↑¨¨` for *each* of these numbers, take that many characters from *each* of the letters:
 `⍳17` one through seventeen
 `¯9+` subtract nine
 `|` find the absolute values
 `1+` add one
`∊¨` enlist (flatten) each
`↑` change one layer of depth into a level of rank (matrify)
[Answer]
# [Java 11 (JDK)](http://jdk.java.net/), 98 bytes
```
o->{for(int i=-9;++i<9;)System.out.println("".join(" ".repeat(i<0?-i:i),"1234567890".split("")));}
```
[Try it online!](https://tio.run/##LU7LTsMwELz3K1Y@xSqxypuQtBwQR8ShR9SD67pljWNb9rqAqnx7cAp7GWkeO2PkUdZm9zmGvLWoQFmZErxKdHCaAfyziSQVOHrcQV@0ak0R3eF9AzIeEgf6iP4rwcu30oHQ/2UBTHkuMqEV@@zUJIhn71LudezetkYrWkFcjr5enfY@VugIcFk37XyOXdPy9U8i3QufSYRSR9ZVjAnjSz8DJqIOWlKF3eKpxkfkF@zy6vrm9u7@oVkwkYJFKn7OeTuMcL72vCoKqaadlcvW8okbZsP4Cw "Java (JDK) – Try It Online")
* -14 bytes by switching to JDK 11, which now has a native `String::repeat`.
# Previous answer ([Java (OpenJDK 8)](http://openjdk.java.net/)), ~~113~~ 112 bytes
```
o->{for(int i=-9;++i<9;)System.out.printf("".join("%1$"+(i<0?-i:i>0?i:"")+"s","1234567890".split(""))+"%n","");}
```
[Try it online!](https://tio.run/##LY7LasMwEEX3@YpBNGDhWjh9O3acRemydJFl6EJR7HRcWTLSKG0J/nZXSTubgXu4nNvJo8zs0Jhu/zkNYadRgdLSe3iVaOA0A/hPPUmK72hxD31kyYYcmsP2HaQ7eA704eyXh5dv1QyE9q8L0EWBCIRatMGoMxDP1vjQN65623WNohrcarJZfWqtS9AQ4CoryjTFqij55sdT0wsbSAxRR23CmOhs1LP54oqlCVb5OsMl1vkal4zxlHl2zRY3t3f3D49PRc6EHzRSrPHI5iZCxstxgsuVl41OSHVenZigNT9n42ycfgE "Java (OpenJDK 8) – Try It Online")
### Explanations
I'm basically constructing the following `String` 17 times (`N` is a variable, not an actual value):
```
"1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n"
```
It's all the expected digits, joined by `%1$Ns` where `N` is the number of spaces between each digit. 
`%1$Ns` basically means "take the first argument and pad it until length is at least `N`". Also, `%1$0s` is not supported so a special case `%1$s` is made for `0`.
Finally, I format-print that string using a single argument: `""`, so the formatter reuses always the same empty string, padding it with spaces as needed.
### Saves
* 1 byte thanks to Kevin Cruijssen
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-R`, ~~19~~ ~~18~~ ~~16~~ ~~14~~ 13 bytes
```
Aõ%A
£qYçÃÔÅê
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.5&code=QfUlQQqjcVnnw3cgxeo=&input=LVI=) or [try it online](https://tio.run/##y0osKPn/3/HwVlVHrkOLCyMPLz/cXK5wuPXwqv//dYMA)
---
## Explanation
```
A             :10
 õ           :Range [1,10]
  %A         :Modulo each by 10
\n           :Assign to variable U
£            :Map each element at 0-based index Y
 q           :  Join U with
  Yç         :   Space repeated Y times
    Ã        :End map
     Ô       :Reverse
      Å      :Slice off first element
       ê     :Mirror
             :Implicitly join with newlines and output
```
[Answer]
# Clojure, ~~126~~ 99 bytes
-27 by fixing a couple of dumb mistakes. The outer use of `a` wasn't necessary, so I was able to get rid of `a` altogether and just write `apply str` once. That also allowed me to use a function macro for the main function, which saved some bytes. I also inlined the call to `Math/abs` instead of rebinding `n-spaces`.
Basically a Clojure port of @Mr.Xcoder's Python idea. In retrospect, I should have used the `abs`/`range` method for the diamond challenge originally, but I then I may not have produced the bugged output!
Pretty simple. Joins the number string with a number of spaces that depends on the current row.
```
#(doseq[n(range -8 9)](println(clojure.string/join(apply str(repeat (Math/abs n)\ ))"1234567890")))
```
---
```
(defn bugged []
  (doseq [n-spaces (range -8 9)]
    (println
        (clojure.string/join
          ; "String multiplication"
          (apply str
                 (repeat (Math/abs n-spaces) \space))
          "1234567890"))))
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~58~~ ~~57~~ 54 bytes
```
i=8
while i+9:print(*'1234567890',sep=' '*abs(i));i-=1
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P9PWgqs8IzMnVSFT29KqoCgzr0RDS93QyNjE1MzcwtJAXac4tcBWXUFdKzGpWCNTU9M6U9fW8P9/AA "Python 3 – Try It Online")
(thanks to @flornquake for the last three bytes; I completely forgot using `sep` to save vs. `.join`)
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 12 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
9{SUē↕∑}¹№╬«
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=OSU3QlNVJXUwMTEzJXUyMTk1JXUyMjExJTdEJUI5JXUyMTE2JXUyNTZDJUFC)
Explanation:
```
9{     }      9 times do
  SU            push "1234567890"
    ē           push e, predefined with the input, which defaults to 0, and then increase it
     ↕          get that many spaces
      ∑         join the string of digits with those spaces
        ¹     collect the results in an array
         №    reverse the array vertically
          ╬«  palindromize vertically with 1 overlap
```
[Answer]
## JavaScript(ES2017), 83 73 72 68 bytes
Thanks [Shaggy](https://codegolf.stackexchange.com/users/58974/shaggy) for saving 10 bytes.
Thanks [Craig](https://codegolf.stackexchange.com/users/68610/craig-ayre) for saving 1 byte.
Thanks [arcs](https://codegolf.stackexchange.com/users/70879/arcs) for saving 4 bytes.
```
for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))
```
```
for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))
console.log(a);
```
```
.as-console-wrapper { max-height: 100% !important; top: 0; }
.as-console-row:after { display: none !important; }
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~30~~ ~~29~~ 28 bytes
```
Ị↺{∧≜;Ṣj₍g;?↔zcc}ᶠ⁹↔;XcP↔Pẉᵐ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@Hurkdtu6ofdSx/1DnH@uHORVmPmnrTre0ftU2pSk6ufbhtwaPGnUCOdURyAJAKqHu4s738////AA "Brachylog – Try It Online")
*Saved one byte thanks to Leaky Nun*.
### Explanation
```
Ị↺                               The string "1234567890"
  {               }ᶠ⁹            Find the first 9 outputs of:
   ∧≜                              Take an integer
       ;Ṣj₍                        Juxtapose " " that number of times
           g;?↔z                   Zip that string of spaces with "1234567890"
                cc                 Concatenate twice into one string
                    ↔            Reverse the resuling list
                     ;XcP↔P      Palindromize the list (concatenate X to it into the list P,
                                   P reversed is still P)
                           ẉᵐ    Map writeln
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 18 bytes
```
Ｆ⁹⪫⁺…Ｉ¹:⟦0¶⟧× ι‖Ｂ↑
```
[Try it online!](https://tio.run/##DcaxCsIwEADQ3a84brqDFnS0ndTNSYpO6hDSiwZiIskp@PVnl8fzT1d9cckslAq0ZTjVmJWOJWbazTNNLj@EDq4pbbgDHHDxiutbxvuyc3xJIwTsIDLzuJokJPG6/6hKDelHw@XNo5n1X@tb@gM "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｆ⁹      Repeat 9 times (i = loop variable)
  ⪫       Join
   ⁺       Concatentate
    …Ｉ¹:    All the characters from str(1) below ":" (i.e. to "9") as a list
    ⟦0¶⟧    A list whose element is the string "0\n"
   × ι     With i spaces
‖Ｂ↑     Reflect everything upwards but without duplicating the top line
```
Note: `Cast(1)` takes the same number of bytes because `"1"` would need a separator before `":"` (which as it happens the deverbosifier fails to insert).
[Answer]
# [R](https://cran.r-project.org/), 108 bytes
```
for(i in abs(-8:8))cat(paste0(el(strsplit("1234567890","")),paste(rep(" ",i),collapse=""),collapse=""),"\n")
```
Just pasting and collapsing the strings.
[Try it online!](http://www.r-fiddle.org/#/fiddle?id=1qEEqjlg)
Edit: thanks for Challenger5 for pointing out a problem. Fixed it now.
Edit 2: saved a byte thanks to bouncyball.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~14~~ 13 bytes
1 byte thanks to Mnemonic.
```
V17j*da8NeMST
```
[Try it online!](http://pyth.herokuapp.com/?code=V17j%2ada8NeMST&debug=0)
[Answer]
## Java 8, 235 234 206 163 bytes
```
interface A{static void main(String[]a){for(int i=-8;i<9;i++){String s="";for(int j=1,k;j<10;j++){s+=j;for(k=0;k<(i>0?i:-i);k++)s+=" ";}System.out.println(s+0);}}}
```
**Update** : -28 bytes thanks to Leaky Nun !  
**Update 2** : -43 bytes thanks to Leaky Nun again !
Ungolfed :  
```
interface A {
    static void main(String[] a) {
        for (int i = -8; i < 9; i++) {
            String s = "";
            for (int j = 1, k; j < 10; j++) {
                s += j;
                for (k = 0; k < (i > 0 ? i : -i); k++)
                    s += " ";
            }
            System.out.println(s + 0);
        }
    }
}
```
[Try it online](https://tio.run/##XY5BCsMgEEWvIq6UNCHZFSYWeoYsSxeSaBltTIg2UMSzpzali3Y5b/7M@0auspxm5cxgtw1dUIuWvSLn6IMM2JN1woGMEh3rwoLudrl6HjU7ckg/CZZvCfL4SREvKAU9LTs2ojlYMG1TgykKHn0hzL60ogbbIthMM6SEQuqePqixmh6hmvOrcHfMF/WfTn912csB83iq37WwbDjsLKW0bS8)
**EDIT :** The code earlier was wrong ! Made a mistake while golfing the code, it should work as intended now !  
[Answer]
## [Husk](https://github.com/barbuz/Husk), 21 bytes
```
mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9
```
This is a full program that prints to STDOUT.
[Try it online!](https://tio.run/##yygtzv7/P/fc4oc7VyVYHVqu/ahtSsnDHYuDLNQVHu5sLE6wMgDyLP//BwA "Husk – Try It Online")
There are lots of trailing spaces.
## Explanation
Husk is still missing lots of essential stuff like a two-argument range function, so parts of this solution are a little hacky.
```
mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9
              ṁs`:0ḣ9  This part evaluates to the string "1234567890".
                   ḣ9   Range from 1 to 9.
                `:0     Append 0.
              ṁs        Convert each number to string and concatenate.
     §+↔tḣR8'          This part evaluates to a list like ["  "," ",""," ","  "]
                       but with 17 elements instead of 5.
          R8'           A string of 8 spaces.
         ḣ              Take prefixes.
     §+                 Concatenate
       ↔                the reversal and
        t               tail of the prefix list, palindromizing it.
  Ṫ                    Take outer product of the two lists
   `:                  with respect to flipped prepeding.
                       This prepends each digit to each string of spaces.
mΣ                     Map concatenation over the results, computing the rows.
                       Implicitly join with newlines and print.
```
[Answer]
# [T-SQL](https://en.wikipedia.org/wiki/Transact-SQL) 145 152 bytes
```
DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1x2x3x4x5x6x7x8x9x0','x',SPACE(ABS(number-8)))+'
'FROM master..spt_values WHERE type='P'PRINT @
```
**Updated** to use:
* `master..spt_values` to generate numbers (`WHERE type = 'P'`, these are always consecutive, starting at 0)
* @ZLK's `TOP 17` idea
* PRINT (to obey the rules - no stringlists)
* @JanDrozen's great idea of including the carriage return in the string (I counted that as just one byte - Windows CRLF what?)
* Idea of @Bridge to use just @ for variable name - all these tricks!!
Results:
```
1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
```
(Thanks @JanDrozen for the REPLACE idea)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
8ŒRA⁶ẋØDṙ1¤jÐ€Y
```
[Try it online!](https://tio.run/##ASQA2/9qZWxsef//OMWSUkHigbbhuovDmEThuZkxwqRqw5DigqxZ//8 "Jelly – Try It Online")
[Answer]
# Mathematica, 92 bytes
```
Column@Join[Reverse@(s=Row/@Table[Riffle[Range@10~Mod~10,""<>Table[" ",i]],{i,0,8}]),Rest@s]
```
[Try it online](https://sandbox.open.wolframcloud.com/app/objects/)
copy/paste code with ctrl-v  
press shift+enter to run
[Answer]
# C, 97 bytes
```
i=-9;main(j){for(;++i<9;putchar(10))for(j=0;++j<11;printf("        "+8-abs(i)))putchar(48+j%10);}
```
Your compiler will probably complain a *lot* about this code; mine threw 7 warnings of 4 different types. Might improve the code later.
[Try it online!](https://tio.run/##NYtBCoAgEAC/EkGwiwgKHZStx5hQrZSF1Sl6uxXUHGcYL/3k4pAzt9LS7DhCwLNfEpAQ3Fhaj92PLoFWiK8OrXpKaLSmNXHceyiLj1IY6boNGBH/rTYiVM9LV843 "C (clang) – Try It Online")
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 14 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
ā9{SUčf@*∑Κ}╬Æ
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUwMTAxOSU3QlNVJXUwMTBEZkAqJXUyMjExJXUwMzlBJTdEJXUyNTZDJUM2)
Explanation:
```
ā               push an empty array
 9{        }    9 times do
   SU             push "1234567890"
     č            chop into characters
      f@*         get current iteration (0-based) amount of spaces
         ∑        join with that
          Κ       prepend this to the array
            ╬Æ  palindromize vertically with 1 overlap
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 11 bytes
```
8╤{± *♂r╫up
```
[Try it online!](https://tio.run/##y00syUjPz0n7/9/i0dQl1Yc2Kmg9mtlU9Gjq6tKC//8B "MathGolf – Try It Online")
## Explanation
```
8             push 8
 ╤            range(-n, n+1)
  {           for each element in range:
   ±          absolute value
              space character
     *        multiply space character x number of times
      ♂r      push 10, create range
        ╫     left-rotate list (0 goes to the end)
         u    join with separator (joins using x spaces)
          p   print with newline
```
Has a trailing newline in the end from printing. @ovs found a mistake in the original code that could be fixed by switching the first `9` to an `8`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 21 20 19 18 bytes
```
Ｆ⁹«Ｆ…¹χ⁺κ… ι0⸿»‖Ｂ↑
```
[Try it online!](https://tio.run/##S85ILErOT8z5///9nmWPGnceWg2iG5Yd2nm@/VHjrnO7gGyFczsNHu3Yf2j3o4Zp7/csetQ28f9/AA "Charcoal – Try It Online")
Link to [the verbose version](https://tio.run/##S85ILErOT8z5/z8tv0hBw1KTq5pLQQHMDkrMS0/VMNQxNNDUBIopKAQUZeaVaDimpGhk6yhAZJUUlHQUMjU1Na25YPJKBjFFSkB@LVdQalpOanKJU2lJSWpRWk6lhlVogab1////dcv@6xbnAAA). Basically I create the lower part of the drawing and then reflect the text up.
[Answer]
## [CJam](https://sourceforge.net/p/cjam), 21 bytes
```
A,(+aH*ee{:\8-zS**n}/
```
[Try it online!](https://tio.run/##S85KzP3/31FHQzvRQys1tdoqxkK3KlhLK69W//9/AA "CJam – Try It Online")
### Explanation
```
A,     e# Get [0 1 2 ... 9].
(+     e# Rotate the 0 to the end.
aH*    e# Wrap in an array and repeat 17 times.
ee     e# Enumerate. This pairs each copy of the array with its index in
       e# the list.
{      e# For each [index array] pair...
  :\   e#   Unwrap the pair and swap its order.
  8-z  e#   Get the absolute difference of the index from 8.
  S*   e#   Get a string of that many spaces.
  *    e#   Riffle the list of digits with the string of spaces.
  n    e#   Print it with a trailing linefeed.
}/
```
[Answer]
## Batch, 163 bytes
```
@set s=1 2 3 4 5 6 7 8 9 0
@set t=         
@for %%l in (9 7)do @for /l %%i in (1,1,%%l)do @call:%%l
:7
@set t=  %t%
:9
@set t=%t:~1%
@call echo %%s: =%t%%%
```
Note: First line ends in 9 spaces. Explanation: Uses creative line numbering! The first loop needs to run 9 times and delete a space each time, while the second loop needs to run 8 times and add a space each time. The former is achieved by running it 7 times and falling through for the 8th time, while the latter is achieved by adding two spaces and falling through to delete one of them again.
[Answer]
# bash (and shell utils), 69 bytes
```
for i in `seq 9 -1 1;seq 2 9`;do seq -f%-$i.f 9|tr -d \\n;echo 0;done
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 76 bytes
```
f(x,y){for(y=-9;++y<9;puts(""))for(x=10;x++;printf("%-*d",abs(y)+1,x%=10));}
```
[Try it online!](https://tio.run/##FcpBCoAgEADAvwjCbquQR9l8TBlGlxI1UKK3W12H8XrzvvcAVTW8w5mgOW2ZqE2W41UyCIH4e3Vm5ErEMe1HCSCkHlah5iVDQzKqyi8g8tP7Cw "C (gcc) – Try It Online")
It outputs some trailing spaces, which is supposed to be OK.
It prints the numbers using left-justified fields of dynamic length - that's what the format string `%-*d` is for.
The inner loop has some funny initialization (starts from 10; any multiple of 10 would be fine) to "simplify" its termination condition.
]