# Print this diamond

This question has been spreading like a virus in my office. There are quite a variety of approaches:

Print the following:

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


Answers are scored in characters with fewer characters being better.

• What is the winning criterion ? And is this a challenge or a golf ? Commented Oct 12, 2012 at 15:33
• I read "kolmogorov-complexity" as "code-golf". Commented Oct 12, 2012 at 16:44
• @DavidCarraher "kolmogorov-complexity" was edited in after the question was asked. The original questioner has not specified the winning criteria yet. Commented Oct 12, 2012 at 20:56
• @Gareth My comment was made after the "kolmogorov-complexity" tag was added but before the "code-golf" tag was added. At that time people were still be asking whether it was a code-golf question. Commented Oct 12, 2012 at 22:00
• perlmonks.com/?node_id=891559 has perl solutions. Commented Oct 20, 2012 at 19:51

## Python, 65

for i in map(int,str(int('1'*9)**2)):print' '*(9-i),int('1'*i)**2

• Try prepending I=int; to your code and replacing all subsequent instances of int with I Commented Nov 27, 2016 at 2:51
• @Cyoce I had thought of that. It would save 2 chars each time int is used, and it's used 3 times, so it saves 6 chars at a cost of 6 chars. Commented Nov 27, 2016 at 4:05

# Bash, 126109 87 chars

87:

q()(printf %$[9+$1%9]s\\n $[$2*$2];[ 7 -lt$1 ]||(q $[$1+1] ${2}1;q$[$1+9]$2))
q 0 1


As it usually goes, changing from iterative to recursive solution helps us win additional bytes.

Meaning of parameters to q:

$1 How much to remove from 8 to get the number of spaces in the beginning. Note value modulo 9 counts here (actual value is also a hint to quit recursion).$2 The current chain of 1s to be squared and output by printf.

The modus operandi is:

1. output the sequence (ie. if $2 is 11111, output 123454321) 2. (if not yet at 12..9..21 - the recursive step) 2.1. output the next sequence (here: 111111 >$2 , output 12345654321

2.2. output the sequence once again (123454321).

In the step 2.2 , we pass (indent value + 9) instead of indent value however, so that the algoritm "knows" we are printing the row for the second time. Without this, the [ 7 -lt $1 ] would be false, causing us to retrigger the recursive step 1. This would never finish then. The recursion goes like this: q 0 1: 1 q 1 11: 121 q 2 111: 12321 q 3 1111: 1234321 q 4 11111: 123454321 q 5 111111: 12345654321 q 6 1111111: 1234567654321 q 7 11111111: 123456787654321 q 8 111111111: 12345678987654321 q 16 11111111: 123456787654321 q 15 1111111: 1234567654321 q 14 111111: 12345654321 q 13 11111: 123454321 q 12 1111: 1234321 q 11 111: 12321 q 10 11: 121 q 9 1: 1  109: p()(printf "%$[8+i]s\n" $[k*k]) k=;for i in seq 9;do k+=1;p;done;for i in seq 8 -1 1;do k=${k:1};p;done;


"k+=1" is much cheaper as k=$[10*k+1] , and for k being a string of ones it's the same. Same goes for${k:1} and $[k/10] . 126: p() (printf "%$[$1+i]s\n"$[k*k];)
k=1;for i in seq 8;do p 8;k=$[10*k+1];done;for i in seq 8 -1 0;do p 9;k=$[k/10];done;


I guess there may be even shorter solution, but weather is glorious, I can't stand sitting in front of computer any more :).

• Try this, 80 chars: tio.run/##S0oszvj/… Commented Jul 19, 2023 at 21:15
• Try even this, 74 chars: tio.run/##S0oszvj/… Commented Jul 19, 2023 at 21:54

# Befunge-93, 155 chars

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


Try it online!

It could definitely be golfed more, but it's my first Funge program and my head already hurts. Had a lot of fun, though

# Ruby, 55

puts (-8..8).map{|i|[?\s*a=i.abs,(?1*(9-a)).to_i**2]*''}


Output:

irb(main):342:0> puts (-8..8).map{|i|[?\s*a=i.abs,(?1*(9-a)).to_i**2]*''}
1
121
12321
1234321
123454321
12345654321
1234567654321
123456787654321
12345678987654321
123456787654321
1234567654321
12345654321
123454321
1234321
12321
121
1


# JavaScript, 170 bytes

My first code golf :)

