배경

토지를 사서 집을 짓고 싶습니다. 내 집은 직사각형이어야하고 가능한 한 커야합니다. 그러나 사용 가능한 줄거리에는 내가 쌓을 수없는 많은 암석 지역이 있으며 줄거리에 잠재적 인 집을 맞추는 데 어려움을 겪고 있습니다. 나에게 줄거리를 분석하는 프로그램을 작성하길 바란다.

입력과 출력

입력 값은 크기가 1x1 이상인 임의의 적절한 형식의 직사각형 2D 비트 배열입니다. 배열은 토지의 음모를 나타냅니다. 1내 집을 지을 수있는 "좋은"지역이고 0집을 지을 수없는 "바위"지역입니다.

출력 1은 입력 배열에서 s의 직사각형의 최대 면적이 됩니다. 그것은 내가 줄거리에서 지을 수있는 가장 큰 집의 면적을 나타냅니다. 1입력에 s 가 없으면 출력은 0입니다.

예

입력을 고려하십시오

101
011
111

1s 의 가장 큰 사각형은 오른쪽 아래 모서리에있는 2 × 2 사각형입니다. 이것은 올바른 출력이 4입니다.

규칙과 득점

전체 프로그램이나 함수를 작성할 수 있습니다. 가장 낮은 바이트 수가 이기고 표준 허점은 허용되지 않습니다.

테스트 사례

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

젤리 , 21 20 18 17 바이트

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

배경

M을 다음과 같은 비트 행렬로 하자.

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

우리 는 M의 각 열에서 1 비트 의 수를 세는 것으로 시작 하여 0 비트 가 발생할 때마다 카운트를 재설정합니다 .

예제 매트릭스의 경우

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

다음으로 각 행의 모든 ​​연속 된 하위 목록을 계산합니다. 길이 k 의 모든 슬라이스를 생성하여이를 달성합니다 . 여기서 k 는 1 과 각 행의 항목 수 사이 에서 다릅니다 .

두 번째 행의 경우

[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]

다음으로 각 슬라이스를 최소 및 길이의 곱에 매핑합니다. 각 슬라이스에 대해 주어진 슬라이스가 맨 아래 행인 최대 높이 1 비트의 사각형 영역을 계산합니다 .

예제 매트릭스의 두 번째 행 의 길이 3 의 슬라이스에 대해

3 3 3 3 12 6 6

남은 것은 모든 행의 모든 ​​슬라이스에서 최대 값을 취하는 것입니다.

예제 행렬의 경우 12가 됩니다.

작동 원리

‘×¥\ç"Ụ€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 바이트

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

이것은 무차별 2D 컨볼 루션 기반 접근 방식을 사용합니다. 가능한 모든 사각형 크기가 생성되고 지형과 관련이 있습니다. 모든 회선의 최대 결과는 최대 사각형 영역입니다.

바이트를 저장하기 위해, 나는 사이의 모든 직사각형 커널을 만들 수 있기 때문에 이는 매우 비효율적 인 솔루션 [1, 1]과 [numel(input) numel(input)]오히려 실제로 행의 수를 결정하는 것보다 / 입력의 열이 적절한 사각형의 치수 범위를 결정합니다.

의 사용법을 제안 M하고 생략 한 @Luis에게 감사 합니다 ]].

온라인으로 사용해보십시오!

설명

        % 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.

줄리아, 83 60 57 53 바이트

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

온라인으로 사용해보십시오! 마지막 테스트 사례는 TIO의 시간 제한을 초과하지만 로컬에서 확인했습니다.

작동 원리

먼저 ! 행렬 인수 M이 전적으로 1 로 구성되어 있는지 확인합니다 .

• 그렇다면 ! 면적과 같은 M 의 엔트리 의 합을 반환합니다 .

• 그렇지 않다면 ! 다음을 수행합니다.

  1. 시계 방향으로 M 을 0 ° , 90 ° , 180 ° 및 270 ° 회전 시킵니다.

  2. 네 개의 회전 각각의 첫 번째 행을 제거하여 M 의 맨 위 행, 맨 아래 행, 가장 왼쪽 열 및 가장 오른쪽 열 중 하나를 효과적으로 제거하십시오 .

  3. 각 서브 매트릭스에서 재귀 적으로 호출하십시오.

  4. 재귀 호출에서 최대 반환 값을 반환합니다.

