Lý lịch

Tôi muốn mua một mảnh đất và xây dựng ngôi nhà của mình trên đó. Nhà tôi nên có hình chữ nhật, và càng lớn càng tốt; tuy nhiên, các ô có sẵn có rất nhiều khu vực đá mà tôi không thể xây dựng được và tôi gặp khó khăn khi lắp một ngôi nhà tiềm năng trên các ô. Tôi muốn bạn viết một chương trình phân tích các âm mưu cho tôi.

Đầu vào và đầu ra

Đầu vào của bạn là một mảng 2D hình chữ nhật, có kích thước tối thiểu 1 × 1, ở bất kỳ định dạng hợp lý nào. Mảng đại diện cho một lô đất; 1s là những khu vực "tốt" nơi tôi có thể xây dựng ngôi nhà của mình và 0s là những khu vực "đá" nơi ngôi nhà không thể được xây dựng.

Đầu ra của bạn sẽ là diện tích tối đa của một hình chữ nhật rắn 1s trong mảng đầu vào. Nó đại diện cho diện tích của ngôi nhà lớn nhất mà tôi có thể xây dựng trên lô đất. Lưu ý rằng nếu không có 1s trong đầu vào, thì đầu ra là 0.

Thí dụ

Xem xét đầu vào

101
011
111

Hình chữ nhật lớn nhất của 1s là hình chữ nhật 2 × 2 ở góc dưới bên phải. Điều này có nghĩa là đầu ra chính xác là 4.

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

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

0
-> 0

1
-> 1

00
00
-> 0

01
10
-> 1

01
11
-> 2

111
010
111
-> 3

101
011
111
-> 4

0111
1110
1100
-> 4

1111111
1110111
1011101
-> 7

111011000
110111100
001111110
011111111
001111110
000111100
000011000
-> 20

000110000
110110010
110111110
110011100
010011111
111111111
111101110
-> 12

Thạch , 21 20 18 17 byte

ṡṂ€€×"
‘×¥\ç"Ụ€FṀ

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

Đặt M là ma trận các bit như

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

Chúng tôi bắt đầu bằng cách đếm số lượng 1 bit trong mỗi cột của M , đặt lại số đếm mỗi lần chúng tôi gặp 0 bit.

Đối với ma trận ví dụ của chúng tôi, điều này mang lại

0 0 0 1 1 0 0 0 0
1 1 0 2 2 0 0 1 0
2 2 0 3 3 1 1 2 0
3 3 0 0 4 2 2 0 0
0 4 0 0 5 3 3 1 1
1 5 1 1 6 4 4 2 2
2 6 2 2 0 5 5 3 0

Tiếp theo, chúng tôi tính toán tất cả các danh sách phụ liên tiếp của mỗi hàng. Chúng tôi đạt được điều này bằng cách tạo ra tất cả các lát có độ dài k , trong đó k thay đổi giữa 1 và số lượng mục trong mỗi hàng.

Đối với hàng áp chót, điều này mang lại

[1], [5], [1], [1], [6], [4], [4], [2], [2]
[1, 5], [5, 1], [1, 1], [1, 6], [6, 4], [4, 4], [4, 2], [2, 2]
[1, 5, 1], [5, 1, 1], [1, 1, 6], [1, 6, 4], [6, 4, 4], [4, 4, 2], [4, 2, 2]
[1, 5, 1, 1], [5, 1, 1, 6], [1, 1, 6, 4], [1, 6, 4, 4], [6, 4, 4, 2], [4, 4, 2, 2]
[1, 5, 1, 1, 6], [5, 1, 1, 6, 4], [1, 1, 6, 4, 4], [1, 6, 4, 4, 2], [6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4], [5, 1, 1, 6, 4, 4], [1, 1, 6, 4, 4, 2], [1, 6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4, 4], [5, 1, 1, 6, 4, 4, 2], [1, 1, 6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4, 4, 2], [5, 1, 1, 6, 4, 4, 2, 2]
[1, 5, 1, 1, 6, 4, 4, 2, 2]