## Golfed

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


## Ungolfed

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

• Welcome to PPCG! Commented Jul 4, 2017 at 10:53

# Octave, 38 bytes

x=abs(-8:8);m=x+x';m(m>8)=25;[57-m,'']


To make it work in MATLAB too, you'd need to write x=ndgrid(abs(-8:8));m=x+x';m(m>8)=25;[57-m,''] or x=meshgrid(abs(-8:8));m=x+x';m(m>8)=25;[57-m,'']

# Gaia, 9 bytes

9┅…ṫ¦€|ṫṣ


### Explanation

9┅         Push [1 2 3 4 5 6 7 8 9]
…        Prefixes; push [[1] [1 2] [1 2 3] ... [1 2 3 4 5 6 7 8 9]]
ṫ¦      Palindromize each row: e.g. [1 2 3 4] -> [1 2 3 4 3 2 1]
€|    Centre-align the rows, padding with spaces
ṫ   Palindromize the rows
ṣ  Join with newlines


# 05AB1E, 9 bytes

žh¦η€ûû.c


Try it online!

# Canvas, 7 bytes

９｛Ｒ⇵］↶┼


Try it here!

Explanation:

9{R⇵]↶┼
9{  ]    map over i = 1..9
R        push a range 1..i
⇵       and reverse that array
in Canvas, an array of arrays is a list of lines,
and the inner arrays are joined together
↶   rotate anti-clockwise
┼  and quad-palindromize with 1 overlap


I've just fixed a couple built-ins to make a 6 byte version possible:

９｛Ｒ］／┼


Try it here!

9{R]/┼
9{ ]    map over 1..9
R       create a range 1..i
/   pad with a diagonal of spaces


# Jelly,  22 18 12  11 bytes

9ŒḄr1z⁶ṚŒḄY


Try it online!

Done alongside caird coinheringaahing in chat.

## How it works

9ŒḄr1z⁶ṚŒḄY - Full program.

9ŒḄ         - The list [1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2, 1].
r1       - Generate [N, N-1, ..., 1] for each N in ^.
z⁶     - Zip; transpose ^ with filler spaces.
Ṛ    - Reverse.
ŒḄ  - Palindromize without vectorization.
Y - Join by newlines.


Saved 6 bytes thanks to Leaky Nun!

• 12 bytes Commented Oct 21, 2017 at 20:22
• 11 bytes Commented Oct 21, 2017 at 20:33

# PICO-8, 131 bytes

cls()function _draw()for i=1,9do for j=i-9,0do for k=-1,1,2do for l=0,1do print(i,72*l-(l-0.5)*(i-j)*8,48+k*j*6)end end end end end


Output:

Ungolfed version:

cls()                               //clear screen
function _draw()                    //keeps commandline off
for i=1,9 do                    //numbers
for j=i-9,0 do              //position control
for k=-1,1,2 do         //y axis switch
for l=0,1 do        //x axis switch
print(i,72*l-(l-0.5)*(i-j)*8,48+k*j*6)
end
end
end
end
end


