# Print the Great Numeric Pyramid

Print or return this exact text:

```
0
0 0
0 1 0
0 1 1 0
0 1 2 1 0
0 1 2 2 1 0
0 1 2 3 2 1 0
0 1 2 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 5 4 3 2 1 0
0 1 2 3 4 5 5 4 3 2 1 0
0 1 2 3 4 5 6 5 4 3 2 1 0
0 1 2 3 4 5 6 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 8 8 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 7 7 7 7 7 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0
0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0
0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0
0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
```

The number represents the distance of the cell from the closest edge.

Trailing whitespace on each line is acceptable. A newline on the last line is optional.

[Python 2], 76 bytes …

7mo ago

Canvas, 19 bytes ‾－｛｛╷¹²－ …

7mo ago

Japt `-R`, 27 22 bytes …

7mo ago

[JavaScript (Node.js)], 137 13 …

7mo ago

BQN, 33 bytesSBCS ``` >(⌽( …

~1mo ago

## 5 answers

# Python 2, 76 bytes

```
i=27
while~i:print' '*i+' '.join(`min(i,j,27-i-j)`for j in range(28-i));i-=1
```

Computes the digit in row `i`

from the bottom, position `j`

as `min(i,j,27-i-j)`

.

For comparison, a bad effect to compute the row numbers arithmetically, made harder by the presence of leading zeroes:

**109 bytes**

```
for i in range(28):print" "*(27-i)+" ".join(str(10**min(27-i,i/2)/9*(10**max(2*i-27,-~i/2)/9)*10).zfill(i+1))
```

#### 0 comments

#
JavaScript (Node.js), ~~137~~ ~~136~~ 117 bytes

```
with(Math)f=n=>(m=(a,b)=>a?m(--a,b)+b(a):[])(28,y=>m(55,x=>x>26-y&x<y+28&(x^y)?min(abs(abs(27-x)-y)/2,27-y):' ')+`
`)
```

#### 1 comment

Multiple well-golfed JavaScript answers on all the questions. I wonder who this is..

#
Japt `-R`

, ~~27~~ 22 bytes

```
27òÈn28 ÇmX27-X-ZÃ¸ÃÔû
```

Lots of credit goes to xnor for finding the `min(i,j,27-i-j)`

trick.

*-5 bytes thanks to @Shaggy*

#### 4 comments

22 bytes but I'm sure it can be improved further. I wonder would just building the left-hand side and then palindromising work out shorter?

@shaggy Is it possible to palindromise the 78987 line? Wouldn't 9 get repeated, invalidating the answer?

@Corsaka, In Japt you can palindromise with or, by default, without repeating the middle character/element.

Ah, command for center padding, nice, thanks @Shaggy you learn something new every day

# Canvas, 19 bytes

```
‾－｛｛╷¹²－ｍ‾－¹－ｍ］ ＊］／
```

```
‾-{{╷¹²-m‾-¹-m] *]/ Program, ascii-fied for monospacing
‾- push 28
{ ] for 1…28 (pushing counter & saving in ¹):
{ ] for 1…counter (pushing counter & saving in ²):
╷ decrement the counter
¹²- push ¹-²
m minimum of top 2; min(²-1, ¹-²)
‾-¹- push 28-¹
m minimum of top 2; min(²-1, ¹-², 28-¹)
* separate items with spaces
/ pad lines with spaces to form a space diagonal on the left
```

#### 0 comments

#
BQN, 33 bytes^{SBCS}

```
>(⌽(⊑¨55↑+˜⊸+⊔'0'+⌽⊸⌊⊸⌊)¨˜1↓↑)↕28
```

Minimum of barycentric coordinates placed according to a skew transformation on two of them. So, the `min(i,j,27-i-j)`

thing pretty much. The result is a character matrix.

The three coordinates are height, distance from left, and distance from right, and always sum to 27. In row `i`

the height is `27-i`

, and the possible values for the other two coordinates range from `0`

to `i`

. So reversing (`⌽`

) `↕28`

gives the height and non-empty Prefixes (`↑`

) are the horizontal coordinates. The location of a number is the height plus *twice* the distance from the left. Group (`⊔`

) places each character at its location, giving a list of lists of characters—always zero or one of them in this case.

```
>(⌽(⊑¨55↑+˜⊸+⊔'0'+⌽⊸⌊⊸⌊)¨˜1↓↑)↕28
↕28 # Range 0…27
(⌽ 1↓↑) # Function train
↑ # Prefixes of ↕28
1↓ # but not the first (empty) one
⌽ # Reversed range 27…0
˜ # Exchange the order
( )¨ # On each pair (e.g. 𝕨=3…27 and 𝕩=25)
⌽⊸⌊⊸⌊ # Min-with-reverse 𝕨; min with 𝕩
'0'+ # Digit character from number
+˜⊸+ # Locations (2×𝕨)+𝕩
⊔ # Put characters at locations
55↑ # Extend to length 55
⊑¨ # First at each location, or space
> # Merge axes to give a matrix
```

It's tacit: see trains and Before as usual.

## 0 comments