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

88 Answers 88

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\$

PowerShell, 49 48

1..9+8..1|%{"  "*(9-$_)+(1..$_+($_-1)..0|?{$_})}
\$\endgroup\$
  • \$\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 Nov 24 '13 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
    \$\begingroup\$ Take the train to save a byte: (⍕>∘0↑⊢) \$\endgroup\$ – Adám Jul 11 '16 at 6:03
2
\$\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
\$\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\$
2
\$\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\$
2
\$\begingroup\$

PHP, 99 91 81 byte

for($y=17;$y--;print"
")for($x=17;$x--;)echo($d=9-abs($x-8)-abs($y-8))>0?$d:" ";

run in command line

php -r "CODE_ABOVE"

18 bytes saved by Jörg Hülsermann

\$\endgroup\$
  • \$\begingroup\$ you must not use open tags if you run PHP from the commndline with the -r option , replacing while with for loops and removing unnessaary spaces ends in Try it online! \$\endgroup\$ – Jörg Hülsermann Jul 4 '17 at 11:07
  • \$\begingroup\$ @JörgHülsermann It works in ubuntu, but not in tio.run Do you know why? \$\endgroup\$ – Евгений Новиков Jul 4 '17 at 11:44
  • \$\begingroup\$ I understand not really the question cause I have linked a working tio.run example. tio.run is not the same as the command line so you need not to use options \$\endgroup\$ – Jörg Hülsermann Jul 4 '17 at 11:56
  • \$\begingroup\$ @JörgHülsermann first i seen about r option. Second about for, new line and other hacks. In fact in tio don't support two line arguments \$\endgroup\$ – Евгений Новиков Jul 4 '17 at 12:01
  • \$\begingroup\$ You need no arguments or input in this case and the bytecount is 80 \$\endgroup\$ – Jörg Hülsermann Jul 4 '17 at 12:04
2
\$\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\$
2
\$\begingroup\$

Jelly,  22 18 12  11 bytes (non-competing)

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\$

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

05AB1E, 17 15 10 bytes

9LJ.pû€û.c

Try it online!

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

Perl 6, 42 41 38 35 chars

say " "x 9-$_,(1 x$_)²for 1…9…1

Try it online!

\$\endgroup\$
  • \$\begingroup\$ @FrownyFrog Something did change in Perl 6 since this was written (this is a very old answer), fixed. \$\endgroup\$ – Konrad Borowski Jul 27 '18 at 12:42
1
\$\begingroup\$

K, 59

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

Javascript - 118 chars

for(i=1,s=8,d=0;i>0;d?(i=(i-1)/10,s++):(i=i*10+1,s--)){for(d=d||i>11111111,p='',j=0;j++<=s;)p+=' ';console.log(p+i*i)}

Output:

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

Unfortunately, I'm also struggling with Javascripts precision problem with the last calculation of 111111111 * 111111111

\$\endgroup\$
  • \$\begingroup\$ There is a bug: The rightmost digit in the center line is 0 in your output. \$\endgroup\$ – Thomas W. Nov 19 '12 at 13:40
  • \$\begingroup\$ I know, that is the mentioned precision problem also appearing in Nippeys second solution - do you know a fix for this? \$\endgroup\$ – codeporn Nov 19 '12 at 13:53
  • \$\begingroup\$ Oh, sorry, I see. No idea how to fix it--at least nothing that wouldn't make the code significantly larger. \$\endgroup\$ – Thomas W. Nov 19 '12 at 14:44
  • \$\begingroup\$ I know, logically this answer is not correct as the output doesn't equal the target output even though its technical implementation should return the correct result. \$\endgroup\$ – codeporn Nov 19 '12 at 14:57
  • \$\begingroup\$ See joequncy answer below; codegolf.stackexchange.com/a/8742/7594 \$\endgroup\$ – Christian Mar 22 '13 at 4:38
1
\$\begingroup\$

Javascript 88

for(i=9,a=Math.abs;--i>-9;console.log(o))for(j=9,o='';j-->-9;)o+=(n=9-a(i)-a(j))>0?n:' '
\$\endgroup\$
1
\$\begingroup\$

Javascript, 129* 126

for(i=1;i<18;i++){s="";a=Math.abs(9-i);for(j=0;j<a;j++)s+=" ";for(k=a+1;k<=9;k++)s+=k-a;for(l=8;l>a;l--)s+=l-a;console.log(s)}

Includes suggestion from Shmiddty in comments. Original preserved below:

for(i=1;i<18;i++){s="";a=Math.abs(9-i);for(j=0;j<a;j++){s+=" "}for(k=a+1;k<=9;k++){s+=k-a}for(l=8;l>a;l--){s+=l-a}console.log(s)}

I'm sure this could be condensed further, but darned if I know how. :P

\$\endgroup\$
  • \$\begingroup\$ This gets the JS nod. It multiplies correctly. \$\endgroup\$ – Christian Mar 22 '13 at 4:37
  • 1
    \$\begingroup\$ Instead of wrapping your for loops in brackets, use a semicolon. eg: for(j=0;j<a;j++)s+=" ";for(k... \$\endgroup\$ – Shmiddty Mar 22 '13 at 18:59
  • \$\begingroup\$ Thank you for pointing that out, @Shmiddty. I've adjusted the snippet. \$\endgroup\$ – joequincy Mar 22 '13 at 21:56
1
\$\begingroup\$

APL (40)

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

I guess I'm not beating marinus. :p

\$\endgroup\$
1
\$\begingroup\$

C++ 223 Byte

#include <iostream>
using std::cout;using std::size_t;int main(){for(int a=0;a<2;++a)for(size_t b=1+a*7;b<10-a;((a!=1)?++b:--b)){size_t c=9-b;for(;c-->0;)cout<<" ";for(c=1;c<b;)cout<<c++;for(c=b;0<c;)cout<<c--;cout<<'\n';}}

Ungolfed:

#include <iostream>
using std::cout; //for not having to type std::cout over and over again
using std::size_t; //for not having to type std::size_t over and over again

int main()
{
    for(int a = 0; a < 2; ++a)
        for(size_t b=1+a*7; b<10-a; ((a!=1)?++b:--b))
        {     //either count up to nine or down from nine
            size_t c = 9-b; //space count we need
            for(; c-- > 0;)
                cout << " ";
            for(c = 1; c < b;) //set c to the counter that will be print
                cout << c++; //post-crement :)
            for(c = b; 0 < c;) //count backwards
                cout << c--; //post-decrement :)
            cout << '\n'; //line is done
        }
}
\$\endgroup\$
  • \$\begingroup\$ Explanation please? \$\endgroup\$ – Lucas Henrique Apr 12 '15 at 16:38
  • \$\begingroup\$ @LucasHenrique updated \$\endgroup\$ – NaCl Apr 12 '15 at 17:20
1
\$\begingroup\$

Ruby 59

(-8..8).map{|i|puts' '*i.abs+"#{eval [?1*(9-i.abs)]*2*?*}"}
\$\endgroup\$
1
\$\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\$
1
\$\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\$
1
\$\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\$
  • \$\begingroup\$ This is a polyglot. It should work in PHP, and some others also. \$\endgroup\$ – NoOneIsHere Feb 24 '17 at 23:13
  • \$\begingroup\$ @NoOneIsHere Yay. \$\endgroup\$ – Comrade SparklePony Feb 24 '17 at 23:38
1
\$\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\$
  • \$\begingroup\$ Any way to run this myself? \$\endgroup\$ – Metoniem Feb 13 '17 at 12:26
  • \$\begingroup\$ esolangs.org/wiki/Deadfish has implementation for most of the common programming languages \$\endgroup\$ – Uriel Apr 3 '17 at 21:51
  • \$\begingroup\$ Deadfish~ version. \$\endgroup\$ – a'_' Oct 13 '19 at 14:14
1
\$\begingroup\$

k, 37 bytes

r:{x,1_|x};`0:`c$r@r'|8{32,-1_x}\49+!9

Try it online.

\$\endgroup\$
1
\$\begingroup\$

Recursiva, 31 22 bytes

{pB9'P+*" "- 9}J""WpB}

Try it online!

Explanation:

{pB9'P+*" "- 9}J""WpB}
{                       - For each
 p                      - palindromize [1,2,..9,..1]
  B9                    - range [1,2...9] 
    '                   - Iteration command begin
     P                  - Print
      +                 - concatenate
       *" "- 9 }        - appropriate number of spaces
                J""WpB} - obtain number string
                J""     - Join with nothing '123454321'
                   W    - map each element as string ['1','2'..'5','2','1']
                    p   - palindromize [1,2,..5,..2,1]
                     B} - range [1,2,3,4,5] 
\$\endgroup\$
1
\$\begingroup\$

APL (Dyalog Classic), 21 bytes

{⊃⍵/⍕⍵}¨9-+/↑|8-⍳2⍴17

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Python 2, 72 bytes

z="123456789"
for i in range(9)+range(8)[::-1]:print"% 8s"%z[:i]+z[i::-1]

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Welcome to the site! I've edited in a link to an interpreter, so that others can test your solution \$\endgroup\$ – caird coinheringaahing Apr 5 '18 at 16:41
1
\$\begingroup\$

T-SQL, 116 115 bytes

DECLARE @ INT=8,@d INT=-1a:PRINT SPACE(@)+STUFF('12345678987654321',9-@,2*@,'')IF @=0SET @d=1SET @+=@d If @<9GOTO a

Pure procedural counter and loop, not very "SQL"-like, but the best I could come up with using what SQL offers. Formatted:

DECLARE @ INT=8, @d INT=-1
a:
    PRINT SPACE(@)+STUFF('12345678987654321',9-@,2*@,'')
    IF @=0 SET @d=1
    SET @+=@d
If @<9 GOTO a

Cuts a length out of a hard-coded string using STUFF. Would work just as easily with any other set of characters.

\$\endgroup\$
  • \$\begingroup\$ You can replace 10 with 9 and we get the same result (but saving 1 byte). \$\endgroup\$ – Razvan Socol Apr 6 '18 at 19:58
1
\$\begingroup\$

Stax, 10 bytes

▌┼î▲░ò╝╪.¢

Run and debug it

\$\endgroup\$
1
\$\begingroup\$

brainfuck, 158 154 bytes

++++++++[->+>++++>+>++++++<<<<]>>>++<<+[-[-<+>>.<]<[->+<]>>>>+>[->+<<.+>]>+[-<+<.->>]<<<.<<]>>>>-[<<<<+[-<+>>.<]<[->+<]>>>>>[->+<<+.>]>-[-<+<-.>>]<<-<.>>]

Try it online!

[spaceMem, spaceCount, space, lf, "0", numCount, numMem]
++++++++[->+>++++>+>++++++<<<<]>>>++<<+
[ for spaceCount
    -[- for spaceCount minus 1
        <+ inc spaceMem
        >>. print space
        < go to spaceCount
    ] 
    <[->+<]> fetch spaceCount from spaceMem
    >>>+ inc number
    >[- for numCount
        >+  inc numMem
        <<.+ print and inc number
        >   go to numCount
    ]
    >+[- for numMem plus 1
        <+ inc numCount
        <.- print and decrement number
        >>  go to numMem
    ]
    <<<. print lf
    <<      go to spaceCount
]
>>>>-[      for numCount
    <<<<+[- for spaceCount plus 1
        <+ inc spaceMem
        >>. print space
        < go to spaceCount
    ] 
        <[->+<]> fetch spaceCount from spaceMem
    >>> inc number
    >[- for numCount
        >+  inc numMem
        <<+. print and inc number
        >   go to numCount
    ]
    >-[- for numMem minus 1
        <+ inc numCount
        <-. print and decrement number
        >>  go to numMem
    ]
    <<-     decrement number
    <. print lf
    >> go to numCount
]
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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