0:2{+x,1_|x}/-9$,$1+!9  Try it online! Takes a lot of inspiration from @zgrep's k answer. • 1+!9 generate "123456789" • ,\ take the prefixes, i.e. (,"1";"12";"123";...) • -9 left-pad each element to nine characters (e.g. (" 1";...)) • 2{...}/ set up a do-reduce, run twice on the above list • 1_|x reverse the input, and drop the first character (e.g. " 123" => "21 ") • x, append this to the input • + transpose the result, so that the next iteration works on the opposite axis • 0: print to stdout (suppressing implicit result) # VyxalC, 7 bytes 9ɾKvṅʁ∞  Try it Online! # Bash, 65 bytes for c in {1..9} {8..1};do printf %[8+c]s\\n [(10**c/9)**2];done  Try it online! • I want to upvote this more, for the cool math tricks Commented Jul 24, 2023 at 14:53 # GolfScript, 36 bytes Assuming that this is meant as a challenge, here's a basic GolfScript solution: 9,.);\-1%+:a{a{1+7-.0>\" "if}%\;n}%  Try it online! # K (ngn/k), 21 bytes Hard to do better than directly translating from ngn's APL. 2{+x,1_|x}/-9,$1+!9  Try it online! 2{+x,1_|x}/-9$,$$\1+!9 1+!9 / 1 2...9 ,\$$     / string prefixes
-9$/ left pad all to width 9 {+x,1_|x} / subroutine with argument x |x / reverse list x 1_ / drop first x, / append to x + / transpose as matrix of chars 2 / / do that twice  Here's a fun different approach but I can only squeeze it down to 22. ($7-a+/:a&:|a:!17)@''1
a:!17      / a is assigned 0 1...16
|a          / reverse a -> 16 15...0
a&             / min with a -> 0 1...7 8 7...0
a :            / reassign to a
a+/:a              / addition table of a with itself
/ -> 0 in corners up to 16 in middle
7-                   / subtract from 7
/ -> 7 in corners down to -9 in middle
$/ convert to strings ( )@''1 / 2nd character of each string / -> space if 0...9, digit if negative  ## Perl 56 54 characters Added 1 char for the -p switch. Uses squared repunits to generate the sequence. s//12345678987654321/;s|(.)|$/.$"x(9-$1).(1x$1)**2|eg  # K, 59 -1'(-:'9+k,1_|k:!9)$,/'$b,1_||:'b:(-1_'a),'|:'a:1_1+!:'!10;  # Groovy 77 75 i=(-8..9);i.each{a->i.each{c=a.abs()+it.abs();print c>8?' ':9-c};println""}  old version: (-8..9).each{a->(-8..9).each{c=a.abs()+it.abs();print c>8?' ':9-c};println""}  • added a 57 char groovy solution. You can replace both each with any to save two chars. Commented Feb 12, 2017 at 10:52 ### Scala - 86 characters val a="543210/.-./012345";for(i<-a){for(j<-a;k=99-i-j)print(if(k<1)" "else k);println}  ## Javascript, 137 With recursion: 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,""))  First time on CG :) ### Or 118 If I can find a JS implementation that executes 111111111**2 with higher precision. (Here: 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)  • 111111111**2 yields 12345678987654320 with my browser too. But you can use one 1 less and get something useful too: '0'+11111111**2+'0' -> "01234567876543210" or use '0'+10*11111111**2 and shave of 1 more byte Commented Jul 8, 2020 at 22:09 ## GolfScript (27 chars) 17,{8-abs' '*19*1$,>~.*n}/


or

17,{8-abs' '*.19*+9<~.*n}/


Both work by building a suitable repunit as a string and then converting to int and squaring to get a Demlo number.

## APL (40)

r←{⍵,1↓⌽⍵}
{⎕←⍵,⍨' '⍴⍨(2×10-⌈/⍵)}¨r¨r⍳¨⍳9


I guess I'm not beating marinus. :p

PowerShell, 49 48

1..9+8..1|%{"  "*(9-$_)+(1..$_+($_-1)..0|?{$_})}

• Nice solution, though it has a lot of spacing not called for in the challenge. Helped me trim mine down to half its original size.
– Iszi
Commented Nov 24, 2013 at 2:24

# APL, 24 chars

⍉⊃{⍕⍵↑⍨⍵>0}¨9-∘.+⍨|9-⍳17


Tested in Nars2000 and Dyalog (requires ⎕ML←3 in the latter.)

Explanation

                     ⍳17    starting with the naturals up to 17
|9-       generate the numbers from 8 to 0 and back to 8
∘.+⍨          make a table of their sum (with 0 in the middle)
9-              turn it into a diamond with 9 in the middle
{       }¨                for each number
⍵↑⍨⍵>0                  keep it only if it's positive
⍕                        then convert the result, if any, to a string
⍉⊃                          disclose the nested array and adjust the dimensions


The last step transposes the result, whose shape is 17 17 1 (because of the disclose ⊃ of nested strings) into 1 17 17, which gets printed like a plain 17 17.

Output

⍉⊃{⍕⍵↑⍨⍵>0}¨9-∘.+⍨|9-⍳17
1
121
12321
1234321
123454321
12345654321
1234567654321
123456787654321
12345678987654321
123456787654321
1234567654321
12345654321
123454321
1234321
12321
121
1

• Take the train to save a byte: (⍕>∘0↑⊢)
Commented Jul 11, 2016 at 6:03

# Ruby 59

(-8..8).map{|i|puts' '*i.abs+"#{eval [?1*(9-i.abs)]*2*?*}"}


## Groovy, 62, 57 chars

((1..9)+(8..1)).any{println' '*(9-it)+('1'*it as int)**2}


