Hãy xem xét các ma trận đường chéo khối nhị phân có các khối vuông 1s trên đường chéo chính và là 0 ở mọi nơi khác. Chúng ta hãy gọi các ma trận "hợp lệ" như vậy.

Ví dụ: đây là một số ma trận 4x4 hợp lệ:

1 0 0 0     1 1 0 0     1 0 0 0     1 0 0 0     1 1 0 0    1 1 1 1
0 1 0 0     1 1 0 0     0 1 1 0     0 1 1 1     1 1 0 0    1 1 1 1
0 0 1 0     0 0 1 0     0 1 1 0     0 1 1 1     0 0 1 1    1 1 1 1
0 0 0 1     0 0 0 1     0 0 0 1     0 1 1 1     0 0 1 1    1 1 1 1

Lưu ý rằng một cách khác để mô tả các ma trận như vậy là có một chuỗi các khối vuông 1 từ trên cùng bên trái sang dưới cùng bên phải, chạm góc này sang góc khác và mọi nơi khác là 0.

Ngược lại, đây là một số ma trận 4x4 không hợp lệ:

1 0 1 0     1 0 1 0     1 1 0 0     0 1 1 1     1 1 0 0    0 0 0 0
0 1 1 1     0 1 0 1     1 1 0 0     0 1 1 1     1 1 0 0    0 0 0 0
1 0 0 1     1 0 1 0     0 0 0 0     0 1 1 1     1 1 0 0    0 0 0 0
0 0 1 0     0 1 0 1     0 0 0 1     1 0 0 0     0 0 1 1    0 0 0 0

Bạn sẽ được cung cấp một nbằng nma trận nhị phân như là đầu vào - số lượng tối thiểu của những gì là 0bit bạn sẽ cần phải thiết lập để 1để có được một ma trận hợp lệ?

Bạn có thể viết một hàm hoặc chương trình lấy bằng bất cứ chuỗi thuận tiện, danh sách hoặc ma trận dạng đại diện cho một nbằng nma trận của 0s và 1s (miễn là nó không được xử lý trước). Các hàng phải được phân tách rõ ràng theo một cách nào đó, vì vậy các định dạng như mảng bit 1D không được phép.

Đây là môn đánh gôn , vì vậy mục tiêu là giảm thiểu số lượng byte trong chương trình của bạn.

Ví dụ

Ví dụ: nếu đầu vào là

0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 1

thì câu trả lời là 5, vì bạn có thể đặt năm 0bit 1để nhận:

1 0 0 0 0
0 1 1 0 0
0 1 1 0 0
0 0 0 1 0
0 0 0 0 1

và đây là số lượng tối thiểu cần thiết. Tuy nhiên, nếu đầu vào là

0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

thì câu trả lời là 24, vì ma trận 5x5 hợp lệ duy nhất trong đó phía trên bên phải là 1ma trận của tất cả 1s.

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

Các thử nghiệm được trình bày ở đây dưới dạng một mảng số nguyên 2D.

[[0]] -> 1
[[1]] -> 0
[[0,1],[0,0]] -> 3
[[1,0],[0,0]] -> 1
[[0,0,0],[0,1,0],[0,0,0]] -> 2
[[0,1,0],[0,0,0],[0,1,0]] -> 7
[[0,1,0],[1,0,0],[0,0,1]] -> 2
[[1,1,1],[1,1,1],[1,1,1]] -> 0
[[0,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,0]] -> 4
[[0,0,1,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]] -> 8
[[0,0,1,0],[0,0,0,0],[0,0,0,0],[0,0,1,0]] -> 14
[[0,0,1,0],[0,0,0,0],[0,0,0,0],[0,1,0,0]] -> 14
[[0,0,0,0,0],[0,0,0,0,0],[0,1,0,0,0],[0,0,0,0,1],[0,0,0,0,0]] -> 7
[[0,0,0,0,0],[0,0,0,0,0],[1,0,0,0,0],[0,0,0,0,1],[0,0,0,0,0]] -> 11
[[0,0,0,0,0],[0,0,1,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,1]] -> 5
[[0,0,0,0,1],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]] -> 24
[[0,0,0,1,0],[0,0,0,0,1],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]] -> 23
[[0,1,0,0,0],[1,0,0,0,0],[0,0,1,0,0],[0,0,0,0,1],[0,0,0,1,0]] -> 4
[[0,1,1,1,0],[0,1,1,0,1],[0,1,1,1,0],[0,1,0,0,1],[0,0,0,0,0]] -> 14

