Cho (bằng mọi cách) hai số tự nhiên khác nhau (có kích thước hợp lý), đầu ra (bằng bất kỳ phương tiện nào) bình phương tổng của chúng như trong các ví dụ dưới đây:

Cho 4 và 3, đầu ra:

12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

Cho 1 và 3, đầu ra:

3 9 9 9
3 9 9 9
3 9 9 9
1 3 3 3

Khoảng trắng có thể khác nhau trong lý do nhưng các cột phải được căn trái, căn phải hoặc trung tâm (giả).

Một dòng mới theo dõi là tốt, nhưng sơ hở tiêu chuẩn thì không.

Đây là môn đánh gôn, vì vậy hãy bao gồm một tiêu đề như # LanguageName, 123trong câu trả lời của bạn, trong đó số là ký tự (byte cho các ngôn ngữ không dựa trên văn bản). Mã đóng gói cho ký tự Unicode lớn không được phép.

Phần thưởng: -3 nếu mã của bạn chỉ xuất ra một ô vuông khi một trong các số là 0; ví dụ: 0 và 3, đầu ra:

9 9 9
9 9 9
9 9 9

J, 9 byte - 3 = 6

#~@|.*/#~

Lấy cảm hứng từ câu trả lời APL của @ NBZ , được đánh dấu bởi @randomra. Điều này định nghĩa một động từ mất một mảng số. Nó được sử dụng như sau:

   (#~@|.*/#~) 4 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

Tôi cũng yêu cầu phần thưởng 3 byte, vì đầu vào bằng 0 tạo ra ma trận con có kích thước bằng 0:

   (#~@|.*/#~) 4 0
16 16 16 16
16 16 16 16
16 16 16 16
16 16 16 16
   (#~@|.*/#~) 0 3
9 9 9
9 9 9
9 9 9

Giải trình

J có một lợi thế nhất định trong thử thách này. Ngoài việc ăn các vấn đề thao tác mảng cho bữa sáng, nó còn in các ma trận 2D theo đúng định dạng.

       #~  Replicate each number n in input n times
#~@|.      The same for reversed input
     */    Compute their multiplication table

Octave, 45 byte - 3 = 42

s=@(m,n)[a=ones(n,1)*n;b=ones(m,1)*m].*[b;a]'

Giải trình

Điều này xây dựng hai vectơ (giả sử m = 4và n = 3):

ones(n, 1)xây dựng một mảng các kích thước n x 1, do đó nhân các mảng có kích thước n:

ones(n, 1) * n => [3 3 3]' (where ' is transpose... n x 1 is a column vector)

a = [3 3 3  4 4 4 4]'   %// a is a column vector
b = [4 4 4 4  3 3 3]    %// b is a row vector

Sau đó, các vectơ được nhân lên theo kiểu phần tử, với khả năng mở rộng phát sóng tự động để các vectơ 7 phần tử tạo ra ma trận 7x7 phần tử:

    [3] .* [4 4 4 4 3 3 3]
    [3]
    [3]
    [4]
    [4]
    [4]
    [4]

Ví dụ, nhân của hàng đầu tiên của abằng cách bcung cấp cho:

    [3] .* [4 4 4 4 3 3 3] = [12 12 12 12  9  9  9]

Và tương tự cho các hàng còn lại của a.

Đầu ra:

>> s(4,3)
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

>> s(3,0)
ans =

   9   9   9
   9   9   9
   9   9   9

Bạn có thể thử nó ở đây trên ideone

APL Dyalog , 10-3 = 7

Lấy cảm hứng * bởi câu trả lời này trong đó các đối số được sao chép và sau đó được sử dụng trong bảng nhân:

⊖∘.×⍨(/⍨⎕)

⎕Đưa ra một dấu nhắc ( ⎕:) và đánh giá bất kỳ biểu thức nào được nhập sau đó. (Vì lý do bảo mật, điều này không hoạt động trên TryAPL nhưng nó hoạt động trên NGN / APL .)
/⍨Sao chép chính đối số của nó lần ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Tạo bảng nhân.
⊖Lật ngược.

Điều này xảy ra để làm việc trên bất kỳ đầu vào độ dài nào (đầu vào được thụt vào 6 khoảng trắng, đầu ra ở lề trái):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ Empty list (the square of nothing)
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0      ⍝ 0​² = 0
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0 1      ⍝ (0+1)​² = 1²
1
      ⊖∘.×⍨(/⍨⎕)
⎕:
      2 3      ⍝ (2+3)​² = 2² + 3²
6 6 9 9 9
6 6 9 9 9
6 6 9 9 9
4 4 6 6 6
4 4 6 6 6
      ⊖∘.×⍨(/⍨⎕)
⎕:
      1 2 3      ⍝ (1+2+3)​² = 1² + 2(1×2) + 2(1×3) + 2² + 2(2×3) + 3²
3 6 6 9 9 9
3 6 6 9 9 9
3 6 6 9 9 9
2 4 4 6 6 6
2 4 4 6 6 6
1 2 2 3 3 3
      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍳4    ⍝ Integers 1 through 4
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
2 4 4  6  6  6  8  8  8  8
2 4 4  6  6  6  8  8  8  8
1 2 2  3  3  3  4  4  4  4

* Ban đầu, tôi có một giải pháp khác nhau: Mỗi hình chữ nhật được tạo riêng bằng cách tạo bảng nhân cho mỗi kết hợp của hai đối số. Sau đó bốn hình vuông được nối với nhau theo chiều dọc và chiều ngang. Nó trông như thế này:

,/⍪⌿⊖∘.(,⍴×)⍨⎕

⎕Nhắc, như trên.
,⍴×<Kết hợp ( ,) các đối số và sử dụng điều đó để định hình ( ⍴) một hình chữ nhật chứa đầy sản phẩm của chúng ( ×).
∘.(... )⍨Tạo một bảng trong đó mỗi tế bào được bất cứ điều gì được quy định tại (... )
⊖Lật theo chiều dọc.
⍪⌿Kết hợp các tế bào theo chiều dọc.
,/Kết hợp các ô theo chiều ngang.

R, 31 - 3 = 28

rev(b<-rep(a<-scan(),a))%*%t(b)

Giải trình:

           a<-scan()            # take numeric input and store as vector a
    b<-rep(         ,a)         # repeat each numeric input by itself and store as vector b
rev(                   )        # the reverse of vector b
                        %*%     # matrix multiplication
                           t(b) # the transposed of vector b

Điều này cũng hoạt động cho hơn hai số. Ví dụ: đầu ra cho (5,3,2) trông như thế này:

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]   10   10   10   10   10    6    6    6    4     4
 [2,]   10   10   10   10   10    6    6    6    4     4
 [3,]   15   15   15   15   15    9    9    9    6     6
 [4,]   15   15   15   15   15    9    9    9    6     6
 [5,]   15   15   15   15   15    9    9    9    6     6
 [6,]   25   25   25   25   25   15   15   15   10    10
 [7,]   25   25   25   25   25   15   15   15   10    10
 [8,]   25   25   25   25   25   15   15   15   10    10
 [9,]   25   25   25   25   25   15   15   15   10    10
[10,]   25   25   25   25   25   15   15   15   10    10

Haskell, 153 125 byte - 3 = 122

(#)=replicate
d=length.show
y%x=unlines$(>>= \n->(1+d(x*x+y*y)-d n)#' '++show n)<$>x#(y#(x*y)++x#(x*x))++y#(y#(y*y)++x#(x*y))

Một nửa mã dành cho định dạng đầu ra. Nó hoạt động cho số nguyên lớn tùy ý. Ví dụ đầu ra:

> putStrLn $ 4 % 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

> putStrLn $ 6 % 0
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36

Đôi khi, có một khoảng trắng bổ sung giữa các số, vì tôi đang tính khoảng trống cần thiết dựa trên x*x+y*ythay vì max (x*x) (y*y), ví dụ:

> putStrLn $ 2 % 3
  6  6  9  9  9
  6  6  9  9  9
  6  6  9  9  9
  4  4  6  6  6
  4  4  6  6  6

Nhưng đó là nhiều nhất một khoảng trắng.

Toán học 56-3 = 53

Cập nhật : Tôi đã thêm một phương thức thứ hai, có cùng kích thước mã, sử dụng hàm được đặt tên. Nó sử dụng một Arraythay vì một Tablenhưng theo cùng một logic. (Xem bên dưới.)

Phương pháp 1

Điều này tạo ra một bảng các sản phẩm, các yếu tố phụ thuộc vào hàng, giá trị cột. Cặp số được nhập dưới dạng danh sách các số nguyên. Các hàm ẩn danh như sau, rất hữu ích nếu chúng chỉ được sử dụng một lần trong một chương trình. Nếu không, nó có ý nghĩa hơn để sử dụng một chức năng được đặt tên.

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&

Mỗi yếu tố là một câu lệnh If-then:

• If[r>#2,#,#2] có nghĩa là, "Nếu số hàng lớn hơn đầu vào thứ hai, hãy sử dụng đầu vào thứ nhất làm hệ số, nếu không thì sử dụng đầu vào thứ hai.
• If[c>#,#2,#] có nghĩa là, "Nếu số cột lớn hơn đầu vào đầu tiên, hãy sử dụng đầu vào thứ hai làm hệ số, nếu không thì sử dụng đầu vào đầu tiên.

ví dụ 1

 Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{5,3}

Ví dụ 2

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{0,3}

Phương pháp 2 (Cũng 56-3 = 53)

Điều này hoạt động tương tự như Phương pháp 1. Nhưng nó yêu cầu ít mã hơn khi được gọi. Và các ô có thể định địa chỉ, không giống như các ô trong bảng. Phương pháp này tốt hơn để sử dụng nếu chức năng sẽ được sử dụng nhiều lần.

a_~f~b_:=Grid@Array[If[#>a,a,b]If[#2>a,b,a]&,{a+b,a+b}]

Các ví dụ từ trên được tạo ra bởi:

Vd 1:

f[4,3]

Vd 2:

f[0,3]

Octave, 34 - 3 = 31

@(a)rot90(b=repelems(a,[1,2;a]))*b

Ví dụ:

octave:1> f = @(a)rot90(b=repelems(a,[1,2;a]))*b;
octave:2> f([4,3])
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

octave:3> f([0,3])
ans =

   9   9   9
   9   9   9
   9   9   9

CJam, 27 byte - 3 = 24

q:L~_]ze~_ff{*sL,2*Se[}W%N*

Đưa đầu vào như một mảng kiểu CJam. Nó sử dụng khoảng cách nhiều hơn một chút so với cần thiết, nhưng tôi nghĩ đó là "trong lý do", và nó luôn luôn được căn chỉnh đúng.

Kiểm tra nó ở đây.

Giải trình

q:L    e# Read the input and store it in L.
~_     e# Evaluate the input, pushing [A B] onto the stack and duplicate it.
]z     e# Wrap both in an array and transpose it to get [[A A] [B B]].
e~     e# Run-length decode, getting A copies of A and B copies of B.
_ff{   e# Double map over each pair of entries in this new array...
  *s   e#   Multiply the two values.
  L,2* e#   Push twice the length of the input string.
  Se[  e#   Pad the result to this width with spaces (from the left).
}
W%     e# Reverse the resulting matrix to get the correct orientation.
N*     e# Join the rows with linefeed characters.

Hàm C (sử dụng glibc), 122 byte - 3 = 119

Chủ yếu là thực hiện đơn giản với 2 vòng lặp. Tôi hy vọng có một số cơ hội chơi gôn mà tôi đã bỏ lỡ ở đây:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

Các đầu vào được truyền trong hai tham số đầu tiên của hàm, hai tham số còn lại là các hình nộm. Các cột được căn phải.

Lưu ý glibc puts() dường như luôn trả về số byte được viết bao gồm cả dòng mới ẩn, đây là những gì chúng ta cần ở đây. Không đảm bảo điều này sẽ làm việc với bất kỳ libc khác.

Trong một chương trình đầy đủ:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

int main (int argc, char **argv) {
    if (argc == 3) {
        f(atoi(argv[1]),atoi(argv[2]));
    }
}

Biên dịch thành gcc sqrbin.c -o sqrbin(hoặc make sqrbin). Cảnh báo có thể được bỏ qua một cách an toàn.

Ví dụ đầu ra:

$ ./sqrbin 4 3
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
$ ./sqrbin 4 0
 16 16 16 16
 16 16 16 16
 16 16 16 16
 16 16 16 16
$ 

Ruby, (133 - 3) = 130 byte

s=1
a=ARGV.map{|e|s*=(e=e.to_i);[e]*e}.flatten
s=s.to_s.size
a.reverse.each{|i|a.each{|j|print (i*j).to_s.rjust(s).ljust(s+3)};puts}

cho 4,3

12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12

cho 1,3

3   9   9   9   
3   9   9   9   
3   9   9   9   
1   3   3   3

cho 0,3

9   9   9   
9   9   9   
9   9   9

Python 2, 176 byte - 3 = 173

def g(m,n):
 y,x,z,l,f='y','x','z','l','%'+str(len(str(max(m*m,n*n))))+'s'
 d={y:m*n,x:n*n,z:m*m,l:'\n'}
 for i in map(lambda x:d[x],(y*m+x*n+l)*n+(z*m+y*n+l)*m): print f % i,

Điều này sử dụng các hàm chuỗi Python để tạo lưới ký tự, sau đó thay thế các ký tự bằng số nguyên và in đầu ra được định dạng.

Matlab, 58 - 3 = 55

Sử dụng chức năng ẩn danh:

@(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)

Thí dụ:

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(4,3)
ans =
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(0,3)
ans =
     9     9     9
     9     9     9
     9     9     9

(Giải pháp cũ) 59 - 3 = 56

Sử dụng chức năng ẩn danh:

@(a,b)[b*a*ones(b,a) b^2*ones(b);a^2*ones(a) a*b*ones(a,b)]

C, (125 - 3) byte

i,j,a;main(b,s){for(sscanf(gets(s),"%d %d",&a,&b);j<a+b;)printf(++i>a+b?i=!++j,"\n":"%*d",strlen(s)*2,(i<a?a:b)*(j<b?b:a));}

Đầu vào được lấy dưới dạng hai số nguyên cách nhau trên cùng một dòng. Mỗi ô được đệm bằng khoảng trắng đến hai lần chiều dài của chuỗi đầu vào.

Bình thường, 39 - 3 = 36

Pyth không có định dạng ma trận tích hợp, làm tăng đáng kể kích thước, vì người ta phải tự đệm các số đầu ra. Đây là những gì tôi nghĩ ra.

JAQL*b]jdm.[`d\ l`eS^R2Jsm*d]*bdJj+yHyG

Hãy thử trực tuyến.

Khối , 51 byte 52 62 82 87 (không cạnh tranh)

::`+`1|U;{`*`1}|A;`+`1,0+`1={`1^2}|;0+`,`1+`={`^2}|

Ung dung:

::
  ` + `1                    | Expand;
  {` * `1}                  | SetAll;
  ` + `1, 0 + `1 = {`1 ^ 2} | Set;
  0 + `, `1 + `  = {` ^ 2}  | Set

Thử nó