JavaScript (ES6), 97 바이트

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

비트 twiddling이 여전히이기는 것으로 밝혀졌습니다. 정수 배열을받습니다. 언 골프 드 :

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;
}

배열은 다른 답변에 따라 행으로 분할되므로 가능한 각 행 범위가 반복됩니다. 행 범위가 주어지면 다음 단계는 사용 가능한 사각형을 측정하는 것입니다. 이것은 행을 비트 단위로 AND로 연결하여 수행됩니다. 결과는 전체 행 범위에서 설정된 비트 목록입니다. 그런 다음 행에서 설정된 비트의 최대 길이를 찾아 범위의 높이에 곱합니다. @ 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>

파이썬 2.7, 93 91 89 81 79 바이트

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

입력은 튜플 목록입니다. 여기서 더 작은 테스트 사례 와 더 큰 테스트 사례를 확인 하십시오 .

그들이 필요로 메모이 제이션이 없다면, 마지막 두 개의 테스트 케이스, Ideone의 제한 시간을 초과, RESP., 1530831935 및 2848806121 로 전화 F 소요, 39 및 72 내 컴퓨터에서 분.

연산

주어진 행렬 M의 경우, 일반적으로 상단 행을 제거하고 1/4 회전을 반 시계 방향으로 회전하여 M의 모든 하위 행렬을 반복하여 전체적으로 구성된 발생하는 하위 행렬의 크기를 추적합니다. 1 비트로 .

위의 아이디어를 간단하게 반복적으로 구현하면 함수 f (M) 하면 다음과 같은 이 발생합니다.

1. 경우 M은 어떤이 포함되어 있지 않습니다 0 비트를, 자사의 수를 반환 한 비트.

2. M을 이미 두 번 회전 했는데 1 비트 가 없으면 0을 반환하십시오 .

3. 이미 M을 5 번 회전 한 경우 0을 반환 합니다.

4. 맨 위 행없이 재귀 적 으로 M에서 f 를 호출하십시오 .

5. 시계 반대 방향으로 1/4 바퀴 회전 한 M의 f 를 재귀 적으로 호출 합니다.

6. 재귀 호출에서 최대 반환 값을 반환합니다.

암호

구현시, 이 특정 행렬을 이미 몇 번 회전했는지 추적하기 위해 기본적으로 1 로 설정된 추가 함수 인수 t 를 사용합니다 . 이를 통해 테스트가 실패한 경우 테스트 및 리턴 하여 1-3 단계를 단일 단계로 압축 할 수 있습니다 .​`t/3`in`M`​​`M`.count(`t`)​

1. 경우 t 1 = 우리는이 지점에서 이전에이 특정 행렬을 회전하지 않았습니다.

   t / 3 = 0 이므로 M 의 문자열 표현에 문자 0이 포함되어 있으면 True​`t/3`in`M`​ 를 반환 합니다.

   그것은, 우리는 반환하지 않는 경우 ​`M`.count(`t`)​, 횟수가 문자 1 개 의 문자열 표현에 나타납니다 M을 .

   이 경우 재귀하지 않기 때문에 0 비트가 없는 행렬 은 t = 1 인 경우에만 발생할 수 있습니다 .

2. 3 ≤ t ≤ 5 인 경우 이전에이 분기에서이 특정 하위 행렬을 두 번 이상 회전했습니다.

   t / 3 = 1 이므로 M 의 문자열 표현에 문자 1이 포함되어 있으면 True​`t/3`in`M`​ 를 반환 합니다.

   그렇지 않으면, 우리는 반환 0 으로 계산 ​`M`.count(`t`)​횟수의 캐릭터 라인 표현 t (즉, 문자 3 , 4 또는 5 )의 문자열 표현에 나타납니다 M을 .

3. t = 6 인 경우 이전에이 분기에서이 특정 하위 행렬을 5 회 회전했습니다.

   t / 3 = 2 이므로 M 의 문자열 표현에 문자 2가 포함되지 않으므로 False​`t/3`in`M`​ 를 반환 합니다 .

   우리는 반환 0 으로 계산 ​`M`.count(`t`)​횟수가 문자 (6 개) 의 문자열 표현에 나타납니다 M .

