Фон

Я хочу придбати земельну ділянку і побудувати на ній свій будинок. Мій будинок повинен бути прямокутним і максимально великим; Однак на наявних ділянках є багато скелястих ділянок, які я не можу будувати, і у мене виникають проблеми з прилаштуванням потенційного будинку на ділянках. Я хочу, щоб ви написали програму, яка аналізує сюжети для мене.

Вхід і вихід

Ваш вхід - це прямокутний 2D масив бітів розміром принаймні 1 × 1 у будь-якому розумному форматі. Масив являє собою земельну ділянку; 1s - "хороші" райони, де я міг би побудувати свій будинок, а 0s - "кам'янисті" ділянки, де будинок неможливо побудувати.

Ваш вихід повинен бути максимальною площею суцільного прямокутника 1s у вхідному масиві. Він являє собою площу найбільшого будинку, який я міг побудувати на ділянці. Зауважте, що якщо 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

Почнемо з підрахунку кількості 1 біта в кожному стовпчику M , скидання підрахунку кожного разу, коли ми зустрічаємо 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)]а не на самому ділі визначення кількості рядків / стовпців у вхідних даних , щоб визначити відповідні діапазони розмірів прямокутника.

Дякуємо @Luis за те, що він запропонував використовувати Mта пропустити ]].

Спробуйте в Інтернеті!

Пояснення

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

• Якщо так, то ! повертає суму записів М , яка дорівнює його площі.

• Якщо ні, то ! робить наступне:

  1. Обертайте M на 0 ° , 90 ° , 180 ° і 270 ° за годинниковою стрілкою.

  2. Видалити перший рядок кожен з чотирьох обертань, ефективно видаляючи один з верхнього ряду, нижнього ряду, крайнього лівого стовпця і правої колонки М .

  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

Виявляється, біт подвійний все одно виграє. Приймає масив масивів цілих чисел. Безголівки:

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

Масив нарізаний рядками відповідно до інших відповідей, тому кожен можливий діапазон рядків перекидається на петлі. Враховуючи діапазон рядків, наступним кроком буде вимірювання наявних прямокутників. Це досягається, розбиваючи рядки разом порозрядно; Результат - це список бітів, які були встановлені у всьому діапазоні рядків. Потім залишається знайти максимальну довжину заданих бітів у рядку та помножити на висоту діапазону. Тест безсоромно викрадено у @ 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 байт

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, оскільки вони вимагають, відповідно, 1530 831 935 та 2 848 806 211 дзвінків на f , що займає 39 і 72 хвилини на моїй машині.

Алгоритм

Для даної матриці M загальна ідея полягає в перегляді всіх підматриць M шляхом видалення верхніх рядків та обертання чверть витків проти годинникової стрілки, відстежуючи розміри зустрічаються підматриць, що складаються повністю з 1 біта.

Гольфінг прямолінійної рекурсивної реалізації вищезазначеної ідеї призводить до функції f (M), яка робить наступне.

1. Якщо M не містить 0 біт, поверніть його кількість 1 біт.

2. Якщо ми вже два рази обертали M і він не містить жодного 1 біта, поверніть 0 .

3. Якщо ми вже обернули M п'ять разів, повернімо 0 .

4. Рекурсивно викликайте f на M без верхнього ряду.

5. Рекурсивно виклик f на M обертається на чверть обороту проти годинникової стрілки.

6. Повернути максимум повернутих значень від рекурсивних викликів.

Код

У реалізації ми використовуємо додатковий аргумент функції t, який за замовчуванням дорівнює 1, щоб відстежувати, скільки разів ми вже обертали цю конкретну матрицю. Це дозволяє конденсувати кроки 1 - 3 в один крок шляхом тестування ​`t/3`in`M`​та повернення, ​`M`.count(`t`)​якщо тест не вдався.