Tiếp theo, chúng tôi ánh xạ từng lát tới sản phẩm tối thiểu và chiều dài của nó. Đối với mỗi lát cắt, phần này tính diện tích hình chữ nhật có 1 bit chiều cao tối đa có lát cắt đã cho là hàng dưới cùng.

Đối với các lát có độ dài 3 của hàng áp chót của ma trận ví dụ của chúng tôi, điều này mang lại

3 3 3 3 12 6 6

Tất cả những gì còn lại phải làm là lấy tối đa trên tất cả các lát của tất cả các hàng.

Đối với ma trận ví dụ của chúng tôi, điều này cho 12 .

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

‘×¥\ç"Ụ€FṀ  Main link. Argument: M (2D list of bits)

   \        Reduce the columns of M by the link to the left.
  ¥           Combine the two atoms to the left into a dyadic chain.
‘               Increment the left argument.
 ×              Multiply the result with the right argument.
      Ụ€    Grade up each; yield the indices of each row of M, sorted by their
            values. The order is not important here; we just need the indices.
    ç"      Apply the helper link to each element of the result to the left and
            the corresponding element of the result to the right.
        F   Flatten the resulting, nested list.
         Ṁ  Extract the maximum.


ṡṂ€€×"      Helper link. Arguments: R (row), X (indices of R)

ṡ           For each k in X, split R into overlapping slices of length k.
 Ṁ€€        Compute the minimum of each individual slice.
    ×"      Multiply the minima of all slices of length k by k.

MATL, 32 31 27 byte

n:"@:"@1M2$ltntG4$bZ+=a*vX>

Điều này sử dụng một cách tiếp cận dựa trên tích chập 2D mạnh mẽ. Tất cả các kích thước hình chữ nhật có thể được tạo ra và kết hợp với địa hình. Kết quả tối đa của tất cả các cấu trúc là diện tích hình chữ nhật tối đa.

Đây là một giải pháp cực kỳ kém hiệu quả vì để tiết kiệm byte, tôi tạo hạt nhân cho tất cả các hình chữ nhật giữa [1, 1]và [numel(input) numel(input)]thay vì thực sự xác định số lượng hàng / cột trong đầu vào để xác định phạm vi kích thước hình chữ nhật phù hợp.

Cảm ơn @Luis đã gợi ý cách sử dụng Mvà bỏ qua ]].

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

Giải trình

        % Implicitly grab input as a 2D numeric array
n       % Compute the number of elements in the input (over estimation of max kernel size)
:       % Create array 1:n
"       % For each value
  @     % Current loop index
  :     % Create an array from 1:(current_index)
  "     % For each of these values   
    @   % Push the current index onto the stack
    1M  % Grab the input to the previous function call (the outer index)
    2$l % Create an array of 1's whose dimensions are specified by top two stack elements
    tn  % Duplicate this array and compute number of elements
    t   % Duplicate this number
    G   % Explicitly grab input
    4$b % Bubble up the 4th element from the stack (the kernel)
    Z+  % Perform 2D convolution of this kernel and the input
    =a  % Determine if any convolution result (in each column) is equal to the area of the kernel.
        % This yields a row vector
    *   % Multiply the logical result by the area
    v   % Vertically concatenate all results (forces the row vectors above to be column vectors)
    X>  % Compute the maximum yielding the largest area
        % Implicitly display the result.

Julia, 83 60 57 53 byte

!M=M⊆1?sum(M):maximum(t->!rotr90(M,t)[2:end,:],0:3)

Hãy thử trực tuyến! Trường hợp thử nghiệm cuối cùng vượt quá giới hạn thời gian của TIO, nhưng tôi đã xác minh nó cục bộ.

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

Đầu tiên , ! kiểm tra xem đối số ma trận M của nó có bao gồm 1 's không.

• Nếu vậy , ! trả về tổng số mục của M , bằng với diện tích của nó.

