Viết mã ngắn nhất để in Bảng nhân sau:

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 byte

Từ cửa sổ ngay lập tức của trình soạn thảo VBA, hãy chạy lệnh sau: Range("A1:I9").Formula="=IF(ROW()<COLUMN(),"""",COLUMN()&""×""&ROW()&""=""&COLUMN()*ROW())" Đầu ra trực tiếp trên trang tính đang hoạt động.

Tôi đánh gôn thêm một byte bằng cách hoán đổi thứ tự của một ifthay đổi >=thành <. Tôi đã không cập nhật ảnh chụp màn hình, nhưng nó chỉ ảnh hưởng đến công thức ở đầu chứ không ảnh hưởng đến đầu ra.

Con trăn (75)

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

chơi golf tốt hơn một chút so với hai phiên bản Python khác.

C ++, 106 98 byte

Tôi đã sử dụng hai vòng lặp và một vài thủ thuật.

#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 ký tự

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

Không có vòng lặp.

APL (37)

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

Và nó thậm chí không chỉ là hai vòng lặp. Trong APL, cấu trúc sau:

x ∘.F y

nơi xvà ylà danh sách, và Flà một chức năng, áp dụng Fcho mỗi cặp các mặt hàng trong xvày và cung cấp cho bạn một ma trận.

Vì vậy: ∆∘.×∆←⍳9giúp bạn có một bảng nhân từ 1 đến 9. Hàm trên tạo ra chuỗi cần thiết cho mỗi cặp, nghĩa là (⍕⍺)biểu diễn chuỗi của số thứ nhất, theo ×sau là (⍕⍵), biểu diễn chuỗi của số thứ hai, theo sau =, theo sau là ⍕⍺×⍵, miễn là ⍺≥⍵.

Ruby: 60 59 ký tự

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

Chạy mẫu:

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 ký tự

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

APL (Dyalog), 28

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

Tương tự như một vòng lặp kép trong các ngôn ngữ khác

{⍵{...}¨⍳⍵}¨⍳9thiết lập vòng lặp đôi
⍕⍵,'×',⍺,'=',⍺×⍵tạo chuỗi cho mỗi cặp
↑ Chuyển đổi mảng chuỗi của chuỗi thành ma trận stings

Đầu ra

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

Toán học , 45

Khá nhàm chán, nhưng tôi đoán nó phục vụ như là một so sánh cú pháp:

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

D, 75 ký tự

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

bạn vừa nói mã không hoạt động hoặc chương trình đầy đủ

VBScript (133); không có vòng lặp.

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

Theo yêu cầu của người thách thức: không có vòng lặp. Mã này sử dụng các cuộc gọi chương trình con đệ quy.

Phong, 64

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

mã máy x86_64 (linux), 175 99 76 byte

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

Đây là một kết xuất của tệp nhị phân và tất cả điều này là 175 byte. Về cơ bản, nó thực hiện hai vòng lặp giống như tất cả các câu trả lời, nhưng in ra bàn điều khiển khó hơn một chút và về cơ bản đòi hỏi phải đẩy các ký tự in lên ngăn xếp, và sau đó tạo một tòa nhà (cụ thể của linux) để thực sự đặt các ký tự đó vào thiết bị xuất chuẩn.

Bây giờ tôi đã tối ưu hóa điều này để chỉ có 1 thao tác ghi được thực hiện (nhanh hơn!) Và có số ma thuật (wow!) Và bằng cách đẩy toàn bộ kết quả lên ngăn xếp về phía trước trước khi thực hiện tòa nhà. Tôi cũng lấy ra thói quen thoát vì ai cần mã thoát đúng?

Đây là một liên kết đến đầu tiên và thứ hai của tôi , theo cú pháp ban đầu của họ.

Tôi hoan nghênh bất cứ ai có bất kỳ đề xuất nào khác về cách cải thiện nó. Tôi cũng có thể giải thích logic chi tiết hơn nếu có ai tò mò.

(Ngoài ra, nó không in các khoảng trắng thừa để làm cho tất cả các cột được căn chỉnh, nhưng nếu điều đó là bắt buộc, tôi có thể đặt logic vào với chi phí thêm một vài byte).

EDIT: Bây giờ in thêm không gian và được chơi golf nhiều hơn nữa! Nó đang làm một số thứ khá điên rồ với các thanh ghi, và có lẽ không ổn định nếu chương trình này được mở rộng.

Javascript, 190 byte

Đến bữa tiệc muộn, nhưng tôi đã bị thu hút bởi bình luận của @jdstankosky và quyết định thực hiện một cách tiếp cận khác. Đây là một mục nhập Javascript tạo ra một mẫu và tự chạy trên đường đi.

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

Phiên bản không chơi gôn (phiên bản cũ hơn một chút trong đó một hàm trả về bảng thay vì tập lệnh cảnh báo nó, nhưng áp dụng các nguyên tắc tương tự):

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 byte

Một thủ tục đệ quy sẽ chăm sóc tất cả mọi thứ. Gọi với 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;

Ung dung:

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;

Fourier, 756 632 byte

Cảm ơn @BetaDecay cho 124 byte!

1o120~Ea1o61a1o10~Na1oEa2o61a2o32~Saa2oEa2o61a4oNa1oEa3o61a3oSaa2oEa3o61a6oSaa3oEa3o61a9o^a1oEa4o61a4oSaa2oEa4o61a8oSaa3oEa4o61a12oSa4oEa4o61a16oNa1oEa5o61a5oSaa2oEa5o61aNoSa3oEa5o61a15oSa4oEa5o61a20oSa5oEa5o61a25oNa1oEa6o61a6oSaa2oEa6o61a12oSa3oEa6o61a18oSa4oEa6o61a24oSa5oEa6o61a30oSa6oEa6o61a36oNa1oEa7o61a7oSaa2oEa7o61a14oSa3oEa7o61a21oSa4oEa7o61a28oSa5oEa7o61a35oSa6oEa7o61a42oSa7oEa7o61a49oNa1oEa8o61a8oSaa2oEa8o61a16oSa3oEa8o61a24oSa4oEa8o61aSoa5oEa8o61a40oSa6oEa8o61a48oSa7oEa8o61a56oSa8oEa8o61a64oNa1oEa9o61a9oSaa2oEa9o61a18oSa3oEa9o61a27oSa4oEa9o61a36oSa5oEa9o61a45oSa6oEa9o61a54oSa7oEa9o61a63oSa8oEa9o61a72oSa9oEa9o61a81o

vba 55

(cửa sổ ngay lập tức)

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

lưu ý - GWBasic chỉ cần thêm 2 ký tự:

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

Tôi tự hỏi nếu một cái gì đó tốt hơn hai (kết hợp?) Cho các vòng lặp có thể ...

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}

Chơi gôn, sử dụng dòng mới rõ ràng và sử dụng tùy chọn đầu không dùng nữa (cảm ơn 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}

Đầu ra:

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 byte

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

Ung dung:

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 cho non-leetspeaker:

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 byte

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

Và không phải là trong tầm nhìn ...

> <> , 50 byte

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

Bạn có thể thử nó trên trình thông dịch trực tuyến .

Lưu ý rằng có các khoảng trắng ở mỗi dòng, điều này có thể làm cho nó không chính xác (OP đã không nêu ở điểm này như câu trả lời này).

/// , 268 byte

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

Sử dụng JShell từ SDK Java 9 cho phép tôi tiết kiệm dung lượng lớn

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

Theo đề nghị của Kevin, tôi giảm 2 byte.

Nhờ cliffroot, tôi đã có thể giảm thêm 1 byte

C 79 byte

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

chính

main(){f();}

cái bàn

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 

98 ký tự

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

Javascript: 82 ký tự

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

Con trăn: 87

Tôi đang chú ý đến các giải pháp mà những người khác đã đăng và hầu hết trong số họ không xuất hiện để có khoảng cách chính xác.

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

Con trăn (79)

hoặc ( 77 ) nếu tôi sử dụng range(10)ngoại trừ việc tạo ra một dòng trống khi bắt đầu

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 ký tự

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