Multiplication tables

From Rosetta Code
Task
Multiplication tables
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Produce a formatted   12×12   multiplication table of the kind memorized by rote when in primary (or elementary) school.


Only print the top half triangle of products.

11l

Translation of: C
V n = 12
L(j) 1..n
   print(‘#3’.format(j), end' ‘ ’)
print(‘│’)
L 1..n
   print(‘────’, end' ‘’)
print(‘┼───’)

L(i) 1..n
   L(j) 1..n
      print(I j < i {‘    ’} E ‘#3 ’.format(i * j), end' ‘’)
   print(‘│ ’i)
Output:
  1   2   3   4   5   6   7   8   9  10  11  12 │
────────────────────────────────────────────────┼───
  1   2   3   4   5   6   7   8   9  10  11  12 │ 1
      4   6   8  10  12  14  16  18  20  22  24 │ 2
          9  12  15  18  21  24  27  30  33  36 │ 3
             16  20  24  28  32  36  40  44  48 │ 4
                 25  30  35  40  45  50  55  60 │ 5
                     36  42  48  54  60  66  72 │ 6
                         49  56  63  70  77  84 │ 7
                             64  72  80  88  96 │ 8
                                 81  90  99 108 │ 9
                                    100 110 120 │ 10
                                        121 132 │ 11
                                            144 │ 12

360 Assembly

*        12*12 multiplication table    14/08/2015
MULTTABL CSECT
         USING  MULTTABL,R12
         LR     R12,R15
         LA     R10,0              buffer pointer
         LA     R3,BUFFER
         MVC    0(4,R3),=C'  | '
         LA     R10,4(R10)
         LA     R5,12
         LA     R4,1               i=1
LOOPN    LA     R3,BUFFER          do i=1 to 12
         AR     R3,R10
         XDECO  R4,XDEC            i
         MVC    0(4,R3),XDEC+8     output i
         LA     R10,4(R10)
         LA     R4,1(R4)
         BCT    R5,LOOPN           end i
         XPRNT  BUFFER,52
         XPRNT  PORT,52            border
         LA     R5,12
         LA     R4,1               i=1 (R4)
LOOPI    LA     R10,0              do i=1 to 12
         MVC    BUFFER,=CL52' '
         LA     R3,BUFFER
         AR     R3,R10
         XDECO  R4,XDEC
         MVC    0(2,R3),XDEC+10
         LA     R10,2(R10)
         LA     R3,BUFFER
         AR     R3,R10
         MVC    0(2,R3),=C'| '
         LA     R10,2(R10)
         LA     R7,12
         LA     R6,1               j=1 (R6)
LOOPJ    CR     R6,R4              do j=1 to 12
         BNL    MULT
         LA     R3,BUFFER
         AR     R3,R10
         MVC    0(4,R3),=C'    '
         LA     R10,4(R10)
         B      NEXTJ
MULT     LR     R9,R4              i
         MR     R8,R6              i*j in R8R9
         LA     R3,BUFFER
         AR     R3,R10
         XDECO  R9,XDEC
         MVC    0(4,R3),XDEC+8
         LA     R10,4(R10)
NEXTJ    LA     R6,1(R6)
         BCT    R7,LOOPJ           end j
ELOOPJ   XPRNT  BUFFER,52
         LA     R4,1(R4)
         BCT    R5,LOOPI           end i
ELOOPI   XR     R15,R15
         BR     R14
BUFFER   DC     CL52' '
XDEC     DS     CL12
PORT     DC     C'--+-------------------------------------------------'
         YREGS
         END    MULTTABL
Output:
  |    1   2   3   4   5   6   7   8   9  10  11  12
--+-------------------------------------------------
 1|    1   2   3   4   5   6   7   8   9  10  11  12
 2|        4   6   8  10  12  14  16  18  20  22  24
 3|            9  12  15  18  21  24  27  30  33  36
 4|               16  20  24  28  32  36  40  44  48
 5|                   25  30  35  40  45  50  55  60
 6|                       36  42  48  54  60  66  72
 7|                           49  56  63  70  77  84
 8|                               64  72  80  88  96
 9|                                   81  90  99 108
10|                                      100 110 120
11|                                          121 132
12|                                              144

8080 Assembly

	org	100h
	lxi	h,output
	;;;	Make the header 
	call	skip	; Four spaces,
	mvi	m,'|'	; separator,
	inx	h
	lxi	d,0C01h	; 12 fields starting at 1
fnum:	mov	a,e	; Field number
	call	num
	inr	e
	dcr 	d	; If not 12 yet, next field number
	jnz	fnum
	call	nl	; Newline
	mvi	a,'-'	; Four dashes,
	mvi	b,4
	call	bchr
	mvi	m,'+'	; Plus,
	inx	h
	mvi	b,12*4	; and 12*4 more dashes
	call	bchr
	call	nl	; Newline
	;;;	Write the 12 lines
	mvi	d,1	; Start at line 1,
line:	mov	a,d	; Add the line number
	call	num
	mvi	m,'|'	; separator
	inx	h
	mvi	e,1	; Start at column 1
	mvi	c,0	; Cumulative sum at C
field:	mov	a,c	; Add line number giving next column
	add	d
	mov	c,a
	mov	a,e	; If column >= line, we need to print
	cmp	d
	mov	a,c	; the current total
	cc	skip	; skip field if column >= line
	cnc	num	; print field if column < line
	inr	e	; next column
	mov	a,e
	cpi	13	; column 13?
	jnz	field	; If not, next field on line
	call 	nl	; But if so, add newline
	inr	d	; next line
	mov	a,d
	cpi	13	; line 13?
	jnz	line	; If not, next line
	mvi	m,'$'	; Write a CP/M string terminator,
	mvi	c,9	; And use CP/M to print the string
	lxi	d,output
	jmp	5
	;;;	Add the character in A to the string at HL, B times
bchr:	mov	m,a
	inx	h
	dcr	b
	jnz	bchr
	ret
	;;;	Add newline to string at HL
nl:	mvi	m,13	; CR
	inx	h
	mvi	m,10	; LF
	inx	h
	ret
	;;;	Add four spaces to string at HL (skip field)
skip:	mvi	b,' '
	mov	m,b
	inx	h
	mov	m,b
	inx	h
	mov	m,b
	inx	h
	mov	m,b
	inx	h
	ret
	;;;	Add 3-digit number in A to string at HL
num:	mvi	m,' '	; Separator space
	inx	h
	ana	a	; Clear carry
	mvi	b,100	; 100s digit
	call	dspc
	mvi	b,10	; 10s digit
	call	dspc
	mvi	b,1	; 1s digit
dspc:	jc	dgt	; If carry, we need a digit		
	cmp	b	; >= digit?
	jnc	dgt	; If not, we need a digit
	mvi	m,' '	; Otherwise, fill with space
	inx	h
	cmc		; Return with carry off
	ret
dgt:	mvi	m,'0'-1	; Calculate digit
dloop:	inr	m	; Increment digit
	sub	b	; while B can be subtracted
	jnc	dloop
	add	b
	inx	h
	ret
output:	equ	$
Output:
    |   1   2   3   4   5   6   7   8   9  10  11  12
----+------------------------------------------------
   1|   1   2   3   4   5   6   7   8   9  10  11  12
   2|       4   6   8  10  12  14  16  18  20  22  24
   3|           9  12  15  18  21  24  27  30  33  36
   4|              16  20  24  28  32  36  40  44  48
   5|                  25  30  35  40  45  50  55  60
   6|                      36  42  48  54  60  66  72
   7|                          49  56  63  70  77  84
   8|                              64  72  80  88  96
   9|                                  81  90  99 108
  10|                                     100 110 120
  11|                                         121 132
  12|                                             144

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program multtable64.s   */

/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ MAXI,   12
/*********************************/
/* Initialized data              */
/*********************************/
.data
sMessValeur:        .fill 11, 1, ' '            // size => 11
szCarriageReturn:   .asciz "\n"
sBlanc1:            .asciz " "
sBlanc2:            .asciz "  "
sBlanc3:            .asciz "   "
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss  
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                           // entry of program 
    ldr x6,qAdrsBlanc1 
    ldr x7,qAdrsBlanc2
    ldr x8,qAdrsBlanc3
                                // display first line
    mov x4,#0
1:                              // begin loop
    mov x0,x4
    ldr x1,qAdrsMessValeur      // display value
    bl conversion10             // call function
    strb wzr,[x1,x0]            // final zéro on display value
    ldr x0,qAdrsMessValeur
    bl affichageMess            // display message
    cmp x4,#10                  // one or two digit in résult
    csel x0,x7,x8,ge            // display 2 or 3 spaces
    bl affichageMess            // display message
    add x4,x4,1                 // increment counter
    cmp x4,MAXI
    ble 1b                      // loop
    ldr x0,qAdrszCarriageReturn   
    bl affichageMess            // display carriage return

    mov x5,#1                   // line counter
2:                              // begin loop lines
    mov x0,x5                   // display column 1 with N° line
    ldr x1,qAdrsMessValeur      // display value
    bl conversion10             // call function
    strb wzr,[x1,x0]            // final zéro
    ldr x0,qAdrsMessValeur
    bl affichageMess            // display message
    cmp x5,#10                  // one or two digit in N° line
    csel x0,x7,x8,ge            // display 2 or 3 spaces
    bl affichageMess  
    mov x4,#1                  // counter column
3:                             // begin loop columns
    mul x0,x4,x5               // multiplication
    mov x3,x0                  // save résult
    ldr x1,qAdrsMessValeur     // display value
    bl conversion10            // call function
    strb wzr,[x1,x0]
    ldr x0,qAdrsMessValeur
    bl affichageMess           // display message
    cmp x3,100                 // 3 digits in résult ?
    csel x0,x6,x0,ge           // display 1 spaces
    bge 4f
    cmp x3,10                  // 2 digits in result
    csel x0,x7,x8,ge           // display 2 or 3 spaces

4:
    bl affichageMess           // display message
    add x4,x4,1                // increment counter column
    cmp x4,x5                  // < counter lines
    ble 3b                     // loop
    ldr x0,qAdrszCarriageReturn  
    bl affichageMess           // display carriage return
    add x5,x5,1                // increment line counter
    cmp x5,MAXI                // MAXI ?
    ble 2b                     // loop

100:                           // standard end of the program 
    mov x0,0                   // return code
    mov x8,EXIT                // request to exit program
    svc 0                      // perform the system call

qAdrsMessValeur:         .quad sMessValeur
qAdrszCarriageReturn:    .quad szCarriageReturn
qAdrsBlanc1:             .quad sBlanc1
qAdrsBlanc2:             .quad sBlanc2
qAdrsBlanc3:             .quad sBlanc3

/******************************************************************/
/*     Converting a register to a decimal unsigned                */ 
/******************************************************************/
/* x0 contains value and x1 address area   */
/* x0 return size of result (no zero final in area) */
/* area size => 11 bytes          */
.equ LGZONECAL,   10
conversion10:
    stp x1,lr,[sp,-16]!            // save  registers
    stp x2,x3,[sp,-16]!            // save  registers
    stp x4,x5,[sp,-16]!            // save  registers
    mov x3,x1
    mov x2,#LGZONECAL
    mov x4,10
1:                                 // start loop
    mov x5,x0
    udiv x0,x5,x4
    msub x1,x0,x4,x5               //  x5 <- dividende. quotient ->x0 reste -> x1
    add x1,x1,48                      // digit    
    strb w1,[x3,x2]                // store digit on area
    cbz x0,2f                      // stop if quotient = 0
    sub x2,x2,1                    // else previous position
    b 1b                           // and loop
                                   // and move digit from left of area
2:
    mov x4,0
3:
    ldrb w1,[x3,x2]
    strb w1,[x3,x4]
    add x2,x2,1
    add x4,x4,1
    cmp x2,LGZONECAL
    ble 3b
                                  // and move spaces in end on area
    mov x0,x4                     // result length
    mov x1,' '                    // space
4:
    strb w1,[x3,x4]               // store space in area
    add x4,x4,1                   // next position
    cmp x4,LGZONECAL
    ble 4b                        // loop if x4 <= area size

100:
    ldp x4,x5,[sp],16                     // restaur  2 registers
    ldp x2,x3,[sp],16                     // restaur  2 registers
    ldp x1,lr,[sp],16                     // restaur  2 registers
    ret                                   // return to address lr x30
/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
Output:
0   1   2   3   4   5   6   7   8   9   10  11  12
1   1
2   2   4
3   3   6   9
4   4   8   12  16
5   5   10  15  20  25
6   6   12  18  24  30  36
7   7   14  21  28  35  42  49
8   8   16  24  32  40  48  56  64
9   9   18  27  36  45  54  63  72  81
10  10  20  30  40  50  60  70  80  90  100
11  11  22  33  44  55  66  77  88  99  110 121
12  12  24  36  48  60  72  84  96  108 120 132 144

Action!

PROC PrintRight(BYTE num,size)
  BYTE i

  IF num<10 THEN
    size==-1
  ELSEIF num<100 THEN
    size==-2
  ELSE
    size==-3
  FI
  FOR i=1 TO size
  DO
    Put(' )
  OD
  PrintB(num)
RETURN

PROC Main()
  BYTE ARRAY colw=[1 1 1 2 2 2 2 2 2 3 3 3]
  BYTE i,j,x,w

  ;clear screen
  Put(125)

  ;draw frame
  Position(1,3)
  FOR i=1 TO 38
  DO Put($12) OD

  FOR j=2 TO 15
  DO
    Position(36,j)
    Put($7C)
  OD

  Position(36,3)
  Put($13)

  ;draw numbers
  FOR j=1 TO 12
  DO
    x=1
    FOR i=1 TO 12
    DO
      w=colw(i-1)
      IF i>=j THEN
        IF j=1 THEN
          Position(x,j+1)
          PrintRight(i*j,w)
        FI
        IF i=12 THEN
          Position(37,j+3)
          PrintRight(j,2)
        FI
        Position(x,j+3)
        PrintRight(i*j,w)
      FI
      x==+w+1
    OD
  OD
RETURN
Output:

Screenshot from Atari 8-bit computer

1 2 3  4  5  6  7  8  9  10  11  12│
───────────────────────────────────┼──
1 2 3  4  5  6  7  8  9  10  11  12│ 1
  4 6  8 10 12 14 16 18  20  22  24│ 2
    9 12 15 18 21 24 27  30  33  36│ 3
      16 20 24 28 32 36  40  44  48│ 4
         25 30 35 40 45  50  55  60│ 5
            36 42 48 54  60  66  72│ 6
               49 56 63  70  77  84│ 7
                  64 72  80  88  96│ 8
                     81  90  99 108│ 9
                        100 110 120│10
                            121 132│11
                                144│12

ActionScript

package {
    
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;
    import flash.text.TextFormat;
    
    [SWF (width = 550, height = 550)]
    public class MultiplicationTable extends Sprite {
        
        public function MultiplicationTable() {
            if ( stage ) _init();
            else addEventListener(Event.ADDED_TO_STAGE, _init);
        }
        
        private function _init(e:Event = null):void {
            
            removeEventListener(Event.ADDED_TO_STAGE, _init);
            
            var format:TextFormat = new TextFormat();
            format.size = 15;
            var blockSize:uint = 40;
            var max:uint = 12;
            
            var i:uint, j:uint;
            var tf:TextField;
            
            for ( i = 1; i <= max; i++ ) {
                tf = new TextField();
                tf.defaultTextFormat = format;
                tf.x = blockSize * i;
                tf.y = 0;
                tf.width = tf.height = blockSize;
                tf.autoSize = TextFieldAutoSize.CENTER;
                tf.text = String(i);
                addChild(tf);
                
                tf = new TextField();
                tf.defaultTextFormat = format;
                tf.x = 0;
                tf.y = blockSize * i;
                tf.width = tf.height = blockSize;
                tf.autoSize = TextFieldAutoSize.CENTER;
                tf.text = String(i);
                addChild(tf);
            }
            
            var yOffset:Number = tf.textHeight / 2;
            y += yOffset;
            
            graphics.lineStyle(1, 0x000000);
            graphics.moveTo(blockSize, -yOffset);
            graphics.lineTo(blockSize, (blockSize * (max + 1)) - yOffset);
            graphics.moveTo(0, blockSize - yOffset);
            graphics.lineTo(blockSize * (max + 1), blockSize - yOffset);
            
            
            for ( i = 1; i <= max; i++ ) {
                for ( j = 1; j <= max; j++ ) {
                    if ( j > i )
                        continue;
                        
                    tf = new TextField();
                    tf.defaultTextFormat = format;
                    tf.x = blockSize * i;
                    tf.y = blockSize * j;
                    tf.width = tf.height = blockSize;
                    tf.autoSize = TextFieldAutoSize.CENTER;
                    tf.text = String(i * j);
                    addChild(tf);
                }
            }
            
        }
        
    }

}

Ada

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Fixed;  use Ada.Strings.Fixed;
procedure Multiplication_Table is
   package IO is new Integer_IO (Integer);
   use IO;
begin
   Put ("  | ");
   for Row in 1..12 loop
      Put (Row, Width => 4);
   end loop;
   New_Line;
   Put_Line ("--+-" & 12 * 4 * '-');
   for Row in 1..12 loop
      Put (Row, Width => 2);
      Put ("| ");
      for Column in 1..12 loop
         if Column < Row then
            Put ("    ");
         else
            Put (Row * Column, Width => 4);
         end if;
      end loop;
      New_Line;
   end loop;
end Multiplication_Table;
  |    1   2   3   4   5   6   7   8   9  10  11  12
--+-------------------------------------------------
 1|    1   2   3   4   5   6   7   8   9  10  11  12
 2|        4   6   8  10  12  14  16  18  20  22  24
 3|            9  12  15  18  21  24  27  30  33  36
 4|               16  20  24  28  32  36  40  44  48
 5|                   25  30  35  40  45  50  55  60
 6|                       36  42  48  54  60  66  72
 7|                           49  56  63  70  77  84
 8|                               64  72  80  88  96
 9|                                   81  90  99 108
10|                                      100 110 120
11|                                          121 132
12|                                              144

Agena

Translation of: ALGOL_W
scope
    # print a school style multiplication table
    # NB: print outputs a newline at the end, write and printf do not
    write( "    " );
    for i to 12 do printf( " %3d", i ) od;
    printf( "\n   +" );
    for i to 12 do write( "----" ) od;
    for i to 12 do
        printf( "\n%3d|", i );
        for j        to i - 1 do write(  "    "        ) od;
        for j from i to 12    do printf( " %3d", i * j ) od;
    od;
    print()
epocs
Output:
       1   2   3   4   5   6   7   8   9  10  11  12
   +------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

ALGOL 68

Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
main:(
  INT max = 12;
  INT width = ENTIER(log(max)*2)+1;
  STRING empty = " "*width, sep="|", hr = "+" + (max+1)*(width*"-"+"+");
  FORMAT ifmt = $g(-width)"|"$; # remove leading zeros #

  printf(($gl$, hr));
  print(sep + IF width<2 THEN "x" ELSE " "*(width-2)+"x " FI + sep);
  FOR col TO max DO printf((ifmt, col)) OD;
  printf(($lgl$, hr));

  FOR row TO max DO
    [row:max]INT product;
    FOR col FROM row TO max DO product[col]:=row*col OD;
    STRING prefix=(empty+sep)*(row-1);
    printf(($g$, sep, ifmt, row, $g$, prefix, ifmt, product, $l$))
  OD;
  printf(($gl$, hr))
)
Output:
+---+---+---+---+---+---+---+---+---+---+---+---+---+
| x |  1|  2|  3|  4|  5|  6|  7|  8|  9| 10| 11| 12|
+---+---+---+---+---+---+---+---+---+---+---+---+---+
|  1|  1|  2|  3|  4|  5|  6|  7|  8|  9| 10| 11| 12|
|  2|   |  4|  6|  8| 10| 12| 14| 16| 18| 20| 22| 24|
|  3|   |   |  9| 12| 15| 18| 21| 24| 27| 30| 33| 36|
|  4|   |   |   | 16| 20| 24| 28| 32| 36| 40| 44| 48|
|  5|   |   |   |   | 25| 30| 35| 40| 45| 50| 55| 60|
|  6|   |   |   |   |   | 36| 42| 48| 54| 60| 66| 72|
|  7|   |   |   |   |   |   | 49| 56| 63| 70| 77| 84|
|  8|   |   |   |   |   |   |   | 64| 72| 80| 88| 96|
|  9|   |   |   |   |   |   |   |   | 81| 90| 99|108|
| 10|   |   |   |   |   |   |   |   |   |100|110|120|
| 11|   |   |   |   |   |   |   |   |   |   |121|132|
| 12|   |   |   |   |   |   |   |   |   |   |   |144|
+---+---+---+---+---+---+---+---+---+---+---+---+---+

ALGOL W

begin
    % print a school style multiplication table                              %
    i_w := 3; s_w := 0; % set output formating                               %
    write( "    " );
    for i := 1 until 12 do writeon( " ", i );
    write( "   +" );
    for i := 1 until 12 do writeon( "----" );
    for i := 1 until 12 do begin
        write( i, "|" );
        for j := 1 until i - 1 do writeon( "    " );
        for j := i until 12    do writeon( " ", i * j );
    end;

end.
Output:
       1   2   3   4   5   6   7   8   9  10  11  12
   +------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

APL

A simple table is trivial:

(12)∘.×⍳12

But that prints out all the duplicated results across the diagonal:

Output:
 1  2  3  4  5  6  7  8   9  10  11  12
 2  4  6  8 10 12 14 16  18  20  22  24
 3  6  9 12 15 18 21 24  27  30  33  36
 4  8 12 16 20 24 28 32  36  40  44  48
 5 10 15 20 25 30 35 40  45  50  55  60
 6 12 18 24 30 36 42 48  54  60  66  72
 7 14 21 28 35 42 49 56  63  70  77  84
 8 16 24 32 40 48 56 64  72  80  88  96
 9 18 27 36 45 54 63 72  81  90  99 108
10 20 30 40 50 60 70 80  90 100 110 120
11 22 33 44 55 66 77 88  99 110 121 132
12 24 36 48 60 72 84 96 108 120 132 144

Getting just the top half, and some labels, requires a bit more work. Text alignment varies with implementation so the numbers will need some tweaking:

Works with: Dyalog APL
('   ×',2' '),4 0⍕⍳12{((4 0),⊂1(4×(-1))' '),4 0(-1)(×⍳12)}¨12
Works with: GNU APL

After printing the table, GNU APL will will output the value of the expression that produced it, so in addition to adjusting the header spacing this solution uses ⍬⊣ to throw that value away.

('    ×',4' '),4 0⍕⍳12{((4 0),⊂1(4×(-1))' '),4 0(-1)(×⍳12)}¨12
Output:
   ×     1   2   3   4   5   6   7   8   9  10  11  12
   1     1   2   3   4   5   6   7   8   9  10  11  12
   2         4   6   8  10  12  14  16  18  20  22  24
   3             9  12  15  18  21  24  27  30  33  36
   4                16  20  24  28  32  36  40  44  48
   5                    25  30  35  40  45  50  55  60
   6                        36  42  48  54  60  66  72
   7                            49  56  63  70  77  84
   8                                64  72  80  88  96
   9                                    81  90  99 108
  10                                       100 110 120
  11                                           121 132
  12                                               144

AppleScript

Iteration

set n to 12 -- Size of table.
repeat with x from 0 to n
    if x = 0 then set {table, x} to {{return}, -1}
    repeat with y from 0 to n
        if y's contents = 0 then
            if x > 0 then set row to {f(x)}
            if x = -1 then set {row, x} to {{f("x")}, 1}
        else
            if y  x then set end of row to f(x * y)
            if y < x then set end of row to f("")
        end if
    end repeat
    set end of table to row & return
end repeat
return table as string

-- Handler/Function for formatting fixed width integer string.
on f(x)
    set text item delimiters to ""
    return (characters -4 thru -1 of ("    " & x)) as string
end f
Output:
"
   x   1   2   3   4   5   6   7   8   9  10  11  12
   1   1   2   3   4   5   6   7   8   9  10  11  12
   2       4   6   8  10  12  14  16  18  20  22  24
   3           9  12  15  18  21  24  27  30  33  36
   4              16  20  24  28  32  36  40  44  48
   5                  25  30  35  40  45  50  55  60
   6                      36  42  48  54  60  66  72
   7                          49  56  63  70  77  84
   8                              64  72  80  88  96
   9                                  81  90  99 108
  10                                     100 110 120
  11                                         121 132
  12                                             144
"

Functional composition

As an alternative to iteration, we could also write the top level more declaratively, composing a solution from a set of generic functions.

Translation of: JavaScript
(ES5 functional version)
------------------- MULTIPLICATION TABLE -----------------

-- multiplicationTable :: Int -> Int -> String
on multiplicationTable(lower, upper)
    tell ap(my tableText, my mulTable)
        |λ|(enumFromTo(lower, upper))
    end tell
end multiplicationTable


-- mulTable :: [Int]-> [[Int]]
on mulTable(axis)
    
    script column
        on |λ|(x)
            script row
                on |λ|(y)
                    if y < x then
                        {}
                    else
                        {x * y}
                    end if
                end |λ|
            end script
            
            {{x} & map(row, axis)}
        end |λ|
    end script
    
    concatMap(column, axis)
end mulTable


-- tableText :: [[Int]] -> String
on tableText(axis, rows)
    
    set colWidth to 1 + (length of (|last|(|last|(rows)) as string))
    set cell to replicate(colWidth, space)
    
    script tableLine
        on |λ|(xys)
            script tableCell
                on |λ|(int)
                    (characters (-colWidth) thru -1 of (cell & int)) as string
                end |λ|
            end script
            
            intercalate(space, map(tableCell, xys))
        end |λ|
    end script
    
    set legend to {{"x"} & axis}
    intercalate(linefeed, map(tableLine, legend & {{}} & rows))
    
end tableText

--------------------------- TEST -------------------------
on run
    multiplicationTable(1, 12) & linefeed & linefeed & ¬
        multiplicationTable(30, 40)
end run


-------------------- GENERIC FUNCTIONS -------------------

-- ap :: (a -> b -> c) -> (a -> b) -> a -> c
on ap(f, g)
    -- The application of f x to g x
    script go
        property mf : |λ| of mReturn(f)
        property mg : |λ| of mReturn(g)
        on |λ|(x)
            mf(x, mg(x))
        end |λ|
    end script
end ap


-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
    set lst to {}
    set lng to length of xs
    tell mReturn(f)
        repeat with i from 1 to lng
            set lst to (lst & |λ|(item i of xs, i, xs))
        end repeat
    end tell
    return lst
end concatMap


-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
    if m > n then
        set d to -1
    else
        set d to 1
    end if
    set lst to {}
    repeat with i from m to n by d
        set end of lst to i
    end repeat
    return lst
end enumFromTo


-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from 1 to lng
            set v to |λ|(v, item i of xs, i, xs)
        end repeat
        return v
    end tell
end foldl


-- intercalate :: Text -> [Text] -> Text
on intercalate(strText, lstText)
    set {dlm, my text item delimiters} to {my text item delimiters, strText}
    set strJoined to lstText as text
    set my text item delimiters to dlm
    return strJoined
end intercalate


-- justifyRight :: Int -> Char -> Text -> Text
on justifyRight(n, cFiller, strText)
    if n > length of strText then
        text -n thru -1 of ((replicate(n, cFiller) as text) & strText)
    else
        strText
    end if
end justifyRight


-- last :: [a] -> a
on |last|(xs)
    item -1 of xs
end |last|


-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to |λ|(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map


-- Lift 2nd class handler function into 1st class script wrapper 
-- mReturn :: Handler -> Script
on mReturn(f)
    if class of f is script then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn


-- replicate :: Int -> String -> String
on replicate(n, s)
    set out to ""
    if n < 1 then return out
    set dbl to s
    
    repeat while (n > 1)
        if (n mod 2) > 0 then set out to out & dbl
        set n to (n div 2)
        set dbl to (dbl & dbl)
    end repeat
    return out & dbl
end replicate
Output:
   x    1    2    3    4    5    6    7    8    9   10   11   12

   1    1    2    3    4    5    6    7    8    9   10   11   12
   2         4    6    8   10   12   14   16   18   20   22   24
   3              9   12   15   18   21   24   27   30   33   36
   4                  16   20   24   28   32   36   40   44   48
   5                       25   30   35   40   45   50   55   60
   6                            36   42   48   54   60   66   72
   7                                 49   56   63   70   77   84
   8                                      64   72   80   88   96
   9                                           81   90   99  108
  10                                               100  110  120
  11                                                    121  132
  12                                                         144

    x    30    31    32    33    34    35    36    37    38    39    40

   30   900   930   960   990  1020  1050  1080  1110  1140  1170  1200
   31         961   992  1023  1054  1085  1116  1147  1178  1209  1240
   32              1024  1056  1088  1120  1152  1184  1216  1248  1280
   33                    1089  1122  1155  1188  1221  1254  1287  1320
   34                          1156  1190  1224  1258  1292  1326  1360
   35                                1225  1260  1295  1330  1365  1400
   36                                      1296  1332  1368  1404  1440
   37                                            1369  1406  1443  1480
   38                                                  1444  1482  1520
   39                                                        1521  1560
   40                                                              1600

ARM Assembly

Works with: as version Raspberry Pi
/* ARM assembly Raspberry PI  */
/*  program multtable.s   */

/************************************/
/* Constantes                       */
/************************************/
.equ STDOUT, 1     @ Linux output console
.equ EXIT,   1     @ Linux syscall
.equ WRITE,  4     @ Linux syscall
.equ MAXI,   12
/*********************************/
/* Initialized data              */
/*********************************/
.data
sMessValeur:       .fill 11, 1, ' '            @ size => 11
szCarriageReturn: .asciz "\n"
sBlanc1:            .asciz " "
sBlanc2:            .asciz "  "
sBlanc3:            .asciz "   "
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss  
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                @ entry of program 
    push {fp,lr}      @ saves 2 registers 
    @ display first line
    mov r4,#0
1:    @ begin loop
    mov r0,r4
    ldr r1,iAdrsMessValeur     @ display value
    bl conversion10             @ call function
    mov r2,#0                      @ final zéro
    strb r2,[r1,r0]               @ on display value
    ldr r0,iAdrsMessValeur
    bl affichageMess            @ display message
    cmp r4,#10                     @ one or two digit in résult
    ldrgt r0,iAdrsBlanc2       @ two  display two spaces
    ldrle r0,iAdrsBlanc3       @ one  display 3 spaces
    bl affichageMess            @ display message
    add r4,#1                      @ increment counter
    cmp r4,#MAXI
    ble 1b                       @ loop
    ldr r0,iAdrszCarriageReturn   
    bl affichageMess            @ display carriage return

    mov r5,#1                   @ line counter
2:    @ begin loop lines
    mov r0,r5                      @ display column 1 with N° line
    ldr r1,iAdrsMessValeur     @ display value
    bl conversion10             @ call function
    mov r2,#0                      @ final zéro
    strb r2,[r1,r0]
    ldr r0,iAdrsMessValeur
    bl affichageMess            @ display message
    cmp r5,#10                      @ one or two digit in N° line
    ldrge r0,iAdrsBlanc2
    ldrlt r0,iAdrsBlanc3
    bl affichageMess  
    mov r4,#1                     @ counter column
3:  @ begin loop columns
    mul r0,r4,r5                   @ multiplication
    mov r3,r0                      @ save résult
    ldr r1,iAdrsMessValeur     @ display value
    bl conversion10             @ call function
    mov r2,#0
    strb r2,[r1,r0]
    ldr r0,iAdrsMessValeur
    bl affichageMess            @ display message
    cmp r3,#100                    @ 3 digits in résult ?
    ldrge r0,iAdrsBlanc1       @ yes, display one space
    bge 4f
    cmp r3,#10                     @ 2 digits in result
    ldrge r0,iAdrsBlanc2       @ yes display 2 spaces
    ldrlt r0,iAdrsBlanc3       @ no  display 3 spaces
4:
    bl affichageMess            @ display message
    add r4,#1                      @ increment counter column
    cmp r4,r5                      @ < counter lines
    ble 3b                        @ loop
    ldr r0,iAdrszCarriageReturn  
    bl affichageMess            @ display carriage return
    add r5,#1                      @ increment line counter
    cmp r5,#MAXI                  @ MAXI ?
    ble 2b                        @ loop

100:   @ standard end of the program 
    mov r0, #0                  @ return code
    pop {fp,lr}                 @restaur 2 registers
    mov r7, #EXIT              @ request to exit program
    svc #0                       @ perform the system call

iAdrsMessValeur:          .int sMessValeur
iAdrszCarriageReturn:	.int szCarriageReturn
iAdrsBlanc1:		.int sBlanc1
iAdrsBlanc2:		.int sBlanc2
iAdrsBlanc3:		.int sBlanc3
/******************************************************************/
/*     display text with size calculation                         */ 
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
    push {r0,r1,r2,r7,lr}      @ save  registres
    mov r2,#0                  @ counter length 
1:      @ loop length calculation 
    ldrb r1,[r0,r2]           @ read octet start position + index 
    cmp r1,#0                  @ if 0 its over 
    addne r2,r2,#1            @ else add 1 in the length 
    bne 1b                    @ and loop 
                                @ so here r2 contains the length of the message 
    mov r1,r0        			@ address message in r1 
    mov r0,#STDOUT      		@ code to write to the standard output Linux 
    mov r7, #WRITE             @ code call system "write" 
    svc #0                      @ call systeme 
    pop {r0,r1,r2,r7,lr}        @ restaur des  2 registres */ 
    bx lr                       @ return  
/******************************************************************/
/*     Converting a register to a decimal unsigned                */ 
/******************************************************************/
/* r0 contains value and r1 address area   */
/* r0 return size of result (no zero final in area) */
/* area size => 11 bytes          */
.equ LGZONECAL,   10
conversion10:
    push {r1-r4,lr}    @ save registers 
    mov r3,r1
    mov r2,#LGZONECAL

1:	   @ start loop
    bl divisionpar10U   @unsigned  r0 <- dividende. quotient ->r0 reste -> r1
    add r1,#48        @ digit	
    strb r1,[r3,r2]  @ store digit on area
    cmp r0,#0         @ stop if quotient = 0 */
    subne r2,#1      @ else previous position
    bne 1b	          @ and loop
    @ and move digit from left of area
    mov r4,#0
2:
    ldrb r1,[r3,r2]
    strb r1,[r3,r4]
    add r2,#1
    add r4,#1
    cmp r2,#LGZONECAL
    ble 2b
    @ and move spaces in end on area
    mov r0,r4     @ result length 
    mov r1,#' '   @ space	
3:
    strb r1,[r3,r4]  @ store space in area
    add r4,#1         @ next position
    cmp r4,#LGZONECAL
    ble 3b           @ loop if r4 <= area size

100:
    pop {r1-r4,lr}    @ restaur registres 
    bx lr             @return

/***************************************************/
/*   division par 10   unsigned                    */
/***************************************************/
/* r0 dividende   */
/* r0 quotient */	
/* r1 remainder  */
divisionpar10U:
    push {r2,r3,r4, lr}
    mov r4,r0         @ save value
    mov r3,#0xCCCD   @ r3 <- magic_number  lower
    movt r3,#0xCCCC  @ r3 <- magic_number  upper
    umull r1, r2, r3, r0      @ r1<- Lower32Bits(r1*r0) r2<- Upper32Bits(r1*r0) 
    mov r0, r2, LSR #3      @ r2 <- r2 >> shift 3
    add r2,r0,r0, lsl #2     @ r2 <- r0 * 5 
    sub r1,r4,r2, lsl #1     @ r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10)
    pop {r2,r3,r4,lr}
    bx lr                  @ leave function

Arturo

mulTable: function [n][
    print ["    |"] ++ map 1..n => [pad to :string & 3]
    print "----+" ++ join map 1..n => "----"
    loop 1..n 'x [
        prints (pad to :string x 3) ++ " |"
        if x>1 -> loop 1..x-1 'y [prints "    "]
        loop x..n 'y [prints " " ++ pad to :string x*y 3]
        print ""
    ]
]

mulTable 12
Output:
    |   1   2   3   4   5   6   7   8   9  10  11  12 
----+------------------------------------------------
  1 |   1   2   3   4   5   6   7   8   9  10  11  12
  2 |       4   6   8  10  12  14  16  18  20  22  24
  3 |           9  12  15  18  21  24  27  30  33  36
  4 |              16  20  24  28  32  36  40  44  48
  5 |                  25  30  35  40  45  50  55  60
  6 |                      36  42  48  54  60  66  72
  7 |                          49  56  63  70  77  84
  8 |                              64  72  80  88  96
  9 |                                  81  90  99 108
 10 |                                     100 110 120
 11 |                                         121 132
 12 |                                             144

AutoHotkey

Gui, -MinimizeBox
Gui, Margin, 0, 0
Gui, Font, s9, Fixedsys
Gui, Add, Edit, h0 w0
Gui, Add, Edit, w432 r14 -VScroll
Gosub, Table
Gui, Show,, Multiplication Table
Return

GuiClose:
GuiEscape:
    ExitApp
Return

Table:
    ; top row
    Table := "  x |"
    Loop, 12
        Table .= SubStr("   " A_Index, -3)
    Table .= "`n"

    ; underlines
    Table .= "----+"
    Loop, 48
        Table .= "-"
    Table .= "`n"

    ; table
    Loop, 12 { ; rows
        Table .= SubStr("  " Row := A_Index, -2) " |"
        Loop, 12 ; columns
            Table .= SubStr("    " (A_Index >= Row ? A_Index * Row : ""), -3)
        Table .= "`n"
    }
    GuiControl,, Edit2, %Table%
Return

Message box shows:

  x |   1   2   3   4   5   6   7   8   9  10  11  12
----+------------------------------------------------
  1 |   1   2   3   4   5   6   7   8   9  10  11  12
  2 |       4   6   8  10  12  14  16  18  20  22  24
  3 |           9  12  15  18  21  24  27  30  33  36
  4 |              16  20  24  28  32  36  40  44  48
  5 |                  25  30  35  40  45  50  55  60
  6 |                      36  42  48  54  60  66  72
  7 |                          49  56  63  70  77  84
  8 |                              64  72  80  88  96
  9 |                                  81  90  99 108
 10 |                                     100 110 120
 11 |                                         121 132
 12 |                                             144

AutoIt

#AutoIt Version: 3.2.10.0
$tableupto=12
$table=""
for $i = 1 To $tableupto
   for $j = $i to $tableupto
      $prod=string($i*$j)
      if StringLen($prod) == 1  then
	 $prod = "    "& $prod
      EndIf
      if StringLen($prod) == 2  then
	 $prod = "  "& $prod
      EndIf
      $table = $table&" "&$prod
   Next
   $table = $table&"  - "&$i&@CRLF
   for  $k = 1 to $i
      $table = $table&"       "
   Next
Next
msgbox(0,"Multiplication Tables",$table)

AWK

BEGIN {
  for(i=1;i<=12;i++){
    for(j=1;j<=12;j++){
      if(j>=i||j==1){printf "%4d",i*j}
      else          {printf "    "}
  }
  print
 }
}
Output:
 
   1   2   3   4   5   6   7   8   9  10  11  12
   2   4   6   8  10  12  14  16  18  20  22  24
   3       9  12  15  18  21  24  27  30  33  36
   4          16  20  24  28  32  36  40  44  48
   5              25  30  35  40  45  50  55  60
   6                  36  42  48  54  60  66  72
   7                      49  56  63  70  77  84
   8                          64  72  80  88  96
   9                              81  90  99 108
  10                                 100 110 120
  11                                     121 132
  12                                         144

Axe

Since the standard text output is poorly suited to this kind of formatted data, this example is implemented by writing to the screen buffer using the small font. Also, the limits were adjusted to 10x8 to make the table fit the screen.

Fix 5
ClrDraw
For(I,1,10)
 Text(I-1*9,0,I▶Dec)
 Text(91,I*7+1,I▶Dec)
End

For(J,1,8)
 For(I,J,10)
  Text(I-1*9,J*7+1,I*J▶Dec)
 End
End

HLine(7)
VLine(89)
DispGraph
getKeyʳ
Fix 4

Approximate output:

1  2  3  4  5  6  7  8  9  10 |
---------------------------------
1  2  3  4  5  6  7  8  9  10 | 1
   4  6  8  10 12 14 16 18 20 | 2
      9  12 15 18 21 24 27 30 | 3
         16 20 24 28 32 36 40 | 4
            25 30 35 40 45 50 | 5
               36 42 48 54 60 | 6
                  49 56 63 70 | 7
                     64 72 80 | 8

BASIC

Applesoft BASIC

100 M = 12
110 DEF FN T(X) = X * 3 + (X < 4) * (4 - X) + (X > 10) * (X - 10) - 1
120 FOR N = -1 TO M
130     IF NOT N THEN PRINT CHR$(13) TAB(5); : FOR J = 5 TO FN T(M + 1) - 2 : PRINT "-"; : NEXT J, N
140     I = ABS(N)
150     IF N > 0 THEN PRINT CHR$(13) MID$("  ", 1, I < 10) I" !";
160     FOR J = I TO M
170         V$ = STR$(I * J)
180         PRINT TAB(FN T(J)) MID$("  ", 1, 3 - LEN(V$) - (J < 4)) V$;
190 NEXT J, N

ASIC

Translation of: Modula-2
REM Multiplication tables
N = 12
PREDN = N - 1
WDTH = 3
CLS
FOR J = 1 TO PREDN
  INTVAL = J
  GOSUB PRINTINT:
  PRINT " ";
NEXT J
INTVAL = N
GOSUB PRINTINT:
PRINT
FOR J = 0 TO PREDN
  PRINT "----";
NEXT J
PRINT "+"
FOR I = 1 TO N
  WDTH = 3
  FOR J = 1 TO N    
    IF J < I THEN
      PRINT "    ";
    ELSE
      INTVAL = I * J      
      GOSUB PRINTINT:
      PRINT " ";
    ENDIF
  NEXT J
  PRINT "| ";
  INTVAL = I
  WDTH = 2
  GOSUB PRINTINT:
  PRINT
NEXT I
END

PRINTINT:
REM Writes the value of INTVAL in a field of the given WDTH
S2$ = STR$(INTVAL)
S2$ = LTRIM$(S2$)
SPNUM = LEN(S2$)
SPNUM = WDTH - SPNUM
S1$ = SPACE$(SPNUM)
PRINT S1$;
PRINT S2$;
RETURN
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
------------------------------------------------+
  1   2   3   4   5   6   7   8   9  10  11  12 |  1
      4   6   8  10  12  14  16  18  20  22  24 |  2
          9  12  15  18  21  24  27  30  33  36 |  3
             16  20  24  28  32  36  40  44  48 |  4
                 25  30  35  40  45  50  55  60 |  5
                     36  42  48  54  60  66  72 |  6
                         49  56  63  70  77  84 |  7
                             64  72  80  88  96 |  8
                                 81  90  99 108 |  9
                                    100 110 120 | 10
                                        121 132 | 11
                                            144 | 12

BASIC256

print "  X|   1   2   3   4   5   6   7   8   9  10  11  12"
print "---+------------------------------------------------"

for i = 1 to 12
    nums$ = right("  " + string(i), 3) + "|"
    for j = 1 to 12
        if i <= j then
            if j >= 1 then
                nums$ += left("    ", (4 - length(string(i * j))))
            end if
            nums$ += string(i * j)
        else
            nums$ += "    "
        end if
    next j
    print nums$
next i

BBC BASIC

BBC BASIC automatically right-justifies numeric output.

      @% = 5 : REM Set column width
      FOR row% = 1 TO 12
        PRINT row% TAB(row% * @%) ;
        FOR col% = row% TO 12
          PRINT row% * col% ;
        NEXT col%
        PRINT
      NEXT row%
Output:
    1    1    2    3    4    5    6    7    8    9   10   11   12
    2         4    6    8   10   12   14   16   18   20   22   24
    3              9   12   15   18   21   24   27   30   33   36
    4                  16   20   24   28   32   36   40   44   48
    5                       25   30   35   40   45   50   55   60
    6                            36   42   48   54   60   66   72
    7                                 49   56   63   70   77   84
    8                                      64   72   80   88   96
    9                                           81   90   99  108
   10                                               100  110  120
   11                                                    121  132
   12                                                         144

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4
Translation of: IS-BASIC
100 cls
110 print tab (4);
120 for i = 1 to 12
130   print using " ###";i;
140 next
150 print
160 print " --+------------------------------------------------"
170 for i = 1 to 12
180   print using " ##|";i;
190   print tab (i*4);
200   for j = i to 12
210     print using " ###";i*j;
220   next
230   print
240 next
250 end

Commodore BASIC

The table consumes every one of the 1000 cells in a 40-column display, and even so has to cheat a little to fit 10x10=100 into the table. It uses the INSERT character (CHR$(148)) to push characters over to the right after printing them without triggering a scroll that would push the top line off the screen.

100 PRINT CHR$(14);CHR$(147);
110 PRINT " X";
120 W=2
130 FOR I=1 TO 10
140 : N=I
150 : GOSUB 520
160 : PRINT ":"N$;
170 NEXT I
180 W=3
190 FOR I=11 TO 12
200 : N=I
210 : GOSUB 520
220 : PRINT ":"N$;
230 NEXT
240 FOR I=1 TO 12
250 : PRINT "--";
260 : FOR J=1 TO 10
270 :  PRINT "+--";
280 : NEXT J
290 : FOR J=11 TO 12
300 :  PRINT "+---";
310 : NEXT J
320 : N=I:W=2:GOSUB 520:PRINT N$;
330 : FOR J=1 TO 10
340 :   W=2
350 :   IF J<I THEN N$=" ":GOSUB 530:GOTO 370
360 :   N=I*J:GOSUB 520
370 :   IF LEN(N$)<3 THEN PRINT ":";
380 :   PRINT N$;
390 : NEXT J
400 : FOR J=11 TO 12
410 :   W=3
420 :   IF J<I THEN N$=" ":GOSUB 530:GOTO 440
430 :   N=I*J:GOSUB 520
440 :   PRINT N$;
450 :   FOR K=1 TO LEN(N$): PRINT CHR$(157);:NEXT K
460 :   PRINT CHR$(148);":";
470 :   IF J<12 THEN FOR K=1 TO LEN(N$):PRINT CHR$(29);: NEXT K
480 : NEXT J: IF I<12 THEN PRINT
490 NEXT I
500 GET K$: IF K$="" THEN 500
510 END
520 N$=MID$(STR$(N),2)
530 IF LEN(N$)<W THEN N$=" "+N$:GOTO 530
540 RETURN
Output:
 x: 1: 2: 3: 4: 5: 6: 7: 8: 9:10: 11: 12
--+--+--+--+--+--+--+--+--+--+--+---+---
 1: 1: 2: 3: 4: 5: 6: 7: 8: 9:10: 11: 12
--+--+--+--+--+--+--+--+--+--+--+---+---
 2:  : 4: 6: 8:10:12:14:16:18:20: 22: 24
--+--+--+--+--+--+--+--+--+--+--+---+---
 3:  :  : 9:12:15:18:21:24:27:30: 33: 36
--+--+--+--+--+--+--+--+--+--+--+---+---
 4:  :  :  :16:20:24:28:32:36:40: 44: 48
--+--+--+--+--+--+--+--+--+--+--+---+---
 5:  :  :  :  :25:30:35:40:45:50: 55: 60
--+--+--+--+--+--+--+--+--+--+--+---+---
 6:  :  :  :  :  :36:42:48:54:60: 66: 72
--+--+--+--+--+--+--+--+--+--+--+---+---
 7:  :  :  :  :  :  :49:56:63:70: 77: 84
--+--+--+--+--+--+--+--+--+--+--+---+---
 8:  :  :  :  :  :  :  :64:72:80: 88: 96
--+--+--+--+--+--+--+--+--+--+--+---+---
 9:  :  :  :  :  :  :  :  :81:90: 99:108
--+--+--+--+--+--+--+--+--+--+--+---+---
10:  :  :  :  :  :  :  :  :  100:110:120
--+--+--+--+--+--+--+--+--+--+--+---+---
11:  :  :  :  :  :  :  :  :  :  :121:132
--+--+--+--+--+--+--+--+--+--+--+---+---
12:  :  :  :  :  :  :  :  :  :  :   :144

FreeBASIC

' FB 1.05.0 Win64

Print "  X|";
For i As Integer = 1 To 12
  Print Using "####"; i;
Next

Print
Print "---+"; String(48, "-")

For i As Integer = 1 To 12
  Print Using "###"; i; 
  Print"|"; Spc(4 * (i - 1));
  For j As Integer = i To 12   
    Print Using "####"; i * j;
  Next j 
  Print
Next i

Print
Print "Press any key to quit"
Sleep
Output:
  X|   1   2   3   4   5   6   7   8   9  10  11  12
---+------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

FutureBasic

long i, j

window 1, @"Multiplication Table", (0,0,420,220)

print "   |";
for i = 1 to 12
print using "####"; i;
next
print :print "---+"; string$(48, "-")
for i = 1 to 12
print using "###"; i;
print"|"; spc(4 * (i - 1));
for j = i to 12
print using "####"; i * j;
next
print
next

HandleEvents
Output:
   |   1   2   3   4   5   6   7   8   9  10  11  12
---+------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

Gambas

Click this link to run this code

'Code 'stolen' from Free Basic and altered to work in Gambas

Public Sub Main()
Dim i, j As Integer

Print "  X|";
For i = 1 To 12
  Print Format(i, "####");
Next
 
Print
Print "---+"; String(48, "-")
 
For i = 1 To 12
  Print Format(i, "###");
  Print "|"; Space(4 * (i - 1));
  For j = i To 12
    Print Format(i * j, "####"); 
  Next  
  Print
Next 

End

Output:

  X|   1   2   3   4   5   6   7   8   9  10  11  12
---+------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

GW-BASIC

Translation of: Modula-2
Works with: BASICA
Works with: PC-BASIC version any
10  ' Multiplication Tables
20  LET N% = 12
30  FOR J% = 1 TO N% - 1
40   PRINT USING "###"; J%; 
50   PRINT " ";
60  NEXT J%
70  PRINT USING "###"; N%
80  FOR J% = 0 TO N% - 1
90   PRINT "----";
100 NEXT J%
110 PRINT "+"
120 FOR I% = 1 TO N% 
130  FOR J% = 1 TO N%
140   IF J% < I% THEN PRINT "    "; ELSE PRINT USING "###"; I% * J%;: PRINT " ";
150  NEXT J%
160  PRINT "| "; USING "##"; I%
170 NEXT I%
Output:
  1   2   3   4   5   6   7   8   9  10  11  12                                 
------------------------------------------------+                               
  1   2   3   4   5   6   7   8   9  10  11  12 |  1                            
      4   6   8  10  12  14  16  18  20  22  24 |  2                            
          9  12  15  18  21  24  27  30  33  36 |  3                            
             16  20  24  28  32  36  40  44  48 |  4                            
                 25  30  35  40  45  50  55  60 |  5                            
                     36  42  48  54  60  66  72 |  6                            
                         49  56  63  70  77  84 |  7                            
                             64  72  80  88  96 |  8                            
                                 81  90  99 108 |  9                            
                                    100 110 120 | 10                            
                                        121 132 | 11                            
                                            144 | 12 

IS-BASIC

100 PROGRAM "Multipli.bas"
110 TEXT 80
120 PRINT TAB(7);
130 FOR I=1 TO 12
140   PRINT USING " ###":I;
150 NEXT
160 PRINT AT 2,5:"----------------------------------------------------"
170 FOR I=1 TO 12
180   PRINT USING "### |":I;:PRINT TAB(I*4+3);
190   FOR J=I TO 12
200     PRINT USING " ###":I*J;
210   NEXT
220   PRINT
230 NEXT

Liberty BASIC

Print "  |    1    2    3    4    5    6    7    8    9   10   11   12"
Print "--+------------------------------------------------------------"

For i = 1 To 12
    nums$ = Right$(" " + str$(i), 2) + "|"
    For ii = 1 To 12
        If i <= ii Then
            If ii >= 1 Then
                nums$ = nums$ + Left$("     ", (5 - Len(str$(i * ii))))
            End If
            nums$ = nums$ + str$(i * ii)
        Else
            nums$ = nums$ + "     "
        End If
    Next ii
    Print nums$
Next i
Output:
  |    1    2    3    4    5    6    7    8    9   10   11   12
--+------------------------------------------------------------
 1|    1    2    3    4    5    6    7    8    9   10   11   12
 2|         4    6    8   10   12   14   16   18   20   22   24
 3|              9   12   15   18   21   24   27   30   33   36
 4|                  16   20   24   28   32   36   40   44   48
 5|                       25   30   35   40   45   50   55   60
 6|                            36   42   48   54   60   66   72
 7|                                 49   56   63   70   77   84
 8|                                      64   72   80   88   96
 9|                                           81   90   99  108
10|                                               100  110  120
11|                                                    121  132
12|                                                         144

Microsoft Small Basic

Translation of: Modula-2
n = 12
For j = 1 To n - 1
  TextWindow.CursorLeft = (j - 1) * 4 + (3 - Text.GetLength(j))
  TextWindow.Write(j)
  TextWindow.Write(" ")
EndFor
TextWindow.CursorLeft = (n - 1) * 4 + (3 - Text.GetLength(n))
TextWindow.Write(n)
TextWindow.WriteLine("")
For j = 0 To n - 1
  TextWindow.Write("----")
EndFor
TextWindow.WriteLine("+")
For i = 1 To n
  For j = 1 To n 
    If j < i Then
      TextWindow.Write("    ")
    Else
      TextWindow.CursorLeft = (j - 1) * 4 + (3 - Text.GetLength(i * j))
      TextWindow.Write(i * j)
      TextWindow.Write(" ")
    EndIf
  EndFor
  TextWindow.Write("| ")
  TextWindow.CursorLeft = n * 4 + (4 - Text.GetLength(i))
  TextWindow.Write(i)
  TextWindow.WriteLine("")
EndFor
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
------------------------------------------------+
  1   2   3   4   5   6   7   8   9  10  11  12 |  1
      4   6   8  10  12  14  16  18  20  22  24 |  2
          9  12  15  18  21  24  27  30  33  36 |  3
             16  20  24  28  32  36  40  44  48 |  4
                 25  30  35  40  45  50  55  60 |  5
                     36  42  48  54  60  66  72 |  6
                         49  56  63  70  77  84 |  7
                             64  72  80  88  96 |  8
                                 81  90  99 108 |  9
                                    100 110 120 | 10
                                        121 132 | 11
                                            144 | 12

PureBasic

Procedure PrintMultiplicationTable(maxx, maxy)
  sp       = Len(Str(maxx*maxy)) + 1
  trenner$ =  "+"
  For l1 = 1 To maxx + 1
    For l2 = 1 To sp
      trenner$ + "-"
    Next
    trenner$ + "+"
  Next
  header$ = "|" + RSet("x", sp) + "|"
  For a = 1 To maxx
    header$ + RSet(Str(a), sp)
    header$ + "|"
  Next
  PrintN(trenner$) 
  PrintN(header$)
  PrintN(trenner$)
  For y = 1 To maxy
    line$ = "|" + RSet(Str(y), sp) + "|"
    For x = 1 To maxx
      If x >= y
        line$ + RSet(Str(x*y), sp)
      Else
        line$ + Space(sp)
      EndIf
      line$ + "|"
    Next
    PrintN(line$)
  Next
  PrintN(trenner$)
EndProcedure

OpenConsole()
PrintMultiplicationTable(12, 12)
Input()

Ouput similar to ALGOL 68

QBasic

CLS

'header row
PRINT "     ";
FOR n = 1 TO 12
    'do it this way for alignment purposes
    o$ = "    "
    MID$(o$, LEN(o$) - LEN(STR$(n)) + 1) = STR$(n)
    PRINT o$;
NEXT
PRINT : PRINT "    "; STRING$(49, "-");

FOR n = 1 TO 12
    PRINT
    IF n < 10 THEN PRINT " ";
    PRINT n; "|";   'row labels
    FOR m = 1 TO n - 1
        PRINT "    ";
    NEXT
    FOR m = n TO 12
        'alignment again
        o$ = "    "
        MID$(o$, LEN(o$) - LEN(STR$(m * n)) + 1) = STR$(m * n)
        PRINT o$;
    NEXT
NEXT
Output:
        1   2   3   4   5   6   7   8   9  10  11  12
    -------------------------------------------------
  1 |   1   2   3   4   5   6   7   8   9  10  11  12
  2 |       4   6   8  10  12  14  16  18  20  22  24
  3 |           9  12  15  18  21  24  27  30  33  36
  4 |              16  20  24  28  32  36  40  44  48
  5 |                  25  30  35  40  45  50  55  60
  6 |                      36  42  48  54  60  66  72
  7 |                          49  56  63  70  77  84
  8 |                              64  72  80  88  96
  9 |                                  81  90  99 108
 10 |                                     100 110 120
 11 |                                         121 132
 12 |                                             144

Run BASIC

html "<TABLE border=1 ><TR bgcolor=silver align=center><TD><TD>1<TD>2<TD>3<TD>4<TD>5<TD>6<TD>7<TD>8<TD>9<TD>10<TD>11<TD>12</td></TR>" 
For i = 1 To 12
	html "<TR align=right><TD>";i;"</td>"
	For ii = 1 To 12
		html "<td width=25>"
		If ii >= i Then   html i * ii
		html "</td>"
	Next ii
next i
html "</table>"
Output:
123456789101112
1123456789101112
24681012141618202224
39121518212427303336
4162024283236404448
52530354045505560
636424854606672
7495663707784
86472808896
9819099108
10100110120
11121132
12144

Tiny BASIC

Translation of: Modula-2
Works with: TinyBasic
 
10 REM MULTIPLICATION TABLES
20 LET N=12
30 REM TO ALIGN NUMBERS TO THE RIGHT
40 REM ASSUME THAT N IS AT MOST TWO-DIGIT.
50 LET J=1
60 PRINT " ";
70 IF J<10 THEN PRINT " ";
80 PRINT J;" ";
90 LET J=J+1
100 IF J=N THEN GOTO 120
110 GOTO 60
120 PRINT " ";
130 IF N<10 THEN PRINT " ";
140 PRINT N
150 LET J=0
160 PRINT "----";
170 J=J+1
180 IF J=N THEN GOTO 200
190 GOTO 160
200 PRINT "+"
210 LET I=1
220 LET J=1
230 IF J<I THEN GOTO 290
240 LET P=I*J
250 IF P<100 THEN PRINT " ";
260 IF P<10 THEN PRINT " ";
270 PRINT P;" ";
280 GOTO 300
290 PRINT "    ";
300 IF J=N THEN GOTO 330
310 LET J=J+1
320 GOTO 230
330 PRINT "! ";
340 IF I<10 THEN PRINT " ";
350 PRINT I
360 IF I=N THEN GOTO 390
370 LET I=I+1
380 GOTO 220
390 END
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
------------------------------------------------+
  1   2   3   4   5   6   7   8   9  10  11  12 !  1
      4   6   8  10  12  14  16  18  20  22  24 !  2
          9  12  15  18  21  24  27  30  33  36 !  3
             16  20  24  28  32  36  40  44  48 !  4
                 25  30  35  40  45  50  55  60 !  5
                     36  42  48  54  60  66  72 !  6
                         49  56  63  70  77  84 !  7
                             64  72  80  88  96 !  8
                                 81  90  99 108 !  9
                                    100 110 120 ! 10
                                        121 132 ! 11
                                            144 ! 12

True BASIC

PRINT "  X|   1   2   3   4   5   6   7   8   9  10  11  12"
PRINT "---+------------------------------------------------"

FOR i = 1 TO 12
    LET nums$ = ("  " & STR$(i))[LEN("  " & STR$(i))-3+1:maxnum] & "|"
    FOR j = 1 TO 12
        IF i <= j THEN
           IF j >= 1 THEN LET nums$ = nums$ & ("    ")[1:(4-LEN(STR$(i*j)))]
           LET nums$ = nums$ & STR$(i*j)
        ELSE
           LET nums$ = nums$ & "    "
        END IF
    NEXT j
    PRINT nums$
NEXT i
PRINT
END

uBasic/4tH

Translation of: BBC BASIC
For R = 1 To 12
  Print R;Tab(R * 5);
  For C = R To 12
    Print Using "_____";R * C;
  Next
  Print
Next
Output:
1        1    2    3    4    5    6    7    8    9   10   11   12
2             4    6    8   10   12   14   16   18   20   22   24
3                  9   12   15   18   21   24   27   30   33   36
4                      16   20   24   28   32   36   40   44   48
5                           25   30   35   40   45   50   55   60
6                                36   42   48   54   60   66   72
7                                     49   56   63   70   77   84
8                                          64   72   80   88   96
9                                               81   90   99  108
10                                                  100  110  120
11                                                       121  132
12                                                            144

0 OK, 0:105

VBA

Option Explicit

Sub Multiplication_Tables()
Dim strTemp As String, strBuff As String
Dim i&, j&, NbDigits As Byte

'You can adapt the following const :
Const NB_END As Byte = 12

    Select Case NB_END
        Case Is < 10: NbDigits = 3
        Case 10 To 31: NbDigits = 4
        Case 31 To 100: NbDigits = 5
        Case Else: MsgBox "Number too large": Exit Sub
    End Select
    strBuff = String(NbDigits, " ")
    
    For i = 1 To NB_END
        strTemp = Right(strBuff & i, NbDigits)
        For j = 2 To NB_END
            If j < i Then
                strTemp = strTemp & strBuff
            Else
                strTemp = strTemp & Right(strBuff & j * i, NbDigits)
            End If
        Next j
        Debug.Print strTemp
    Next i
End Sub
Output:
   1   2   3   4   5   6   7   8   9  10  11  12
   2   4   6   8  10  12  14  16  18  20  22  24
   3       9  12  15  18  21  24  27  30  33  36
   4          16  20  24  28  32  36  40  44  48
   5              25  30  35  40  45  50  55  60
   6                  36  42  48  54  60  66  72
   7                      49  56  63  70  77  84
   8                          64  72  80  88  96
   9                              81  90  99 108
  10                                 100 110 120
  11                                     121 132
  12                                         144

Visual Basic

Works with: Visual Basic version VB6 Standard
Sub Main()
    Const nmax = 12, xx = 3
    Const x = xx + 1
    Dim i As Integer, j As Integer, s As String
    s = String(xx, " ") & " |"
    For j = 1 To nmax
        s = s & Right(String(x, " ") & j, x)
    Next j
    Debug.Print s
    s = String(xx, "-") & " +"
    For j = 1 To nmax
        s = s & " " & String(xx, "-")
    Next j
    Debug.Print s
    For i = 1 To nmax
        s = Right(String(xx, " ") & i, xx) & " |"
        For j = 1 To nmax
            If j >= i _
            Then s = s & Right(String(x, " ") & i * j, x) _
            Else s = s & String(x, " ")
        Next j
        Debug.Print s
    Next i
End Sub 'Main
Output:
    |   1   2   3   4   5   6   7   8   9  10  11  12
--- + --- --- --- --- --- --- --- --- --- --- --- ---
  1 |   1   2   3   4   5   6   7   8   9  10  11  12
  2 |       4   6   8  10  12  14  16  18  20  22  24
  3 |           9  12  15  18  21  24  27  30  33  36
  4 |              16  20  24  28  32  36  40  44  48
  5 |                  25  30  35  40  45  50  55  60
  6 |                      36  42  48  54  60  66  72
  7 |                          49  56  63  70  77  84
  8 |                              64  72  80  88  96
  9 |                                  81  90  99 108
 10 |                                     100 110 120
 11 |                                         121 132
 12 |                                             144

XBasic

Translation of: Modula-2
Works with: Windows XBasic
PROGRAM "multiplicationtables"
VERSION "0.0001"

DECLARE FUNCTION Entry()

FUNCTION Entry()
  $N = 12
  FOR j@@ = 1 TO $N - 1
    PRINT FORMAT$("### ", j@@);
  NEXT j@@
  PRINT FORMAT$("###", $N)
  FOR j@@ = 0 TO $N - 1
    PRINT "----";
  NEXT j@@
  PRINT "+"
  FOR i@@ = 1 TO $N
    FOR j@@ = 1 TO $N
      IF j@@ < i@@ THEN
        PRINT "    ";
      ELSE
        PRINT FORMAT$("### ", i@@ * j@@);
      END IF
    NEXT j@@
    PRINT "|"; FORMAT$(" ##", i@@)
  NEXT i@@
END FUNCTION
END PROGRAM
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
------------------------------------------------+
  1   2   3   4   5   6   7   8   9  10  11  12 |  1
      4   6   8  10  12  14  16  18  20  22  24 |  2
          9  12  15  18  21  24  27  30  33  36 |  3
             16  20  24  28  32  36  40  44  48 |  4
                 25  30  35  40  45  50  55  60 |  5
                     36  42  48  54  60  66  72 |  6
                         49  56  63  70  77  84 |  7
                             64  72  80  88  96 |  8
                                 81  90  99 108 |  9
                                    100 110 120 | 10
                                        121 132 | 11
                                            144 | 12

Yabasic

print "  X|   1   2   3   4   5   6   7   8   9  10  11  12"
print "---+------------------------------------------------"

for i = 1 to 12
    nums$ = right$("  " + str$(i), 3) + "|"
    for j = 1 to 12
        if i <= j then
            if j >= 1 then
                nums$ = nums$ + left$("    ", (4 - len(str$(i * j))))
            end if
            nums$ = nums$ + str$(i * j)
        else
            nums$ = nums$ + "    "
        end if
    next j
    print nums$
next i

Batch File

@echo off
setlocal enabledelayedexpansion

::The Main Thing...
cls
set colum=12&set row=12
call :multable
echo.
pause
exit /b 0
::/The Main Thing.

::The Functions...
:multable
	echo.
	for /l %%. in (1,1,%colum%) do (
	call :numstr %%.
	set firstline=!firstline!!space!%%.
	set seconline=!seconline!-----
	)
	echo !firstline!
	echo !seconline!

	::The next lines here until the "goto :EOF" prints the products...

	for /l %%X in (1,1,%row%) do (
		for /l %%Y in (1,1,%colum%) do (
			if %%Y lss %%X (set "line%%X=!line%%X!     ") else (
				set /a ans=%%X*%%Y
				call :numstr !ans!
				set "line%%X=!line%%X!!space!!ans!"
			)
		)
		echo.!line%%X! ^| %%X
	)
	goto :EOF

:numstr
	::This function returns the number of whitespaces to be applied on each numbers.
	set cnt=0&set proc=%1&set space=
	:loop
	set currchar=!proc:~%cnt%,1!
	if not "!currchar!"=="" set /a cnt+=1&goto loop
	set /a numspaces=5-!cnt!
	for /l %%A in (1,1,%numspaces%) do set "space=!space! "
goto :EOF
::/The Functions.
Output:
    1    2    3    4    5    6    7    8    9   10   11   12
------------------------------------------------------------
    1    2    3    4    5    6    7    8    9   10   11   12 | 1
         4    6    8   10   12   14   16   18   20   22   24 | 2
              9   12   15   18   21   24   27   30   33   36 | 3
                  16   20   24   28   32   36   40   44   48 | 4
                       25   30   35   40   45   50   55   60 | 5
                            36   42   48   54   60   66   72 | 6
                                 49   56   63   70   77   84 | 7
                                      64   72   80   88   96 | 8
                                           81   90   99  108 | 9
                                               100  110  120 | 10
                                                    121  132 | 11
                                                         144 | 12

Press any key to continue . . .

Befunge

0>51p0>52p51g52g*:51g52g`!*\!51g52g+*+0\3>01p::55+%68*+\!28v
w^p2<y|!`+66:+1,+*84*"\"!:g25$_,#!>#:<$$_^#!:-1g10/+55\-**<<
"$9"^x>$55+,51g1+:66+`#@_055+68*\>\#<1#*-#9:#5_$"+---">:#,_$
Output:
   |  1   2   3   4   5   6   7   8   9  10  11  12
---+-----------------------------------------------
  1|  1   2   3   4   5   6   7   8   9  10  11  12
  2|      4   6   8  10  12  14  16  18  20  22  24
  3|          9  12  15  18  21  24  27  30  33  36
  4|             16  20  24  28  32  36  40  44  48
  5|                 25  30  35  40  45  50  55  60
  6|                     36  42  48  54  60  66  72
  7|                         49  56  63  70  77  84
  8|                             64  72  80  88  96
  9|                                 81  90  99 108
 10|                                    100 110 120
 11|                                        121 132
 12|                                            144


BQN

Table formats a multiplication table for any given n. The result is a character array and can be printed with •Out˘. The overall structure is to build a 3-by-3 array of parts, then put them together with a two-dimensional join ().

Table  {
  m  •Repr¨ ×⌜˜1+↕𝕩             # The numbers, formatted individually
  main                         # Bottom part: three sections
    >(-⌈10𝕩)¨m               # Original numbers
    𝕩'|'                        # Divider
    ˘(-1+⌈10𝕩×𝕩)¨(⌜˜𝕩)/¨m  # Multiplied numbers, padded and joined
  
  head  ' '¨ ¨ main          # Header: first row but with space left of |
   >head, "-+-"¨¨head, main  # Header, divider, and main
}
 
•Out˘ Table 12
Output:
  |  1   2   3   4   5   6   7   8   9  10  11  12
--+-----------------------------------------------
 1|  1   2   3   4   5   6   7   8   9  10  11  12
 2|      4   6   8  10  12  14  16  18  20  22  24
 3|          9  12  15  18  21  24  27  30  33  36
 4|             16  20  24  28  32  36  40  44  48
 5|                 25  30  35  40  45  50  55  60
 6|                     36  42  48  54  60  66  72
 7|                         49  56  63  70  77  84
 8|                             64  72  80  88  96
 9|                                 81  90  99 108
10|                                    100 110 120
11|                                        121 132
12|                                            144

Bracmat

  ( multiplicationTable
  =     high i j row row2 matrix padFnc tmp
      , celPad leftCelPad padFnc celDashes leftDashes
    .   !arg:?high
      & ( padFnc
        =   L i w d
          .   @(!arg:? [?L)
            & 1+(!L:?i):?L
            & " ":?w
            & "-":?d
            &   whl
              ' ( !i+-1:~<0:?i
                & " " !w:?w
                & "-" !d:?d
                )
            & str$!w:?w
            & (   
                ' ( 
                  .   @(str$(rev$!arg ()$w):?arg [($L) ?)
                    & rev$!arg
                  )
              . str$!d
              )
        )
      & padFnc$(!high^2):((=?celPad).?celDashes)
      & @(!high:?tmp [-2 ?)
      & padFnc$!tmp:((=?leftCelPad).?leftDashes)
      & 0:?i
      & :?row:?row2
      &   whl
        ' ( 1+!i:~>!high:?i
          & !row celPad$!i:?row
          & !celDashes !row2:?row2
          )
      &   str$(leftCelPad$X "|" !row \n !leftDashes "+" !row2 \n)
        : ?matrix
      & 0:?j
      &   whl
        ' ( 1+!j:~>!high:?j
          & 0:?i
          & :?row
          &   whl
            ' ( 1+!i:<!j:?i
              & celPad$() !row:?row
              )
          & leftCelPad$!j "|" !row:?row
          &   whl
            ' ( 1+!i:~>!high:?i
              & !row celPad$(!i*!j):?row
              )
          & !matrix str$(!row \n):?matrix
          )
      & str$!matrix
  )
& out$(multiplicationTable$12)
& done;
Output:
 X|   1   2   3   4   5   6   7   8   9  10  11  12
--+------------------------------------------------
 1|   1   2   3   4   5   6   7   8   9  10  11  12
 2|       4   6   8  10  12  14  16  18  20  22  24
 3|           9  12  15  18  21  24  27  30  33  36
 4|              16  20  24  28  32  36  40  44  48
 5|                  25  30  35  40  45  50  55  60
 6|                      36  42  48  54  60  66  72
 7|                          49  56  63  70  77  84
 8|                              64  72  80  88  96
 9|                                  81  90  99 108
10|                                     100 110 120
11|                                         121 132
12|                                             144

C

#include <stdio.h>

int main(void)
{
	int i, j, n = 12;
 
	for (j = 1; j <= n; j++) printf("%3d%c", j, j != n ? ' ' : '\n');
	for (j = 0; j <= n; j++) printf(j != n ? "----" : "+\n");

	for (i = 1; i <= n; i++) {
		for (j = 1; j <= n; j++)
			printf(j < i ? "    " : "%3d ", i * j);
                printf("| %d\n", i);
        }
 
	return 0;
}
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
------------------------------------------------+
  1   2   3   4   5   6   7   8   9  10  11  12 | 1
      4   6   8  10  12  14  16  18  20  22  24 | 2
          9  12  15  18  21  24  27  30  33  36 | 3
             16  20  24  28  32  36  40  44  48 | 4
                 25  30  35  40  45  50  55  60 | 5
                     36  42  48  54  60  66  72 | 6
                         49  56  63  70  77  84 | 7
                             64  72  80  88  96 | 8
                                 81  90  99 108 | 9
                                    100 110 120 | 10
                                        121 132 | 11
                                            144 | 12

C#

using System;

namespace multtbl
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write(" X".PadRight(4));
            for (int i = 1; i <= 12; i++)
                Console.Write(i.ToString("####").PadLeft(4));

            Console.WriteLine();
            Console.Write(" ___");

            for (int i = 1; i <= 12; i++)
                Console.Write(" ___");

            Console.WriteLine();
            for (int row = 1; row <= 12; row++)
            {
                Console.Write(row.ToString("###").PadLeft(3).PadRight(4));
                for (int col = 1; col <= 12; col++)
                {
                    if (row <= col)
                        Console.Write((row * col).ToString("###").PadLeft(4));
                    else
                        Console.Write("".PadLeft(4));
                }

                Console.WriteLine();
            }

            Console.WriteLine();
            Console.ReadLine();
        }
    }
}
Output:
 X     1   2   3   4   5   6   7   8   9  10  11  12
 ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___
  1    1   2   3   4   5   6   7   8   9  10  11  12
  2        4   6   8  10  12  14  16  18  20  22  24
  3            9  12  15  18  21  24  27  30  33  36
  4               16  20  24  28  32  36  40  44  48
  5                   25  30  35  40  45  50  55  60
  6                       36  42  48  54  60  66  72
  7                           49  56  63  70  77  84
  8                               64  72  80  88  96
  9                                   81  90  99 108
 10                                      100 110 120
 11                                          121 132
 12                                              144

C++

This is a slightly more-generalized version that takes any minimum and maximum table value, and formats the table columns.

#include <iostream>
#include <iomanip>
#include <cmath> // for log10()
#include <algorithm> // for max()

size_t table_column_width(const int min, const int max)
{
    unsigned int abs_max = std::max(max*max, min*min);

    // abs_max is the largest absolute value we might see.
    // If we take the log10 and add one, we get the string width
    // of the largest possible absolute value.
    // Add one more for a little whitespace guarantee.
    size_t colwidth = 2 + std::log10(abs_max);

    // If only one of them is less than 0, then some will
    // be negative. If some values may be negative, then we need to add some space
    // for a sign indicator (-)
    if (min < 0 && max > 0)
	++colwidth;
    return colwidth;
}

struct Writer_
{
    decltype(std::setw(1)) fmt_;
    Writer_(size_t w) : fmt_(std::setw(w)) {}
    template<class T_> Writer_& operator()(const T_& info) { std::cout << fmt_ << info; return *this; }
};

void print_table_header(const int min, const int max)
{
    Writer_ write(table_column_width(min, max));

    // table corner
    write(" ");
    for(int col = min; col <= max; ++col)
        write(col);

    // End header with a newline and blank line.
    std::cout << std::endl << std::endl;
}

void print_table_row(const int num, const int min, const int max)
{
    Writer_ write(table_column_width(min, max));

    // Header column
    write(num);

    // Spacing to ensure only the top half is printed
    for(int multiplicand = min; multiplicand < num; ++multiplicand)
        write(" ");

    // Remaining multiplicands for the row.
    for(int multiplicand = num; multiplicand <= max; ++multiplicand)
        write(num * multiplicand);

    // End row with a newline and blank line.
    std::cout << std::endl << std::endl;
}

void print_table(const int min, const int max)
{
    // Header row
    print_table_header(min, max);

    // Table body
    for(int row = min; row <= max; ++row)
        print_table_row(row, min, max);
}

int main()
{
    print_table(1, 12);
    return 0;
}
Output:
       1   2   3   4   5   6   7   8   9  10  11  12

   1   1   2   3   4   5   6   7   8   9  10  11  12

   2       4   6   8  10  12  14  16  18  20  22  24

   3           9  12  15  18  21  24  27  30  33  36

   4              16  20  24  28  32  36  40  44  48

   5                  25  30  35  40  45  50  55  60

   6                      36  42  48  54  60  66  72

   7                          49  56  63  70  77  84

   8                              64  72  80  88  96

   9                                  81  90  99 108

  10                                     100 110 120

  11                                         121 132

  12                                             144

Chef

Multigrain Bread.

Prints out a multiplication table.

Ingredients.
12 cups flour
12 cups grains
12 cups seeds
1 cup water
9 dashes yeast
1 cup nuts
40 ml honey
1 cup sugar

Method.
Sift the flour.
 Put flour into the 1st mixing bowl.
 Put yeast into the 1st mixing bowl.
Shake the flour until sifted.
Put grains into the 2nd mixing bowl.
Fold flour into the 2nd mixing bowl.
Put water into the 2nd mixing bowl.
Add yeast into the 2nd mixing bowl.
Combine flour into the 2nd mixing bowl.
Fold nuts into the 2nd mixing bowl.
Liquify nuts.
Put nuts into the 1st mixing bowl.
Pour contents of the 1st mixing bowl into the baking dish.
Sieve the flour.
 Put yeast into the 2nd mixing bowl.
 Add water into the 2nd mixing bowl.
 Sprinkle the seeds.
   Put flour into the 2nd mixing bowl.
   Combine seeds into the 2nd mixing bowl.
   Put yeast into the 2nd mixing bowl.
   Put seeds into the 2nd mixing bowl.
   Remove flour from the 2nd mixing bowl.
   Fold honey into the 2nd mixing bowl.
   Put water into the 2nd mixing bowl.
   Fold sugar into the 2nd mixing bowl.
   Squeeze the honey.
     Put water into the 2nd mixing bowl.
     Remove water from the 2nd mixing bowl.
     Fold sugar into the 2nd mixing bowl.
     Set aside.
   Drip until squeezed.
   Scoop the sugar.
     Crush the seeds.
       Put yeast into the 2nd mixing bowl.
     Grind the seeds until crushed.
     Put water into the 2nd mixing bowl.
     Fold seeds into the 2nd mixing bowl.
     Set aside.
   Drop until scooped.
 Randomize the seeds until sprinkled.
 Fold honey into the 2nd mixing bowl.
 Put flour into the 2nd mixing bowl.
 Put grains into the 2nd mixing bowl.
 Fold seeds into the 2nd mixing bowl.
Shake the flour until sieved.
Put yeast into the 2nd mixing bowl.
Add water into the 2nd mixing bowl.
Pour contents of the 2nd mixing bowl into the 2nd baking dish.

Serves 2.
Output:
  x    1   2   3   4   5   6   7   8   9  10  11  12
   1   1   2   3   4   5   6   7   8   9  10  11  12
   2       4   6   8  10  12  14  16  18  20  22  24
   3           9  12  15  18  21  24  27  30  33  36
   4              16  20  24  28  32  36  40  44  48
   5                  25  30  35  40  45  50  55  60
   6                      36  42  48  54  60  66  72
   7                          49  56  63  70  77  84
   8                              64  72  80  88  96
   9                                  81  90  99 108
  10                                     100 110 120
  11                                         121 132
  12                                             144

Clojure

This is more generalized. Any size can be used and the table will be formatted appropriately.

(let [size 12
      trange (range 1 (inc size))
      fmt-width (+ (.length (str (* size size))) 1)
      fmt-str (partial format (str "%" fmt-width "s"))
      fmt-dec (partial format (str "% " fmt-width "d"))]

  (doseq [s (cons
             (apply str (fmt-str " ") (map #(fmt-dec %) trange))
             (for [i trange]
               (apply str (fmt-dec i) (map #(fmt-str (str %))
                                           (map #(if (>= % i) (* i %) " ")
                                                (for [j trange] j))))))]
    (println s)))
Output:
       1   2   3   4   5   6   7   8   9  10  11  12
   1   1   2   3   4   5   6   7   8   9  10  11  12
   2       4   6   8  10  12  14  16  18  20  22  24
   3           9  12  15  18  21  24  27  30  33  36
   4              16  20  24  28  32  36  40  44  48
   5                  25  30  35  40  45  50  55  60
   6                      36  42  48  54  60  66  72
   7                          49  56  63  70  77  84
   8                              64  72  80  88  96
   9                                  81  90  99 108
  10                                     100 110 120
  11                                         121 132
  12                                             144

COBOL

       identification division.
       program-id. multiplication-table.

       environment division.
       configuration section.
       repository.
           function all intrinsic.

       data division.
       working-storage section.
       01 multiplication.
          05 rows occurs 12 times.
             10 colm occurs 12 times.
                15 num    pic 999.
       77 cand pic 99.
       77 ier  pic 99.
       77 ind  pic z9.
       77 show pic zz9.

       procedure division.
       sample-main.
       perform varying cand from 1 by 1 until cand greater than 12
                  after ier from 1 by 1 until ier greater than 12
           multiply cand by ier giving num(cand, ier)
       end-perform

       perform varying cand from 1 by 1 until cand greater than 12
           move cand to ind
           display "x " ind "| " with no advancing
           perform varying ier from 1 by 1 until ier greater than 12
               if ier greater than or equal to cand then
                   move num(cand, ier) to show
                   display show with no advancing
                   if ier equal to 12 then
                       display "|"
                   else
                       display space with no advancing
                   end-if
               else
                   display "    " with no advancing
               end-if
           end-perform
       end-perform

       goback.
       end program multiplication-table.
Output:
prompt$ cobc -xj multiplication-table.cob
x  1|   1   2   3   4   5   6   7   8   9  10  11  12|
x  2|       4   6   8  10  12  14  16  18  20  22  24|
x  3|           9  12  15  18  21  24  27  30  33  36|
x  4|              16  20  24  28  32  36  40  44  48|
x  5|                  25  30  35  40  45  50  55  60|
x  6|                      36  42  48  54  60  66  72|
x  7|                          49  56  63  70  77  84|
x  8|                              64  72  80  88  96|
x  9|                                  81  90  99 108|
x 10|                                     100 110 120|
x 11|                                         121 132|
x 12|                                             144|

CoffeeScript

print_multiplication_tables = (n) ->
  width = 4
  
  pad = (s, n=width, c=' ') ->
    s = s.toString()
    result = ''
    padding = n - s.length
    while result.length < padding
      result += c
    result + s

  s = pad('') + '|'
  for i in [1..n]
    s += pad i
  console.log s

  s = pad('', width, '-') + '+'
  for i in [1..n]
    s += pad '', width, '-'
  console.log s


  for i in [1..n]
    s = pad i
    s += '|'
    s += pad '', width*(i - 1)
    for j in [i..n]
       s += pad i*j
    console.log s
    
print_multiplication_tables 12
Output:
> coffee multiply.coffee 
    |   1   2   3   4   5   6   7   8   9  10  11  12
----+------------------------------------------------
   1|   1   2   3   4   5   6   7   8   9  10  11  12
   2|       4   6   8  10  12  14  16  18  20  22  24
   3|           9  12  15  18  21  24  27  30  33  36
   4|              16  20  24  28  32  36  40  44  48
   5|                  25  30  35  40  45  50  55  60
   6|                      36  42  48  54  60  66  72
   7|                          49  56  63  70  77  84
   8|                              64  72  80  88  96
   9|                                  81  90  99 108
  10|                                     100 110 120
  11|                                         121 132
  12|                                             144

Common Lisp

(do ((m 0 (if (= 12 m) 0 (1+ m)))
     (n 0 (if (= 12 m) (1+ n) n)))
    ((= n 13))
  (if (zerop n)
      (case m
        (0 (format t "  *|"))
        (12 (format t "  12~&---+------------------------------------------------~&"))
        (otherwise
         (format t "~4,D" m)))
      (case m
        (0 (format t "~3,D|" n))
        (12 (format t "~4,D~&" (* n m)))
        (otherwise
         (if (>= m n)
             (format t "~4,D" (* m n))
             (format t "    "))))))

Output:


  *|   1   2   3   4   5   6   7   8   9  10  11  12
---+------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

D

Translation of: PicoLisp
void main() {
    import std.stdio, std.array, std.range, std.algorithm;

    enum n = 12;
    writefln("    %(%4d%)\n%s", iota(1, n+1), "-".replicate(4*n + 4));
    foreach (immutable y; 1 .. n + 1)
        writefln("%4d" ~ " ".replicate(4 * (y - 1)) ~ "%(%4d%)", y,
                 iota(y, n + 1).map!(x => x * y));
}
Output:
       1   2   3   4   5   6   7   8   9  10  11  12
----------------------------------------------------
   1   1   2   3   4   5   6   7   8   9  10  11  12
   2       4   6   8  10  12  14  16  18  20  22  24
   3           9  12  15  18  21  24  27  30  33  36
   4              16  20  24  28  32  36  40  44  48
   5                  25  30  35  40  45  50  55  60
   6                      36  42  48  54  60  66  72
   7                          49  56  63  70  77  84
   8                              64  72  80  88  96
   9                                  81  90  99 108
  10                                     100 110 120
  11                                         121 132
  12                                             144

DCL

$ max = 12
$ h = f$fao( "!4* " )
$ r = 0
$ loop1:
$  o = ""
$  c = 0
$  loop2:
$   if r .eq. 0 then $ h = h + f$fao( "!4SL", c )
$   p = r * c
$   if c .ge. r
$   then
$    o = o + f$fao( "!4SL", p )
$   else
$    o = o + f$fao( "!4* " )
$   endif
$   c = c + 1
$   if c .le. max then $ goto loop2
$  if r .eq. 0
$  then
$   write sys$output h
$   n = 4 * ( max + 2 )
$   write sys$output f$fao( "!''n*-" )
$  endif
$  write sys$output f$fao( "!4SL", r ) + o
$  r = r + 1
$  if r .le. max then $ goto loop1
Output:
$ @multiplication_tables
       0   1   2   3   4   5   6   7   8   9  10  11  12
--------------------------------------------------------
   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   1       1   2   3   4   5   6   7   8   9  10  11  12
   2           4   6   8  10  12  14  16  18  20  22  24
   3               9  12  15  18  21  24  27  30  33  36
   4                  16  20  24  28  32  36  40  44  48
   5                      25  30  35  40  45  50  55  60
   6                          36  42  48  54  60  66  72
   7                              49  56  63  70  77  84
   8                                  64  72  80  88  96
   9                                      81  90  99 108
  10                                         100 110 120
  11                                             121 132
  12                                                 144

Delphi

Translation of: DWScript
program MultiplicationTables;

{$APPTYPE CONSOLE}

uses SysUtils;

const
  MAX_COUNT = 12;
var
  lRow, lCol: Integer;
begin
  Write('  | ');
  for lRow := 1 to MAX_COUNT do
    Write(Format('%4d', [lRow]));
  Writeln('');
  Writeln('--+-' + StringOfChar('-', MAX_COUNT * 4));
  for lRow := 1 to MAX_COUNT do
  begin
    Write(Format('%2d', [lRow]));
    Write('| ');
    for lCol := 1 to MAX_COUNT do
    begin
      if lCol < lRow then
        Write('    ')
      else
        Write(Format('%4d', [lRow * lCol]));
    end;
    Writeln;
  end;
end.

Draco

/* Print N-by-N multiplication table */
proc nonrec multab(byte n) void:
    byte i,j;
    
    /* write header */
    write("    |");
    for i from 1 upto n do write(i:4) od;
    writeln();
    write("----+");
    for i from 1 upto n do write("----") od;
    writeln();
    
    /* write lines */
    for i from 1 upto n do
        write(i:4, "|");
        for j from 1 upto n do
            if i <= j then write(i*j:4)
            else write("    ")
            fi
        od;
        writeln()
    od
corp

/* Print 12-by-12 multiplication table */
proc nonrec main() void: multab(12) corp
Output:
    |   1   2   3   4   5   6   7   8   9  10  11  12
----+------------------------------------------------
   1|   1   2   3   4   5   6   7   8   9  10  11  12
   2|       4   6   8  10  12  14  16  18  20  22  24
   3|           9  12  15  18  21  24  27  30  33  36
   4|              16  20  24  28  32  36  40  44  48
   5|                  25  30  35  40  45  50  55  60
   6|                      36  42  48  54  60  66  72
   7|                          49  56  63  70  77  84
   8|                              64  72  80  88  96
   9|                                  81  90  99 108
  10|                                     100 110 120
  11|                                         121 132
  12|                                             144

DWScript

const size = 12;
var row, col : Integer;

Print('  | ');
for row:=1 to size do
   Print(Format('%4d', [row]));
PrintLn('');
PrintLn('--+-'+StringOfChar('-', size*4));
for row:=1 to size do begin
   Print(Format('%2d', [row]));
   Print('| ');
   for col:=1 to size do begin
      if col<row then
         Print('    ')
      else Print(Format('%4d', [row*col]));
   end;
   PrintLn('');
end;

E

  def size := 12
  println(`{|style="border-collapse: collapse; text-align: right;"`)
  println(`|`)
  for x in 1..size {
    println(`|style="border-bottom: 1px solid black; " | $x`)
  }
  for y in 1..size {
    println(`|-`)
      println(`|style="border-right: 1px solid black;" | $y`)
    for x in 1..size {
      println(`| &nbsp;${if (x >= y) { x*y } else {""}}`)
    }
  }
  println("|}")

Targets MediaWiki markup.

Output:
1 2 3 4 5 6 7 8 9 10 11 12
1  1  2  3  4  5  6  7  8  9  10  11  12
2    4  6  8  10  12  14  16  18  20  22  24
3      9  12  15  18  21  24  27  30  33  36
4        16  20  24  28  32  36  40  44  48
5          25  30  35  40  45  50  55  60
6            36  42  48  54  60  66  72
7              49  56  63  70  77  84
8                64  72  80  88  96
9                  81  90  99  108
10                    100  110  120
11                      121  132
12                        144

EasyLang

n = 12
numfmt 0 4
write "     "
for i = 1 to n
   write i
.
print ""
write "     "
for i = 1 to n
   write "----"
.
print ""
for i = 1 to n
   write i
   write "|"
   for j = 1 to n
      if j < i
         write "    "
      else
         write i * j
      .
   .
   print ""
.

EchoLisp

(lib 'matrix)

(define (mtable i j)
    (cond
    ((and (zero? i) (zero? j)) "😅")
    ((= i 0) j)
    ((= j 0) i)
    ((>= j i ) (* i j ))
    (else " ")))

(array-print (build-array 13 13 mtable))
Output:
  😅   1   2   3   4    5    6    7    8    9    10    11    12  
  1    1   2   3   4    5    6    7    8    9    10    11    12  
  2        4   6   8    10   12   14   16   18   20    22    24  
  3            9   12   15   18   21   24   27   30    33    36  
  4                16   20   24   28   32   36   40    44    48  
  5                     25   30   35   40   45   50    55    60  
  6                          36   42   48   54   60    66    72  
  7                               49   56   63   70    77    84  
  8                                    64   72   80    88    96  
  9                                         81   90    99    108 
  10                                             100   110   120 
  11                                                   121   132 
  12                                                         144 

Elixir

defmodule RC do
  def multiplication_tables(n) do
    IO.write " X |"
    Enum.each(1..n, fn i -> :io.fwrite("~4B", [i]) end)
    IO.puts "\n---+" <> String.duplicate("----", n)
    Enum.each(1..n, fn j ->
      :io.fwrite("~2B |", [j])
      Enum.each(1..n, fn i ->
        if i<j, do: (IO.write "    "), else: :io.fwrite("~4B", [i*j]) 
      end)
      IO.puts ""
    end)
  end
end

RC.multiplication_tables(12)
Output:
 X |   1   2   3   4   5   6   7   8   9  10  11  12
---+------------------------------------------------
 1 |   1   2   3   4   5   6   7   8   9  10  11  12
 2 |       4   6   8  10  12  14  16  18  20  22  24
 3 |           9  12  15  18  21  24  27  30  33  36
 4 |              16  20  24  28  32  36  40  44  48
 5 |                  25  30  35  40  45  50  55  60
 6 |                      36  42  48  54  60  66  72
 7 |                          49  56  63  70  77  84
 8 |                              64  72  80  88  96
 9 |                                  81  90  99 108
10 |                                     100 110 120
11 |                                         121 132
12 |                                             144

EMal

Translation of: TypeScript
int NUMBER = 12
for int j = 1; j <= NUMBER; ++j do write((text!j).padStart(3, " ") + " ") end
writeLine()
writeLine("----" * NUMBER + "+")
for int i = 1; i <= NUMBER; i++
  for int j = 1; j <= NUMBER; ++j
    write(when(j < i, "    ", (text!(i * j)).padStart(3, " ") + " "))
  end
  writeLine("| " + (text!i).padStart(2, " "))
end
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
------------------------------------------------+
  1   2   3   4   5   6   7   8   9  10  11  12 |  1
      4   6   8  10  12  14  16  18  20  22  24 |  2
          9  12  15  18  21  24  27  30  33  36 |  3
             16  20  24  28  32  36  40  44  48 |  4
                 25  30  35  40  45  50  55  60 |  5
                     36  42  48  54  60  66  72 |  6
                         49  56  63  70  77  84 |  7
                             64  72  80  88  96 |  8
                                 81  90  99 108 |  9
                                    100 110 120 | 10
                                        121 132 | 11
                                            144 | 12

Erlang

-module( multiplication_tables ).

-export( [print_upto/1, task/0, upto/1] ).

print_upto( N ) ->
	Upto_tuples = [{X, {Y, Sum}} || {X, Y, Sum} <- upto(N)],
	io:fwrite( "  " ),
	[io:fwrite( "~5B", [X]) || X <- lists:seq(1, N)],
	io:nl(),
	io:nl(),
	[print_upto(X, proplists:get_all_values(X, Upto_tuples)) || X <- lists:seq(1, N)].
	

task() -> print_upto( 12 ).

upto( N ) -> [{X, Y, X*Y} || X <- lists:seq(1, N), Y <- lists:seq(1, N), Y >= X].



print_upto( N, Uptos ) ->
	io:fwrite( "~2B", [N] ),
	io:fwrite( "~*s", [5*(N - 1), " "] ),
	[io:fwrite("~5B", [Sum]) || {_Y, Sum} <- Uptos],
	io:nl().
Output:
25> multiplication_tables:task().
      1    2    3    4    5    6    7    8    9   10   11   12

 1    1    2    3    4    5    6    7    8    9   10   11   12
 2         4    6    8   10   12   14   16   18   20   22   24
 3              9   12   15   18   21   24   27   30   33   36
 4                  16   20   24   28   32   36   40   44   48
 5                       25   30   35   40   45   50   55   60
 6                            36   42   48   54   60   66   72
 7                                 49   56   63   70   77   84
 8                                      64   72   80   88   96
 9                                           81   90   99  108
10                                               100  110  120
11                                                    121  132
12                                                         144

Euphoria

puts(1," x")
for i = 1 to 12 do
    printf(1," %3d",i)
end for

puts(1,'\n')

for i = 1 to 12 do
  printf(1,"%2d",i)
  for j = 1 to 12 do
    if j<i then
      puts(1,"    ")
    else
      printf(1," %3d",i*j)
    end if
  end for
  puts(1,'\n')
end for
Output:
  x   1   2   3   4   5   6   7   8   9  10  11  12
  1   1   2   3   4   5   6   7   8   9  10  11  12
  2       4   6   8  10  12  14  16  18  20  22  24
  3           9  12  15  18  21  24  27  30  33  36
  4              16  20  24  28  32  36  40  44  48
  5                  25  30  35  40  45  50  55  60
  6                      36  42  48  54  60  66  72
  7                          49  56  63  70  77  84
  8                              64  72  80  88  96
  9                                  81  90  99 108
 10                                     100 110 120
 11                                         121 132
 12                                             144

Excel

LAMBDA

Binding the name FNOVERHALFCARTESIANPRODUCT to the following lambda expression in the Name Manager of the Excel WorkBook:

(See LAMBDA: The ultimate Excel worksheet function)

FNOVERHALFCARTESIANPRODUCT
=LAMBDA(f,
    LAMBDA(n,
        LET(
            ixs, SEQUENCE(n, n, 1, 1),

            REM, "1-based indices.",
            x, 1 + MOD(ixs - 1, n),
            y, 1 + QUOTIENT(ixs - 1, n),
            
            IF(x >= y,
                f(x)(y),
                ""
            )
        )
    )
)

and also assuming the following generic bindings in the Name Manager for the WorkBook:

MUL
=LAMBDA(a, LAMBDA(b, a * b))


POW
=LAMBDA(n,
    LAMBDA(e,
        POWER(n, e)
    )
)

(The single formula in cell B2 below populates the whole 12*12 grid)

Output:
fx =FNOVERHALFCARTESIANPRODUCT( MUL )(12)
A B C D E F G H I J K L M
1 x*y applied over every unique pair in a cartesian product of [1..12] with itself
2 1 1 2 3 4 5 6 7 8 9 10 11 12
3 2 4 6 8 10 12 14 16 18 20 22 24
4 3 9 12 15 18 21 24 27 30 33 36
5 4 16 20 24 28 32 36 40 44 48
6 5 25 30 35 40 45 50 55 60
7 6 36 42 48 54 60 66 72
8 7 49 56 63 70 77 84
9 8 64 72 80 88 96
10 9 81 90 99 108
11 10 100 110 120
12 11 121 132
13 12 144
fx =FNOVERHALFCARTESIANPRODUCT( POW )(12)
A B C D E F G H I J K L M
1 x^y applied over every unique pair in a cartesian product of [1..12] with itself
2 1 1 2 3 4 5 6 7 8 9 10 11 12
3 2 4 9 16 25 36 49 64 81 100 121 144
4 3 27 64 125 216 343 512 729 1000 1331 1728
5 4 256 625 1296 2401 4096 6561 10000 14641 20736
6 5 3125 7776 16807 32768 59049 100000 161051 248832
7 6 46656 117649 262144 531441 1000000 1771561 2985984
8 7 823543 2097152 4782969 10000000 19487171 35831808
9 8 16777216 43046721 100000000 214358881 429981696
10 9 387420489 1000000000 2357947691 5159780352
11 10 10000000000 25937424601 61917364224
12 11 285311670611 743008370688
13 12 8916100448256

F#

Translation of C#

open System

let multTable () =
    Console.Write (" X".PadRight (4))
    for i = 1 to 12 do Console.Write ((i.ToString "####").PadLeft 4)
    Console.Write "\n ___"
    for i = 1 to 12 do Console.Write " ___"
    Console.WriteLine ()
    for row = 1 to 12 do
        Console.Write (row.ToString("###").PadLeft(3).PadRight(4))
        for col = 1 to 12 do
            if row <= col then Console.Write ((row * col).ToString("###").PadLeft(4))
            else
                Console.Write ("".PadLeft 4)
        Console.WriteLine ()
    Console.WriteLine ()
    Console.ReadKey () |> ignore

multTable ()
Output:
 X     1   2   3   4   5   6   7   8   9  10  11  12
 ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___
  1    1   2   3   4   5   6   7   8   9  10  11  12
  2        4   6   8  10  12  14  16  18  20  22  24
  3            9  12  15  18  21  24  27  30  33  36
  4               16  20  24  28  32  36  40  44  48
  5                   25  30  35  40  45  50  55  60
  6                       36  42  48  54  60  66  72
  7                           49  56  63  70  77  84
  8                               64  72  80  88  96
  9                                   81  90  99 108
 10                                      100 110 120
 11                                          121 132
 12                                              144

Factor

USING: io kernel math math.parser math.ranges sequences ;
IN: multiplication-table

: print-row ( n -- )
    [ number>string 2 CHAR: space pad-head write " |" write ]
    [ 1 - [ "    " write ] times ]
    [
        dup 12 [a,b]
        [ * number>string 4 CHAR: space pad-head write ] with each
    ] tri nl ;

: print-table ( -- )
    "    " write
    1 12 [a,b] [ number>string 4 CHAR: space pad-head write ] each nl
    "   +" write
    12 [ "----" write ] times nl
    1 12 [a,b] [ print-row ] each ;
       1   2   3   4   5   6   7   8   9  10  11  12
   +------------------------------------------------
 1 |   1   2   3   4   5   6   7   8   9  10  11  12
 2 |       4   6   8  10  12  14  16  18  20  22  24
 3 |           9  12  15  18  21  24  27  30  33  36
 4 |              16  20  24  28  32  36  40  44  48
 5 |                  25  30  35  40  45  50  55  60
 6 |                      36  42  48  54  60  66  72
 7 |                          49  56  63  70  77  84
 8 |                              64  72  80  88  96
 9 |                                  81  90  99 108
10 |                                     100 110 120
11 |                                         121 132
12 |                                             144

FALSE

[$100\>[" "]?$10\>[" "]?." "]p:
[$p;! m: 2[$m;\>]["    "1+]# [$13\>][$m;*p;!1+]#%"
"]l:
1[$13\>][$l;!1+]#%

Fantom

class Main
{
  static Void multiplicationTable (Int n)
  {
    // print column headings
    echo ("    |" + (1..n).map |Int a -> Str| { a.toStr.padl(4)}.join("") )
    echo ("-----" + (1..n).map { "----" }.join("") )
    // work through each row
    (1..n).each |i|
    {
      echo ( i.toStr.padl(4) + "|" +
             Str.spaces(4*(i-1)) + 
             (i..n).map |Int j -> Str| { (i*j).toStr.padl(4)}.join("") )
    }
  }

  public static Void main ()
  {
    multiplicationTable (12)
  }
}

Forth

: multiplication-table
  cr 2 spaces  13 2 do i 4 u.r loop
  cr
  13 2 do
    cr i 2 u.r
    13 2 do
      i j < if 4 spaces else i j * 4 u.r then
    loop
  loop ;

Fortran

Works with: Fortran version 90 and later
program multtable
implicit none

  integer :: i, j, k

    write(*, "(a)") " x|   1   2   3   4   5   6   7   8   9  10  11  12"
    write(*, "(a)") "--+------------------------------------------------"
    do i = 1, 12
      write(*, "(i2, a)", advance="no") i, "|"
	do k = 2, i
    	  write(*, "(a4)", advance="no") ""
        end do
    	do j = i, 12
          write(*, "(i4)", advance="no") i*j
        end do
        write(*, *)
    end do

end program multtable

Traditional approach

The usual style is to write whole lines at a go, traditionally to fast lineprinters. Producing a tabular layout is easy (four characters per field to allow room to print 144 with a space separator), the difficulty lies in having blank parts at the start of the line followed by results. Having results followed by blanks is normal. The simplest way to achieve this would be to have a CHARACTER*4 function IFMT4(n) that returns four spaces for n <= 0, otherwise the digits, similar to the above example. But the plan is to write a line of such function calls at a go (with n = 0 for unwanted results), and alas, very few Fortran implementations allow recursive use of the formatted I/O system - here one level would be inside the function to produce the result for N > 0, and the other is the original WRITE statement that invokes the function.

So instead, write the table by first writing a line to a CHARACTER variable then blanking out the unwanted part.

Cast forth a twelve times table, suitable for chanting at school.
      INTEGER I,J	!Steppers.
      CHARACTER*52 ALINE	!Scratchpad.
      WRITE(6,1) (I,I = 1,12)	!Present the heading.
    1 FORMAT ("  ×|",12I4,/," --+",12("----"))	!Alas, can't do overprinting with underlines now.
      DO 3 I = 1,12		!Step down the lines.
        WRITE (ALINE,2) I,(I*J, J = 1,12)	!Prepare one line.
    2   FORMAT (I3,"|",12I4)		!Aligned with the heading.
        ALINE(5:1 + 4*I) = ""		!Scrub the unwanted part.
    3   WRITE (6,"(A)") ALINE		!Print the text.
      END	!"One one is one! One two is two! One three is three!...

Output in the same style as above, with underlining unavailable: those who have used a lineprinter's overprint facility to properly underline find the flabby modern requirement of a second line vexing, but, few output devices support underlining in so easy a way.

 ×|   1   2   3   4   5   6   7   8   9  10  11  12
--+------------------------------------------------
 1|   1   2   3   4   5   6   7   8   9  10  11  12
 2|       4   6   8  10  12  14  16  18  20  22  24
 3|           9  12  15  18  21  24  27  30  33  36
 4|              16  20  24  28  32  36  40  44  48
 5|                  25  30  35  40  45  50  55  60
 6|                      36  42  48  54  60  66  72
 7|                          49  56  63  70  77  84
 8|                              64  72  80  88  96
 9|                                  81  90  99 108
10|                                     100 110 120
11|                                         121 132
12|                                             144

Going to the trouble of preparing results, and then blanking some might seem a little too crude. An alternative would be to use a different FORMAT statement for each line of output. But, a collection of a dozen output statements hardly represents a programming solution. Instead, create and then use the text of FORMAT statements, as follows. Notice that there are no reserved words in Fortran.

Cast forth a twelve times table, suitable for chanting at school.
      INTEGER I,J	!Steppers.
      CHARACTER*16 FORMAT	!Scratchpad.
      WRITE(6,1) (I,I = 1,12)	!Present the heading.
    1 FORMAT ("  ×|",12I4,/," --+",12("----"))	!Alas, can't do overprinting with underlines now.
      DO 3 I = 1,12		!Step down the lines.
        WRITE (FORMAT,2) (I - 1)*4,13 - I	!Spacing for omitted fields, count of wanted fields.
    2   FORMAT ("(I3,'|',",I0,"X,",I0,"I4)")	!The format of the FORMAT statement.
    3   WRITE (6,FORMAT) I,(I*J, J = I,12)	!Use it.
      END	!"One one is one! One two is two! One three is three!...

The output is the same, so instead, here are the generated FORMAT texts:

(I3,'|',0X,12I4)
(I3,'|',4X,11I4)
(I3,'|',8X,10I4)
(I3,'|',12X,9I4)
(I3,'|',16X,8I4)
(I3,'|',20X,7I4)
(I3,'|',24X,6I4)
(I3,'|',28X,5I4)
(I3,'|',32X,4I4)
(I3,'|',36X,3I4)
(I3,'|',40X,2I4)
(I3,'|',44X,1I4)

A zero count for spacing (the 0X, due to there being no omitted results on the first line) was possibly a weak point, but if not handled, the fallback position would have been to arrange that instead of 12I4 format, the first would be 1X,I3.

Some fortrans offer an extension to FORMAT statements, whereby a variable can appear in place of an integer constant, thus instead of say FORMAT (12I4) there could be FORMAT (<n>I4) for example. Then, during the interpretation of the FORMAT text, the current value of variable n would be accessed. Note that this is on-the-fly:

READ(in,"(I2,<N>I4)") N,(A(I),I = 1,N)

would read N as a two-digit integer, and, as the READ statement executes further, use that value of N both in the FORMAT text's interpretation and in the further processing of the READ statement.

VAX FORTRAN

      PROGRAM TABLES
      IMPLICIT NONE
C
C     Produce a formatted multiplication table of the kind memorised by rote
C     when in primary school. Only print the top half triangle of products. 
C
C     23 Nov 15 - 0.1   - Adapted from original for VAX FORTRAN - MEJT
C
      INTEGER I,J,K                                             ! Counters.
      CHARACTER*32 S                                            ! Buffer for format specifier.
C
      K=12
C
      WRITE(S,1) K,K
    1 FORMAT(8H(4H0  |,,I2.2,11HI4,/,4H --+,I2.2,9H(4H----)))
      WRITE(6,S) (I,I = 1,K)                                    ! Print heading.
C
      DO 3 I=1,K		                                ! Step down the lines.
        WRITE(S,2) (I-1)*4+1,K                                  ! Update format string.
    2   FORMAT(12H(1H ,I2,1H|,,I2.2,5HX,I3,,I2.2,3HI4),8X)      ! Format string includes an explicit carridge control character.
        WRITE(6,S) I,(I*J, J = I,K)                             ! Use format to print row with leading blanks, unused fields are ignored.
    3 CONTINUE
C
      END
Based on the above code but with a slight modification as VAX FORTRAN doesn't allow zero width fields in a format statement. The number of rows and columns can also be altered by modifying the value of K which must be in the range 1 - 25.

FORTRAN-IV

      PROGRAM TABLES
C
C     Produce a formatted multiplication table of the kind memorised by rote
C     when in primary school. Only print the top half triangle of products. 
C
C     23 Nov 15 - 0.1   - Adapted from original for VAX FORTRAN - MEJT
C     24 Nov 15 - 0.2   - FORTRAN IV version adapted from VAX FORTRAN and 
C                         compiled using Microsoft FORTRAN-80 - MEJT
C
      DIMENSION K(12)
      DIMENSION A(6)
      DIMENSION L(12)
C
      COMMON //A
      EQUIVALENCE (A(1),L(1))
C
      DATA A/'(1H ',',I2,','1H|,','01X,','I3,1','2I4)'/
C
      WRITE(1,1) (I,I=1,12)
    1 FORMAT(4H0  |,12I4,/,4H --+12(4H----))
C
C     Overlaying the format specifier with an integer array makes it possibe
C     to modify the number of blank spaces.  The number of blank spaces is 
C     stored as two consecuitive ASCII characters that overlay on the 
C     integer value in L(7) in the ordr low byte, high byte.
C
      DO 3 I=1,12
        L(7)=(48+(I*4-3)-((I*4-3)/10)*10)*256+48+((I*4-3)/10)
        DO 2 J=1,12
          K(J)=I*J
    2   CONTINUE
        WRITE(1,A)I,(K(J), J = I,12)
    3 CONTINUE
C
      END
Rather more changes are needed to produce the same result, in particular we cannot modify the format specifier directly and have to rely on overlaying it with an integer array and calculating the ASCII values needed for each byte we need to modify. Nested implicit DO loops are allowed, but not used as it isn't possible to compute K on the fly so we have to calculate (and store) the results for each row before printing it. Note also that the unit numbers for the output devices are different and when using Hollerith strings to define values in a DATA statement the size of each string must match the size of the data type.

Microsoft FORTRAN-80

The use of a non standard(?) BYTE data type available in Microsoft FORTRAN-80 makes it easier to understand what is going on.

      PROGRAM TABLES
C
C     Produce a formatted multiplication table of the kind memorised by rote
C     when in primary school. Only print the top half triangle of products. 
C
C     23 Nov 15 - 0.1   - Adapted from original for VAX FORTRAN - MEJT
C     24 Nov 15 - 0.2   - FORTRAN IV version adapted from VAX FORTRAN and 
C                         compiled using Microsoft FORTRAN-80 - MEJT
C     25 Nov 15 - 0.3   - Microsoft FORTRAN-80 version using a BYTE array
C                         which makes it easier to understand what is going
C                         on. - MEJT 
C
      BYTE A
      DIMENSION A(24)
      DIMENSION K(12)
C
      DATA A/'(','1','H',' ',',','I','2',',','1','H','|',',',
     +       '0','1','X',',','I','3',',','1','1','I','4',')'/
C
C     Print a heading and (try to) underline it.
C
      WRITE(1,1) (I,I=1,12)
    1 FORMAT(4H   |,12I4,/,4H --+12(4H----))
      DO 3 I=1,12
        A(13)=48+((I*4-3)/10)
        A(14)=48+(I*4-3)-((I*4-3)/10)*10
        DO 2 J=1,12
          K(J)=I*J
    2   CONTINUE
        WRITE(1,A)I,(K(J), J = I,12)
    3 CONTINUE
C
      END
Inserting the following two lines before the inner DO loop will print the format specifier used to print each row of the table.
        WRITE(1,4) (A(J), J = 1,24)
    4   FORMAT(1x,24A1)
Running the program produces the following output
  |   1   2   3   4   5   6   7   8   9  10  11  12
--+------------------------------------------------
 1|   1   2   3   4   5   6   7   8   9  10  11  12
 2|       4   6   8  10  12  14  16  18  20  22  24
 3|           9  12  15  18  21  24  27  30  33  36
 4|              16  20  24  28  32  36  40  44  48
 5|                  25  30  35  40  45  50  55  60
 6|                      36  42  48  54  60  66  72
 7|                          49  56  63  70  77  84
 8|                              64  72  80  88  96
 9|                                  81  90  99 108
10|                                     100 110 120
11|                                         121 132
12|                                             144

Frink

a = makeArray[[13,13], {|a,b| a==0 ? b : (b==0 ? a : (a<=b ? a*b : ""))}]
formatTable[a,"right"]
Output:
 0 1 2 3  4  5  6  7  8  9  10  11  12
 1 1 2 3  4  5  6  7  8  9  10  11  12
 2   4 6  8 10 12 14 16 18  20  22  24
 3     9 12 15 18 21 24 27  30  33  36
 4       16 20 24 28 32 36  40  44  48
 5          25 30 35 40 45  50  55  60
 6             36 42 48 54  60  66  72
 7                49 56 63  70  77  84
 8                   64 72  80  88  96
 9                      81  90  99 108
10                         100 110 120
11                             121 132
12                                 144

Go

package main

import (
    "fmt"
)

func main() {
    fmt.Print(" x |")
    for i := 1; i <= 12; i++ {
        fmt.Printf("%4d", i)
    }
    fmt.Print("\n---+")
    for i := 1; i <= 12; i++ {
        fmt.Print("----")
    }
    for j := 1; j <= 12; j++ {
        fmt.Printf("\n%2d |", j)
        for i := 1; i <= 12; i++ {
            if i >= j {
                fmt.Printf("%4d", i*j)
            } else {
                fmt.Print("    ")
            }
        }
    }
    fmt.Println("")
}

Groovy

Solution:

def printMultTable = { size = 12 ->
    assert size > 1
    
    // factor1 line
    print '  |'; (1..size).each { f1 -> printf('%4d', f1) }; println ''
    
    // dividing line
    print '--+'; (1..size).each { printf('----', it) }; println ''
    
    // factor2 result lines
    (1..size).each { f2 ->
        printf('%2d|', f2)
        (1..<f2).each{ print '    ' }
        (f2..size).each{ f1 -> printf('%4d', f1*f2) }
        println ''
    }
}

printMultTable()
Output:
  |   1   2   3   4   5   6   7   8   9  10  11  12
--+------------------------------------------------
 1|   1   2   3   4   5   6   7   8   9  10  11  12
 2|       4   6   8  10  12  14  16  18  20  22  24
 3|           9  12  15  18  21  24  27  30  33  36
 4|              16  20  24  28  32  36  40  44  48
 5|                  25  30  35  40  45  50  55  60
 6|                      36  42  48  54  60  66  72
 7|                          49  56  63  70  77  84
 8|                              64  72  80  88  96
 9|                                  81  90  99 108
10|                                     100 110 120
11|                                         121 132
12|                                             144


Haskell

import Data.Maybe (fromMaybe, maybe)

------------------- MULTIPLICATION TABLE -----------------

mulTable :: [Int] -> [[Maybe Int]]
mulTable xs =
  (Nothing : labels) :
  zipWith
    (:)
    labels
    [[upperMul x y | y <- xs] | x <- xs]
  where
    labels = Just <$> xs
    upperMul x y
      | x > y = Nothing
      | otherwise = Just (x * y)


--------------------------- TEST -------------------------
main :: IO ()
main =
  putStrLn . unlines $
    showTable . mulTable
      <$> [ [13 .. 20],
            [1 .. 12],
            [95 .. 100]
          ]

------------------------ FORMATTING ----------------------
showTable :: [[Maybe Int]] -> String
showTable xs = unlines $ head rows : [] : tail rows
  where
    w = succ $ (length . show) (fromMaybe 0 $ (last . last) xs)
    gap = replicate w ' '
    rows = (maybe gap (rjust w ' ' . show) =<<) <$> xs
    rjust n c = (drop . length) <*> (replicate n c <>)
Output:
      13  14  15  16  17  18  19  20

  13 169 182 195 208 221 234 247 260
  14     196 210 224 238 252 266 280
  15         225 240 255 270 285 300
  16             256 272 288 304 320
  17                 289 306 323 340
  18                     324 342 360
  19                         361 380
  20                             400

       1   2   3   4   5   6   7   8   9  10  11  12

   1   1   2   3   4   5   6   7   8   9  10  11  12
   2       4   6   8  10  12  14  16  18  20  22  24
   3           9  12  15  18  21  24  27  30  33  36
   4              16  20  24  28  32  36  40  44  48
   5                  25  30  35  40  45  50  55  60
   6                      36  42  48  54  60  66  72
   7                          49  56  63  70  77  84
   8                              64  72  80  88  96
   9                                  81  90  99 108
  10                                     100 110 120
  11                                         121 132
  12                                             144

          95    96    97    98    99   100

    95  9025  9120  9215  9310  9405  9500
    96        9216  9312  9408  9504  9600
    97              9409  9506  9603  9700
    98                    9604  9702  9800
    99                          9801  9900
   100                               10000

Or, more roughly and directly:

import Data.List (groupBy)
import Data.Function (on)
import Control.Monad (join)

main :: IO ()
main =
  mapM_ print $
  fmap (uncurry (*)) <$>
  groupBy
    (on (==) fst)
    (filter (uncurry (>=)) $ join ((<*>) . fmap (,)) [1 .. 12])
Output:
[1]
[2,4]
[3,6,9]
[4,8,12,16]
[5,10,15,20,25]
[6,12,18,24,30,36]
[7,14,21,28,35,42,49]
[8,16,24,32,40,48,56,64]
[9,18,27,36,45,54,63,72,81]
[10,20,30,40,50,60,70,80,90,100]
[11,22,33,44,55,66,77,88,99,110,121]
[12,24,36,48,60,72,84,96,108,120,132,144]

hexiscript

fun format n l
  let n tostr n
  while len n < l; let n (" " + n); endwhile
  return n
endfun

print   "   |"
for let i 1; i <= 12; i++; print format i 4; endfor
print "\n --+"
for let i 1; i <= 12; i++; print "----"; endfor
println ""
for let i 1; i <= 12; i++
  print format i 3 + "|"
  for let j 1; j <= 12; j++
    if j < i; print "    "
    else print format (i * j) 4; endif
  endfor
  println ""
endfor

HicEst

WRITE(Row=1) " x   1   2   3   4   5   6   7   8   9  10  11  12"
DO line = 1, 12
  WRITE(Row=line+2, Format='i2') line
  DO col = line, 12
    WRITE(Row=line+2, Column=4*col, Format='i3') line*col
  ENDDO
ENDDO

HolyC

Translation of: C
U8 i, j, n = 12;
for (j = 1; j <= n; j++)
  if (j != n)
    Print("%3d%c", j, ' ');
  else
    Print("%3d%c", j, '\n');

for (j = 0; j <= n; j++)
  if (j != n)
    Print("----");
  else
    Print("+\n");

for (i = 1; i <= n; i++) {
  for (j = 1; j <= n; j++)
    if (j < i)
      Print("    ");
    else
      Print("%3d ", i * j);
  Print("| %d\n", i);
}

Icon and Unicon

procedure main()
lim := 13 
wid :=  5
every writes(right("* |" | (1 to lim) | "\n",wid)|right("\n",wid*(lim+1),"_"))         # header row and separator 
every (i := 1 to lim) & 
   writes(right( i||" |" | (j := 1 to lim, if j < i then "" else i*j) | "\n",wid))     # table content and triangle
end

The above example is a somewhat exaggerated example of contractions. In both cases 'every' is used to force all alternatives including row labels, column headings, content, line terminators. The upper triangle is produced by embedding an 'if' expression inside the object of an 'every' (normally an error prone construct which would malfunction if not carefully separated from the generators for 'i' and 'j' - an all too tempting possibility once you get into this mind set.)

Output:
 * |    1    2    3    4    5    6    7    8    9   10   11   12   13    
_____________________________________________________________________
  1 |    1    2    3    4    5    6    7    8    9   10   11   12   13    
  2 |         4    6    8   10   12   14   16   18   20   22   24   26    
  3 |              9   12   15   18   21   24   27   30   33   36   39    
  4 |                  16   20   24   28   32   36   40   44   48   52    
  5 |                       25   30   35   40   45   50   55   60   65    
  6 |                            36   42   48   54   60   66   72   78    
  7 |                                 49   56   63   70   77   84   91    
  8 |                                      64   72   80   88   96  104    
  9 |                                           81   90   99  108  117    
 10 |                                               100  110  120  130    
 11 |                                                    121  132  143    
 12 |                                                         144  156    
 13 |                                                              169 

Insitux

(var pad-num (comp str (pad-left " " 4)))

(join "\n"
  (for y (range 1 13)
    (... str "x" (pad-num y)
      (for x (range 1 13)
        (if (> y x)
            "    "
            (pad-num (* x y)))))))
Output:
x   1   1   2   3   4   5   6   7   8   9  10  11  12
x   2       4   6   8  10  12  14  16  18  20  22  24
x   3           9  12  15  18  21  24  27  30  33  36
x   4              16  20  24  28  32  36  40  44  48
x   5                  25  30  35  40  45  50  55  60
x   6                      36  42  48  54  60  66  72
x   7                          49  56  63  70  77  84
x   8                              64  72  80  88  96
x   9                                  81  90  99 108
x  10                                     100 110 120
x  11                                         121 132
x  12                                             144

J

   multtable=: <:/~ * */~
   format=: 'b4.0' 8!:2 ]
   (('*' ; ,.) ,. ({. ; ])@format@multtable) >:i.12
┌──┬────────────────────────────────────────────────┐
*    1   2   3   4   5   6   7   8   9  10  11  12
├──┼────────────────────────────────────────────────┤
 1   1   2   3   4   5   6   7   8   9  10  11  12
 2       4   6   8  10  12  14  16  18  20  22  24
 3           9  12  15  18  21  24  27  30  33  36
 4              16  20  24  28  32  36  40  44  48
 5                  25  30  35  40  45  50  55  60
 6                      36  42  48  54  60  66  72
 7                          49  56  63  70  77  84
 8                              64  72  80  88  96
 9                                  81  90  99 108
10                                     100 110 120
11                                         121 132
12                                             144
└──┴────────────────────────────────────────────────┘

That said, note that */~ is the core primitive used to construct a multiplication table and this is a general technique so that, for example, +/~ would make an addition table. The rest is just to make it look pretty (and to blank out the lower triangle -- we use a less than or equal table (<:/~) to control that, and format zeros as spaces to blank them out).

Java

public class MultiplicationTable {
    public static void main(String[] args) {
        for (int i = 1; i <= 12; i++)
            System.out.print("\t" + i);
        
        System.out.println();
        for (int i = 0; i < 100; i++)
            System.out.print("-");
        System.out.println();
        for (int i = 1; i <= 12; i++) {
            System.out.print(i + "|");
            for(int j = 1; j <= 12; j++) {
                System.out.print("\t");
                if (j >= i)
                    System.out.print("\t" + i * j);
            }
            System.out.println();
        }
    }
}
Output:
        1       2       3       4       5       6       7       8       9       10      11      12
----------------------------------------------------------------------------------------------------
1|      1       2       3       4       5       6       7       8       9       10      11      12
2|              4       6       8       10      12      14      16      18      20      22      24
3|                      9       12      15      18      21      24      27      30      33      36
4|                              16      20      24      28      32      36      40      44      48
5|                                      25      30      35      40      45      50      55      60
6|                                              36      42      48      54      60      66      72
7|                                                      49      56      63      70      77      84
8|                                                              64      72      80      88      96
9|                                                                      81      90      99      108
10|                                                                             100     110     120
11|                                                                                     121     132
12|                                                                                             144

JavaScript

Unicode output

The following example works with any (modern) JavaScript runtime:

function timesTable(){
	let output = "";
	const size = 12;
	for(let i = 1; i <= size; i++){
		output += i.toString().padStart(3);
		output += i !== size ? " " : "\n";
	}
	for(let i = 0; i <= size; i++)
		output += i !== size ? "════" : "╕\n";

	for(let i = 1; i <= size; i++){
		for(let j = 1; j <= size; j++){
			output += j < i
				? "    "
				: (i * j).toString().padStart(3) + " ";
		}
		output += `│ ${i}\n`;
	}
	return output;
}
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
════════════════════════════════════════════════╕
  1   2   3   4   5   6   7   8   9  10  11  12 │ 1
      4   6   8  10  12  14  16  18  20  22  24 │ 2
          9  12  15  18  21  24  27  30  33  36 │ 3
             16  20  24  28  32  36  40  44  48 │ 4
                 25  30  35  40  45  50  55  60 │ 5
                     36  42  48  54  60  66  72 │ 6
                         49  56  63  70  77  84 │ 7
                             64  72  80  88  96 │ 8
                                 81  90  99 108 │ 9
                                    100 110 120 │ 10
                                        121 132 │ 11
                                            144 │ 12

HTML tables

The following examples require a browser or browser-like environment:

Imperative

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" >
<title>12 times table</title>
<script type='text/javascript'>
    function multiplication_table(n, target) {
        var table = document.createElement('table');

        var row = document.createElement('tr');
        var cell = document.createElement('th');
        cell.appendChild(document.createTextNode('x'));
        row.appendChild(cell);
        for (var x = 1; x <=n; x++) {
            cell = document.createElement('th');
            cell.appendChild(document.createTextNode(x));
            row.appendChild(cell);
        }
        table.appendChild(row);

        for (var x = 1; x <=n; x++) {
            row = document.createElement('tr');
            cell = document.createElement('th');
            cell.appendChild(document.createTextNode(x));
            row.appendChild(cell);
            var y;
            for (y = 1; y < x; y++) {
                cell = document.createElement('td');
                cell.appendChild(document.createTextNode('\u00a0'));
                row.appendChild(cell);
            }
            for (; y <= n; y++) {
                cell = document.createElement('td');
                cell.appendChild(document.createTextNode(x*y));
                row.appendChild(cell);
            }
            table.appendChild(row);
        }
        target.appendChild(table);
    }
</script>
<style type='text/css'>
    body {font-family: sans-serif;}
    table {border-collapse: collapse;}
    th, td {border: 1px solid black; text-align: right; width: 4ex;}
</style>
</head>
<body onload="multiplication_table(12, document.getElementById('target'));">
<div id='target'></div>
</body>
</html>
Output:
(minus the style)
x123456789101112
1123456789101112
2 4681012141618202224
3 9121518212427303336
4 162024283236404448
5 2530354045505560
6 36424854606672
7 495663707784
8 6472808896
9 819099108
10 100110120
11 121132
12 144

Functional

ES5
(function (m, n) {

    // [m..n]
    function range(m, n) {
        return Array.apply(null, Array(n - m + 1)).map(function (x, i) {
            return m + i;
        });
    }
 
    // Monadic bind (chain) for lists
    function mb(xs, f) {
        return [].concat.apply([], xs.map(f));
    }

    var rng = range(m, n),
        lstTable = [['x'].concat(   rng )]
                         .concat(mb(rng,   function (x) {
        return       [[x].concat(mb(rng,   function (y) {
            return y < x ? [''] : [x * y];               // triangle only
    }))]}));
  
    /*                        FORMATTING OUTPUT                             */
 
    // [[a]] -> bool -> s -> s
    function wikiTable(lstRows, blnHeaderRow, strStyle) {
        return '{| class="wikitable" ' + (
            strStyle ? 'style="' + strStyle + '"' : ''
        ) + lstRows.map(function (lstRow, iRow) {
            var strDelim = ((blnHeaderRow && !iRow) ? '!' : '|');
 
            return '\n|-\n' + strDelim + ' ' + lstRow.map(function (v) {
                return typeof v === 'undefined' ? ' ' : v;
            }).join(' ' + strDelim + strDelim + ' ');
        }).join('') + '\n|}';
    }
 
    // Formatted as WikiTable
    return wikiTable(
        lstTable, true,
        'text-align:center;width:33em;height:33em;table-layout:fixed;'
    ) + '\n\n' +
 
    // or simply stringified as JSON
    JSON.stringify(lstTable);
})(1, 12);
Output:
x 1 2 3 4 5 6 7 8 9 10 11 12
1 1 2 3 4 5 6 7 8 9 10 11 12
2 4 6 8 10 12 14 16 18 20 22 24
3 9 12 15 18 21 24 27 30 33 36
4 16 20 24 28 32 36 40 44 48
5 25 30 35 40 45 50 55 60
6 36 42 48 54 60 66 72
7 49 56 63 70 77 84
8 64 72 80 88 96
9 81 90 99 108
10 100 110 120
11 121 132
12 144
[["x",1,2,3,4,5,6,7,8,9,10,11,12],
 [1,1,2,3,4,5,6,7,8,9,10,11,12],
 [2,"",4,6,8,10,12,14,16,18,20,22,24],
 [3,"","",9,12,15,18,21,24,27,30,33,36],
 [4,"","","",16,20,24,28,32,36,40,44,48],
 [5,"","","","",25,30,35,40,45,50,55,60],
 [6,"","","","","",36,42,48,54,60,66,72],
 [7,"","","","","","",49,56,63,70,77,84],
 [8,"","","","","","","",64,72,80,88,96],
 [9,"","","","","","","","",81,90,99,108],
 [10,"","","","","","","","","",100,110,120],
 [11,"","","","","","","","","","",121,132],
 [12,"","","","","","","","","","","",144]]
ES6
(() => {
    "use strict";

    // -------------- MULTIPLICATION TABLE ---------------

    // multTable :: Int -> Int -> [[String]]
    const multTable = m => n => {
        const xs = enumFromTo(m)(n);

        return [
            ["x", ...xs],
            ...xs.flatMap(
                x => [
                    [x, ...xs.flatMap(
                        y => y < x ? (
                            [""]
                        ) : [`${x * y}`]
                    )]
                ]
            )
        ];
    };

    // ---------------------- TEST -----------------------

    // main :: () -> IO String
    const main = () =>
        wikiTable({
            class: "wikitable",
            style: [
                "text-align:center",
                "width:33em",
                "height:33em",
                "table-layout:fixed"
            ].join(";")
        })(
            multTable(1)(12)
        );

    // ---------------- GENERIC FUNCTIONS ----------------

    // enumFromTo :: Int -> Int -> [Int]
    const enumFromTo = m => n =>
        n >= m ? Array.from({
            length: Math.floor(n - m) + 1
        }, (_, i) => m + i) : [];


    // ------------------- FORMATTING --------------------

    // wikiTable :: Dict -> [[a]] -> String
    const wikiTable = opts =>
        rows => {
            const
                style = ["class", "style"].reduce(
                    (a, k) => k in opts ? (
                        `${a}${k}="${opts[k]}" `
                    ) : a, ""
                ),
                body = rows.map((row, i) => {
                    const
                        cells = row.map(
                            x => `${x}` || " "
                        ).join(" || ");

                    return `${i ? "|" : "!"} ${cells}`;
                }).join("\n|-\n");

            return `{| ${style}\n${body}\n|}`;
        };

    //  MAIN ---
    return main();
})();
Output:
x 1 2 3 4 5 6 7 8 9 10 11 12
1 1 2 3 4 5 6 7 8 9 10 11 12
2 4 6 8 10 12 14 16 18 20 22 24
3 9 12 15 18 21 24 27 30 33 36
4 16 20 24 28 32 36 40 44 48
5 25 30 35 40 45 50 55 60
6 36 42 48 54 60 66 72
7 49 56 63 70 77 84
8 64 72 80 88 96
9 81 90 99 108
10 100 110 120
11 121 132
12 144

jq

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

def multiplication($n):
  ($n*$n|tostring|length) as $len
  | ["x", range(0; $n + 1)] | map(lpad($len)) | join(" "),
    (["", range(0; $n + 1)] | map($len*"-")   | join(" ")),
    ( range(0; $n + 1) as $i
      | [$i, 
         range(0; $n + 1) as $j
         | if $j>=$i then $i*$j else "" end]
      | map(lpad($len))
      | join(" ") ) ;

multiplication(12)
Output:
  x   0   1   2   3   4   5   6   7   8   9  10  11  12
--- --- --- --- --- --- --- --- --- --- --- --- --- ---
  0   0   0   0   0   0   0   0   0   0   0   0   0   0
  1       1   2   3   4   5   6   7   8   9  10  11  12
  2           4   6   8  10  12  14  16  18  20  22  24
  3               9  12  15  18  21  24  27  30  33  36
  4                  16  20  24  28  32  36  40  44  48
  5                      25  30  35  40  45  50  55  60
  6                          36  42  48  54  60  66  72
  7                              49  56  63  70  77  84
  8                                  64  72  80  88  96
  9                                      81  90  99 108
 10                                         100 110 120
 11                                             121 132
 12                                                 144

Jsish

/* Multiplication tables, is Jsish */
var m, n, tableSize = 12;

if (console.args.length > 0) tableSize = parseInt(console.args[0]);
if (tableSize < 1 || tableSize > 20) tableSize = 12;

var width = String(tableSize * tableSize).length;
var spaces = ' '.repeat(width+1);

printf(spaces);
for (m = 1; m <= tableSize; m++) printf(' %*d', width, m);
printf('\n' + ' '.repeat(width) + '+');
printf('-'.repeat((width+1) * tableSize));
for (m = 1; m <= tableSize; m++) {
    printf('\n%*d|', width, m);
    for (n = m; n < m; n++) printf(spaces);
    for (n = 1; n <= tableSize; n++) {
        if (m <= n) printf(' %*d', width, m * n); else printf(spaces);
    }
}
printf('\n');
Output:
prompt$ jsish multiplication-tables.jsi
       1   2   3   4   5   6   7   8   9  10  11  12
   +------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

prompt$ jsish multiplication-tables.jsi 4
     1  2  3  4
  +------------
 1|  1  2  3  4
 2|     4  6  8
 3|        9 12
 4|          16

Julia

using Printf

println(" X |   1   2   3   4   5   6   7   8   9  10  11  12")
println("---+------------------------------------------------")

for i=1:12, j=0:12
    if j == 0
        @printf("%2d | ", i)
    elseif i <= j
        @printf("%3d%c", i * j, j == 12 ? '\n' : ' ')
    else
        print("    ")
    end
end
Output:
 X |   1   2   3   4   5   6   7   8   9  10  11  12
---+------------------------------------------------
 1 |   1   2   3   4   5   6   7   8   9  10  11  12
 2 |       4   6   8  10  12  14  16  18  20  22  24
 3 |           9  12  15  18  21  24  27  30  33  36
 4 |              16  20  24  28  32  36  40  44  48
 5 |                  25  30  35  40  45  50  55  60
 6 |                      36  42  48  54  60  66  72
 7 |                          49  56  63  70  77  84
 8 |                              64  72  80  88  96
 9 |                                  81  90  99 108
10 |                                     100 110 120
11 |                                         121 132
12 |                                             144

Kotlin

// version 1.0.6

fun main(args: Array<String>) {
    print("  x|")
    for (i in 1..12) print("%4d".format(i))
    println("\n---+${"-".repeat(48)}")
    for (i in 1..12) { 
        print("%3d".format(i) +"|${" ".repeat(4 * i - 4)}")
        for (j in i..12) print("%4d".format(i * j))
        println()
    }
}
Output:
  x|   1   2   3   4   5   6   7   8   9  10  11  12
---+------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

Lambdatalk

Outputs are visible in http://lambdaway.free.fr/lambdawalks/?view=multiplication_table

{def format
 {lambda {:w :c}
  {@ style="width::wpx; 
            color::c; 
            text-align:right;"
}}} 
-> format

{def operation
 {lambda {:op :i :j}
  {if {and {= :i 0} {= :j 0}}                    // left top cell
   then {format 30 #fff}                         // is empty 
   else {if {= :i 0}                             // top row
   then {format 30 #ff0}:j                       // is yellow
   else {if {= :j 0}                             // left col
   then {format 30 #0ff}:i                       // is cyan
   else {format 30 #ccc}                         // is lightgrey
        {if {<= :i :j} then {:op :i :j} else .}  // cell [i,j]
}}}}} 
-> operation

{def make_table
 {lambda {:func :row :col}
  {table {@ style="box-shadow:0 0 8px #000;"} 
   {S.map                                   // apply
    {{lambda {:func :col :j}                // function row
     {tr {S.map                             // apply
      {{lambda {:func :i :j}                // function cell
       {td {:func :i :j}}} :func :j}        // apply func on [i,j]
        {S.serie 0 :col}}}} :func :col}     // from 0 to col
         {S.serie 0 :row}                   // from 0 to row
}}}}
-> make_table

The following calls: 

1) {make_table {operation +} 5 15}
2) {make_table {operation *} 12 12} 
3) {make_table {operation pow} 6 10}

Lasso

define printTimesTables(max::integer) => {
    local(result)  = ``
    local(padSize) = string(#max*#max)->size + 1

    // Print header row
    #result->append((' ' * #padSize) + '|')
    loop(#max) => {
        #result->append(loop_count->asString(-padding=#padSize))
    }
    #result->append("\n" + (`-` * #padSize) + '+' + (`-` * (#padSize * #max)))

    with left in 1 to #max do {
        // left column
        #result->append("\n" + #left->asString(-padding=#padSize) + '|')

        // Table results
        with right in 1 to #max do {
            #result->append(
                #right < #left
                    ? ' ' * #padSize
                    | (#left * #right)->asString(-padding=#padSize)
            )
        }
    }

    return #result
}

printTimesTables(12)
Output:
----+------------------------------------------------
   1|   1   2   3   4   5   6   7   8   9  10  11  12
   2|       4   6   8  10  12  14  16  18  20  22  24
   3|           9  12  15  18  21  24  27  30  33  36
   4|              16  20  24  28  32  36  40  44  48
   5|                  25  30  35  40  45  50  55  60
   6|                      36  42  48  54  60  66  72
   7|                          49  56  63  70  77  84
   8|                              64  72  80  88  96
   9|                                  81  90  99 108
  10|                                     100 110 120
  11|                                         121 132
  12|                                             144


Works with: UCB Logo
to mult.table :n
  type "|  | for [i 2 :n] [type form :i 4 0] (print)
  (print)
  for [i 2 :n] [
    type form :i 2 0
    for [j 2 :n] [
      type ifelse :i > :j ["|    |] [form :i*:j 4 0]
    ]
    (print)
  ]
end

mult.table 12

Lua

io.write( "   |" )
for i = 1, 12 do
    io.write( string.format( "%#5d", i ) )
end
io.write( "\n", string.rep( "-", 12*5+4 ), "\n" )

for i = 1, 12 do
    io.write( string.format( "%#2d |", i ) )
    
    for j = 1, 12 do
        if j < i then
            io.write( "     " )
        else
            io.write( string.format( "%#5d", i*j ) )
        end
    end
    io.write( "\n" )
end
   |    1    2    3    4    5    6    7    8    9   10   11   12
----------------------------------------------------------------
 1 |    1    2    3    4    5    6    7    8    9   10   11   12
 2 |         4    6    8   10   12   14   16   18   20   22   24
 3 |              9   12   15   18   21   24   27   30   33   36
 4 |                  16   20   24   28   32   36   40   44   48
 5 |                       25   30   35   40   45   50   55   60
 6 |                            36   42   48   54   60   66   72
 7 |                                 49   56   63   70   77   84
 8 |                                      64   72   80   88   96
 9 |                                           81   90   99  108
10 |                                               100  110  120
11 |                                                    121  132
12 |                                                         144

M2000 Interpreter

Using jagged array (arrays of arrays)

Module CheckIt {
      Dim Base 1, A(12)
      Mult=lambda (n)-> {
            Flush  ' empty stack
            For i=1 to n : Data i*n : Next i
            =Array([])   ' copy stack in an array, and return a pointer
      }
      i=Each(A())
      Print "  |";
      while i {
            Print Format$("{0:0:-4}",i^+1);
            A(i^+1)=Mult(i^+1)
      }
      Print
      Print "--+"+string$("-",4*12)
      For i=1 to 12 {
            Print Format$("{0:0:-2}|",i); 
            For j=1 to 12 {
                  If len(A(j)())>=i then {
                        Print Format$("{0:0:-4}",A(j)(i-1));
                  } Else Print "    ";
            }
            Print
      }
}
CheckIt

Final loop can be this, using Each() and r1 as pointer to array.

For i=1 to 12 {
      j=Each(A())
      Print Format$("{0:0:-2}|",i); 
      While j {
            r1=A(j^+1)
            If len(r1)>=i then {
                  Print Format$("{0:0:-4}",Array(r1,i-1));
            } Else Print "    ";
      }
      Print
}
Output:
   |   1   2   3   4   5   6   7   8   9  10  11  12
 --+------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

Maple

printf("    ");
for i to 12 do
	printf("%-3d   ", i);
end do;
printf("\n");
for i to 75 do
	printf("-");
end do;
for i to 12 do
	printf("\n%2d| ", i);
	for j to 12 do
		if j<i then
			printf("      ");
		else
			printf("%-3d   ", i * j);
		end if
	end do
end do
Output:
    1     2     3     4     5     6     7     8     9     10    11    12    
---------------------------------------------------------------------------
 1| 1     2     3     4     5     6     7     8     9     10    11    12    
 2|       4     6     8     10    12    14    16    18    20    22    24    
 3|             9     12    15    18    21    24    27    30    33    36    
 4|                   16    20    24    28    32    36    40    44    48    
 5|                         25    30    35    40    45    50    55    60    
 6|                               36    42    48    54    60    66    72    
 7|                                     49    56    63    70    77    84    
 8|                                           64    72    80    88    96    
 9|                                                 81    90    99    108   
10|                                                       100   110   120   
11|                                                             121   132   
12|                                                                   144

Mathematica/Wolfram Language

Grid[{{Range[12]//Column,Grid[UpperTriangularize[KroneckerProduct[Range[12],Range[12]]]/.{0->""}]}}]
Output:
1 1	2	3	4	5	6	7	8	9	10	11	12
2	4	6	8	10	12	14	16	18	20	22	24
3		9	12	15	18	21	24	27	30	33	36
4			16	20	24	28	32	36	40	44	48
5				25	30	35	40	45	50	55	60
6					36	42	48	54	60	66	72
7						49	56	63	70	77	84
8							64	72	80	88	96
9								81	90	99	108
10									100	110	120
11										121	132
12											144

MATLAB / Octave

timesTable.m: (creates Times Table of N degree)

function table = timesTable(N)
    table = [(0:N); (1:N)' triu( kron((1:N),(1:N)') )];
end

A minimally vectorized version of the above code:

function table = timesTable(N)

    %Generates a column vector with integers from 1 to N
    rowLabels = (1:N)';
    
    %Generate a row vector with integers from 0 to N
    columnLabels = (0:N);
    
    %Generate the multiplication table using the kronecker tensor product
    %of two vectors one a column vector and the other a row vector
    table = kron((1:N),(1:N)');
    
    %Make it upper triangular and concatenate the rowLabels and 
    %columnLabels to the table
    table = [columnLabels; rowLabels triu(table)];
      
end
Output:

For N=12:

timesTable(12)

ans =

     0     1     2     3     4     5     6     7     8     9    10    11    12
     1     1     2     3     4     5     6     7     8     9    10    11    12
     2     0     4     6     8    10    12    14    16    18    20    22    24
     3     0     0     9    12    15    18    21    24    27    30    33    36
     4     0     0     0    16    20    24    28    32    36    40    44    48
     5     0     0     0     0    25    30    35    40    45    50    55    60
     6     0     0     0     0     0    36    42    48    54    60    66    72
     7     0     0     0     0     0     0    49    56    63    70    77    84
     8     0     0     0     0     0     0     0    64    72    80    88    96
     9     0     0     0     0     0     0     0     0    81    90    99   108
    10     0     0     0     0     0     0     0     0     0   100   110   120
    11     0     0     0     0     0     0     0     0     0     0   121   132
    12     0     0     0     0     0     0     0     0     0     0     0   144

Maxima

for i: 1 thru 12 do (
  for j: 1 thru 12 do (
    if j>=i or j=1 then printf(true, "~4d", i*j) else printf(true, "    ")
    ),
  printf(true, "~%")
  );

Constructing a function to handle cases like this one

File:Multiplication table.png
Formatted output using table_form
/* Auxiliar function */
aux_table(n,k):=append([k],makelist(0,i,1,k-1),makelist(k*i,i,k,n))$

/* Function to construct the formatted table */
table_mult(n):=block(
    append([makelist(i,i,0,n)],makelist(aux_table(n,k),k,1,n)),
    makelist(at(%%[i],0=""),i,2,length(%%)),
    table_form(%%))$

/* Test case */
table_mult(12);

МК-61/52

П0	КИП0	КИП4	КИП5	ИП4	ИП5	*	С/П
ИП5	ИП0	-	x=0	03
ИП4	ИП0	-	x#0	22	ИП4	П5	БП	02
С/П

Input: 12 С/П ...

Output:
(compiled)
    1   2   3   4   5   6   7   8   9  10  11  12
        4   6   8  10  12  14  16  18  20  22  24
            9  12  15  18  21  24  27  30  33  36
               16  20  24  28  32  36  40  44  48
                   25  30  35  40  45  50  55  60
                       36  42  48  54  60  66  72
                           49  56  63  70  77  84
                               64  72  80  88  96
                                   81  90  99 108
                                      100 110 120
                                          121 132
                                              144

Modula-2

Works with: ADW Modula-2 version any (Compile with the linker option Console Application).
MODULE MultiplicationTables;

FROM SWholeIO IMPORT
  WriteInt;
FROM STextIO IMPORT
  WriteString, WriteLn;

CONST
  N = 12;

VAR
  I, J: INTEGER;

BEGIN
  FOR J := 1 TO N - 1 DO
    WriteInt(J, 3);
    WriteString(" ");
  END;
  WriteInt(N, 3);
  WriteLn;
  FOR J := 0 TO N - 1 DO
    WriteString("----");
  END;
  WriteString("+");
  WriteLn;
  FOR I := 1 TO N DO
    FOR J := 1 TO N DO
      IF J < I THEN
        WriteString("    ");
      ELSE
        WriteInt(I * J, 3);
        WriteString(" ");
      END;
    END;
    WriteString("| ");
    WriteInt(I, 2);
    WriteLn;
  END;
END MultiplicationTables.
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
------------------------------------------------+
  1   2   3   4   5   6   7   8   9  10  11  12 |  1
      4   6   8  10  12  14  16  18  20  22  24 |  2
          9  12  15  18  21  24  27  30  33  36 |  3
             16  20  24  28  32  36  40  44  48 |  4
                 25  30  35  40  45  50  55  60 |  5
                     36  42  48  54  60  66  72 |  6
                         49  56  63  70  77  84 |  7
                             64  72  80  88  96 |  8
                                 81  90  99 108 |  9
                                    100 110 120 | 10
                                        121 132 | 11
                                            144 | 12

MOO

This quick example is designed to demonstrate raw MOO. In other words it does not use any of the helper functions available in popular DBs such as LambdaMOO.

@verb me:@tables none none none rxd
@program me:@tables
player:tell("    |      1    2    3    4    5    6    7    8    9   10   11   12");
player:tell("-------------------------------------------------------------------");
for i in [1..12]
  line = ((i < 10) ? "  " | " ") + tostr(i) + " |  ";
  for j in [1..12]
    if (j >= i)
      product = i * j;
      "calculate spacing for right justification of values";
      if (product >= 100)
        spacer = "";
      elseif (product >= 10)
        spacer = " ";
      else
        spacer = "  ";
      endif
      line = line + "  " + spacer + tostr(product);
    else
      line = line + "     ";
    endif
  endfor
  player:tell(line);
endfor
.

LambdaMOO string utilities version:

@program me:@tables
player:tell("    |      1    2    3    4    5    6    7    8    9   10   11   12");
player:tell($string_utils:space(67, "-"));
for i in [1..12]
  line = " " + $string_utils:right(i, 2) + " |  ";
  for j in [1..12]
    line = line + "  " + ((i > j) ? "   " | $string_utils:right(j*i, 3));
  endfor
  player:tell(line);
endfor
.
Output:
@tables
    |      1    2    3    4    5    6    7    8    9   10   11   12
-------------------------------------------------------------------
  1 |      1    2    3    4    5    6    7    8    9   10   11   12
  2 |           4    6    8   10   12   14   16   18   20   22   24
  3 |                9   12   15   18   21   24   27   30   33   36
  4 |                    16   20   24   28   32   36   40   44   48
  5 |                         25   30   35   40   45   50   55   60
  6 |                              36   42   48   54   60   66   72
  7 |                                   49   56   63   70   77   84
  8 |                                        64   72   80   88   96
  9 |                                             81   90   99  108
 10 |                                                 100  110  120
 11 |                                                      121  132
 12 |                                                           144

MUMPS

MULTTABLE(SIZE)
 ;Print out a multiplication table
 ;SIZE is the size of the multiplication table to make
 ;MW is the maximum width of the numbers
 ;D is the down axis
 ;A is the across axis
 ;BAR is the horizontal bar under the operands
 NEW MW,D,A,BAR
 IF $DATA(SIZE)<1 SET SIZE=12
 SET MW=$LENGTH(SIZE*SIZE)
 SET BAR="" FOR I=1:1:(MW+2) SET BAR=BAR_"-"
 FOR D=1:1:(SIZE+2) DO
 .FOR A=1:1:(SIZE+1) DO
 ..WRITE:(D=1)&(A=1) !,$JUSTIFY("",MW-1)," X|"
 ..WRITE:(D=1)&(A>1) ?((A-1)*5),$JUSTIFY((A-1),MW)
 ..WRITE:(D=2)&(A=1) !,BAR
 ..WRITE:(D=2)&(A'=1) BAR
 ..WRITE:(D>2)&(A=1) !,$JUSTIFY((D-2),MW)," |"
 ..WRITE:((A-1)>=(D-2))&((D-2)>=1) ?((A-1)*5),$JUSTIFY((D-2)*(A-1),MW)
 KILL MW,D,A,BAR
 QUIT
Output:
USER>D MULTTABLE^ROSETTA
 
   X|  1    2    3    4    5    6    7    8    9   10   11   12
-----------------------------------------------------------------
  1 |  1    2    3    4    5    6    7    8    9   10   11   12
  2 |       4    6    8   10   12   14   16   18   20   22   24
  3 |            9   12   15   18   21   24   27   30   33   36
  4 |                16   20   24   28   32   36   40   44   48
  5 |                     25   30   35   40   45   50   55   60
  6 |                          36   42   48   54   60   66   72
  7 |                               49   56   63   70   77   84
  8 |                                    64   72   80   88   96
  9 |                                         81   90   99  108
 10 |                                             100  110  120
 11 |                                                  121  132
 12 |                                                       144

N/t/roff

Works with gnu nroff. Please note that the script example contains tab characters which are essential for the correct tabular output.

.nf
.ta T 2mR
.nr x 1 1
.nr y 2 1
.nr p 0
.while (\n[x] <= 12) \{\
.if (\n[x]<10) \0\c
\n[x]\c
.if (\n[x]=1)           \c
.while (\n[y] <= 12) \{\
.nr p \n[x]*\n[y]
.ie (\n[y]>=\n[x])      \n[p]   \c
.el             \c
.nr y +1
.\}
.br
.nr x +1
.nr y 1 1
.\}
Output:
 1     2   3   4   5   6   7   8   9  10  11  12
 2     4   6   8  10  12  14  16  18  20  22  24
 3         9  12  15  18  21  24  27  30  33  36
 4            16  20  24  28  32  36  40  44  48
 5                25  30  35  40  45  50  55  60
 6                    36  42  48  54  60  66  72
 7                        49  56  63  70  77  84
 8                            64  72  80  88  96
 9                                81  90  99 108
10                                   100 110 120
11                                       121 132
12                                           144

Neko

/**
 Multiplication table, in Neko
 Tectonics:
   nekoc multiplication-table.neko
   neko multiplication-table
*/

var sprintf = $loader.loadprim("std@sprintf", 2);

var i, j;

i = 1;
$print("  X |");
while i < 13 {
  $print(sprintf("%4d", i));
  i += 1;
}
$print("\n");
$print(" ---+");
i = 1;
while i < 13 {
  $print("----");
  i += 1;
}
$print("\n");

j = 1;
while j < 13 {
  $print(sprintf("%3d", j));
  $print(" |");
  i = 1;
  while i < 13 {
    if j > i {
      $print("    ");
    } else {
      $print(sprintf("%4d", i*j));
    }
    i += 1;
  }
  $print("\n");
  j += 1;
}
Output:
prompt$ nekoc multiplication-table.neko
prompt$ neko multiplication-table
  X |   1   2   3   4   5   6   7   8   9  10  11  12
 ---+------------------------------------------------
  1 |   1   2   3   4   5   6   7   8   9  10  11  12
  2 |       4   6   8  10  12  14  16  18  20  22  24
  3 |           9  12  15  18  21  24  27  30  33  36
  4 |              16  20  24  28  32  36  40  44  48
  5 |                  25  30  35  40  45  50  55  60
  6 |                      36  42  48  54  60  66  72
  7 |                          49  56  63  70  77  84
  8 |                              64  72  80  88  96
  9 |                                  81  90  99 108
 10 |                                     100 110 120
 11 |                                         121 132
 12 |                                             144

Nim

Translation of: C
import strfmt

const n = 12

for j in 1..n:
  stdout.write "{:3d}{:s}".fmt(j, if n-j>0: " " else: "\n")
for j in 0..n:
  stdout.write if n-j>0: "----" else: "+\n"
for i in 1..n:
  for j in 1..n:
    stdout.write if j<i: "    " else: "{:3d} ".fmt(i*j)
  echo "| {:2d}".fmt(i)
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
------------------------------------------------+
  1   2   3   4   5   6   7   8   9  10  11  12 |  1
      4   6   8  10  12  14  16  18  20  22  24 |  2
          9  12  15  18  21  24  27  30  33  36 |  3
             16  20  24  28  32  36  40  44  48 |  4
                 25  30  35  40  45  50  55  60 |  5
                     36  42  48  54  60  66  72 |  6
                         49  56  63  70  77  84 |  7
                             64  72  80  88  96 |  8
                                 81  90  99 108 |  9
                                    100 110 120 | 10
                                        121 132 | 11
                                            144 | 12

OCaml

Translation of: C
let () =
  let max = 12 in
  let fmax = float_of_int max in

  let dgts = int_of_float (ceil (log10 (fmax *. fmax))) in
  let fmt = Printf.printf " %*d" dgts in
  let fmt2 = Printf.printf "%*s%c" dgts in

  fmt2 "" 'x';
  for i = 1 to max do fmt i done;
  print_string "\n\n";

  for j = 1 to max do
    fmt j;
    for i = 1 to pred j do fmt2 "" ' '; done;
    for i = j to max do fmt (i*j); done;
    print_newline()
  done;
  print_newline()

PARI/GP

Quick and dirty one-liner:

for(y=1,12,printf("%2Ps| ",y);for(x=1,12,print1(if(y>x,"",x*y)"\t"));print)

Pascal

See Delphi

Perl

our $max = 12;
our $width = length($max**2) + 1;

printf "%*s", $width, $_ foreach 'x|', 1..$max;
print "\n", '-' x ($width - 1), '+', '-' x ($max*$width), "\n";
foreach my $i (1..$max) { 
	printf "%*s", $width, $_
            foreach "$i|", map { $_ >= $i and $_*$i } 1..$max;
	print "\n";
}
Output:
  x|   1   2   3   4   5   6   7   8   9  10  11  12
---+------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

Phix

Translation of: Ada
printf(1,"  | ")
for col=1 to 12 do
    printf(1,"%4d",col)
end for
printf(1,"\n--+-"&repeat('-',12*4))
for row=1 to 12 do
    printf(1,"\n%2d| ",row)
    for col=1 to 12 do
        printf(1,iff(col<row?"    ":sprintf("%4d",row*col)))
    end for
end for
Output:
  |    1   2   3   4   5   6   7   8   9  10  11  12
--+-------------------------------------------------
 1|    1   2   3   4   5   6   7   8   9  10  11  12
 2|        4   6   8  10  12  14  16  18  20  22  24
 3|            9  12  15  18  21  24  27  30  33  36
 4|               16  20  24  28  32  36  40  44  48
 5|                   25  30  35  40  45  50  55  60
 6|                       36  42  48  54  60  66  72
 7|                           49  56  63  70  77  84
 8|                               64  72  80  88  96
 9|                                   81  90  99 108
10|                                      100 110 120
11|                                          121 132
12|                                              144

Phixmonti

/# Rosetta Code problem: https://rosettacode.org/wiki/Multiplication_tables
by Galileo, 11/2022 #/

def tab 9 tochar print enddef

tab 12 for print tab endfor nl
tab '-' 12 8 * repeat print nl
12 for
	dup print tab 8 tochar print "|" print
	dup for
		over * print tab
	endfor
	drop nl
endfor
Output:
        1       2       3       4       5       6       7       8       9       10      11      12
        ------------------------------------------------------------------------------------------------
1      |1
2      |2       4
3      |3       6       9
4      |4       8       12      16
5      |5       10      15      20      25
6      |6       12      18      24      30      36
7      |7       14      21      28      35      42      49
8      |8       16      24      32      40      48      56      64
9      |9       18      27      36      45      54      63      72      81
10     |10      20      30      40      50      60      70      80      90      100
11     |11      22      33      44      55      66      77      88      99      110     121
12     |12      24      36      48      60      72      84      96      108     120     132     144

=== Press any key to exit ===

Picat

go => 
  N=12,
  make_table(N),
  nl.

%
% Make a table of size N
%
make_table(N) => 
  printf("     "),
  foreach(I in 1..N) printf("%4w", I) end,
  nl,
  println(['-' : _ in 1..(N+1)*4+1]),
  foreach(I in 1..N)
    printf("%2d | ", I),
    foreach(J in 1..N)
      if J>=I then
        printf("%4w", I*J)
      else
        printf("    ")
      end
    end,
    nl
  end,
  nl.
Output:
        1   2   3   4   5   6   7   8   9  10  11  12
-----------------------------------------------------
 1 |    1   2   3   4   5   6   7   8   9  10  11  12
 2 |        4   6   8  10  12  14  16  18  20  22  24
 3 |            9  12  15  18  21  24  27  30  33  36
 4 |               16  20  24  28  32  36  40  44  48
 5 |                   25  30  35  40  45  50  55  60
 6 |                       36  42  48  54  60  66  72
 7 |                           49  56  63  70  77  84
 8 |                               64  72  80  88  96
 9 |                                   81  90  99 108
10 |                                      100 110 120
11 |                                          121 132
12 |                                              144

PicoLisp

sp>(de mulTable (N)
   (space 4)
   (for X N
      (prin (align 4 X)) )
   (prinl)
   (prinl)
   (for Y N
      (prin (align 4 Y))
      (space (* (dec Y) 4))
      (for (X Y (>= N X) (inc X))
         (prin (align 4 (* X Y))) )
      (prinl) ) )

(mulTable 12)
Output:
       1   2   3   4   5   6   7   8   9  10  11  12

   1   1   2   3   4   5   6   7   8   9  10  11  12
   2       4   6   8  10  12  14  16  18  20  22  24
   3           9  12  15  18  21  24  27  30  33  36
   4              16  20  24  28  32  36  40  44  48
   5                  25  30  35  40  45  50  55  60
   6                      36  42  48  54  60  66  72
   7                          49  56  63  70  77  84
   8                              64  72  80  88  96
   9                                  81  90  99 108
  10                                     100 110 120
  11                                         121 132
  12                                             144

PL/I

/* 12 x 12 multiplication table. */

multiplication_table: procedure options (main);
   declare (i, j) fixed decimal (2);

   put skip edit ((i do i = 1 to 12)) (X(4), 12 F(4));
   put skip edit ( (49)'_') (X(3), A);

   do i = 1 to 12;
      put skip edit (i, ' |', (i*j do j = i to 12))
         (F(2), a, col(i*4+1), 12 F(4));
   end;

end multiplication_table;

Result:

       1   2   3   4   5   6   7   8   9  10  11  12
   _________________________________________________
 1 |   1   2   3   4   5   6   7   8   9  10  11  12
 2 |       4   6   8  10  12  14  16  18  20  22  24
 3 |           9  12  15  18  21  24  27  30  33  36
 4 |              16  20  24  28  32  36  40  44  48
 5 |                  25  30  35  40  45  50  55  60
 6 |                      36  42  48  54  60  66  72
 7 |                          49  56  63  70  77  84
 8 |                              64  72  80  88  96
 9 |                                  81  90  99 108
10 |                                     100 110 120
11 |                                         121 132
12 |                                             144

PowerShell

#  For clarity
$Tab = "`t"
 
#  Create top row
$Tab + ( 1..12 -join $Tab )
 
#  For each row
ForEach ( $i in 1..12 )
    {
    $(  #  The number in the left column
        $i
 
        #  An empty slot for the bottom triangle
        @( "" ) * ( $i - 1 )
 
        #  Calculate the top triangle
        $i..12 | ForEach { $i * $_ }
 
        #  Combine them all together
        ) -join $Tab
    }
Output:
	1	2	3	4	5	6	7	8	9	10	11	12
1	1	2	3	4	5	6	7	8	9	10	11	12
2		4	6	8	10	12	14	16	18	20	22	24
3			9	12	15	18	21	24	27	30	33	36
4				16	20	24	28	32	36	40	44	48
5					25	30	35	40	45	50	55	60
6						36	42	48	54	60	66	72
7							49	56	63	70	77	84
8								64	72	80	88	96
9									81	90	99	108
10										100	110	120
11											121	132
12												144

A more general solution

function Get-TimesTable ( [int]$Size )
    {
    #  For clarity
    $Tab = "`t"
 
    #  Create top row
    $Tab + ( 1..$Size -join $Tab )
 
    #  For each row
    ForEach ( $i in 1..$Size )
        {
        $(  #  The number in the left column
            $i
 
            #  An empty slot for the bottom triangle
            @( "" ) * ( $i - 1 )
 
            #  Calculate the top triangle
            $i..$Size | ForEach { $i * $_ }
 
         #  Combine them all together (and send them to the out put stream, which in PowerShell implicityly returns them)
         ) -join $Tab
        }
    }
 
Get-TimesTable 18
Output:
	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18
1	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18
2		4	6	8	10	12	14	16	18	20	22	24	26	28	30	32	34	36
3			9	12	15	18	21	24	27	30	33	36	39	42	45	48	51	54
4				16	20	24	28	32	36	40	44	48	52	56	60	64	68	72
5					25	30	35	40	45	50	55	60	65	70	75	80	85	90
6						36	42	48	54	60	66	72	78	84	90	96	102	108
7							49	56	63	70	77	84	91	98	105	112	119	126
8								64	72	80	88	96	104	112	120	128	136	144
9									81	90	99	108	117	126	135	144	153	162
10										100	110	120	130	140	150	160	170	180
11											121	132	143	154	165	176	187	198
12												144	156	168	180	192	204	216
13													169	182	195	208	221	234
14														196	210	224	238	252
15															225	240	255	270
16																256	272	288
17																	289	306
18																		324

Prolog

make_table(S,E) :-
	print_header(S,E),
	make_table_rows(S,E),
	fail.
make_table(_,_).

print_header(S,E) :-
	nl,
	write('      '),
	forall(between(S,E,X), print_num(X)),
	nl,
	Sp is E * 4 + 2,
	write('    '),
	forall(between(1,Sp,_), write('-')).
	
make_table_rows(S,E) :-
	between(S,E,N),
	nl,
	print_num(N), write(': '),
	between(S,E,N2), 
	X is N * N2,
	print_row_item(N,N2,X).
	
print_row_item(N, N2, _) :-
	N2 < N,
	write('    ').
print_row_item(N, N2, X) :-
	N2 >= N,
	print_num(X).
	
print_num(X) :- X < 10,	          format('   ~p', X).
print_num(X) :- between(10,99,X), format('  ~p', X).
print_num(X) :- X > 99,	          format(' ~p', X).
Output:
?- make_table(1,12).

         1   2   3   4   5   6   7   8   9  10  11  12
    --------------------------------------------------
   1:    1   2   3   4   5   6   7   8   9  10  11  12
   2:        4   6   8  10  12  14  16  18  20  22  24
   3:            9  12  15  18  21  24  27  30  33  36
   4:               16  20  24  28  32  36  40  44  48
   5:                   25  30  35  40  45  50  55  60
   6:                       36  42  48  54  60  66  72
   7:                           49  56  63  70  77  84
   8:                               64  72  80  88  96
   9:                                   81  90  99 108
  10:                                      100 110 120
  11:                                          121 132
  12:                                              144
true.

?-

Python

Procedural

>>> size = 12
>>> width = len(str(size**2))
>>> for row in range(-1,size+1):
	if row==0:
		print("─"*width + "┼"+"─"*((width+1)*size-1))
	else:
		print("".join("%*s%1s" % ((width,) + (("x","│")      if row==-1 and col==0
					              else (row,"│") if row>0   and col==0
					              else (col,"")  if row==-1
					              else ("","")   if row>col
					              else (row*col,"")))
			       for col in range(size+1)))

		
  x  1   2   3   4   5   6   7   8   9  10  11  12 
───┼───────────────────────────────────────────────
  1  1   2   3   4   5   6   7   8   9  10  11  12 
  2      4   6   8  10  12  14  16  18  20  22  24 
  3          9  12  15  18  21  24  27  30  33  36 
  4             16  20  24  28  32  36  40  44  48 
  5                 25  30  35  40  45  50  55  60 
  6                     36  42  48  54  60  66  72 
  7                         49  56  63  70  77  84 
  8                             64  72  80  88  96 
  9                                 81  90  99 108 
 10                                    100 110 120 
 11                                        121 132 
 12                                            144 
>>>

The above works with Python 3.X, which uses Unicode strings by default.
Declaring a file type of UTF-8 and adding a u to all string literals to transform them into Unicode literals would make the above work in Python 2.X. (As would using ASCII minus, plus, and pipe characters: "-", "+", "|"; instead of the non-ASCII chars used to draw a frame).

Functional

We can define a multiplication table string first in terms of a list comprehension (mulTable function),

and then again, for comparison, as an equivalent list monad expression (mulTable2 function):

'''Multiplication table

   1. by list comprehension (mulTable ),
   2. by list monad.        (mulTable2)'''

from itertools import chain


# mulTable :: Int -> String
def mulTable(n):
    '''A multiplication table of dimension n,
       without redundant entries beneath
       the diagonal of squares.'''

    # colWidth :: Int
    colWidth = len(str(n * n))

    # pad :: String -> String
    def pad(s):
        return s.rjust(colWidth, ' ')

    xs = enumFromTo(1)(n)
    return unlines([
        pad(str(y) + ':') + unwords([
            pad(str(x * y) if x >= y else '')
            for x in xs
        ]) for y in xs
    ])


# mulTable2 :: Int -> String
def mulTable2(n):
    '''Identical to mulTable above,
       but the list comprehension is directly
       desugared to an equivalent list monad expression.'''

    # colWidth :: Int
    colWidth = len(str(n * n))

    # pad :: String -> String
    def pad(s):
        return s.rjust(colWidth, ' ')

    xs = enumFromTo(1)(n)
    return unlines(
        bind(xs)(lambda y: [
            pad(str(y) + ':') + unwords(
                bind(xs)(lambda x: [
                    pad(str(x * y) if x >= y else '')
                ])
            )
        ])
    )


# TEST ----------------------------------------------------
# main :: IO ()
def main():
    '''Test'''

    for s, f in [
            ('list comprehension', mulTable),
            ('list monad', mulTable2)
    ]:
        print(
            'By ' + s + ' (' + f.__name__ + '):\n\n',
            f(12).strip() + '\n'
        )


# GENERIC -------------------------------------------------

# bind (>>=) :: [a] -> (a -> [b]) -> [b]
def bind(xs):
    '''The injection operator for the list monad.
       Equivalent to concatMap with its arguments flipped.'''
    return lambda f: list(
        chain.from_iterable(
            map(f, xs)
        )
    )


# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
    '''Integer enumeration from m to n.'''
    return lambda n: list(range(m, 1 + n))


# unlines :: [String] -> String
def unlines(xs):
    '''A newline-delimited string derived from a list of lines.'''
    return '\n'.join(xs)


# unwords :: [String] -> String
def unwords(xs):
    '''A space-delimited string derived from a list of words.'''
    return ' '.join(xs)


if __name__ == '__main__':
    main()
Output:
By list comprehension (mulTable):

 1:  1   2   3   4   5   6   7   8   9  10  11  12
 2:      4   6   8  10  12  14  16  18  20  22  24
 3:          9  12  15  18  21  24  27  30  33  36
 4:             16  20  24  28  32  36  40  44  48
 5:                 25  30  35  40  45  50  55  60
 6:                     36  42  48  54  60  66  72
 7:                         49  56  63  70  77  84
 8:                             64  72  80  88  96
 9:                                 81  90  99 108
10:                                    100 110 120
11:                                        121 132
12:                                            144

By list monad (mulTable2):

 1:  1   2   3   4   5   6   7   8   9  10  11  12
 2:      4   6   8  10  12  14  16  18  20  22  24
 3:          9  12  15  18  21  24  27  30  33  36
 4:             16  20  24  28  32  36  40  44  48
 5:                 25  30  35  40  45  50  55  60
 6:                     36  42  48  54  60  66  72
 7:                         49  56  63  70  77  84
 8:                             64  72  80  88  96
 9:                                 81  90  99 108
10:                                    100 110 120
11:                                        121 132
12:                                            144


Or, with a little more abstraction, and a complete separation of model from view:

Translation of: Haskell
Works with: Python version 3.7
'''Generalised multiplication tables'''

import collections
import itertools
import inspect


# table :: Int -> [[Maybe Int]]
def table(xs):
    '''An option-type model of a multiplication table:
       a tabulation of Just(x * y) values for all
       pairings (x, y) of integers in xs where x > y,
       and Nothing values where y <= x.
    '''
    axis = fmap(Just)(xs)
    return list(cons(
        cons(Nothing())(axis)
    )(zipWith(cons)(axis)([
        [
            Nothing() if y > x else Just(x * y)
            for x in xs
        ]
        for y in xs
    ])))


# TEST ----------------------------------------------------
# main :: IO ()
def main():
    '''Test'''
    print('\n\n'.join(
        fmap(fmap(fmap(showTable)(table))(
            liftA2(enumFromTo)(fst)(snd)
        ))(
            [(13, 20), (1, 12), (95, 100)]
        )
    ))


# DISPLAY -------------------------------------------------

# showTable :: [[Maybe Int]] -> String
def showTable(xs):
    '''A stringification of an abstract model
       of a multiplication table.
    '''
    w = 1 + len(str(last(last(xs))['Just']))
    gap = ' ' * w
    rows = fmap(fmap(concat)(
        fmap(maybe(gap)(
            fmap(justifyRight(w)(' '))(str)
        ))
    ))(xs)
    return unlines([rows[0]] + [''] + rows[1:])


# GENERIC -------------------------------------------------

# Just :: a -> Maybe a
def Just(x):
    '''Constructor for an inhabited Maybe (option type) value.'''
    return {'type': 'Maybe', 'Nothing': False, 'Just': x}


# Nothing :: Maybe a
def Nothing():
    '''Constructor for an empty Maybe (option type) value.'''
    return {'type': 'Maybe', 'Nothing': True}


# concat :: [[a]] -> [a]
# concat :: [String] -> String
def concat(xs):
    '''The concatenation of all the elements
       in a list or iterable.'''
    chain = itertools.chain

    def f(ys):
        zs = list(chain(*ys))
        return ''.join(zs) if isinstance(ys[0], str) else zs

    return (
        f(xs) if isinstance(xs, list) else (
            chain.from_iterable(xs)
        )
    ) if xs else []


# cons :: a -> [a] -> [a]
def cons(x):
    '''Construction of a list from x as head,
       and xs as tail.'''
    chain = itertools.chain
    return lambda xs: [x] + xs if (
        isinstance(xs, list)
    ) else chain([x], xs)


# curry :: ((a, b) -> c) -> a -> b -> c
def curry(f):
    '''A curried function derived
       from an uncurried function.'''
    signature = inspect.signature
    if 1 < len(signature(f).parameters):
        return lambda x: lambda y: f(x, y)
    else:
        return f


# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
    '''Integer enumeration from m to n.'''
    return lambda n: list(range(m, 1 + n))


# fmap :: Functor f => (a -> b) -> f a -> f b
def fmap(f):
    '''A function f mapped over a functor.'''
    def go(x):
        defaultdict = collections.defaultdict
        return defaultdict(list, [
            ('list', fmapList),
            # ('iter', fmapNext),
            # ('Either', fmapLR),
            # ('Maybe', fmapMay),
            # ('Tree', fmapTree),
            # ('tuple', fmapTuple),
            ('function', fmapFn),
            ('type', fmapFn)
        ])[
            typeName(x)
        ](f)(x)
    return lambda v: go(v)


# fmapFn :: (a -> b) -> (r -> a) -> r -> b
def fmapFn(f):
    '''fmap over a function.
       The composition of f and g.
    '''
    return lambda g: lambda x: f(g(x))


# fmapList :: (a -> b) -> [a] -> [b]
def fmapList(f):
    '''fmap over a list.
       f lifted to a function over a list.
    '''
    return lambda xs: list(map(f, xs))


# fst :: (a, b) -> a
def fst(tpl):
    '''First member of a pair.'''
    return tpl[0]


# justifyRight :: Int -> Char -> String -> String
def justifyRight(n):
    '''A string padded at left to length n,
       using the padding character c.
    '''
    return lambda c: lambda s: s.rjust(n, c)


# last :: [a] -> a
def last(xs):
    '''The last element of a non-empty list.'''
    return xs[-1]


# liftA2 :: (a -> b -> c) -> f a -> f b -> f c
def liftA2(f):
    '''Lift a binary function to the type of a.'''
    def go(a, b):
        defaultdict = collections.defaultdict
        return defaultdict(list, [
            # ('list', liftA2List),
            # ('Either', liftA2LR),
            # ('Maybe', liftA2May),
            # ('Tree', liftA2Tree),
            # ('tuple', liftA2Tuple),
            ('function', liftA2Fn)
        ])[
            typeName(a)
        ](f)(a)(b)
    return lambda a: lambda b: go(a, b)


# liftA2Fn :: (a0 -> b -> c) -> (a -> a0) -> (a -> b) -> a -> c
def liftA2Fn(op):
    '''Lift a binary function to a composition
       over two other functions.
       liftA2 (*) (+ 2) (+ 3) 7 == 90
    '''
    def go(f, g):
        return lambda x: curry(op)(
            f(x)
        )(g(x))
    return lambda f: lambda g: go(f, g)


# maybe :: b -> (a -> b) -> Maybe a -> b
def maybe(v):
    '''Either the default value v, if m is Nothing,
       or the application of f to x,
       where m is Just(x).
    '''
    return lambda f: lambda m: v if m.get('Nothing') else (
        f(m.get('Just'))
    )


# typeName :: a -> String
def typeName(x):
    '''Name string for a built-in or user-defined type.
       Selector for type-specific instances
       of polymorphic functions.
    '''
    if isinstance(x, dict):
        return x.get('type') if 'type' in x else 'dict'
    else:
        return 'iter' if hasattr(x, '__next__') else (
            type(x).__name__
        )


# snd :: (a, b) -> b
def snd(tpl):
    '''Second member of a pair.'''
    return tpl[1]


# uncurry :: (a -> b -> c) -> ((a, b) -> c)
def uncurry(f):
    '''A function over a pair of arguments,
       derived from a vanilla or curried function.
    '''
    signature = inspect.signature
    if 1 < len(signature(f).parameters):
        return lambda xy: f(*xy)
    else:
        return lambda x, y: f(x)(y)


# unlines :: [String] -> String
def unlines(xs):
    '''A single string derived by the intercalation
       of a list of strings with the newline character.
    '''
    return '\n'.join(xs)


# zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
def zipWith(f):
    '''A list constructed by zipping with a
       custom function, rather than with the
       default tuple constructor.
    '''
    return lambda xs: lambda ys: (
        map(uncurry(f), xs, ys)
    )


# MAIN ---
if __name__ == '__main__':
    main()
Output:
      13  14  15  16  17  18  19  20

  13 169 182 195 208 221 234 247 260
  14     196 210 224 238 252 266 280
  15         225 240 255 270 285 300
  16             256 272 288 304 320
  17                 289 306 323 340
  18                     324 342 360
  19                         361 380
  20                             400

       1   2   3   4   5   6   7   8   9  10  11  12

   1   1   2   3   4   5   6   7   8   9  10  11  12
   2       4   6   8  10  12  14  16  18  20  22  24
   3           9  12  15  18  21  24  27  30  33  36
   4              16  20  24  28  32  36  40  44  48
   5                  25  30  35  40  45  50  55  60
   6                      36  42  48  54  60  66  72
   7                          49  56  63  70  77  84
   8                              64  72  80  88  96
   9                                  81  90  99 108
  10                                     100 110 120
  11                                         121 132
  12                                             144

          95    96    97    98    99   100

    95  9025  9120  9215  9310  9405  9500
    96        9216  9312  9408  9504  9600
    97              9409  9506  9603  9700
    98                    9604  9702  9800
    99                          9801  9900
   100                               10000


Quackery

  [ swap number$ 
    tuck size - 
    times sp echo$ ] is echo-rj ( n n --> )

  say "  * |"
  12 times [ i^ 1+ 4 echo-rj ] cr
  say " ---+" 
  char - 48 of echo$ cr
  [ 12 times
     [ i^ 1+ 
       dup 3 echo-rj
       say " |"
      12 times
        [ i^ 1+ 
          2dup > iff
            [ drop 4 times sp ]
          else 
            [ dip dup 
              * 4 echo-rj ] ] 
       cr drop ] ]
Output:
  * |   1   2   3   4   5   6   7   8   9  10  11  12
 ---+------------------------------------------------
  1 |   1   2   3   4   5   6   7   8   9  10  11  12
  2 |       4   6   8  10  12  14  16  18  20  22  24
  3 |           9  12  15  18  21  24  27  30  33  36
  4 |              16  20  24  28  32  36  40  44  48
  5 |                  25  30  35  40  45  50  55  60
  6 |                      36  42  48  54  60  66  72
  7 |                          49  56  63  70  77  84
  8 |                              64  72  80  88  96
  9 |                                  81  90  99 108
 10 |                                     100 110 120
 11 |                                         121 132
 12 |                                             144

R

multiplication_table <- function(n=12)
{
   one_to_n <- 1:n
   x <- matrix(one_to_n) %*% t(one_to_n)
   x[lower.tri(x)] <- 0
   rownames(x) <- colnames(x) <- one_to_n
   print(as.table(x), zero.print="")
   invisible(x)
}
multiplication_table()

Racket

#lang racket

(define (show-line xs)
  (for ([x xs]) (display (~a x #:width 4 #:align 'right)))
  (newline))

(show-line (cons "" (range 1 13)))
(for ([y (in-range 1 13)])
  (show-line (cons y (for/list ([x (in-range 1 13)])
                       (if (<= y x) (* x y) "")))))
Output:
       1   2   3   4   5   6   7   8   9  10  11  12
   1   1   2   3   4   5   6   7   8   9  10  11  12
   2       4   6   8  10  12  14  16  18  20  22  24
   3           9  12  15  18  21  24  27  30  33  36
   4              16  20  24  28  32  36  40  44  48
   5                  25  30  35  40  45  50  55  60
   6                      36  42  48  54  60  66  72
   7                          49  56  63  70  77  84
   8                              64  72  80  88  96
   9                                  81  90  99 108
  10                                     100 110 120
  11                                         121 132
  12                                             144

Raku

(formerly Perl 6)

(my $f = "%{$_}s" given my $width = ($_**2).chars ) given my $max = 12;

say '×'.fmt($f)  ~ ' ┃ ' ~ (1..$max).fmt($f);
say '━' x $width ~ '━╋'  ~ '━' x $max × (1+$width);

for 1..$max -> $i {
    say $i.fmt($f) ~ ' ┃ ' ~ ( $i$_ ?? $i×$_ !! '' for 1..$max ).fmt($f);
}
Output:
  x│   1   2   3   4   5   6   7   8   9  10  11  12
───┼────────────────────────────────────────────────
  1│   1   2   3   4   5   6   7   8   9  10  11  12
  2│       4   6   8  10  12  14  16  18  20  22  24
  3│           9  12  15  18  21  24  27  30  33  36
  4│              16  20  24  28  32  36  40  44  48
  5│                  25  30  35  40  45  50  55  60
  6│                      36  42  48  54  60  66  72
  7│                          49  56  63  70  77  84
  8│                              64  72  80  88  96
  9│                                  81  90  99 108
 10│                                     100 110 120
 11│                                         121 132
 12│                                             144

REBOL

REBOL [
	Title: "12x12 Multiplication Table"
	URL: http://rosettacode.org/wiki/Print_a_Multiplication_Table
]

size: 12

; Because of REBOL's GUI focus, it doesn't really do pictured output,
; so I roll my own. See Formatted_Numeric_Output for more
; comprehensive version:

pad: func [pad n][
    n: to-string n
    insert/dup n " " (pad - length? n)
    n 
]
p3: func [v][pad 3 v]  ; A shortcut, I hate to type...

--: has [x][repeat x size + 1 [prin "+---"]  print "+"]  ; Special chars OK.

.row: func [label y /local row x][
	row: reduce ["|" label "|"]  
	repeat x size [append row reduce [either x < y ["   "][p3 x * y] "|"]]
	print rejoin row
]

--  .row " x " 1  --  repeat y size [.row  p3 y  y]  --

print rejoin [ crlf  "What about "  size: 5  "?"  crlf ]
--  .row " x " 1  --  repeat y size [.row  p3 y  y]  --

print rejoin [ crlf  "How about "  size: 20  "?"  crlf ]
--  .row " x " 1  --  repeat y size [.row  p3 y  y]  --
Output:
(only 12x12 shown)
+---+---+---+---+---+---+---+---+---+---+---+---+---+
| x |  1|  2|  3|  4|  5|  6|  7|  8|  9| 10| 11| 12|
+---+---+---+---+---+---+---+---+---+---+---+---+---+
|  1|  1|  2|  3|  4|  5|  6|  7|  8|  9| 10| 11| 12|
|  2|   |  4|  6|  8| 10| 12| 14| 16| 18| 20| 22| 24|
|  3|   |   |  9| 12| 15| 18| 21| 24| 27| 30| 33| 36|
|  4|   |   |   | 16| 20| 24| 28| 32| 36| 40| 44| 48|
|  5|   |   |   |   | 25| 30| 35| 40| 45| 50| 55| 60|
|  6|   |   |   |   |   | 36| 42| 48| 54| 60| 66| 72|
|  7|   |   |   |   |   |   | 49| 56| 63| 70| 77| 84|
|  8|   |   |   |   |   |   |   | 64| 72| 80| 88| 96|
|  9|   |   |   |   |   |   |   |   | 81| 90| 99|108|
| 10|   |   |   |   |   |   |   |   |   |100|110|120|
| 11|   |   |   |   |   |   |   |   |   |   |121|132|
| 12|   |   |   |   |   |   |   |   |   |   |   |144|
+---+---+---+---+---+---+---+---+---+---+---+---+---+

REXX

/*REXX program displays a  NxN  multiplication table  (in a boxed grid) to the terminal.*/
parse arg sz .                                   /*obtain optional argument from the CL.*/
if sz=='' | sz==","  then sz= 12                 /*Not specified?  Then use the default.*/
w= max(3, length(sz**2) );    __= copies('─', w) /*calculate the width of the table cell*/
                             ___= __'──'         /*literals used in the subroutines.    */
        do r=1  for sz                           /*calculate & format a row of the table*/
        if r==1  then call top left('│(x)', w+1) /*show title of multiplication table.  */
        $= '│'center(r"x", w)"│"                 /*index for a multiplication table row.*/
               do c=1  for sz;     prod=         /*build a row of multiplication table. */
               if r<=c  then prod= r * c         /*only display when the  row ≤ column. */
               $= $  ||  right(prod,  w+1) '|'   /*append product to a cell in the row. */
               end   /*k*/
        say $                                    /*show a row of multiplication table.  */
        if r\==sz  then call sep                 /*show a separator except for last row.*/
        end          /*j*/
call bot                                         /*show the bottom line of the table.   */
exit 0                                           /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
hdr: $= ?'│';   do i=1  for sz; $=$ || right(i"x|", w+3);  end;  say $;   call sep; return
dap: $= left($, length($) - 1)arg(1);                                               return
top: $= '┌'__"┬"copies(___'┬', sz);  call dap "┐";  ?= arg(1);   say $;   call hdr; return
sep: $= '├'__"┼"copies(___'┼', sz);  call dap "┤";               say $;             return
bot: $= '└'__"┴"copies(___'┴', sz);  call dap "┘";               say $;             return
output   when using the default input of:     12
┌───┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│(x)│   1x|   2x|   3x|   4x|   5x|   6x|   7x|   8x|   9x|  10x|  11x|  12x|
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│1x │   1 |   2 |   3 |   4 |   5 |   6 |   7 |   8 |   9 |  10 |  11 |  12 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│2x │     |   4 |   6 |   8 |  10 |  12 |  14 |  16 |  18 |  20 |  22 |  24 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│3x │     |     |   9 |  12 |  15 |  18 |  21 |  24 |  27 |  30 |  33 |  36 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│4x │     |     |     |  16 |  20 |  24 |  28 |  32 |  36 |  40 |  44 |  48 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│5x │     |     |     |     |  25 |  30 |  35 |  40 |  45 |  50 |  55 |  60 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│6x │     |     |     |     |     |  36 |  42 |  48 |  54 |  60 |  66 |  72 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│7x │     |     |     |     |     |     |  49 |  56 |  63 |  70 |  77 |  84 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│8x │     |     |     |     |     |     |     |  64 |  72 |  80 |  88 |  96 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│9x │     |     |     |     |     |     |     |     |  81 |  90 |  99 | 108 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│10x│     |     |     |     |     |     |     |     |     | 100 | 110 | 120 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│11x│     |     |     |     |     |     |     |     |     |     | 121 | 132 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│12x│     |     |     |     |     |     |     |     |     |     |     | 144 |
└───┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
output   when using the input of:     16
┌───┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│(x)│   1x|   2x|   3x|   4x|   5x|   6x|   7x|   8x|   9x|  10x|  11x|  12x|  13x|  14x|  15x|  16x|
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│1x │   1 |   2 |   3 |   4 |   5 |   6 |   7 |   8 |   9 |  10 |  11 |  12 |  13 |  14 |  15 |  16 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│2x │     |   4 |   6 |   8 |  10 |  12 |  14 |  16 |  18 |  20 |  22 |  24 |  26 |  28 |  30 |  32 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│3x │     |     |   9 |  12 |  15 |  18 |  21 |  24 |  27 |  30 |  33 |  36 |  39 |  42 |  45 |  48 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│4x │     |     |     |  16 |  20 |  24 |  28 |  32 |  36 |  40 |  44 |  48 |  52 |  56 |  60 |  64 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│5x │     |     |     |     |  25 |  30 |  35 |  40 |  45 |  50 |  55 |  60 |  65 |  70 |  75 |  80 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│6x │     |     |     |     |     |  36 |  42 |  48 |  54 |  60 |  66 |  72 |  78 |  84 |  90 |  96 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│7x │     |     |     |     |     |     |  49 |  56 |  63 |  70 |  77 |  84 |  91 |  98 | 105 | 112 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│8x │     |     |     |     |     |     |     |  64 |  72 |  80 |  88 |  96 | 104 | 112 | 120 | 128 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│9x │     |     |     |     |     |     |     |     |  81 |  90 |  99 | 108 | 117 | 126 | 135 | 144 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│10x│     |     |     |     |     |     |     |     |     | 100 | 110 | 120 | 130 | 140 | 150 | 160 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│11x│     |     |     |     |     |     |     |     |     |     | 121 | 132 | 143 | 154 | 165 | 176 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│12x│     |     |     |     |     |     |     |     |     |     |     | 144 | 156 | 168 | 180 | 192 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│13x│     |     |     |     |     |     |     |     |     |     |     |     | 169 | 182 | 195 | 208 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│14x│     |     |     |     |     |     |     |     |     |     |     |     |     | 196 | 210 | 224 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│15x│     |     |     |     |     |     |     |     |     |     |     |     |     |     | 225 | 240 |
├───┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│16x│     |     |     |     |     |     |     |     |     |     |     |     |     |     |     | 256 |
└───┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Ring

multiplication_table(12)
func multiplication_table n
  nSize = 4   See "    |   " 
  for t = 1 to n see  fsize(t, nSize) next 
  see nl + "----+-" + copy("-", nSize*n) + nl
  for t1 = 1 to n
     see fsize(t1, nSize) + "|   "
     for t2 = 1 to n if t2 >= t1 see  fsize(t1*t2,nSize) else see copy(" ", nSize) ok next
     see nl
  next 
func fsize x,n return string(x) + copy(" ",n-len(string(x)))

Output

    |   1   2   3   4   5   6   7   8   9   10  11  12
----+-------------------------------------------------
1   |   1   2   3   4   5   6   7   8   9   10  11  12
2   |       4   6   8   10  12  14  16  18  20  22  24
3   |           9   12  15  18  21  24  27  30  33  36
4   |               16  20  24  28  32  36  40  44  48
5   |                   25  30  35  40  45  50  55  60
6   |                       36  42  48  54  60  66  72
7   |                           49  56  63  70  77  84
8   |                               64  72  80  88  96
9   |                                   81  90  99  108
10  |                                       100 110 120
11  |                                           121 132
12  |                                               144

Ruby

def multiplication_table(n)
  puts "    |" + (" %3d" * n) % [*1..n]
  puts "----+" + "----" * n
  1.upto(n) do |x|
    print "%3d |" % x
    1.upto(x-1) {|y| print "    "}
    x.upto(n)   {|y| print " %3d" % (x*y)}
    puts
  end
end

multiplication_table 12
Output:
    |   1   2   3   4   5   6   7   8   9  10  11  12
----+------------------------------------------------
  1 |   1   2   3   4   5   6   7   8   9  10  11  12
  2 |       4   6   8  10  12  14  16  18  20  22  24
  3 |           9  12  15  18  21  24  27  30  33  36
  4 |              16  20  24  28  32  36  40  44  48
  5 |                  25  30  35  40  45  50  55  60
  6 |                      36  42  48  54  60  66  72
  7 |                          49  56  63  70  77  84
  8 |                              64  72  80  88  96
  9 |                                  81  90  99 108
 10 |                                     100 110 120
 11 |                                         121 132
 12 |                                             144

Rust

const LIMIT: i32 = 12;

fn main() {
    for i in 1..LIMIT+1 {
        print!("{:3}{}", i, if LIMIT - i == 0 {'\n'} else {' '})
    }
    for i in 0..LIMIT+1 {
        print!("{}", if LIMIT - i == 0 {"+\n"} else {"----"});
    }

    for i in 1..LIMIT+1 {
        for j in 1..LIMIT+1 {
            if j < i {
                print!("    ")
            } else { 
                print!("{:3} ", j * i)
            }
        }
        println!("| {}", i);
    }
}

or, in terms of map:

fn main() {
    let xs = (1..=12)
        .map(|a| {
            (1..=12)
                .map(|b| {
                    if a > b {
                        String::from("    ")
                    } else {
                        format!("{:4}", a * b)
                    }
                })
                .collect::<String>()
        })
        .collect::<Vec<String>>();

    println!("{}", xs.join("\n"))
}

Scala

//Multiplication Table
print("%5s".format("|"))
for (i <- 1 to 12) print("%5d".format(i))
println()
println("-----" * 13)

for (i <- 1 to 12) {
  print("%4d|".format(i))

  for (j <- 1 to 12) {
    if (i <= j)
      print("%5d".format(i * j))
    else
      print("%5s".format(""))
  }

  println("")
}

case

implicit def intToString(i: Int) = i.toString
val cell = (x:String) => print("%5s".format(x))

for {
  i <- 1 to 14
  j <- 1 to 14
}
yield {
  (i, j) match {
    case (i, 13) => cell("|")
    case (i, 14) if i > 12 => cell("\n")
    case (13, j) => cell("-----")
    case (i, 14) => cell(i + "\n")
    case (14, j) => cell(j)
    case (i, j) if i <= j => cell(i*j)
    case (i, j) => cell("-")
  }
}

Scheme

A better implementation of iota is provided by SRFI-1 [1].

(define iota
  (lambda (count start step)
    (let loop ((result (list (+ start (* (- count 1) step)))))
      (let ((acc (car result)))
        (if (= acc start)
            result
            (loop (cons (- acc step) result)))))))


(define table
  (lambda (x)
    (let loop ((count 1)
               (numbers (iota x 1 1)))
      (if (not (null? numbers))
          (begin
            (display (make-string (* 6 (- count 1)) #\space))
            (for-each
             (lambda (n)
               (let ((number (number->string (* n count))))
                 (display (string-append
                           (make-string (- 6 (string-length number)) #\space)
                           number))))
             numbers)
            (newline)
            (loop (+ count 1)
                  (cdr numbers)))))))
(table 12)
     1     2     3     4     5     6     7     8     9    10    11    12
           4     6     8    10    12    14    16    18    20    22    24
                 9    12    15    18    21    24    27    30    33    36
                      16    20    24    28    32    36    40    44    48
                            25    30    35    40    45    50    55    60
                                  36    42    48    54    60    66    72
                                        49    56    63    70    77    84
                                              64    72    80    88    96
                                                    81    90    99   108
                                                         100   110   120
                                                               121   132
                                                                     144

Scilab

Works with: Scilab version 5.5.1
    nmax=12, xx=3
    s= blanks(xx)+" |"
    for j=1:nmax
        s=s+part(blanks(xx)+string(j),$-xx:$)
    end
    printf("%s\n",s)
    s=strncpy("-----",xx)+" +"
    for j=1:nmax
        s=s+" "+strncpy("-----",xx)
    end
    printf("%s\n",s)
    for i=1:nmax
        s=part(blanks(xx)+string(i),$-xx+1:$)+" |"
        for j = 1:nmax
            if j >= i then 
                s=s+part(blanks(xx)+string(i*j),$-xx:$) 
            else 
                s=s+blanks(xx+1)
	    end
        end
        printf("%s\n",s)
    end
Output:
    |   1   2   3   4   5   6   7   8   9  10  11  12
--- + --- --- --- --- --- --- --- --- --- --- --- ---
  1 |   1   2   3   4   5   6   7   8   9  10  11  12
  2 |       4   6   8  10  12  14  16  18  20  22  24
  3 |           9  12  15  18  21  24  27  30  33  36
  4 |              16  20  24  28  32  36  40  44  48
  5 |                  25  30  35  40  45  50  55  60
  6 |                      36  42  48  54  60  66  72
  7 |                          49  56  63  70  77  84
  8 |                              64  72  80  88  96
  9 |                                  81  90  99 108
 10 |                                     100 110 120
 11 |                                         121 132
 12 |                                             144

Seed7

$ include "seed7_05.s7i";
 
const proc: main is func
  local
    const integer: n is 12;
    var integer: i is 0;
    var integer: j is 0;
  begin
    for j range 1 to n do
      write(j lpad 3 <& " ");
    end for;
    writeln;
    writeln("-" mult 4 * n);
    for i range 1 to n do
      for j range 1 to n do
        if j < i then
          write("    ");
        else
          write(i * j lpad 3 <& " ");
        end if;
      end for;
      writeln("|" <& i lpad 3);
    end for;
  end func;
Output:
  1   2   3   4   5   6   7   8   9  10  11  12 
------------------------------------------------
  1   2   3   4   5   6   7   8   9  10  11  12 |  1
      4   6   8  10  12  14  16  18  20  22  24 |  2
          9  12  15  18  21  24  27  30  33  36 |  3
             16  20  24  28  32  36  40  44  48 |  4
                 25  30  35  40  45  50  55  60 |  5
                     36  42  48  54  60  66  72 |  6
                         49  56  63  70  77  84 |  7
                             64  72  80  88  96 |  8
                                 81  90  99 108 |  9
                                    100 110 120 | 10
                                        121 132 | 11
                                            144 | 12

Sidef

var max = 12
var width = (max**2 -> len+1)
 
func fmt_row(*items) {
    items.map {|s| "%*s" % (width, s) }.join
}
 
say fmt_row('x┃', (1..max)...)
say "#{'━' * (width - 1)}#{'━' * (max * width)}"

{ |i| 
    say fmt_row("#{i}┃", {|j| i <= j ? i*j : ''}.map(1..max)...)
} << 1..max
Output:
  x┃   1   2   3   4   5   6   7   8   9  10  11  12
━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  1┃   1   2   3   4   5   6   7   8   9  10  11  12
  2┃       4   6   8  10  12  14  16  18  20  22  24
  3┃           9  12  15  18  21  24  27  30  33  36
  4┃              16  20  24  28  32  36  40  44  48
  5┃                  25  30  35  40  45  50  55  60
  6┃                      36  42  48  54  60  66  72
  7┃                          49  56  63  70  77  84
  8┃                              64  72  80  88  96
  9┃                                  81  90  99 108
 10┃                                     100 110 120
 11┃                                         121 132
 12┃                                             144

Simula

Translation of: ALGOL W
begin
    integer i, j;
    outtext( "    " );
    for i := 1 step 1 until 12 do outint( i, 4 );
    outimage;
    outtext( "   +" );
    for i := 1 step 1 until 12 do outtext( "----" );
    outimage;
    for i := 1 step 1 until 12 do
    begin
        outint( i, 3 );
        outtext( "|" );
        for j := 1 step 1 until i - 1 do outtext( "    " );
        for j := i step 1 until 12 do outint( i * j, 4 );
        outimage
    end;
end
Output:
       1   2   3   4   5   6   7   8   9  10  11  12
   +------------------------------------------------
  1|   1   2   3   4   5   6   7   8   9  10  11  12
  2|       4   6   8  10  12  14  16  18  20  22  24
  3|           9  12  15  18  21  24  27  30  33  36
  4|              16  20  24  28  32  36  40  44  48
  5|                  25  30  35  40  45  50  55  60
  6|                      36  42  48  54  60  66  72
  7|                          49  56  63  70  77  84
  8|                              64  72  80  88  96
  9|                                  81  90  99 108
 10|                                     100 110 120
 11|                                         121 132
 12|                                             144

Swift

import Foundation

let size = 12
 
func printRow(with:Int, upto:Int) {
    
    print(String(repeating: " ", count: (with-1)*4), terminator: "")

    for i in with...upto {
            print(String(format: "%l4d", i*with), terminator: "")
    }
    print()
}

print("    ", terminator: ""); printRow( with: 1, upto: size)
print( String(repeating: "–", count: (size+1)*4 ))
for i in 1...size {
    print(String(format: "%l4d",i), terminator:"")
    printRow( with: i, upto: size)
 }

Tailspin

templates formatN&{width:}
  [ 1..$width -> ' ', '$;'... ] -> '$(last-$width+1..last)...;' !
end formatN

'  |$:1..12 -> formatN&{width: 4};
' -> !OUT::write
'--+$:1..12*4 -> '-';
' -> !OUT::write
1..12 -> \( def row: $;
  '$ -> formatN&{width:2};|$:1..($-1)*4 -> ' ';$:$..12 -> $*$row -> formatN&{width:4};
' ! \) -> !OUT::write
Output:
  |   1   2   3   4   5   6   7   8   9  10  11  12
--+------------------------------------------------
 1|   1   2   3   4   5   6   7   8   9  10  11  12
 2|       4   6   8  10  12  14  16  18  20  22  24
 3|           9  12  15  18  21  24  27  30  33  36
 4|              16  20  24  28  32  36  40  44  48
 5|                  25  30  35  40  45  50  55  60
 6|                      36  42  48  54  60  66  72
 7|                          49  56  63  70  77  84
 8|                              64  72  80  88  96
 9|                                  81  90  99 108
10|                                     100 110 120
11|                                         121 132
12|                                             144

Tcl

puts "  x\u2502   1   2   3   4   5   6   7   8   9  10  11  12"
puts \u0020\u2500\u2500\u253c[string repeat \u2500 48]
for {set i 1} {$i <= 12} {incr i} {
    puts -nonewline [format "%3d" $i]\u2502[string repeat " " [expr {$i*4-4}]]
    for {set j 1} {$j <= 12} {incr j} {
	if {$j >= $i} {
	    puts -nonewline [format "%4d" [expr {$i*$j}]]
	}
    }
    puts ""
}
Output:
  x│   1   2   3   4   5   6   7   8   9  10  11  12
 ──┼────────────────────────────────────────────────
  1│   1   2   3   4   5   6   7   8   9  10  11  12
  2│       4   6   8  10  12  14  16  18  20  22  24
  3│           9  12  15  18  21  24  27  30  33  36
  4│              16  20  24  28  32  36  40  44  48
  5│                  25  30  35  40  45  50  55  60
  6│                      36  42  48  54  60  66  72
  7│                          49  56  63  70  77  84
  8│                              64  72  80  88  96
  9│                                  81  90  99 108
 10│                                     100 110 120
 11│                                         121 132
 12│                                             144

TUSCRIPT

$$ MODE TUSCRIPT
x=y="1'2'3'4'5'6'7'8'9'10'11'12"
LOOP n,col=x,cnt=""
 skip=n-1
 LOOP m,row=y
  IF (m==skip) THEN
   td=""
  ELSE
   td=col*row
   coleqrow=col*n
   IF (td.lt.#coleqrow) td=""
  ENDIF
 td=CENTER (td,+3," ")
 cnt=APPEND (cnt,td," ")
 ENDLOOP
 col=CENTER (col,+3," ")
 PRINT col,cnt
ENDLOOP
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
  2   4   6   8  10  12  14  16  18  20  22  24
  3       9  12  15  18  21  24  27  30  33  36
  4          16  20  24  28  32  36  40  44  48
  5              25  30  35  40  45  50  55  60
  6                  36  42  48  54  60  66  72
  7                      49  56  63  70  77  84
  8                          64  72  80  88  96
  9                              81  90  99 108
 10                                 100 110 120
 11                                     121 132
 12                                         144

TypeScript

Translation of: Modula-2
// Multiplication tables

var n = 12;
console.clear();
for (j = 1; j < n; j++)
  process.stdout.write(j.toString().padStart(3, ' ') + " ");
console.log(n.toString().padStart(3, ' '));
console.log("----".repeat(n) + "+");
for (i = 1; i <= n; i++) {
  for (j = 1; j <= n; j++)
    process.stdout.write(j < i ? 
      "    " : (i * j).toString().padStart(3, ' ') + " ");
  console.log("| " + i.toString().padStart(2, ' '));
}
Output:
  1   2   3   4   5   6   7   8   9  10  11  12
------------------------------------------------+
  1   2   3   4   5   6   7   8   9  10  11  12 |  1
      4   6   8  10  12  14  16  18  20  22  24 |  2
          9  12  15  18  21  24  27  30  33  36 |  3
             16  20  24  28  32  36  40  44  48 |  4
                 25  30  35  40  45  50  55  60 |  5
                     36  42  48  54  60  66  72 |  6
                         49  56  63  70  77  84 |  7
                             64  72  80  88  96 |  8
                                 81  90  99 108 |  9
                                    100 110 120 | 10
                                        121 132 | 11
                                            144 | 12

Ursala

It's no more difficult to express the general case than the size 12 case, so a table generating function parameterized by the size is used.

#import std
#import nat

table "n" =

~&plrTS(
   ~&xS pad` @xS <'x  ','--'>-- --' | '*hS %nP* nrange/1 "n",
   ^CthPiC(`-!*h,~&) mat` *xSSK7 pad` *K7ihxPBSS (~&i&& %nP)** nleq&&product**iiK0lK2x nrange/1 "n")

#show+

main = table 12

A better way of using Ursala to make tables would be with the tbl library included with the standard package, which can generate LaTeX code for arbitrary heading hierarchies and typesetting options, but here it is in ASCII art.

  x  1 2 3  4  5  6  7  8  9  10  11  12
   -------------------------------------
 1 | 1 2 3  4  5  6  7  8  9  10  11  12
 2 |   4 6  8 10 12 14 16 18  20  22  24
 3 |     9 12 15 18 21 24 27  30  33  36
 4 |       16 20 24 28 32 36  40  44  48
 5 |          25 30 35 40 45  50  55  60
 6 |             36 42 48 54  60  66  72
 7 |                49 56 63  70  77  84
 8 |                   64 72  80  88  96
 9 |                      81  90  99 108
10 |                         100 110 120
11 |                             121 132
12 |                                 144

VBScript

function pad(s,n) if n<0 then pad= right(space(-n) & s ,-n) else  pad= left(s& space(n),n) end if 
End Function
Sub print(s): 
  On Error Resume Next
  WScript.stdout.Write (s)  
  If  err= &h80070006& Then WScript.Echo " Please run this script with CScript": WScript.quit
End Sub
For i=1 To 12
  print pad(i,-4)
Next
print vbCrLf & String(48,"_")
For i=1 To 12
  print vbCrLf
  For j=1 To 12
    if j<i Then print Space(4) Else  print pad(i*j,-4)
  Next
  print "|"& pad(i,-2)
Next
Output:

   1   2   3   4   5   6   7   8   9  10  11  12
________________________________________________
   1   2   3   4   5   6   7   8   9  10  11  12| 1
       4   6   8  10  12  14  16  18  20  22  24| 2
           9  12  15  18  21  24  27  30  33  36| 3
              16  20  24  28  32  36  40  44  48| 4
                  25  30  35  40  45  50  55  60| 5
                      36  42  48  54  60  66  72| 6
                          49  56  63  70  77  84| 7
                              64  72  80  88  96| 8
                                  81  90  99 108| 9
                                     100 110 120|10
                                         121 132|11
                                             144|12

Wren

Library: Wren-fmt
import "./fmt" for Fmt

var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
Fmt.print("  x | $4d", nums)
System.print("----+%("-" * 60)")
for (i in 1..12) {
    var nums2 = nums.map { |n| (n >= i) ? (n * i).toString : "    " }.toList
    Fmt.print("$3d | $4s", i, nums2)
}
Output:
  x |    1    2    3    4    5    6    7    8    9   10   11   12
----+------------------------------------------------------------
  1 |    1    2    3    4    5    6    7    8    9   10   11   12
  2 |         4    6    8   10   12   14   16   18   20   22   24
  3 |              9   12   15   18   21   24   27   30   33   36
  4 |                  16   20   24   28   32   36   40   44   48
  5 |                       25   30   35   40   45   50   55   60
  6 |                            36   42   48   54   60   66   72
  7 |                                 49   56   63   70   77   84
  8 |                                      64   72   80   88   96
  9 |                                           81   90   99  108
 10 |                                               100  110  120
 11 |                                                    121  132
 12 |                                                         144

XPL0

include c:\cxpl\codes;
int X, Y;
[Format(4, 0);
Text(0, "    |");  for X:= 1 to 12 do RlOut(0, float(X));
CrLf(0);
Text(0, "  --+");  for X:= 1 to 12 do Text(0, "----");
CrLf(0);
for Y:= 1 to 12 do
    [RlOut(0, float(Y));  ChOut(0, ^|);
    for X:= 1 to 12 do
        if X>=Y then RlOut(0, float(X*Y)) else Text(0, " . .");
    CrLf(0);
    ];
]
Output:
    |   1   2   3   4   5   6   7   8   9  10  11  12
  --+------------------------------------------------
   1|   1   2   3   4   5   6   7   8   9  10  11  12
   2| . .   4   6   8  10  12  14  16  18  20  22  24
   3| . . . .   9  12  15  18  21  24  27  30  33  36
   4| . . . . . .  16  20  24  28  32  36  40  44  48
   5| . . . . . . . .  25  30  35  40  45  50  55  60
   6| . . . . . . . . . .  36  42  48  54  60  66  72
   7| . . . . . . . . . . . .  49  56  63  70  77  84
   8| . . . . . . . . . . . . . .  64  72  80  88  96
   9| . . . . . . . . . . . . . . . .  81  90  99 108
  10| . . . . . . . . . . . . . . . . . . 100 110 120
  11| . . . . . . . . . . . . . . . . . . . . 121 132
  12| . . . . . . . . . . . . . . . . . . . . . . 144

zkl

fcn multiplicationTable(n){
   w,fmt := (n*n).numDigits, " %%%dd".fmt(w).fmt;  // eg " %3".fmt
   header:=[1..n].apply(fmt).concat();	   // 1  2  3  4 ...
   println(" x ", header, "\n   ", "-"*header.len());
   dash:=String(" "*w,"-");	// eg "   -"
   foreach a in ([1..n]){
      print("%2d|".fmt(a),dash*(a-1));
      [a..n].pump(String,'*(a),fmt).println();
   }
}(12);
Output:
 x   1   2   3   4   5   6   7   8   9  10  11  12
   -----------------------------------------------
 1|  1   2   3   4   5   6   7   8   9  10  11  12 
 2|  -   4   6   8  10  12  14  16  18  20  22  24 
 3|  -   -   9  12  15  18  21  24  27  30  33  36 
 4|  -   -   -  16  20  24  28  32  36  40  44  48 
 5|  -   -   -   -  25  30  35  40  45  50  55  60 
 6|  -   -   -   -   -  36  42  48  54  60  66  72 
 7|  -   -   -   -   -   -  49  56  63  70  77  84 
 8|  -   -   -   -   -   -   -  64  72  80  88  96 
 9|  -   -   -   -   -   -   -   -  81  90  99 108 
10|  -   -   -   -   -   -   -   -   - 100 110 120 
11|  -   -   -   -   -   -   -   -   -   - 121 132 
12|  -   -   -   -   -   -   -   -   -   -   - 144