• Nếu không , ! làm như sau:

  1. Xoay M bằng 0 ° , 90 ° , 180 ° và 270 ° theo chiều kim đồng hồ.

  2. Di chuyển hàng đầu tiên của mỗi người trong số bốn phép quay, có hiệu quả loại bỏ một trong những dòng đầu tiên, hàng dưới cùng, cột tận cùng bên trái và cột ngoài cùng bên phải của M .

  3. Gọi chính nó đệ quy trên mỗi mô hình con.

  4. Trả về mức tối đa của các giá trị trả về từ các cuộc gọi đệ quy.

JavaScript (ES6), 97 byte

a=>a.map((b,i)=>a.slice(i).map((c,j)=>c.map((d,k)=>(n=(b[k]&=d)&&n+j+1)>r?r=n:0,n=0),c=[]),r=0)|r

Hóa ra bit twiddling vẫn thắng. Chấp nhận một mảng các số nguyên. Ung dung:

function rect(array) {
    var max = 0;
    for (var i = 0; i < array.length; i++) {
        var bits = array[i];
        for (var j = 0; i + j < array.length;) {
            var row = array[i + j];
            j++;
            var size = 0;
            for (var k = 0; k < row.length; k++) {
                if (!row[k]) bits[k] = 0;
                size = ones[k] ? size + j : 0;
                if (size > max) max = size;
            }
        }
    }
    return max;
}

Mảng được cắt theo hàng theo các câu trả lời khác, vì vậy mỗi phạm vi hàng có thể được lặp lại. Cho một phạm vi các hàng, bước tiếp theo là đo các hình chữ nhật có sẵn. Điều này đạt được bằng cách ANDing các hàng với nhau theo chiều bit; kết quả là một danh sách các bit được đặt trong toàn bộ phạm vi của các hàng. Sau đó, vẫn còn để tìm độ dài tối đa của các bit được đặt trong hàng và nhân số đó với chiều cao của phạm vi. Kiểm tra bị đánh cắp một cách đáng xấu hổ từ @ ed65:

f=
a=>a.map((b,i)=>a.slice(i).map((c,j)=>c.map((d,k)=>(n=(b[k]&=d)&&n+j+1)>r?r=n:0,n=0),c=[]),r=0)|r

// test cases as strings, converted to 2d arrays
result.textContent = [
  ['0', 0],
  ['1', 1], 
  ['00 00', 0],
  ['01 10', 1],
  ['01 11', 2],
  ['111 010 111', 3],
  ['101 011 111', 4],
  ['0111 1110 1100', 4],
  ['1111111 1110111 1011101', 7],
  ['111011000 110111100 001111110 011111111 001111110 000111100 000011000', 20],
  ['000110000 110110010 110111110 110011100 010011111 111111111 111101110', 12]
].map(t => t[0].replace(/ /g, '\n') + '\n' + t[1] + '\n' + f(t[0].split` `.map(r => [...r]))).join`\n\n`

<pre id=result></pre>

Python 2.7, 93 91 89 81 79 byte

f=lambda M,t=1:max(f(M[1:]),f(zip(*M)[::-1],t+1))if`t/3`in`M`else`M`.count(`t`)

Đầu vào là một danh sách các bộ dữ liệu. Xác nhận các trường hợp thử nghiệm nhỏ hơn ở đây và các trường hợp thử nghiệm lớn hơn ở đây .

Không có ghi nhớ, hai trường hợp thử nghiệm cuối cùng vượt quá giới hạn thời gian của Ideone, vì chúng yêu cầu, tương ứng, 1.530.831.935 và 2.848.806.121 cuộc gọi đến f , mất 39 và 72 phút trên máy của tôi.

Thuật toán

Đối với một ma trận M đã cho , ý tưởng chung là lặp lại trên tất cả các ma trận con của M bằng cách loại bỏ các hàng trên cùng và xoay vòng quay ngược chiều kim đồng hồ, theo dõi kích thước của các ma trận con gặp phải chỉ bao gồm 1 bit.

Chơi golf một cách thực hiện đệ quy đơn giản của ý tưởng trên dẫn đến một hàm f (M) thực hiện như sau.

