Một ma trận dấu xen kẽ là một nbằng nma trận bao gồm các số -1, 0, 1, sao cho:

• Tổng của mỗi hàng và cột là 1
• Các mục khác không trong mỗi hàng và cột thay thế trong dấu

Các ma trận này khái quát hóa các ma trận hoán vị và số lượng ma trận như vậy ncho một thời gian đã được quan tâm trong một thời gian. Chúng xảy ra một cách tự nhiên trong phương pháp ngưng tụ Dodgson trong việc xác định ma trận xác định (được đặt theo tên của Charles Dodgson, được biết đến với cái tên Lewis Carroll).

Dưới đây là một số ví dụ về ma trận ký hiệu 4 x 4 xen kẽ:

 0  1  0  0          1  0  0  0          0  0  1  0          0  0  1  0    
 0  0  1  0          0  0  1  0          0  1 -1  1          1  0 -1  1
 1  0  0  0          0  1 -1  1          1 -1  1  0          0  1  0  0
 0  0  0  1          0  0  1  0          0  1  0  0          0  0  1  0

Và đây là một số ví dụ về ma trận 4 x 4 không ma trận ký hiệu xen kẽ:

 0  1  0  0
 0  0  0  1
 1  0  0  0
 0  0  1 -1    (last row and last column don't add to 1)

 0  0  0  1
 1  0  0  0
-1  1  1  0
 1  0  0  0    (third row does not alternate correctly)

Chương trình hoặc hàm của bạn sẽ được cung cấp nbởi nma trận ( n >= 1) là -1, 0 và 1 - xuất giá trị trung thực nếu ma trận đã cho là ma trận dấu xen kẽ, nếu không thì xuất ra giá trị sai.

Đây là môn đánh gôn , vì vậy mục tiêu là giảm thiểu số lượng byte được sử dụng.

Các trường hợp thử nghiệm

Các trường hợp thử nghiệm sau đây được đưa ra ở định dạng danh sách 2D giống như Python.

Sự thật:

[[1]]
[[1,0],[0,1]]
[[0,1],[1,0]]
[[0,1,0],[0,0,1],[1,0,0]]
[[0,1,0],[1,-1,1],[0,1,0]]
[[0,1,0,0],[0,0,1,0],[1,0,0,0],[0,0,0,1]]
[[1,0,0,0],[0,0,1,0],[0,1,-1,1],[0,0,1,0]]
[[0,0,1,0],[0,1,-1,1],[1,-1,1,0],[0,1,0,0]]
[[0,0,1,0],[1,0,-1,1],[0,1,0,0],[0,0,1,0]]
[[0,0,1,0,0],[0,1,-1,1,0],[1,-1,1,0,0],[0,1,0,-1,1],[0,0,0,1,0]]
[[0,0,1,0,0,0,0,0],[1,0,-1,0,1,0,0,0],[0,0,0,1,-1,0,0,1],[0,0,1,-1,1,0,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,1,0,0],[0,1,-1,1,0,0,0,0],[0,0,1,0,0,0,0,0]]
[[0,0,0,0,1,0,0,0],[0,0,1,0,-1,1,0,0],[0,0,0,1,0,0,0,0],[1,0,0,-1,1,-1,1,0],[0,1,-1,1,-1,1,0,0],[0,0,0,0,1,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1]]

Giả mạo:

[[0]]
[[-1]]
[[1,0],[0,0]]
[[0,0],[0,1]]
[[-1,1],[1,0]]
[[0,1],[1,-1]]
[[0,0,0],[0,0,0],[0,0,0]]
[[0,1,0],[1,0,1],[0,1,0]]
[[-1,1,1],[1,-1,1],[1,1,-1]]
[[0,0,1],[1,0,0],[0,1,-1]]
[[0,1,0,0],[0,0,0,1],[1,0,0,0],[0,0,1,-1]]
[[0,0,1,0],[0,0,1,0],[1,0,-1,1],[0,1,0,0]]
[[0,0,0,1],[1,0,0,0],[-1,1,1,0],[1,0,0,0]]
[[1,0,1,0,-1],[0,1,0,0,0],[0,0,0,0,1],[0,0,0,1,0],[0,0,0,0,1]]
[[0,0,1,0,0],[0,1,-1,1,0],[1,-1,1,0,0],[0,1,1,-1,0],[0,0,-1,1,1]]
[[0,-1,0,1,1],[1,-1,1,-1,1],[0,1,1,0,-1],[1,1,-1,1,-1],[-1,1,0,0,1]]
[[0,0,1,0,0,0,0,0],[1,0,1,0,1,0,0,0],[0,0,0,1,-1,0,0,1],[0,0,1,-1,1,0,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,1,0,0],[0,1,-1,1,0,0,0,0],[0,0,1,0,0,0,0,0]]

Võng mạc , 62 58 56 53 byte

Số lượng byte giả định mã hóa ISO 8859-1 và \tnên được thay thế bằng các tab thực tế (0x09 sẽ được SE biến thành khoảng trắng bằng cách khác).

$
\t$`¶
O$#`...(?<=^[^\t]*(.+))
$.1
T` 0
^(1(-11)*\s)+$

Định dạng đầu vào là một ma trận trong đó mỗi cột sử dụng ba ký tự được căn phải, ví dụ:

  0  0  1  0
  1  0 -1  1
  0  1  0  0
  0  0  1  0

Đầu ra là 0(giả) hoặc 1(trung thực).

Bộ thử nghiệm. (Một vài dòng đầu tiên chuyển đổi định dạng đầu vào và để Retina chạy một số trường hợp thử nghiệm cùng một lúc.)

Giải trình

Rất may, đầu vào là một ma trận vuông: các hình vuông hoán vị chỉ có thể thực hiện được ở Retina, trong khi hình chữ nhật chuyển vị là một nỗi đau lớn.

$
\t$`¶

Chúng tôi bắt đầu bằng cách nối thêm một tab, toàn bộ đầu vào lại (sử dụng tiền tố $`) và sau đó là một nguồn cấp dữ liệu ở cuối (sử dụng bí danh của Retina ¶). Chúng tôi đang sử dụng một tab để phân tách hai bản sao để chúng tôi có thể phân biệt giữa chúng khi chúng hoán đổi một trong số chúng và bằng cách sử dụng một ký tự khoảng trắng, chúng tôi có thể lưu một vài byte sau này.

O$#`...(?<=^[^\t]*(.+))
$.1

Đây là bit khó nhất: hoán chuyển bản sao đầu tiên của ma trận. Ý tưởng là khớp các ô trong bản sao đầu tiên và sau đó sắp xếp chúng (ổn định) theo vị trí nằm ngang. Chúng tôi khớp các ô với ...(vì chúng luôn rộng ba ký tự) và sau đó đo vị trí ngang với (.+)bên trong giao diện. Sau đó, để đảm bảo rằng chúng tôi chỉ chuyển đổi bản sao đầu tiên, chúng tôi kiểm tra xem chúng tôi có thể đến đầu chuỗi không mà không di chuyển qua một tab.

Bạn có thể nhận thấy rằng điều này cũng sẽ khớp với một số chuỗi ba byte (thậm chí không thẳng hàng với các ô) trong hàng đầu tiên của bản sao thứ hai, bởi vì .+ có thể đi qua tab. Tuy nhiên, đây không phải là vấn đề vì vị trí nằm ngang của các trận đấu này lớn hơn bất kỳ bên trong bản sao đầu tiên, vì vậy những trận đấu này vẫn ở vị trí của chúng.

Phần còn lại khá đơn giản:

T` 0

Chúng tôi loại bỏ khoảng trắng và số không từ đầu vào.

^(1(-11)*\s)+$

Và cuối cùng, chúng tôi kiểm tra xem toàn bộ đầu vào có các hàng kết thúc bằng khoảng trắng của biểu mẫu 1(-11)*, tức là một chuỗi xen kẽ 1và -1bắt đầu và kết thúc bằng 1(vì nếu không thì nó không tính tổng 1).

Thạch, 15 byte

;Zḟ€0;€-;@€-IFP

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

;Zḟ€0;€-;@€-IFP   Main monadic chain. Argument: z

;Z                Concatenate with its transpose.
  ḟ€0             Remove zeros from each sub-list. At this point,
                  one expects lists of the form [1, -1, 1, -1, ..., 1] for truthy,
                  and any other arrays containing purely 1 and -1 for falsey.
     ;€-          Append -1 to each sub-list.
        ;€@-      Prepend -1 to each sub-list.
            I     Compute the difference between each term. At this point,
                  for truthy, one expects arrays filled with 2, and arrays
                  containing 0 otherwise.
             FP   Product of every item. This checks if any item is equal to zero.

Bình thường, 16 byte

!sm-sM._+d_1U2+C

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình:

!sm-sM._+d_1U2+CQQ   two implicit Qs (=input matrix) at the end
              +CQQ   zip Q and connect it with Q (=list of columns and rows)
  m                  map each column/row d to:
        +d_1            append -1 to d
      ._                compute all prefixes of ^
    sM                  compute the sums of the prefixes
   -        U2          remove zeros and ones
                        a column/row is correct, if this gives an empty list 
 s                   connect up all resulting lists
!                    check, if this result is empty

Thạch , 11 byte

;Zj-+\ṚQḄ=2

Trả về 1 cho ma trận ký hiệu xen kẽ, 0 nếu không. Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Lý lịch

Bỏ qua các số 0, mỗi hàng và cột phải bao gồm mẫu (1, -1) * 1 , nghĩa là, các lần xuất hiện xen kẽ của 1 và -1 , bắt đầu và kết thúc bằng 1 (vì vậy tổng là 1 ).

Để xác minh đây là trường hợp, chúng tôi lấy mảng của tất cả các hàng và cột và nối chúng với nhau bằng -1 làm dấu phân cách. Vì tất cả các điểm cuối là 1 , nên mảng phẳng kết quả thỏa mãn mẫu (1, -1) * 1 khi và chỉ khi các hàng và cột thực hiện.

Đối với thử nghiệm thực tế, chúng tôi tính tổng tích lũy của mảng. Đối với ma trận ký hiệu xen kẽ, kết quả sẽ là một mảng 0 và 1 kết thúc bằng 1 .

Chúng tôi đảo ngược tổng tích lũy và lặp lại nó, giữ thứ tự xuất hiện ban đầu của tất cả các yếu tố duy nhất. Đối với đầu vào trung thực, kết quả sẽ là danh sách [1, 0] .

Để xuất Boolean tương ứng, chúng tôi chuyển đổi các tổng tích lũy trùng lặp từ nhị phân sang số nguyên và kiểm tra nếu kết quả là 2 .

Làm thế nào nó hoạt động

;Zj-+\ṚQḄ=2  Main link. Argument: M (matrix / 2D array)

 Z           Zip; transpose M's rows and columns.
;            Concatenate M and zipped M.
  j-         Join, separating by -1.
    +\       Take the cumulative sum of the result.
      Ṛ      Reverse the array of partial sums.
       Q     Unique; deduplicate the partial sums.
        Ḅ    Unbinary; convert from base 2 to integer.
         =2  Test for equality with 2.

MATL, 18 16 15 13 byte

3 byte được lưu nhờ @Luis

t!h"@s1=@Xzdv

Giải pháp này chấp nhận một mảng 2D làm đầu vào và sẽ xuất ra một mảng trung thực hoặc falsey . Điều quan trọng cần lưu ý là trong MATL, một mảng trung thực bao gồm tất cả các phần tử khác không trong khi kết quả falsey có ít nhất một phần tử 0. Đây là một minh chứng khác về mảng trung thực / falsey .

Dùng thử trực tuyến

Phiên bản sửa đổi để hiển thị tất cả các trường hợp thử nghiệm

Giải trình

        % Implicitly grab input matrix
t!      % Duplicate and transpose input
h       % Horizontally concatenate input with transpose. This allows us to 
        % process only columns since now the columns *also* contain the rows.
"       % For each column (of our column/row combined matrix)
  @s1=  % Compute the sum and ensure it is equal to 1
  @Xz   % Get the non-zeros
  d     % Compute the element-to-element difference. The 1 and -1 alternate only if
        % all these differences are non-zero
  v     % Vertically concatenate everything on the stack
        % Implicit end of loop and implicitly display truthy/falsey value

Julia, 36 byte

!x=[x^0 x^0;-x -x'][:]|>cumsum⊆0:1

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

JavaScript (ES6), 112 100 byte

a=>!/(^|,)(?!0*10*(-10*10*)*(,|$))/.test(a.map(b=>b.join``)+','+a.map((_,i)=>a.map(b=>b[i]).join``))

Làm phẳng mảng và chuyển vị của nó thành các chuỗi, sau đó (bỏ qua 0s) kiểm tra mẫu 1-11...1-11trong mỗi chuỗi.

Chỉnh sửa: Đã lưu 12 byte nhờ @PeterTaylor.

Python 2, 63 60 byte

s=0;x=input()
for r in x+zip(*x):
 for n in(-1,)+r:s+=[n][s]

Đầu vào là một danh sách các bộ dữ liệu.

Điều này chấm dứt với mã thoát 0 cho ma trận ký hiệu xen kẽ và mã thoát 1 nếu không. Đây là những gì đúng và sai làm, và - như được hiển thị trong phần xác minh - nó thực sự có thể được sử dụng như một điều kiện trong, ví dụ, tập lệnh Bash.

xác minh

test-case.txt

[(1,)]
[(1, 0), (0, 1)]
[(0, 1), (1, 0)]
[(0, 1, 0), (0, 0, 1), (1, 0, 0)]
[(0, 1, 0), (1, -1, 1), (0, 1, 0)]
[(0, 1, 0, 0), (0, 0, 1, 0), (1, 0, 0, 0), (0, 0, 0, 1)]
[(1, 0, 0, 0), (0, 0, 1, 0), (0, 1, -1, 1), (0, 0, 1, 0)]
[(0, 0, 1, 0), (0, 1, -1, 1), (1, -1, 1, 0), (0, 1, 0, 0)]
[(0, 0, 1, 0), (1, 0, -1, 1), (0, 1, 0, 0), (0, 0, 1, 0)]
[(0, 0, 1, 0, 0), (0, 1, -1, 1, 0), (1, -1, 1, 0, 0), (0, 1, 0, -1, 1), (0, 0, 0, 1, 0)]
[(0, 0, 1, 0, 0, 0, 0, 0), (1, 0, -1, 0, 1, 0, 0, 0), (0, 0, 0, 1, -1, 0, 0, 1), (0, 0, 1, -1, 1, 0, 0, 0), (0, 0, 0, 0, 0, 0, 1, 0), (0, 0, 0, 0, 0, 1, 0, 0), (0, 1, -1, 1, 0, 0, 0, 0), (0, 0, 1, 0, 0, 0, 0, 0)]
[(0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 1, 0, -1, 1, 0, 0), (0, 0, 0, 1, 0, 0, 0, 0), (1, 0, 0, -1, 1, -1, 1, 0), (0, 1, -1, 1, -1, 1, 0, 0), (0, 0, 0, 0, 1, 0, 0, 0), (0, 0, 1, 0, 0, 0, 0, 0), (0, 0, 0, 0, 0, 0, 0, 1)]
[(0,)]
[(-1,)]
[(1, 0), (0, 0)]
[(0, 0), (0, 1)]
[(-1, 1), (1, 0)]
[(0, 1), (1, -1)]
[(0, 0, 0), (0, 0, 0), (0, 0, 0)]
[(0, 1, 0), (1, 0, 1), (0, 1, 0)]
[(-1, 1, 1), (1, -1, 1), (1, 1, -1)]
[(0, 0, 1), (1, 0, 0), (0, 1, -1)]
[(0, 1, 0, 0), (0, 0, 0, 1), (1, 0, 0, 0), (0, 0, 1, -1)]
[(0, 0, 1, 0), (0, 0, 1, 0), (1, 0, -1, 1), (0, 1, 0, 0)]
[(0, 0, 0, 1), (1, 0, 0, 0), (-1, 1, 1, 0), (1, 0, 0, 0)]
[(1, 0, 1, 0, -1), (0, 1, 0, 0, 0), (0, 0, 0, 0, 1), (0, 0, 0, 1, 0), (0, 0, 0, 0, 1)]
[(0, 0, 1, 0, 0), (0, 1, -1, 1, 0), (1, -1, 1, 0, 0), (0, 1, 1, -1, 0), (0, 0, -1, 1, 1)]
[(0, -1, 0, 1, 1), (1, -1, 1, -1, 1), (0, 1, 1, 0, -1), (1, 1, -1, 1, -1), (-1, 1, 0, 0, 1)]
[(0, 0, 1, 0, 0, 0, 0, 0), (1, 0, 1, 0, 1, 0, 0, 0), (0, 0, 0, 1, -1, 0, 0, 1), (0, 0, 1, -1, 1, 0, 0, 0), (0, 0, 0, 0, 0, 0, 1, 0), (0, 0, 0, 0, 0, 1, 0, 0), (0, 1, -1, 1, 0, 0, 0, 0), (0, 0, 1, 0, 0, 0, 0, 0)]

test -suite.sh

while read; do
        if python2 asmv.py <<< "$REPLY"; then
                echo "true"
        else
                echo "false"
        fi
done < test-cases.txt 2>&- | uniq -c

Đầu ra

$ bash test-suite.sh
     12 true
     17 false

Làm thế nào nó hoạt động

Bỏ qua các số 0, mỗi hàng và cột phải bao gồm mẫu (1, -1) * 1 , nghĩa là, các lần xuất hiện xen kẽ của 1 và -1 , bắt đầu và kết thúc bằng 1 (vì vậy tổng là 1 ).

Để xác minh đây là trường hợp, chúng tôi nén / hoán chuyển ma trận đầu vào M , nối kết quả vào M (hiện bao gồm danh sách các hàng và cột) và thêm -1 cho mỗi hàng / cột.

Ví dụ: nếu M là một trong các ma trận sau (hợp lệ, không hợp lệ)

     0  1  0         0  0  0
     0  0  1         1  0  0
     1  0  0         0  1 -1

kết quả là

-1 | 0  1  0    -1 | 0  0  0
-1 | 0  0  1    -1 | 1  0  0
-1 | 1  0  0    -1 | 0  1 -1
------------    ------------
-1 | 0  0  1    -1 | 0  1  0
-1 | 1  0  0    -1 | 0  0  1
-1 | 0  1  0    -1 | 0  0 -1

Đọc hàng ma trận được tạo phải khôn ngoan phải dẫn đến một chuỗi phẳng có mẫu (-1, 1) * . Để xác minh đây là trường hợp, chúng tôi lấy tổng số tích lũy của tất cả các mục, bắt đầu bằng hàng trên cùng.

Đối với các ma trận ví dụ, điều này dẫn đến

-1 -1  0  0 -1 -1 -1  0 -1  0  0  0 -1 -1 -1  0 -1  0  0  0 -1 -1  0  0
-1 -1 -1 -1 -2 -1 -1 -1 -2 -2 -1 -2 -3 -3 -2 -2 -3 -3 -3 -2 -3 -3 -3 -4

Đối với ma trận ký hiệu xen kẽ hợp lệ, đầu ra sẽ bao gồm -1 và 0 và - vì mỗi -1 hủy bỏ 1 trước đó và ngược lại - không có số nào khác.

Thoạt nhìn, điều này có thể thất bại trong việc kiểm tra nếu cột cuối cùng kết thúc bằng 1 . Tuy nhiên, đối với ma trận n × n chứa k số 0, các hàng hợp lệ sẽ chứa n + k . Nếu tất cả các cột ngoại trừ cột cuối cùng cũng hợp lệ, sẽ có n + k - 1 cột trong các cột, điều này là không thể.

Để kiểm tra rằng không có số nào khác, chúng tôi lưu trữ một phần tổng trong một biến s và cập nhật chúng cho mỗi mục nhập với ma trận được tạo với s+=[n][s].

Nếu s = 0 hoặc s = -1 , điều này tương đương với s+=n. Tuy nhiên, đối với tất cả các giá trị khác của s , nó gây ra IndexError , do đó Python ngay lập tức chấm dứt với mã thoát 1 . Nếu điều này không xảy ra tại bất kỳ thời điểm nào, chương trình sẽ kết thúc hoàn toàn với mã thoát 0 .

R, 54 byte

Hàm ẩn danh, sử dụng logic tương tự như câu trả lời Python 2, Jelly và Julia của Dennis.

function(x)all(abs(cumsum(rbind(-1,cbind(t(x),x))))<2)