Hình vuông ma thuật là một mảng vuông gồm các số có cạnh n bao gồm các số nguyên dương 1, 2, ..., n ² được sắp xếp sao cho tổng của n số trong bất kỳ đường chéo ngang, dọc hoặc chính nào luôn luôn là cùng một số, được gọi là hằng số ma thuật.

Chương trình của bạn phải nhập, thông qua tiêu chuẩn, một số chỉ định độ dài của cạnh hình vuông của bạn, sau đó là các số trong hình vuông. Không được sử dụng nhiều số hơn một lần, không được sử dụng số nào lớn hơn n ² và tất cả các số phải lớn hơn 0. Chương trình phải xác định xem tổ hợp số đó có phải là một hình vuông ma thuật hay không.

CJam, 47 39 35 33 31 byte

l~/{_1fb_,Y${\(_@=\}%:++\z}2*;=

Có đầu vào như

4 [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]

Đầu ra 1nếu ma thuật vuông, 0nếu không.

Cách thức hoạt động :

l~/                               "Evaluates the input and split the array into chunks"
                                  "of size N where N is the first integer";
   {                      }2*     "Run this code block 2 times";
    _1fb                          "Copy the 2D array and calculate sum of each row of copy";
        _,                        "Copy the array containing sum of each row and get"
                                  "its length. This is equal to N";
          Y${      }%             "Run this code block for each array of the original"
                                  "2D array that we copied from stack";
             \(_                  "Put the length number to top of stack, decrement and"
                                  "copy that";
                @=\               "Take the element at that index from each row and put"
                                  "N back behind at second position in stack";
                     :+           "Take sum of elements of the array. This is sum of"
                                  "one of the diagonals of the 2D array";
                       +          "Push diagonal sum to row sum array";
                        \z        "Bring original array to top and transpose columns";
                             ;    "At this point, the stack contain 3 arrays:"
                                  "  Array with sum of rows and main diagonal,"
                                  "  Array with sum of columns and secondary diagonal and"
                                  "  The original array. Pop the original array";
                              =   "Check if sum of rows + main diagonal array is equal to ";
                                  "sum of columns + secondary diagonal array";

Điều này có thể được đánh gôn hơn nữa.

Dùng thử trực tuyến tại đây

Python 2: 132 ký tự

n,l=input()
r=range
print r(1,n*n+1)==sorted(l)*len({sum(l[i::j][:n])for(i,j)in zip(r(n)+r(0,n*n,n)+[0,n-1],[n]*n+[1]*n+[n+1,n-1])})

Một ví dụ chạy:

STDIN: 4,[16,3,2,13,5,10,11,8,9,6,7,12,4,15,14,1]
Output: True

Có hai điều cần kiểm tra:

1. Các tổng là các hàng, cột và đường chéo đều bằng nhau
2. Các yếu tố là một hoán vị của [1,2,...,n*n].

Đầu tiên được kiểm tra bằng cách lấy các lát tương ứng với các tập con này. Mỗi hàng, cột hoặc đường chéo được mô tả bởi giá trị bắt đầu và độ dịch chuyển của nó. Chúng tôi lấy danh sách lát tương ứng, cắt ngắn cho ncác phần tử và tính tổng nó. Trong [start:end:step]ký hiệu của Python , các hàng là [r*n::1], các cột [c::n]và hai đường chéo là [0::n+1]và [n-1::n-1]. Chúng được lưu trữ dưới dạng một danh sách các 2*n+2cặp được sản xuất bởi zip.

Chúng tôi lấy các tập hợp và kiểm tra xem nó có độ dài 1. Ngoài ra, chúng tôi sắp xếp đầu vào và kiểm tra xem đó có phải là danh sách [1,2,...,n*n].Trên thực tế, chúng tôi kết hợp cả hai thành một kiểm tra bằng cách nhân sorted(l)với độ dài của các tập hợp, một kiểm tra luôn luôn thất bại trừ khi tập hợp có độ dài 1.

APL, 35

∧/2=/(+⌿x,⍉x),+/↑1 1∘⍉¨x(⌽x←⎕⍴⍨,⍨⎕)

Lời
x←⎕⍴⍨,⍨⎕ nhắc giải thích cho đầu vào, định hình nó thành một ma trận và gán cho x
⌽Đảo ngược ma trận từ trái sang phải
x(...)Tạo một mảng các ma trận: xvà xđảo ngược
1 1∘⍉¨Đối với mỗi ma trận đó, hãy
+/↑tạo một đường chéo ma trận 2 × n của các số trên các ma trận đó đường chéo và tổng hợp các hàng

⍉xChuyển đổi x
x,sau đó nối với nhau xđể tạo thành ma trận × 2n
+⌿và tính tổng các cột

(+⌿x,⍉x),+/↑1 1∘⍉¨x(⌽x←⎕⍴⍨,⍨⎕)nối để tạo thành một mảng của tổng
2=/kiểm tra nếu các cặp liên tiếp bằng nhau
∧/và AND cùng với tất cả các kết quả đó

Toán học 128 125

d = Diagonal; r = Reverse; i = Input[];
Length@Union[Tr /@ Join[p = Partition[i[[2]], i[[1]]], 
t = Transpose@p, {d@p}, {d@t}, {d@r@p}, {d@r@t}]] == 1

Có đầu vào như

{4,{16, 3, 2, 13, 5, 10, 11, 8, 9, 6, 7, 12, 4, 15, 14, 1}}

Thật

APL 47 32

Sử dụng giải pháp tuyệt vời của TwiNight và áp dụng một số điều chỉnh khác:

∧/2=/+⌿(1 1∘⍉∘⌽,1 1∘⍉,⍉,⊢)⎕⍴⍨,⍨⎕

Giải trình:

Điều này sử dụng các hàm chức năng, được giới thiệu trong v14 của trình thông dịch Dyalog. APL được thực hiện từ phải sang trái, are là đầu vào, vì vậy trước tiên là kích thước, sau đó là vectơ số.

, Tạo ma trận NxN

Sau đó, đào tạo hàm về cơ bản chỉ là một chuỗi các hàm (giữa các dấu ngoặc) được áp dụng cho đối số đúng. Các chức năng là:

Trả về đúng đối số (đó là ma trận)

Chuyển đổi ma trận đối số đúng

1 1∘⍉ Trả về đường chéo

1 1∘⍉∘⌽ Trả về đường chéo của ma trận đảo ngược (theo chiều ngang)

Tất cả các kết quả được nối với hàm ","

Tại thời điểm này, kết quả là một ma trận có các cột sau đó được tính tổng (+). Các giá trị thu được theo cách này sau đó được kiểm tra giống với / 2 = /

Tôi cũng sẽ để lại giải pháp cũ của mình ở đây:

{M←⍺ ⍺⍴⍵⋄d←M=⍉M⋄(⊃≡∪)((+/,+⌿)M),+/∘,¨d(⌽d)ר⊂M}

lấy thứ nguyên làm đối số bên trái, vectơ của các phần tử làm đối số bên phải, ví dụ:

4{M←⍺ ⍺⍴⍵⋄d←M=⍉M⋄(⊃≡∪)((+/,+⌿)M),+/∘,¨d(⌽d)ר⊂M}16 3 2 13 5 10 11 8 9 6 7 12 4 15 14 1
1

Có thể dùng thử trực tuyến tại đây: www.tryapl.org

GolfScript 67 ( bản demo )

~]:q(/q(/zip+[q()/{(\;}%]+[q((/);(;{(\;}%]+{{+}*}%.&,2<q(2?,{)}%-!*

JavaScript (E6) 194

Sử dụng dấu nhắc để đọc đầu vào và hiển thị đầu ra.
Thử nghiệm trong bảng điều khiển với FireFox> 31 (Array.fill rất mới)

z=(p=prompt)(n=p()|0).split(' '),u=Array(2*n).fill(e=d=n*(n*n+1)/2),z.map((v,i)=>(r=i/n|0,u[r+n]-=v,u[c=i%n]-=v,d-=v*(r==c),e-=v*(r+c+1==n))),o=!(e|d|u.some(v=>v)),z.sort((a,b)=>a-b||(o=0)),p(o)

Ít chơi gôn

n = prompt()|0; // input side length
z = prompt().split(' '); // input list of space separeted numbers  
e = d = n*(n*n+1)/2; // Calc sum for each row, column and diagonal
u = Array(2*n).fill(e), // Init check values for n rows and n columns

z.map( (v,i) => { // loop on number array 
  r = i / n | 0; // row number
  c = i % n; // column number
  u[r+n] -= v; // subtract current value, if correct it will be 0 at loop end
  u[c] -= v; 
  if (r==c) d -= v; // subtract if diagonal \
  if (r+c+1==n) e -=v; // subtract if diagonal /
}),
o=!(e|d|u.some(v=>v)); // true if values for rows, cols and diags are 0
z.sort((a,b)=>a-b||(o=0)); // use sort to verify if there are repeated values in input
alert(o);

Bình thường, 24 30 byte

&q1l{sM++JcEQCJm.e@bkd_BJqSlQS

Hãy thử trực tuyến tại đây .

&q1l{sM++JcEQCJm.e@bkd_BJqSlQSQ   Implicit: Q = evaluated 1st input (contents), E = evaluated 2nd input (side length)
                                  Trailing Q inferred
          cEQ                     Chop E into pieces or length Q
         J                        Store in J
                      _BJ         Pair J with itself with rows reversed
               m                  Map the original and it's reverse, as d, using:
                .e   d              Map each row in d, as b with index k, using:
                  @bk                 Get the kth element of b
                                  The result of this map is [[main diagonal], [antidiagonal]]
        +J                        Prepend rows from J
       +     CJ                   Prepend columns from J (transposed J)
     sM                           Sum each
    {                             Deduplicate
   l                              Length
 q1                               Is the above equal to 1?
&                                 Logic AND the above with...
                          SlQ     ... is the range [1-length(Q)]...
                         q        ... equal to...
                             SQ   ... sorted(Q)

Chỉnh sửa: đã sửa một lỗi, cảm ơn @KevinCruijssen đã cho tôi biết: o)

LUA 186 Chars

s=io.read(1)v=io.read(2)d=0 r=0 for i=1,#s do t=0 for j = 1, #s do t=t+s[i][j]end d=d+s[i][i] r=r+s[i][#s-i+1]if t ~= v then o=true end end if d~=v and r~= v then o=true end print(not o)

05AB1E , 24 byte

ô©O®øO®Å\O®Å/O)˜Ë²{¹nLQ*

Định dạng đầu vào : 4\n[2,16,13,3,11,5,8,10,7,9,12,6,14,4,1,15]. Đầu ra 1/ 0cho sự thật / falsey tương ứng.

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

Giải trình:

ô       # Split the 2nd (implicit) input into parts of a size of the 1st (implicit) input
        #  i.e. [2,16,13,3,11,5,8,10,7,9,12,6,14,4,1,15] and 4
        #   → [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]]
 ©      # Store it in the register (without popping)
  O     # Take the sum of each row
        #  i.e. [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]] → [34,34,34,34]
®       # Push the matrix from the register again
 ø      # Zip/transpose; swapping rows/columns
        #  i.e. [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]]
        #   → [[2,11,7,14],[16,5,9,4],[13,8,12,1],[3,10,6,15]]
  O     # Sum each inner list again
        #  i.e. [[2,11,7,14],[16,5,9,4],[13,8,12,1],[3,10,6,15]] → [34,34,34,34]
®       # Push the matrix from the register again
 Å\     # Get the top-left to bottom-right main diagonal of it
        #  i.e. [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]] → [2,5,12,15]
   O    # Sum it together
        #  i.e. [2,5,12,15] → 34
®       # Push the matrix from the register again
 Å/     # Get the top-right to bottom-left main diagonal of it
        #  i.e. [[2,16,13,3],[11,5,8,10],[7,9,12,6],[14,4,1,15]] → [3,8,9,14]
   O    # Sum it together
        #  i.e. [3,8,9,14] → 34
)       # Wrap everything on the stack into a list
        #  → [[34,34,34,34],[34,34,34,34],34,34]
 ˜      # Flatten this list
        #  i.e. [[34,34,34,34],[34,34,34,34],34,34] → [34,34,34,34,34,34,34,34,34,34]
  Ë     # Check if all values are equal to each other
        #  i.e. [34,34,34,34,34,34,34,34,34,34] → 1 (truthy)
²       # Push the second input again
 {      # Sort it
        #  i.e. [2,16,13,3,11,5,8,10,7,9,12,6,14,4,1,15]
        #  → [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
  ¹n    # Push the first input again, and take its square
        #  i.e. 4 → 16
    L   # Create a list in the range [1, squared_input]
        #  i.e. 16 → [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
     Q  # Check if the two lists are equal
        #  i.e. [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
        #   and [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16] → 1 (truthy)
*       # Check if both checks are truthy by multiplying them with each other
        #  i.e. 1 and 1 → 1
        # (and output the result implicitly)