1. Nếu M không chứa 0 bit nào, hãy trả về số 1 bit của nó.

2. Nếu chúng ta đã quay M hai lần và nó không chứa 1 bit nào, hãy trả về 0 .

3. Nếu chúng ta đã quay M năm lần rồi, trả về 0 .

4. Gọi đệ quy f trên M mà không có hàng trên cùng.

5. Gọi đệ quy f trên M quay một phần tư ngược chiều kim đồng hồ.

6. Trả về mức tối đa của các giá trị trả về từ các cuộc gọi đệ quy.

Mã

Trong quá trình triển khai, chúng tôi sử dụng một đối số hàm bổ sung t mặc định là 1 để theo dõi số lần chúng tôi đã xoay ma trận cụ thể này. Điều này cho phép ngưng tụ các bước từ 1 đến 3 thành một bước duy nhất bằng cách kiểm tra ​`t/3`in`M`​và quay lại ​`M`.count(`t`)​nếu thử nghiệm thất bại.

1. Nếu t = 1 , chúng ta chưa quay được hàm con đặc biệt này trước đây trong nhánh này.

   t / 3 = 0 , vì vậy ​`t/3`in`M`​sẽ trả về True iff, biểu diễn chuỗi của M chứa ký tự 0 .

   Nếu không, chúng tôi trở lại ​`M`.count(`t`)​, số lần nhân vật 1 xuất hiện trong chuỗi đại diện của M .

   Lưu ý rằng một ma trận không có 0 bit chỉ có thể xảy ra nếu t = 1 , vì chúng ta không tái diễn trong trường hợp này.

2. Nếu 3 ≤ t 5 , trước đây chúng tôi đã xoay hàm con đặc biệt này ít nhất hai lần trong nhánh này.

   t / 3 = 1 , vì vậy ​`t/3`in`M`​sẽ trả về True iff, biểu diễn chuỗi của M chứa ký tự 1 .

   Nếu không, chúng tôi quay trở lại 0 tính như ​`M`.count(`t`)​, số lần chuỗi đại diện của t (ví dụ, nhân vật 3 , 4 hoặc 5 ) xuất hiện trong chuỗi đại diện của M .

3. Nếu t = 6 , trước đây chúng tôi đã quay hàm con đặc biệt này năm lần trong nhánh này.

   t / 3 = 2 , do đó ​`t/3`in`M`​sẽ trả về Sai , vì biểu diễn chuỗi của M không chứa ký tự 2 .

   Chúng tôi trở về 0 tính như ​`M`.count(`t`)​, số lần nhân vật 6 xuất hiện trong chuỗi đại diện của M .

Nếu f chưa trở lại, các bước còn lại sẽ được thực hiện.

4. f(M[1:])gọi f trên M mà không có hàng trên cùng của nó. Kể từ khi t không được chỉ định, nó mặc định là 1 , báo hiệu rằng đây là lần đầu tiên e gặp submatrix đặc biệt này trong ngành này.

5. f(zip(*M)[::-1],t+1)các cuộc gọi f trên M được quay một phần tư theo chiều ngược chiều kim đồng hồ, tăng t để theo dõi thời gian chúng ta đã xoay hàm con đặc biệt này trong nhánh này.

   Lần lượt quý được lấy bằng cách nén các hàng M với nhau, trả lại các bộ phần tử tương ứng của các hàng M , do đó hoán vị M , sau đó đảo ngược thứ tự các hàng (nghĩa là đặt hàng trên cùng ở dưới cùng và ngược lại ).

6. Cuối cùng maxtrả về mức tối đa của các giá trị trả về từ các cuộc gọi đệ quy.

JavaScript (ES6), 154 176

Chỉnh sửa đã cố rút ngắn một chút, nhưng không thể cạnh tranh với giải pháp của @ Neil

Hãy thử mọi hình chữ nhật có thể, trả lại kích thước tối đa. Có lẽ cùng một thuật toán của câu trả lời Matl, chỉ dài hơn 6 lần.
Nhập dưới dạng mảng 2d của số nguyên