Ghi chú

• Thử thách liên quan: In Ma trận khối chéo
• Cảm hứng: Freedom Factory, Google Code Jam 2016 Vấn đề 2D

MATL , 46 43 byte

nX^tQt:qZ^!tsb=Z)"@!"@1$l]@n$YdG-Q?6MG>zvX<

Đầu vào là một mảng 2D với dấu chấm phẩy là dấu phân cách hàng. Ví dụ: đầu vào cho trường hợp thử nghiệm cuối cùng là

[0,1,1,1,0;0,1,1,0,1;0,1,1,1,0;0,1,0,0,1;0,0,0,0,0]

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm (mã được sửa đổi một chút để lấy tất cả các đầu vào; kết quả xuất hiện sau vài giây)

Giải trình

Hãy để cho đầu vào là một N × N ma trận. Trước tiên, mã sẽ tính tất cả ( N +1) -tuples kích thước khối tạo ra kích thước ma trận phù hợp. Ví dụ, đối với N = 4 tuples là 0 0 0 0 4, 0 0 0 1 3, ..., 4 0 0 0 0. Đối với mỗi bộ dữ liệu, nó xây dựng ma trận khối chéo với các kích thước khối đó. Sau đó, nó sẽ kiểm tra xem ma trận có bao gồm tất cả các 1mục trong đầu vào hay không và nếu có thì sẽ lưu ý đến số lượng các 1mục không có trong đầu vào. Kết quả cuối cùng là tối thiểu của tất cả các số thu được.

nX^      % Implicit input  an N×N matrix. Get N
t        % Duplicate N
Qt:q     % Vector [0 1 ... N]
Z^       % Cartesian power. Gives 2D array
!ts      % Transpose, duplicate, sum of each column
b=       % Logical vector that equals true if the sum is N
Z)       % Filter columns according to that. Only keep columns that sum to N. Each 
         % column is the size of one block
"        % For each column
  @      %   Push that column
  "      %   For each entry of that column
    @    %     Push that entry
    1$l  %     Square matrix with that size, filled with 1
  ]      %   End
  @n     %   Column size. This is the number of blocks in the block-diagonal matrix
  $Yd    %   Build block-diagonal matrix from those blocks
  G-Q    %   Subtract input matrix element-wise, and add 1
  ?      %   If all entries are nonzero (this means each that entry that is 1 in the
         %   block-diagonal matrix is also 1 in the input matrix)
    6M   %   Push block-diagonal matrix again
    G>   %   For each entry, gives 1 if it exceeds the corresponding entry of the
         %   input, that is, if the block-diagonal matrix is 1 and the input is 0
    z    %   Number of 1 entries
    v    %   Concatenate vertically with previous values
    X<   %   Take minimum so far
         %   Implicit end
         % Implicit end
         % Implicit display

Python với numpy, 102

from numpy import*
lambda M:sum(diff([k for k in range(len(M)+1)if(M|M.T)[:k,k:].any()-1])**2)-M.sum()

Một thuật toán hiệu quả. Tìm "điểm cổ" trên đường chéo có thể tách các khối. Những cái này có tất cả 0 trên và phải, cũng như bên dưới và bên trái. Các khối tối thiểu là những người giữa các điểm cổ.

??000
??000
00???
00???
00???

Độ dài của một khối là sự khác biệt giữa các điểm cổ liên tiếp, do đó tổng diện tích của chúng là tổng bình phương của các điểm này. Trừ tổng của ma trận gốc sau đó đưa ra số lần lật cần thiết từ 0 đến 1.

Bình thường, 45 byte

-hSlMf@I.DRlQx1sQTms.b^+LsYN2d+0._ds.pM./lQss

