编写最短的代码以打印以下乘法表：

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

Excel，92 91字节

在VBA编辑器的立即窗口中，运行以下命令： Range("A1:I9").Formula="=IF(ROW()<COLUMN(),"""",COLUMN()&""×""&ROW()&""=""&COLUMN()*ROW())" 输出直接在活动工作表上。

通过交换将的顺序if更改>=为，我得到了一个额外的字节<。我没有更新屏幕截图，但它只影响顶部的公式，而不影响输出。

巨蟒（75）

r=range(1,10)
for i in r:print''.join('%sx%s=%-3s'%(j,i,i*j)for j in r[:i])

打高尔夫球比其他两个Python版本要好一些。

C ++，106 98字节

我使用了两个循环和一些技巧。

#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);}

J：57 51个字符

([:;"2*\#"2(":@],'x',":@[,'=',":@*,' '"_)"0/~)>:i.9

没有循环。

APL（37）

∆∘.{⊃(⍺≥⍵)/,/(⍕⍺)'×'(⍕⍵)'=',⍕⍺×⍵}∆←⍳9

而且它不仅是两个for循环。在APL中，以下构造：

x ∘.F y

其中x和y是列表，并且F是一个函数，适用F于x和中的每一对项目，y并为您提供一个矩阵。

因此：∆∘.×∆←⍳9获得一个从1到9的乘法表。上面的函数为每对生成所需的字符串，即(⍕⍺)第一个数字的字符串表示形式，然后是×，然后是(⍕⍵)，第二个数字的字符串表示形式，然后是=，然后是⍕⍺×⍵，只要⍺≥⍵。

Ruby：60个 59个字符

1.upto(9){|i|puts (1..i).map{|j|"%dx%d=%-3d"%[j,i,i*j]}*""}

样品运行：

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

Perl，54个字符

printf"%dx$?=%-3d"x$?.$/,map{$_,$_*$?}1..$?while$?++<9

APL（Dyalog），28岁

↑{⍵{⍕⍵,'×',⍺,'=',⍺×⍵}¨⍳⍵}¨⍳9

类似于其他语言中的双循环

{⍵{...}¨⍳⍵}¨⍳9设置双循环
⍕⍵,'×',⍺,'=',⍺×⍵，为每对创建一个字符串
↑将字符串数组转换为字符串矩阵

输出量

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

Mathematica，45岁

很无聊，但是我想它可以作为语法比较：

Grid@Table[Row@{a, "x", b, "=", a b}, {a, 9}, {b, a}]

D，75个字符

foreach(i,1..10){foreach(j,1..i+1){writef("%dx%d=%d ",i,j,i*j);}writeln();}

您只是说代码不起作用或程序不完整

VBScript（133）; 没有循环。

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

应挑战者的要求：无循环。此代码使用递归子例程调用。

枫树，64

seq(printf(seq(printf("%ax%a=%a ",j,i,i*j),j=1..i),"\n"),i=1..9)

x86_64机器码（Linux），175 99 76字节

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

这是二进制文件的转储，所有这些都是175个字节。它基本上执行与所有答案相同的两个循环，但是打印到控制台要困难一些，并且基本上需要将字符反向推送到堆栈上，然后进行（特定于Linux的）系统调用来实际放置这些字符进入标准输出。

现在，我已经对此进行了优化，以便仅执行1次写入操作（更快！）并具有幻数（哇！），并且在进行syscall之前将整个结果向后推入堆栈。我还退出了退出例程，因为谁需要适当的退出代码？

这是我的第一和第二个链接尝试，它们使用的是原始的nasm语法。

我欢迎任何对如何改进它有其他建议的人。如果有人好奇，我也可以更详细地解释逻辑。

（此外，它不会打印多余的空格以使所有列对齐，但是如果需要的话，我可以花更多的字节来放入逻辑）。

编辑：现在打印出额外的空间，并且向下打高尔夫球！它正在用寄存器做一些非常疯狂的事情，并且如果要扩展此程序，可能会不稳定。

Javascript，190字节

晚会晚了，但是@jdstankosky的评论让我很激动，因此决定采用其他方法。这是一个Javascript条目，它会欺骗模板并逐步评估自身。

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

非高尔夫版本（稍旧的版本，在该版本中，函数返回表而不是脚本来警告该表，但适用相同的原理）：

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;
}

Pascal，128个字节

一种递归过程可以处理所有事情。致电m(9,9)。

procedure m(i,j:integer);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,' ');end;

取消高尔夫：

procedure mul(i, j: integer);
begin
  if i<1 then
    Exit;
  if i=j then
  begin
    mul(i-1, j-1);
    writeln;
  end;
  mul(i-1, j);
  write(i,'x',j,'=',i*j,' ');
end;

傅里叶 756 632字节

感谢@BetaDecay的124个字节！

1o120~Ea1o61a1o10~Na1oEa2o61a2o32~Saa2oEa2o61a4oNa1oEa3o61a3oSaa2oEa3o61a6oSaa3oEa3o61a9o^a1oEa4o61a4oSaa2oEa4o61a8oSaa3oEa4o61a12oSa4oEa4o61a16oNa1oEa5o61a5oSaa2oEa5o61aNoSa3oEa5o61a15oSa4oEa5o61a20oSa5oEa5o61a25oNa1oEa6o61a6oSaa2oEa6o61a12oSa3oEa6o61a18oSa4oEa6o61a24oSa5oEa6o61a30oSa6oEa6o61a36oNa1oEa7o61a7oSaa2oEa7o61a14oSa3oEa7o61a21oSa4oEa7o61a28oSa5oEa7o61a35oSa6oEa7o61a42oSa7oEa7o61a49oNa1oEa8o61a8oSaa2oEa8o61a16oSa3oEa8o61a24oSa4oEa8o61aSoa5oEa8o61a40oSa6oEa8o61a48oSa7oEa8o61a56oSa8oEa8o61a64oNa1oEa9o61a9oSaa2oEa9o61a18oSa3oEa9o61a27oSa4oEa9o61a36oSa5oEa9o61a45oSa6oEa9o61a54oSa7oEa9o61a63oSa8oEa9o61a72oSa9oEa9o61a81o

VBA 55

（立即窗口）

for f=1 to 9:for j=1 to f:?f;"x";j;"=";f*j,:next:?:next

注意-GWBasic仅需要2个额外的字符：

1 for f=1 to 9:for j=1 to f:?f;"x";j;"=";f*j,:next:?:next

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+" "

我想知道是否可能有比两个（合并的）for循环更好的东西...

的coreutils /击：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}

打高尔夫球，使用显式换行符，并且使用不推荐使用的head选项（感谢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}

输出：

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

LOLCODE，202个字节

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

取消高尔夫：

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

非演讲者使用Python处理：

for multiplicand in range(1, 10):
    output = ""
    for multiplier in range(1, multiplicand + 1):
        output = output + (multiplier + "x" + multiplicand + "=" + str(multiplicand * multiplier) + " ")
    print(output)

c＃，142个字节

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

而不是眼前一亮...

> <>，50个字节

1v
 1
?\::n"x"o{::n"="o}*n" "o1+:{:})
 \~1+:a=?;ao

您可以在在线解释器上尝试。

请注意，每行上都有尾随空格，这可能使它不正确（截至本回答为止，OP尚未在此声明）。

/// 268字节

/_/\/\///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

JAVA，103 94 92 90字节

使用Java 9 SDK中的JShell可以节省大量空间

for(int i=0,j;i++<9;)for(j=1;j<=i;)System.out.print(i+"*"+j+"="+i*j+"\t"+(j++<i?"":"\n"))

按照Kevin的建议，我将解决方案减少了2个字节。

多亏了悬崖根，我得以再减少一个字节

C 79字节

i=1,j=1;f(){printf("%dx%d=%d ",j,i,i*j);++i>j?++j,i=1,j<=9?puts(""),f():0:f();}

主要的

main(){f();}

桌子

1x1=1 
2x1=2 2x2=4 
3x1=3 3x2=6 3x3=9 
4x1=4 4x2=8 4x3=12 4x4=16 
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81 

Tcl 98个字符

while {[incr a]<10} {set b 0;while {[incr b]<=$a} {puts -nonewline "$a×$b=[expr $a*$b] "};puts ""}

Javascript：82个字符

o="";for(a=1;a<10;a++){for(b=1;b<=a;b++){o+=a+"x"+b+"="+(a*b)+" "}o+="\n"}alert(o)

的Python：87

我正在关注其他人发布的解决方案，但大多数解决方案似乎并没有使间距正确。

for i in range(1,10):print''.join(('%s×%s=%s'%(j,i,i*j)).ljust(7)for j in range(1,i+1))

巨蟒（79）

或（77）如果我使用，range(10)除了会在开始时产生一个空行

for i in range(1,10):print' '.join('%dx%d=%-2d'%(j,i,j*i)for j in range(1,i+1))

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

Perl：65个，62个字符

map{map{printf"%dx%d=%2d ",$_,$i,$_*$i}1..($i=$_);print$/}1..9