g=>g.map((r,i)=>r.map((x,j)=>v=s(r,j,(_,l)=>s(g,i,(_,k)=>!s(g,k,r=>s(r,l,x=>!x,l+j+1),k+i+1)))&(t=-~i*-~j)>v?t:v),s=(a,i,l,j)=>a.slice(i,j).some(l),v=0)|v

Ít chơi gôn

Đây là thuật toán ban đầu, phiên bản golf lạm dụng rất nhiều chức năng duyệt qua mảng istead của các vòng lặp

g=>{
  v = 0
  for(i = h = g.length; i; i--)
    for(j = w = g[0].length; j; j--)
    {
      p = true
      for(k=0; p && k <= h-i; k++)
        for(l=0; p && l <= w-j; j++)
          p = g.slice(k, k+i).some(r=>r.slice(l, l+j).some(x=>!x));
      if (!p && i*j<v)
        v = i*j
    }
  return v
}

Kiểm tra

f=g=>g.map((r,i)=>r.map((x,j)=>v=s(r,j,(_,l)=>s(g,i,(_,k)=>!s(g,k,r=>s(r,l,x=>!x,l+j+1),k+i+1)))&(t=-~i*-~j)>v?t:v),s=(a,i,l,j)=>a.slice(i,j).some(l),v=0)|v

console.log=(...x)=>O.textContent+=x+'\n'

// test cases as strings, converted to 2d arrays
;[
  ['0',0],['1',1],['00 00',0],['01 10',1],['01 11',2],
  ['111 010 111',3],['101 011 111',4],
  ['0111 1110 1100',4],['1111111 1110111 1011101',7],
  ['111011000 110111100 001111110 011111111 001111110 000111100 000011000',20],
  ['000110000 110110010 110111110 110011100 010011111 111111111 111101110',12]
].forEach(t=>{
  var k=t[1]
  var p=t[0].split` `.map(r=>[...r].map(x=>+x))
  var r=f(p)
  console.log((r==k?'OK':'KO')+' '+r+(r==k?'':' expected '+k)+'\n'+p.join`\n`+'\n')
  })

<pre id=O></pre>

APL (Dyalog mở rộng) , 27 23 20 byte

-3 byte bởi Adám và ngn

{⌈/∊(×/×⍵⍷⍨⍴∘1)¨⍳⍴⍵}

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

{⌈/∊(×/×⍵⍷⍨⍴∘1)¨⍳⍴⍵}    Monadic function taking an argument ⍵:
                 ⍳⍴⍵     Indices: e.g. for a 3x7 array
                                       (1 1) (1 2) ...  (1 7)
                                       (2 1) (2 2)  ... (2 7)
                                       (3 1) (3 2)  ... (3 7)
    (×/×⍵⍷⍨⍴∘1)         Helper fn: Takes ⍵ and x (e.g. (2 2))
            ⍴∘1             Make an array of 1s of shape x. Call it a.
        ⍵⍷⍨                 All places where a exists in x
     ×/                      Product of x's dims (size of a)
       ×                 Size of a where a is in ⍵, and 0 elsewhere.
    (×/×⍵⍷⍨⍴∘1)¨        Call the helper function on x and each (¨) index.
                            We now have a nested list containing sizes of blocks in ⍵
                            and many 0s.
   ∊                        Flatten
 ⌈/                        Find the maximum value.

Brachylog , 20 17 15 byte

Cảm ơn Kroppeb cho 2 byte

{s\sc≡ᵛ¹l}ᶠ⌉|hh

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

Giải trình