old version:

((1..9)+(8..1)).any{println"\${('1'*it as int)**2}".center(17)}


explanation: we create a list [1,2,...,9,8,7,..,1]. Within the closure we create strings '1', '11', '111,..., convert them to numbers, run power of two and center.

# ///, 233 bytes

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


Try it online!

Yay.

• This is a polyglot. It should work in PHP, and some others also. Commented Feb 24, 2017 at 23:13
• @NoOneIsHere Yay. Commented Feb 24, 2017 at 23:38

iisiisddddooooooooiiiiiiiiiiiiiiiiiodddddddddddddddddddddddddddddddddddddddoddddsddddoooooooiiiiiiiiiiiiiiiiioiododddddddddddddddddddddddddddddddddddddddoddddsddddooooooiiiiiiiiiiiiiiiiioioiodododddddddddddddddddddddddddddddddddddddddoddddsddddoooooiiiiiiiiiiiiiiiiioioioiododododddddddddddddddddddddddddddddddddddddddoddddsddddooooiiiiiiiiiiiiiiiiioioioioiodododododddddddddddddddddddddddddddddddddddddddoddddsddddoooiiiiiiiiiiiiiiiiioioioioioiododododododddddddddddddddddddddddddddddddddddddddoddddsddddooiiiiiiiiiiiiiiiiioioioioioioiodododododododddddddddddddddddddddddddddddddddddddddoddddsddddoiiiiiiiiiiiiiiiiioioioioioioioiododododododododddddddddddddddddddddddddddddddddddddddodddsoioioioioioioioiodododododododododddddddddddddddddddddddddddddddddddddddoddddsddddoiiiiiiiiiiiiiiiiioioioioioioioiododododododododddddddddddddddddddddddddddddddddddddddoddddsddddooiiiiiiiiiiiiiiiiioioioioioioiodododododododddddddddddddddddddddddddddddddddddddddoddddsddddoooiiiiiiiiiiiiiiiiioioioioioiododododododddddddddddddddddddddddddddddddddddddddoddddsddddooooiiiiiiiiiiiiiiiiioioioioiodododododddddddddddddddddddddddddddddddddddddddoddddsddddoooooiiiiiiiiiiiiiiiiioioioiododododddddddddddddddddddddddddddddddddddddddoddddsddddooooooiiiiiiiiiiiiiiiiioioiodododddddddddddddddddddddddddddddddddddddddoddddsddddoooooooiiiiiiiiiiiiiiiiioiododddddddddddddddddddddddddddddddddddddddoddddsddddooooooooiiiiiiiiiiiiiiiiiodddddddddddddddddddddddddddddddddddddddo


A more human friendly spaced version:

iisiisdddd oooooooo iiiiiiiiiiiiiiiii o dddddddddddddddddddddddddddddddddddddddo
ddddsdddd ooooooo iiiiiiiiiiiiiiiii oiodo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd oooooo iiiiiiiiiiiiiiiii oioiododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd ooooo iiiiiiiiiiiiiiiii oioioiodododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd oooo iiiiiiiiiiiiiiiii oioioioiododododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd ooo iiiiiiiiiiiiiiiii oioioioioiodododododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd oo iiiiiiiiiiiiiiiii oioioioioioiododododododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd o iiiiiiiiiiiiiiiii oioioioioioioiodododododododo dddddddddddddddddddddddddddddddddddddddo
ddds oioioioioioioioiododododododododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd o iiiiiiiiiiiiiiiii oioioioioioioiodododododododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd oo iiiiiiiiiiiiiiiii oioioioioioiododododododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd ooo iiiiiiiiiiiiiiiii oioioioioiodododododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd oooo iiiiiiiiiiiiiiiii oioioioiododododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd ooooo iiiiiiiiiiiiiiiii oioioiodododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd oooooo iiiiiiiiiiiiiiiii oioiododo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd ooooooo iiiiiiiiiiiiiiiii oiodo dddddddddddddddddddddddddddddddddddddddo
ddddsdddd oooooooo iiiiiiiiiiiiiiiii o dddddddddddddddddddddddddddddddddddddddo

• Any way to run this myself? Commented Feb 13, 2017 at 12:26
• esolangs.org/wiki/Deadfish has implementation for most of the common programming languages Commented Apr 3, 2017 at 21:51
z=@cellfun;
`