1. Якщо t = 1 , ми не обертали цю конкретну підматрицю раніше в цій гілці.

   t / 3 = 0 , тому ​`t/3`in`M`​повернеться True, якщо в рядку представлення M містить символ 0 .

   Якщо цього не станеться , ми повертаємося ​`M`.count(`t`)​, число раз символьні 1 з'являється в строковому поданні М .

   Зауважимо, що матриця без 0 біт може виникати лише за умови t = 1 , оскільки в цьому випадку ми не повторюємось.

2. Якщо 3 ≤ t ≤ 5 , ми раніше обертали цю конкретну підматрицю принаймні два рази в цій гілці.

   t / 3 = 1 , тож ​`t/3`in`M`​поверне True iff, якщо рядкове представлення M містить символ 1 .

   Якщо цього не станеться , ми повертаємо 0 , обчислений , як ​`M`.count(`t`)​, скільки разів строкове представлення т (тобто символ 3 , 4 або 5 ) з'являється в рядку уявлення М .

3. Якщо t = 6 , ми попередньо п'ять разів обертали цю конкретну підматрицю в цій гілці.

   t / 3 = 2 , тому ​`t/3`in`M`​повернеться False , оскільки рядкове представлення M не містить символу 2 .

   Повертається 0 обчислюється ​`M`.count(`t`)​, число раз символьні 6 з'являється в строковому поданні М .

Якщо f вже не повернувся, інші кроки виконуються.

4. f(M[1:])викликає f на M без верхнього ряду. Оскільки t не вказано, він за замовчуванням дорівнює 1 , що сигналізує, що це перший раз, коли f стикається з цією підматрицею в цій гілці.

5. f(zip(*M)[::-1],t+1)виклики f на M обертаються на чверть обороту проти годинникової стрілки, збільшуючи t, щоб відслідковувати час, коли ми повернули цю конкретну підматрицю в цій гілці.

   Чверть обороту виходить стиснути рядки М один з одним, повертаючи кортежі відповідних елементів M рядків «с, таким чином переносячи М , потім змінює порядок рядків (тобто, поміщаючи верхній рядок у нижній частині, і навпаки ).

6. Нарешті maxповертає максимум повернутих значень від рекурсивних викликів.

JavaScript (ES6), 154 176

Правка намагалася трохи скоротити, але не може конкурувати з рішенням @ Ніла

Спробуйте кожен можливий прямокутник, поверніть максимальний розмір. Напевно, той самий алгоритм відповіді Матла, лише в 6 разів довший.
Введіть як 2d масив цілих чисел

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

Менше гольфу

Це оригінальний алгоритм, версія для гольфу зловживає безліччю функцій переходу масиву, що використовується для циклів

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 байт

-3 байти за Adám та ngn

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

Брахілог , 20 17 15 байт

Завдяки Кроппебу за 2 байти

{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 , 129 122 байти

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

Стакс , 14 байт

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

Запустіть і налагоджуйте його

Матлаб 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

Операція в циклі починається з 2D згортки conv2()вхідного масиву з p*mмасивом одиниць. ==p*mперевіряє, чи містить отриманий масив елемент, рівний p*m. До відповідного елемента звернено, до 1всіх інших елементів звернено 0. any()перетворює масив у вектор. Стовпці, що містять щонайменше один ненульовий запис, повертаються в 1іншому випадку 0.p*m*()примножує вектор, p*mтим самим перетворюючи всі 1-і на p*m. [__,r]квадратні дужки з'єднують отриманий результат з попередньою максимальною площею, що зберігається в r. Нарешті, max()знаходить максимальне значення в отриманому векторі.

Матлаб (222)(209)

Насправді це рішення приносить мені ганьбу за те, що я подвійний розмір фактичного одномовного рішення, але ... кричуще, я думав про це протягом 6 годин! а трюк - дещо інший склад від відповідей Денніса та Ніла.

    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

Спробуйте всі тестові випадки

Приблизно порт Деніс відповів Желе. Тестові приклади - це просто двовимірні масиви чисел, перетворені з формату запитання за допомогою цього .

Пояснення:

®      Ã                          #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.