{        }ᶠ      Find all possible outputs of the following predicate:
 s                Find a sublist of the array (i.e. remove 0 or more rows from the top
                  and/or bottom)
  \               Transpose the array
   s              Find a sublist again
                  The result is some sub-rectangle of the array
    c             Concatenate all the rows in that rectangle into one list
     ≡ᵛ¹          Verify that all the elements are 1
        l         Get the length (i.e. how many 1's make up the rectangle)
                 Now we have a list of the sizes of all possible 1-rectangles
           ⌉     Take the maximum

            |    If no 1-rectangles could be found:
             hh   Take the head of the head of the array (i.e. the top left element)
                 Since the array contains no 1's in this case, this will give 0

R , 129 122 byte

function(M,D=dim(M),L=`for`){L(i,1:D,L(j,1:D[2],L(r,0:(D-i),L(c,0:(D[2]-j),F<-max(F,i*j*(i*j==sum(M[r+1:i,c+1:j])))))))
F}

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

Phương pháp tiếp cận đơn giản và đơn giản.

Mã không được kiểm soát và giải thích:

function(M){                       # M is the matrix of 0/1
n = 0                              # n is the biggest rectangle found
R=nrow(M)
C=ncol(M)
for(i in 1:R)                      # for each possible num of rows of the rectangle
  for(j in 1:C)                    # for each possible num of cols of the rectangle
    for(r in 0:(R-i))              # for each possible position offset on the rows
      for(c in 0:(C-j){            # for each possible position offset on the cols

         subM = M[1:i+r,1:j+c]     # sub-set the matrix given the size of rectangle and offsets

         if(sum(subM)==i*j)        # if sub-matrix is full of 1's
            rec = i*j              # (i.e. nrow*ncol == sum of values in sub-matrix)
         else                      # store the rectangle area
            rec = 0                # otherwise store 0

         n = max(n,rec)            # keep the maximum rectangle found
      }
}

Stax , 14 byte

π└ÿ§L▓═J║φ§╦╢9

Chạy và gỡ lỗi nó

Matlab 106 byte

x=input('');[n,k]=size(x);r=0;for p=1:n;for m=1:k;r=max([p*m*(any(conv2(x,ones(p,m))==p*m)),r]);end;end;r

Ung dung:

x=input(''); %//Take input
[n,k]=size(x); %//Determine array size
r=0; %//Variable for output. Initially zero
for p=1:n; %// Loop through the columns
    for m=1:k; %// Loop through the rows
        r=max([p*m*(any(conv2(x,ones(p,m))==p*m)),r]);%//See explanation below
    end;
end;
r %//Display result

Hoạt động trong vòng lặp bắt đầu với tích chập 2D conv2()của mảng đầu vào với p*mmảng của các mảng. ==p*mkiểm tra xem mảng kết quả có chứa một phần tử bằng không p*m. Phần tử tương ứng được chuyển sang 1, tất cả các phần tử khác được chuyển sang 0. any()biến mảng thành vector. Các cột chứa ít nhất một mục nhập khác không được chuyển sang 1, nếu không 0. p*m*()nhân vectơ bằng cách p*mbiến tất cả các- 1thành p*m. [__,r]dấu ngoặc vuông nối kết quả thu được với diện tích tối đa trước đó được lưu trữ trong r. Cuối cùng, max()tìm giá trị tối đa trong vector kết quả.

Matlab (222)(209)

Trên thực tế, giải pháp này mang lại cho tôi sự xấu hổ vì đã tăng gấp đôi giải pháp cùng ngôn ngữ thực tế nhưng ... thật đáng tiếc, tôi đã nghĩ về nó trong 6 giờ! và mánh khóe là một cách xây dựng hơi khác so với câu trả lời của Dennis và Neil.

    function p=g(x,a,u,i,j),i=i+~u;j=j+u;p=0;if(j*u+i*~u>=size(a,2-u))return;end,x=circshift(x,[0-u -1+u]),a=(x+a).*~~x.*~~a;for h=0+u:1,p=max([p,reshape(a(1:end-j,1:end-i),1,[]),g(~u*(a*h+x*~h)+u*x,a,h,i,j)]);end

• Hàm được gọi là

  y=[1 1 1 0 1 1 0 0 0;
  1 1 0 1 1 1 1 0 0;
  0 0 1 1 1 1 1 1 0;
  0 1 1 1 1 1 1 1 1;
  0 0 1 1 1 1 1 1 0;];
  t=g(y,y,[],0,0,0);t,
  

• Tôi có thể tiết kiệm nhiều byte hơn nếu giới thiệu độ dài ma trận trong các hàm của hàm, mặc dù vậy, việc chơi gôn đang diễn ra nhiều hơn.

• Làm thế nào điều này tiến hành?

  Thuật toán này thêm ma trận thực tế vào chính nó đã dịch chuyển nó sang hướng trái, với một chút xoay (&). trong bất kỳ giai đoạn nào, ma trận kết quả được đặt thành ban đầu và được thêm vào chính nó được dịch chuyển lên trên nhiều lần, sau đó di chuyển lại từ đầu với ma trận mới. Tất cả các yếu tố phụ của tất cả các ma trận được tạo ra bởi hoạt động này (original_matrix+shifted_matrix)&shifted_and_original_matrices)được tối đa hóa cho đầu ra.

thí dụ:

     1 1 1         1 1 0                      2 2 0                  0 2 0                        0 4 0
 M0= 0 1 1  M0<<1= 1 1 0  M1=(M0+M0<<1)&both= 0 2 0    shift(M1,up)= 2 0 0  M2=(M1+sh(M1,u)&both= 0 0 0  
     1 1 0         1 0 0                      2 0 0                  0 0 0                        0 0 0
                        2 0 0                               4 0 0
 M3=(M0<<1+M0<<2)&both= 2 0 0 , M4=(M3+shift(M3,up))&both=  0 0 0
                        0 0 0                               0 0 0

                3 0 0                             
 M5=(M1+M0<<2)= 0 0 0 , M6=(M5+shift(M5,up))&both=zeros(3,3).
                0 0 0

 Max_of_all_values=Max(0,1,2,3,4)=4

Japt , 30 byte

®åÏ*°X}ÃÕ®£ZãYÄÃm®rm *Zl}Ãc rw

