101
\$\begingroup\$

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.

\$\endgroup\$
8
  • 5
    \$\begingroup\$ What is the winning criterion ? And is this a challenge or a golf ? \$\endgroup\$
    – Paul R
    Commented Oct 12, 2012 at 15:33
  • 26
    \$\begingroup\$ I read "kolmogorov-complexity" as "code-golf". \$\endgroup\$
    – DavidC
    Commented Oct 12, 2012 at 16:44
  • 2
    \$\begingroup\$ @DavidCarraher "kolmogorov-complexity" was edited in after the question was asked. The original questioner has not specified the winning criteria yet. \$\endgroup\$
    – Gareth
    Commented Oct 12, 2012 at 20:56
  • 1
    \$\begingroup\$ @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. \$\endgroup\$
    – DavidC
    Commented Oct 12, 2012 at 22:00
  • 3
    \$\begingroup\$ perlmonks.com/?node_id=891559 has perl solutions. \$\endgroup\$
    – b_jonas
    Commented Oct 20, 2012 at 19:51

140 Answers 140

3
\$\begingroup\$

Python, 65

for i in map(int,str(int('1'*9)**2)):print' '*(9-i),int('1'*i)**2
\$\endgroup\$
2
  • \$\begingroup\$ Try prepending I=int; to your code and replacing all subsequent instances of int with I \$\endgroup\$
    – Cyoce
    Commented Nov 27, 2016 at 2:51
  • 1
    \$\begingroup\$ @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. \$\endgroup\$ Commented Nov 27, 2016 at 4:05
3
\$\begingroup\$

Bash, 126 109 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 :).

\$\endgroup\$
2
3
\$\begingroup\$

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

\$\endgroup\$
3
\$\begingroup\$

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
\$\endgroup\$
3
\$\begingroup\$

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>");
\$\endgroup\$
1
3
\$\begingroup\$

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,'']

\$\endgroup\$
3
\$\begingroup\$

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
\$\endgroup\$
3
\$\begingroup\$

05AB1E, 9 bytes

žh¦η€ûû.c

Try it online!

\$\endgroup\$
3
\$\begingroup\$

Canvas, 7 bytes

9{R⇵]↶┼

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:

9{R]/┼

Try it here!

9{R]/┼
9{ ]    map over 1..9
  R       create a range 1..i
    /   pad with a diagonal of spaces
     ┼  and quad-palindromize
\$\endgroup\$
3
\$\begingroup\$

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!

\$\endgroup\$
2
  • \$\begingroup\$ 12 bytes \$\endgroup\$
    – Leaky Nun
    Commented Oct 21, 2017 at 20:22
  • 1
    \$\begingroup\$ 11 bytes \$\endgroup\$
    – Leaky Nun
    Commented Oct 21, 2017 at 20:33
3
\$\begingroup\$

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:

enter image description here

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
\$\endgroup\$
3
\$\begingroup\$

K (ngn/k), 24 bytes

`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)
\$\endgroup\$
3
\$\begingroup\$

Vyxal C, 7 bytes

9ɾKvṅʁ∞

Try it Online!

\$\endgroup\$
3
\$\begingroup\$

Bash, 65 bytes

for c in {1..9} {8..1};do printf %$[8+c]s\\n $[(10**c/9)**2];done

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ I want to upvote this more, for the cool math tricks \$\endgroup\$
    – roblogic
    Commented Jul 24, 2023 at 14:53
3
\$\begingroup\$

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!

\$\endgroup\$
3
\$\begingroup\$

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 
\$\endgroup\$
2
\$\begingroup\$

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
\$\endgroup\$
2
\$\begingroup\$

K, 59

-1'(-:'9+k,1_|k:!9)$,/'$b,1_||:'b:(-1_'a),'|:'a:1_1+!:'!10;
\$\endgroup\$
2
\$\begingroup\$

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""}
\$\endgroup\$
1
  • \$\begingroup\$ added a 57 char groovy solution. You can replace both each with any to save two chars. \$\endgroup\$ Commented Feb 12, 2017 at 10:52
2
\$\begingroup\$

Scala - 86 characters

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

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)
\$\endgroup\$
1
  • 1
    \$\begingroup\$ 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 \$\endgroup\$ Commented Jul 8, 2020 at 22:09
2
\$\begingroup\$

GolfScript (27 chars)

17,{8-abs' '*1`9*1$,>~.*n}/

or

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

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

\$\endgroup\$
2
\$\begingroup\$

APL (40)

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

I guess I'm not beating marinus. :p

\$\endgroup\$
2
\$\begingroup\$

PowerShell, 49 48

1..9+8..1|%{"  "*(9-$_)+(1..$_+($_-1)..0|?{$_})}
\$\endgroup\$
1
  • \$\begingroup\$ 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. \$\endgroup\$
    – Iszi
    Commented Nov 24, 2013 at 2:24
2
\$\begingroup\$

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        
\$\endgroup\$
1
  • 2
    \$\begingroup\$ Take the train to save a byte: (⍕>∘0↑⊢) \$\endgroup\$
    – Adám
    Commented Jul 11, 2016 at 6:03
2
\$\begingroup\$

Ruby 59

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

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.

\$\endgroup\$
2
\$\begingroup\$

///, 233 bytes

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

Try it online!

Yay.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ This is a polyglot. It should work in PHP, and some others also. \$\endgroup\$ Commented Feb 24, 2017 at 23:13
  • \$\begingroup\$ @NoOneIsHere Yay. \$\endgroup\$
    – sporkl
    Commented Feb 24, 2017 at 23:38
2
\$\begingroup\$

Deadfish, 1446 bytes

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
\$\endgroup\$
3
  • \$\begingroup\$ Any way to run this myself? \$\endgroup\$
    – Metoniem
    Commented Feb 13, 2017 at 12:26
  • \$\begingroup\$ esolangs.org/wiki/Deadfish has implementation for most of the common programming languages \$\endgroup\$
    – Uriel
    Commented Apr 3, 2017 at 21:51
  • \$\begingroup\$ Deadfish~ version. \$\endgroup\$
    – user85052
    Commented Oct 13, 2019 at 14:14
2
\$\begingroup\$

Matlab 227 223 221 209 208 bytes

z=@cellfun;
C=z(@(a,b,c)[a b c fliplr([a b])],[mat2cell(repelem(' ',36),1,8:-1:1),{''}],[{''},mat2cell(nonzeros(tril(repmat(49:56,8,1))')',1,1:8)],num2cell(49:57),'un',0)';
z(@(c)disp(c),[C;flipud(C(1:end-1))])
\$\endgroup\$
0

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.