Nhiệm vụ khó khăn, vì vậy nó khá dài.

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

Giải trình:

s.pM./lQtính toán tất cả các phân vùng số nguyên của len(matrix). ms.b^+LsYN2d+0._dchuyển đổi chúng thành cặp tọa độ. Ví dụ phân vùng [1, 2, 2]của 5xâm nhập vào được chuyển đổi [[0,0], [1,1], [1,2], [2,1], [2,2], [3,3], [3,4], [4,3], [4,4].

f@I.DRlQx1sQTsau đó lọc các phân vùng, hoàn toàn trùng lặp ma trận ( .DRlQx1sQtính toán tất cả các cặp tọa độ của các ô đang hoạt động trong ma trận).

-hSlM...ss đếm các ô của mỗi phân vùng còn lại, chọn một ô có ít ô nhất và trừ các ô đã hoạt động.

Matricks , 180 byte (không lọc)

Matricks là một esolang mới mà tôi đã tạo ra gần đây để xử lý các vấn đề ma trận (chẳng hạn như cái này), chỉ bằng 2 loại dữ liệu: phao và ma trận. Nó chưa được giới thiệu đầy đủ và vẫn còn nhiều thao tác bị thiếu (tôi đã phải thêm một số chức năng cho thử thách này). Dù sao, đây là mã:

il=1:j3;:bdx;;;s1::L;j1;;
b{q:1;mgr:c;|gc:r;|(r=c)|(gr-1:c;|gr:c+1;)&(rec)|(gr+1:c;|gr:c-1;)&(cer):l:L;};z:(l-1)/2;B1;s1::g1:;-1;ig1:;=0:j2;:j1;;
s1::d{q:1;};;kg1:;-g:;;
kg:;*-1+1;

Giải trình

Phần đầu tiên, il=1:j3;:...;kiểm tra xem mảng có kích thước 1. Nếu có, nó nhảy đến dòng cuối cùng kg:;*-1+1;, đây là một 0 <-> 1hàm đơn giản .

Mặt khác, nó tiếp tục với phần còn lại của mã. bdx;;;đặt ô 0,0thành tổng hiện tại và s1::L;j1;tạo một bộ đếm trong ô ở hàng bên dưới.

Dòng tiếp theo phức tạp hơn một chút. Nó là một vòng lặp chạy nthời gian, nlà kích thước của ma trận. Tôi sẽ sử dụng trường hợp thử nghiệm thứ 3 làm ví dụ. Khi chúng ta lần đầu tiên đến dòng thứ hai, ma trận trông như thế này:

1 0 1
2 0 0

Đầu tiên, chúng ta đi vào việc hiểu ma trận {q:1;m...;}. Điều này làm cho đường chéo và cố gắng hết sức để dọn sạch 0 cần điền. Tất cả điều này được thực hiện bằng cách sử dụng các toán tử boolean đơn giản. Sau đó, chúng tôi đưa nó vào ma trận hiện tại, đưa ra điều này:

    V--data we want to keep
1 1 1 0 1 <-|
1 1 2 0 0 <-- old matrix

Sau đó, chúng tôi cắt ma trận cũ bằng cách sử dụng z:(l-1)/2;và xoay toàn bộ ma trận sang trái bằng cách sử dụng B1;. Điều đó cho chúng ta một ma trận sẵn sàng cho lần lặp tiếp theo, trông giống như:

1 1 1
2 1 1

Cuối cùng, chúng tôi giảm số lượt truy cập, kiểm tra và tiếp tục với ig1:;=0:j2;:j1;;

Khi vòng lặp bị phá vỡ, chúng tôi tìm tổng mới và đặt điểm cũ của bộ đếm với s1::d{q:1;};;. Cuối cùng, chúng tôi lấy sự khác biệt và trở lại kg1:;-g:;;. kđặt mảng hiện tại thành một giá trị và in ấn là ẩn.

...

Như bạn có thể thấy, Matricks khá dài dòng và không phải là một ngôn ngữ chơi gôn tốt. Nhưng chết tiệt, tôi muốn thể hiện nó ra.