Hãy thử tất cả các trường hợp thử nghiệm

Khoảng một câu trả lời Jelly của Dennis. Các trường hợp kiểm tra chỉ đơn giản là các mảng số 2D, được chuyển đổi từ định dạng của câu hỏi bằng cách sử dụng này .

Giải trình:

®      Ã                          #For each row:
 å    }                           # Replace each number with this running total:
    °X                            #  Increment the previous total
  Ï*                              #  Multiply it by the current number
        Õ                         #Transpose rows and columns
         ®               Ã        #For each column:
          £    Ã                  # Iterate over the range [0..length) as Y:
           ZãYÄ                   #  Get the subsections of that column with length Y+1
                m®      }         # For each subsection:
                  rm              #  Get the minimum
                     *Zl          #  Multiply it by the length
                          c       #Flatten everything to a single list of possible rectangle sizes
                            rw    #Get the maximum

J , 38 byte

,"0/&(1+i.)/@$>./@,@:((#**/)@,;._3"$)]

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

làm sao

,"0/&(1 + i.)/@$ >./@,@:((# * */)@,;._3"$) ]
              @$                             NB. pass the shape of
                                             NB. the input (rows, cols)
                                             NB. to...
,"0/&(1 + i.)/                               NB. this verb, which will
    &(1 + i.)/                               NB. will first create 2
                                             NB. lists: 1...num rows
                                             NB. and 1...num cols.
,"0/                                         NB. and then creat a cross
                                             NB. of every possible 
                                             NB. concatenation of the two,
                                             NB. giving us all possible 
                                             NB. rectangle sizes. pass 
                                             NB. that and...
                                           ] NB. the original input
                 >./@,@:((# * */)@,;._3"$)   NB. to this verb, which
                                   ;._3"$    NB. will take every 
                                             NB. possible rectangle of
                                             NB. every size,
                                 @,          NB. flatten it and...
                         (# * */)            NB. multiply the size of
                                             NB. the list by the list's 
                                             NB. product, yielding the
                                             NB. size of the list if it's
                                             NB. all ones, zero otherwise.
                     ,@:                     NB. Flatten all those results
                                             NB. into one big list
                 >./@                        NB. and take the max.