경우 f는 이미 반환하지 않은 나머지 단계가 실행됩니다.

4. f(M[1:])맨 위 행없이 M에서 f 를 호출 합니다. 이후 t는 로 기본값을 지정하지 1 이 처음인지 시그널링 F 만남이 지점에서 특정 행렬.

5. f(zip(*M)[::-1],t+1)전화 F 에 M이 증가하는 1/4 회전 반 시계 방향으로 회전 t을 우리는이 지점에서이 특정 행렬을 회전 한 시간을 추적 할 수 있습니다.

   분기 턴은의 로우 압축에 의해 얻어지는 M을 의 대응하는 요소의 튜플 복귀 서로 M 전치 따라서,의 행 M을 (즉, 바닥 역도의 상부 행을 배치 반대로 다음 행의 순서를 반전 ).

6. 마지막으로 max재귀 호출에서 최대 반환 값을 반환합니다.

자바 스크립트 (ES6) 154 176

편집 은 조금 단축하려고했지만 @Neil의 솔루션과 경쟁 할 수 없습니다

가능한 모든 사각형을 시도하고 최대 크기를 반환하십시오. 아마도 Matl 답변과 동일한 알고리즘으로 6 배 더 길 것입니다.
정수의 2 차원 배열로 입력

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

덜 골프

이것은 원래 알고리즘입니다. 골프 버전은 for 루프 대신 많은 배열 탐색 기능을 남용합니다.

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
}

테스트

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 Extended) , 27 23 20 바이트

Adám 및 ngn으로 -3 바이트

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

온라인으로 사용해보십시오!

{⌈/∊(×/×⍵⍷⍨⍴∘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 바이트

2 바이트 Kroppeb 덕분에

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

온라인으로 사용해보십시오!

설명

{        }ᶠ      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 , 129122 바이트

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}

온라인으로 사용해보십시오!

평범하고 간단한 무차별 접근 방식.

풀린 코드 및 설명 :

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 바이트

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

실행 및 디버깅

Matlab 106 바이트

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

언 골프 드 :

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

루프의 연산 conv2()은 입력 배열과 p*m배열 배열의 2D 컨벌루션 으로 시작 합니다. ==p*m결과 배열에 같은 요소가 포함되어 있는지 확인합니다 p*m. 해당 요소가로 바뀌고 1다른 모든 요소가로 바뀝니다 0. any()배열을 벡터로 바꿉니다. 적어도 하나 개의 제로가 아닌 항목을 포함하는 열이에 설정되어 1그렇지 0. all -s를로 변환 p*m*()하여 벡터를 곱합니다 . 대괄호는 얻은 결과를에 저장된 이전 최대 영역과 연결합니다 . 마지막으로 결과 벡터에서 최대 값을 찾습니다.p*m1p*m[__,r]rmax()

MATLAB (222)(209)

실제로,이 솔루션은 실제 동일한 언어 솔루션의 두 배 크기에 대한 수치심을 안겨주지만 ... 트릭은 Dennis와 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

• 이 함수는

  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,
  

• 함수의 차원에서 행렬 길이를 도입하면 더 많은 바이트를 절약 할 수 있지만 더 많은 골프가 진행되고 있습니다.

• 어떻게 진행됩니까?

  이 알고리즘은 실제 매트릭스를 약간 왼쪽으로 돌리고 (&) 왼쪽으로 이동시킵니다. 어떤 단계에서든 결과 행렬은 초기 값으로 설정되고 반복적으로 위쪽으로 반복 이동 된 다음 새 행렬의 처음부터 다시 반복됩니다. 이 연산 (original_matrix+shifted_matrix)&shifted_and_original_matrices)으로 생성 된 모든 행렬의 모든 하위 요소가 출력으로 최대화됩니다.

예:

     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 바이트

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

모든 테스트 사례를 시도하십시오

대략 데니스 젤리의 항구. 테스트 사례는 단순히 2D 숫자 배열이며 this를 사용하여 질문 형식에서 변환됩니다 .

설명:

®      Ã                          #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 바이트

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

온라인으로 사용해보십시오!

방법

,"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.