[Question]
  [
Write shortest code to print the following Multiplication Table:
```
1×1=1
1×2=2  2×2=4
1×3=3  2×3=6  3×3=9
1×4=4  2×4=8  3×4=12 4×4=16
1×5=5  2×5=10 3×5=15 4×5=20 5×5=25
1×6=6  2×6=12 3×6=18 4×6=24 5×6=30 6×6=36
1×7=7  2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49
1×8=8  2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64
1×9=9  2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81
```
  
[Answer]
## Excel, ~~92~~ 91 Bytes
From the VBA editor's immediate window, run the following command:
`Range("A1:I9").Formula="=IF(ROW()<COLUMN(),"""",COLUMN()&""×""&ROW()&""=""&COLUMN()*ROW())"`
The output is directly on the active worksheet.
[![Excel output screenshot](https://i.stack.imgur.com/8r4jl.png)](https://i.stack.imgur.com/8r4jl.png)
I golfed an extra byte by swapping the order of an `if` to change `>=` to `<`. I didn't update the screenshot, but it only affects the formula at the top, not the output.
[Answer]
# Python (75)
```
r=range(1,10)
for i in r:print''.join('%sx%s=%-3s'%(j,i,i*j)for j in r[:i])
```
a little better golfed than the other two Python versions.
[Answer]
# C++, ~~106~~ 98 bytes
I used two loops and a few tricks.
```
#import <cstdio>
main(){for(int i,j;i++-9;j=0)while(j++-i)printf("%dx%d=%d%c",j,i,i*j,j<i?32:10);}
```
[Answer]
# J: 57 51 characters
```
([:;"2*\#"2(":@],'x',":@[,'=',":@*,' '"_)"0/~)>:i.9
```
No loops.
[Answer]
## APL (37)
```
∆∘.{⊃(⍺≥⍵)/,/(⍕⍺)'×'(⍕⍵)'=',⍕⍺×⍵}∆←⍳9
```
And it's not even just two for-loops. In APL, the following construct:
```
x ∘.F y
```
where `x` and `y` are lists, and `F` is a function, applies `F` to each pair of items in `x` and `y` and gives you a matrix.
So: `∆∘.×∆←⍳9` gets you a multiplication table from 1 to 9. The above function generates the required string for each pair, i.e. `(⍕⍺)`, string representation of the first number, followed by `×`, followed by `(⍕⍵)`, string representation of the second number, followed by `=`, followed by `⍕⍺×⍵`, as long as `⍺≥⍵`.
[Answer]
# Ruby: ~~60~~ 59 characters
```
1.upto(9){|i|puts (1..i).map{|j|"%dx%d=%-3d"%[j,i,i*j]}*""}
```
Sample run:
```
bash-4.2$ ruby -e '1.upto(9){|i|puts (1..i).map{|j|"%dx%d=%-3d"%[j,i,i*j]}*""}'
1x1=1 
1x2=2  2x2=4 
1x3=3  2x3=6  3x3=9 
1x4=4  2x4=8  3x4=12 4x4=16
1x5=5  2x5=10 3x5=15 4x5=20 5x5=25
1x6=6  2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x7=7  2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x8=8  2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x9=9  2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81
```
[Answer]
# Perl, 54 Characters
```
printf"%dx$?=%-3d"x$?.$/,map{$_,$_*$?}1..$?while$?++<9
```
[Answer]
## APL (Dyalog), 28
```
↑{⍵{⍕⍵,'×',⍺,'=',⍺×⍵}¨⍳⍵}¨⍳9
```
Analogous to a double loop in other languages
`{⍵{...}¨⍳⍵}¨⍳9` sets up the double loop  
`⍕⍵,'×',⍺,'=',⍺×⍵` creates the string for each pair  
`↑` Convert array of array of strings to a matrix of stings
**Output**
```
1 × 1 = 1                                                                                                 
1 × 2 = 2  2 × 2 = 4                                                                                      
1 × 3 = 3  2 × 3 = 6   3 × 3 = 9                                                                          
1 × 4 = 4  2 × 4 = 8   3 × 4 = 12  4 × 4 = 16                                                             
1 × 5 = 5  2 × 5 = 10  3 × 5 = 15  4 × 5 = 20  5 × 5 = 25                                                 
1 × 6 = 6  2 × 6 = 12  3 × 6 = 18  4 × 6 = 24  5 × 6 = 30  6 × 6 = 36                                     
1 × 7 = 7  2 × 7 = 14  3 × 7 = 21  4 × 7 = 28  5 × 7 = 35  6 × 7 = 42  7 × 7 = 49                         
1 × 8 = 8  2 × 8 = 16  3 × 8 = 24  4 × 8 = 32  5 × 8 = 40  6 × 8 = 48  7 × 8 = 56  8 × 8 = 64             
1 × 9 = 9  2 × 9 = 18  3 × 9 = 27  4 × 9 = 36  5 × 9 = 45  6 × 9 = 54  7 × 9 = 63  8 × 9 = 72  9 × 9 = 81
```
[Answer]
## *Mathematica*, 45
Pretty boring, but I guess it serves as a syntax comparison:
```
Grid@Table[Row@{a, "x", b, "=", a b}, {a, 9}, {b, a}]
```
[Answer]
# D, 75 chars
```
foreach(i,1..10){foreach(j,1..i+1){writef("%dx%d=%d ",i,j,i*j);}writeln();}
```
you just said code not function or full program
[Answer]
## VBScript (133); without loops.
```
g=""
sub m(x,y)
    g=x&"x"&y&"="&x*y&vbTab&g
    if x>1 then 
        m x-1,y
    elseif y>1 then 
        g=vbLf&g 
        m y-1,y-1
    end if
end sub
m 9,9
wscript.echo g
```
On request of the challenger: no loops. This code uses recursive subroutine calls.
[Answer]
# Maple, 64
```
seq(printf(seq(printf("%ax%a=%a ",j,i,i*j),j=1..i),"\n"),i=1..9)
```
[Answer]
# x86\_64 machine code (linux), ~~175~~ ~~99~~ 76 bytes
```
0000000000400080 <_start>:
  400080:   66 bf 09 00             mov    $0x9,%di
0000000000400084 <_table.L2>:
  400084:   6a 0a                   pushq  $0xa
  400086:   89 fe                   mov    %edi,%esi
0000000000400088 <_table.L3>:
  400088:   89 f0                   mov    %esi,%eax
  40008a:   f7 e7                   mul    %edi
000000000040008c <_printInteger>:
  40008c:   6a 20                   pushq  $0x20
  40008e:   3c 0a                   cmp    $0xa,%al
  400090:   7d 02                   jge    400094 <_printInteger.L1>
  400092:   6a 20                   pushq  $0x20
0000000000400094 <_printInteger.L1>:
  400094:   66 31 d2                xor    %dx,%dx
  400097:   b3 0a                   mov    $0xa,%bl
  400099:   66 f7 f3                div    %bx
  40009c:   83 c2 30                add    $0x30,%edx
  40009f:   52                      push   %rdx
  4000a0:   66 85 c0                test   %ax,%ax
  4000a3:   75 ef                   jne    400094 <_printInteger.L1>
  4000a5:   6a 3d                   pushq  $0x3d
  4000a7:   66 57                   push   %di
  4000a9:   80 04 24 30             addb   $0x30,(%rsp)
  4000ad:   6a 78                   pushq  $0x78
  4000af:   66 56                   push   %si
  4000b1:   80 04 24 30             addb   $0x30,(%rsp)
  4000b5:   ff ce                   dec    %esi
  4000b7:   75 cf                   jne    400088 <_table.L3>
  4000b9:   ff cf                   dec    %edi
  4000bb:   75 c7                   jne    400084 <_table.L2>
00000000004000bd <_printChars>:
  4000bd:   66 ba 00 08             mov    $0x800,%dx
  4000c1:   b0 01                   mov    $0x1,%al
  4000c3:   66 bf 01 00             mov    $0x1,%di
  4000c7:   48 89 e6                mov    %rsp,%rsi
  4000ca:   0f 05                   syscall
```
~~This is a dump of the binary file, and all of this is 175 bytes. It basically does the same two loops that all the answers do, but printing to the console is a bit harder and basically requires pushing the characters to print onto the stack in reverse, and then making a (linux specific) syscall to actually put those chars into stdout.~~
I've now optimized this so that only 1 write operation is performed (faster!) and has magic numbers (wow!) and by pushing the entire result onto the stack backwards before making the syscall. I also took out the exit routine because who needs proper exit code? 
Here's a link to my [first](https://bitbucket.org/daveyhughes/ppcg/raw/8d730dafacaf6492673e3d348d2003e1485b8697/asm/mult_table.asm) and [second](https://bitbucket.org/daveyhughes/ppcg/raw/8d730dafacaf6492673e3d348d2003e1485b8697/asm/mult_table2.asm) attempts, in their original nasm syntax.
I welcome anyone who has any other suggestions on how it can be improved. I can also explain the logic in more detail if anyone is curious.
~~(Also, it doesn't print the extra spaces to make all the columns aligned, but if that's required I can put the logic in at the cost of a few more bytes).~~
EDIT: Now prints extra spaces and is golfed down even more! It's doing some pretty crazy stuff with the registers, and is probably unstable if this program were to be expanded.
[Answer]
## Javascript, 190 bytes
Late to the party, but I was piqued by @jdstankosky 's comment and decided to take a different approach. Here's a Javascript entry that mauls a template and evals itself along the way.
```
t="a*b=c ";u="";r=u;for(i=1;i<10;i++){a=0;u=u+t;r+=u.split(' ').map(x=>x.replace('a',++a).replace('b',i)).map(x=>x.replace('*','x').replace('c',eval(x.substr(0,3)))).join(' ')+'\n'}alert(r);
```
Un-golfed version (slightly older version in which a function returns the table instead of a script alerting it, but the same principles apply):
```
function f()
{
    t="a*b=c "; // template for our multiplication table
    u="";r="";  // tmp- and return values
    for(i=1;i<10;i++)
    {
        a=0;    // is auto-incremented in MAP
        u=u+t;// extend the template once per iteration
        v=u.split(' '); // Smash the template to pieces
        w=v.map(x=>x.replace('a', ++a).replace('b', i)) // MAP replaces the A and B's with the correct numbers
        w=w.map(x=>x.replace('*', 'x').replace('c', eval(x.substring(0,3)))).join(' '); // second map evals that and replaces c with the answer, makes the asteriks into an X
        r=r+w+'\n'  // results get concatenated
    }
    return r;
}
```
[Answer]
# Fourier, ~~756~~ 632 bytes
Thanks @BetaDecay for 124 bytes!
```
1o120~Ea1o61a1o10~Na1oEa2o61a2o32~Saa2oEa2o61a4oNa1oEa3o61a3oSaa2oEa3o61a6oSaa3oEa3o61a9o^a1oEa4o61a4oSaa2oEa4o61a8oSaa3oEa4o61a12oSa4oEa4o61a16oNa1oEa5o61a5oSaa2oEa5o61aNoSa3oEa5o61a15oSa4oEa5o61a20oSa5oEa5o61a25oNa1oEa6o61a6oSaa2oEa6o61a12oSa3oEa6o61a18oSa4oEa6o61a24oSa5oEa6o61a30oSa6oEa6o61a36oNa1oEa7o61a7oSaa2oEa7o61a14oSa3oEa7o61a21oSa4oEa7o61a28oSa5oEa7o61a35oSa6oEa7o61a42oSa7oEa7o61a49oNa1oEa8o61a8oSaa2oEa8o61a16oSa3oEa8o61a24oSa4oEa8o61aSoa5oEa8o61a40oSa6oEa8o61a48oSa7oEa8o61a56oSa8oEa8o61a64oNa1oEa9o61a9oSaa2oEa9o61a18oSa3oEa9o61a27oSa4oEa9o61a36oSa5oEa9o61a45oSa6oEa9o61a54oSa7oEa9o61a63oSa8oEa9o61a72oSa9oEa9o61a81o
```
[Answer]
# [Pascal (FPC)](https://www.freepascal.org/), ~~128 125~~ 138 bytes
One recursive procedure takes care of everything. Call with `m(9,9)`.
```
procedure m(i,j:int8);begin if i<1then Exit;if i=j then begin m(i-1,j-1);writeln;end;m(i-1,j);write(i,'x',j,'=',i*j,' ':2-i*j div 10);end;
```
Ungolfed:
```
procedure m(i, j: int8);
begin
  if i<1 then
    Exit;
  if i=j then
  begin
    m(i-1, j-1);
    writeln;
  end;
  m(i-1, j);
  write(i,'x',j,'=',i*j,' ':2-i*j div 10);
end;
```
The reason for the byte count going up: the output was not aligned correctly. It is fixed now.
[Try it online!](https://tio.run/##LYxBEsIgFEP3PcXfUZyPI65ssUsPUoHqZ1pkELW3R8SukrxJEsanHmcxBZ1ziA9tzStaWFpC15NPJ66u9kYeaAI6y3S3Hi4rJfXLg4MK/o2yERKdkFx9IiU7e2W9URveYPllK0OHbGBIu6LA@qMoDgy9QR54HeV62Sxthx1XTUH7/AU "Pascal (FPC) – Try It Online")
[Answer]
# [ConTeXt](https://wiki.contextgarden.net/Main_Page), ~~67~~ 60 bytes
```
\let~\dorecurse\starttext~9{~#1{##1x#1=\luaexpr{#1*##1} }
}
```
[![enter image description here](https://i.stack.imgur.com/R9maS.png)](https://i.stack.imgur.com/R9maS.png)
[Answer]
## vba 55
(immediate window)
```
for f=1 to 9:for j=1 to f:?f;"x";j;"=";f*j,:next:?:next
```
note - GWBasic only needs 2 extra characters:
```
1 for f=1 to 9:for j=1 to f:?f;"x";j;"=";f*j,:next:?:next
```
[Answer]
## Javascript, 75
```
for(s="",a=b=1;a<10;b=a==b?(a++,alert(s),s="",1):b+1)s+=b+"x"+a+"="+a*b+" "
```
I wonder if something better than two (combined?) for loops is possible...
[Answer]
# Coreutils/Bash: 147 136 135
```
for i in {1..9}; do
  yes $'\n' | head -n $[i-1] > $i
  paste -dx= <(yes $i) <(seq $i 9) <(seq $[i*i] $i $[9*i]) |head -n$[10-i] >> $i
done
paste {1..9}
```
Golfed, using explicit newline and, using deprecated head option (thanks manatwork):
```
for i in {1..9};do yes '
'|head -$[i-1]>$i;paste -dx= <(yes $i) <(seq $i 9) <(seq $[i*i] $i $[9*i])| head -$[10-i]>>$i;done;paste {1..9}
```
Output:
```
1x1=1                               
1x2=2   2x2=4                           
1x3=3   2x3=6   3x3=9                       
1x4=4   2x4=8   3x4=12  4x4=16                  
1x5=5   2x5=10  3x5=15  4x5=20  5x5=25              
1x6=6   2x6=12  3x6=18  4x6=24  5x6=30  6x6=36          
1x7=7   2x7=14  3x7=21  4x7=28  5x7=35  6x7=42  7x7=49      
1x8=8   2x8=16  3x8=24  4x8=32  5x8=40  6x8=48  7x8=56  8x8=64  
1x9=9   2x9=18  3x9=27  4x9=36  5x9=45  6x9=54  7x9=63  8x9=72  9x9=81
```
[Answer]
# Python 2, 72
```
i=1;exec"j=1;exec'print\"%sx%s=%-2s\"%(j,i,j*i),;j+=1;'*i;print;i+=1;"*9
```
Output:
```
1x1=1 
1x2=2  2x2=4 
1x3=3  2x3=6  3x3=9
1x4=4  2x4=8  3x4=12 4x4=16
1x5=5  2x5=10 3x5=15 4x5=20 5x5=25
1x6=6  2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x7=7  2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x8=8  2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x9=9  2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81
```
[Answer]
## LOLCODE, 202 bytes
```
IM IN YR o UPPIN YR b TIL BOTH SAEM b AN 10
c R ""
IM IN YR i UPPIN YR a TIL BOTH SAEM a AN SUM OF b AN 1
c R SMOOSH c SMOOSH a "x" b "=" PRODUKT OF a AN b " " MKAY
IM OUTTA YR i
VISIBLE c
IM OUTTA YR o
```
Ungolfed:
```
HAI 1.3 BTW Unnecessary in current implementations
IM IN YR outer UPPIN YR multiplicand TIL BOTH SAEM multiplicand AN 10
    I HAS A output ITZ ""
    IM IN YR inner UPPIN YR multiplier TIL BOTH SAEM multiplier AN SUM OF multiplicand AN 1
        output R SMOOSH output AN SMOOSH multiplier AN "x" AN multiplicand AN "=" AN PRODUCKT OF multiplicand AN multiplier AN " " MKAY MKAY BTW AN is optional to separate arguments, a linebreak is an implicit MKAY.
    IM OUTTA YR inner
    VISIBLE output
IM OUTTA YR outer
KTHXBYE BTW Unnecessary in current implementations
```
Pythonated for non-leetspeakers:
```
for multiplicand in range(1, 10):
    output = ""
    for multiplier in range(1, multiplicand + 1):
        output = output + (multiplier + "x" + multiplicand + "=" + str(multiplicand * multiplier) + " ")
    print(output)
```
[Answer]
**c#, 142 bytes**
```
Enumerable.Range(1,9).ToList().ForEach(i =>Enumerable.Range(1,i).ToList().ForEach(j=>Console.Write("{0}x{1}={2}{3}",j,i,j*i,j==i?"\n":"\t")));
```
And not a for in sight...
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 50 bytes
```
1v
 1
?\::n"x"o{::n"="o}*n" "o1+:{:})
 \~1+:a=?;ao
```
You can try it on the [online interpreter](https://fishlanguage.com/playground).
Note that there is trailing spaces on each lines, which might make it incorrect (OP hasn't stated on this point as of this answer).
[Answer]
# [///](https://esolangs.org/wiki////), 268 bytes
```
/_/\/\///x/×_N/x9=_E/x8=_V/x7=_S/x6=_F/x5=_R/x4=_O/
1_t/  2_h/ 3/1x1=1Ox2=2tx2=4Ox3=3tx3=6 hx3=9OR4tR8 hR12 4R16OF5tF10hF15 4F20 5F25OS6tS12hS18 4S24 5S30 6S36OV7tV14hV21 4V28 5V35 6V42 7V49OE8tE16hE24 4E32 5E40 6E48 7E56 8E64ON9tN18hN27 4N36 5N45 6N54 7N63 8N72 9N81
```
[Answer]
# JAVA, ~~103 94 92~~ 90 bytes
Using JShell from Java 9 SDK allows me to save large amount of space
```
for(int i=0,j;i++<9;)for(j=1;j<=i;)System.out.print(i+"*"+j+"="+i*j+"\t"+(j++<i?"":"\n"))
```
Following Kevin's suggestion I reduced solution by 2 bytes.
Thanks to cliffroot, I was able to reduce it by another 1 byte
[Answer]
## Pyke, ~~17~~ 16 bytes (noncompeting)
Pyke was created after this question was asked
```
TFjSF\xj\=ij*s(P
```
[Try it here!](http://pyke.catbus.co.uk/?code=TFjSF%5Cxj%5C%3Dij%2as%28P&warnings=0)
```
TFj           (  - for j in range(10):
   SF         (  -     for i in range(1,j+1):
     \xj\=ij*s   -         sum(i,"x",j,"=",i*j)
               P - pretty_print(^)
```
[Answer]
## Tcl 98 chars
```
while {[incr a]<10} {set b 0;while {[incr b]<=$a} {puts -nonewline "$a×$b=[expr $a*$b] "};puts ""}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 23 bytes
```
9õÈõ_[X'×Z'=X*Z]¬ú6Ã¸Ã·
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=OfXI9V9bWCfXWic9WCpaXaz6NsO4w7c=&input=)
---
## Explanation
```
9õ                          :Range [1,9]
  È                  Ã      :Pass each integer X through a function
   õ                        :  Range [1,X]
    _              Ã        :  Pass each integer Z through a function
     [X'×Z'=X*Z]            :    Array [X,"×",Z,"=",X*Z]
                ¬           :    Join to a string
                 ú6         :    Pad end with spaces to length 6
                    ¸       :  Join with spaces
                      ·     :Join with newlines
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~54~~ 52 bytes
```
1..9|%{''+(1..($l=$_)|%{"$_`×$l={0,-2}"-f($_*$l)})}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/31BPz7JGtVpdXVsDyNRQybFVidcECiipxCccng7kVhvo6BrVKummaajEa6nkaNZq1v7/DwA "PowerShell – Try It Online")
]