sfondo

Voglio comprare un appezzamento di terra e costruirci sopra la mia casa. La mia casa dovrebbe essere rettangolare e il più grande possibile; tuttavia, le trame disponibili hanno molte aree rocciose su cui non posso costruire, e sto avendo problemi a sistemare una potenziale casa sulle trame. Voglio che tu scriva un programma che analizzi le trame per me.

Ingresso e uscita

Il tuo input è un array 2D rettangolare di bit, di dimensioni almeno 1 × 1, in qualsiasi formato ragionevole. La matrice rappresenta un appezzamento di terra; 1sono aree "buone" dove potrei costruire la mia casa, e 0sono aree "rocciose" dove la casa non può essere costruita.

L'output deve essere l'area massima di un rettangolo solido di 1s nell'array di input. Rappresenta l'area della casa più grande che potrei costruire sulla trama. Notare che se non ci sono 1s nell'input, allora lo è 0.

Esempio

Considera l'input

101
011
111

Il rettangolo più grande di 1s è il rettangolo 2 × 2 nell'angolo in basso a destra. Ciò significa che è l'output corretto 4.

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

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

Gelatina , 21 20 18 17 byte

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

Provalo online! o verifica tutti i casi di test .

sfondo

Sia M una matrice di bit come

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

Iniziamo contando il numero di 1 bit in ogni colonna di M , ripristinando il conteggio ogni volta che incontriamo uno 0 bit.

Per la nostra matrice di esempio, questo dà

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

Successivamente, calcoliamo tutte le liste secondarie contigue di ogni riga. Raggiungiamo questo obiettivo generando tutte le sezioni di lunghezza k , dove k varia tra 1 e il numero di voci in ciascuna riga.

Per la penultima riga, questo dà

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

Successivamente, mappiamo ogni sezione sul prodotto del suo minimo e della sua lunghezza. Per ogni sezione, calcola l'area del rettangolo di 1 bit di altezza massima che ha la sezione data come riga inferiore.

Per le fette di lunghezza 3 della penultima riga della nostra matrice di esempio, questo dà

3 3 3 3 12 6 6

Tutto quello che resta da fare è prendere il massimo tra tutte le sezioni di tutte le righe.

Per la nostra matrice di esempio, questo dà 12 .

Come funziona

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

Questo utilizza un approccio basato sulla convoluzione 2D a forza bruta. Tutte le possibili dimensioni del rettangolo vengono create e contorte con il terreno. Il risultato massimo di tutte le convoluzioni è l'area del rettangolo massimo.

Questa è una soluzione estremamente inefficiente perché al fine di salvare i byte, creo kernel per tutti i rettangoli tra [1, 1]e [numel(input) numel(input)]piuttosto che determinare effettivamente il numero di righe / colonne nell'input per determinare gli intervalli di dimensioni rettangolari corretti.

Grazie a @Luis per aver suggerito l'utilizzo Me l'omissione di ]].

Provalo online!

Spiegazione

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

Provalo online!L'ultimo test case supera il limite di tempo di TIO, ma l'ho verificato localmente.

Come funziona

Innanzitutto ! controlla se il suo argomento di matrice M è costituito interamente da 1 .

• Se è così ,! restituisce la somma delle voci di M , che è uguale alla sua area.

• Altrimenti ,! fa quanto segue:

  1. Ruota M di 0 ° , 90 ° , 180 ° e 270 ° in senso orario.

  2. Rimuovere la prima fila di ciascuno dei quattro rotazioni, rimuovendo in modo efficace una fila superiore, fila inferiore, colonna più a sinistra e più a destra della colonna M .

  3. Chiamare se stesso in modo ricorsivo su ciascuna delle matrici.

  4. Restituisce il massimo dei valori di ritorno dalle chiamate ricorsive.

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

Si scopre che il twiddling vince ancora. Accetta una matrice di matrice di numeri interi. Ungolfed:

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

L'array è suddiviso in righe secondo le altre risposte, quindi ogni possibile intervallo di righe viene ripetuto. Dato un intervallo di righe, il passaggio successivo è misurare i rettangoli disponibili. Ciò si ottiene ANDing le righe insieme bit a bit; il risultato è un elenco di bit impostati nell'intero intervallo di righe. Resta quindi da trovare la lunghezza massima dei bit impostati nella riga e moltiplicarla per l'altezza dell'intervallo. Test spudoratamente rubato da @ 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`)

L'input è un elenco di tuple. Verificare i casi di test più piccoli qui e le più grandi casi di test qui .

Senza memoizzazione, gli ultimi due casi di test superano il limite di tempo di Ideone, in quanto richiedono, rispettivamente, 1.530.831.935 e 2.848.806.121 chiamate a f , che richiede 39 e 72 minuti sulla mia macchina.

Algoritmo

Per una data matrice M , l'idea generale è quella di scorrere su tutte le matrici di M rimuovendo le file superiori e ruotando i quarti di giro in senso antiorario, tenendo traccia delle dimensioni delle matrici incontrate che sono costituite interamente da 1 bit.

Giocare a golf un'implementazione semplice e ricorsiva dell'idea di cui sopra porta a una funzione f (M) che procede come segue.

1. Se M non contiene 0 bit, restituisce il suo numero di 1 bit.

2. Se abbiamo già ruotato M due volte e non ne contiene alcuna 1 bit, restituisce 0 .

3. Se abbiamo ruotato M cinque volte, restituisce 0 .

4. Chiamare in modo ricorsivo f su M senza la sua riga superiore.

5. Chiamare in modo ricorsivo f su M ruotato di un quarto di giro in senso antiorario.

6. Restituisce il massimo dei valori di ritorno dalle chiamate ricorsive.

Codice

Nell'implementazione, utilizziamo un argomento di funzione aggiuntiva t che per impostazione predefinita è 1 per tenere traccia di quante volte abbiamo già ruotato questa particolare matrice. Ciò consente di condensare i passaggi da 1 a 3 in un unico passaggio testando ​`t/3`in`M`​e restituendo ​`M`.count(`t`)​se il test fallisce.

1. Se t = 1 , non abbiamo ruotato questa particolare matrice secondaria in questo ramo.

   t / 3 = 0 , quindi ​`t/3`in`M`​restituirà True se la rappresentazione di stringa di M contiene il carattere 0 .

   In caso contrario, si ritorna ​`M`.count(`t`)​, il numero di volte in cui i caratteri 1 appare nella rappresentazione di stringa di M .

   Si noti che una matrice senza 0 bit può verificarsi solo se t = 1 , poiché in questo caso non si fa ricorso.

2. Se 3 ≤ t ≤ 5 , abbiamo precedentemente ruotato questa particolare sottostruttura almeno due volte in questo ramo.

   t / 3 = 1 , quindi ​`t/3`in`M`​restituirà True se la rappresentazione di stringa di M contiene il carattere 1 .

   In caso contrario, si ritorna 0 calcolato come ​`M`.count(`t`)​il numero di volte che la rappresentazione di stringa di t (cioè, il carattere 3 , 4 o 5 ) appare nella rappresentazione di stringa di M .

3. Se t = 6 , abbiamo precedentemente ruotato questa particolare sottotrix cinque volte in questo ramo.

   t / 3 = 2 , quindi ​`t/3`in`M`​restituirà False , poiché la rappresentazione in stringa di M non contiene il carattere 2 .

   Torniamo 0 calcolato come ​`M`.count(`t`)​, il numero di volte che i caratteri 6 appare nella rappresentazione di stringa di M .

Se f non è già tornato, vengono eseguiti i passaggi rimanenti.

4. f(M[1:])chiama f su M senza la sua riga superiore. Poiché t non è specificato, il default è 1 , segnalando che questa è la prima volta f incontra questo particolare sottomatrice in questo ramo.

5. f(zip(*M)[::-1],t+1)le chiamate f su M ruotavano di un quarto di giro in senso antiorario, aumentando t per tenere traccia del tempo in cui abbiamo ruotato questa particolare sottostruttura in questo ramo.

   Il quarto di giro si ottiene zippando le file di M tra loro, restituendo tuple degli elementi corrispondenti delle file di M , trasponendo così M , quindi invertendo l'ordine delle righe (cioè, posizionando la riga superiore in basso e viceversa ).

6. Infine maxrestituisce il massimo dei valori restituiti dalle chiamate ricorsive.

JavaScript (ES6), 154 176

modificare provato ad accorciare un po ', ma non può competere con la soluzione di @ Neil

Prova ogni possibile rettangolo, restituisci la dimensione massima. Probabilmente lo stesso algoritmo della risposta Matl, solo 6 volte più a lungo.
Input come un array 2d di numeri interi

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

Meno golf

Questo è l'algoritmo originale, la versione golfata abusa di molte funzioni di attraversamento dell'array prima dei loop

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
}

Test

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 byte

-3 byte di Adám e ngn

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

Provalo online!

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

Grazie a Kroppeb per 2 byte

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

Provalo online!

Spiegazione

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

Provalo online!

Approccio alla forza bruta semplice e chiaro.

Codice non spiegato e spiegazione:

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

Esegui ed esegui il debug

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

Ungolfed:

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

L'operazione nel loop inizia con la convoluzione 2D conv2()dell'array di input con l' p*marray di quelli. ==p*mcontrolla se l'array risultante contiene un elemento uguale a p*m. L'elemento corrispondente è rivolto a 1, tutti gli altri elementi sono rivolti a 0. any()trasforma l'array in vettoriale. Le colonne contenenti almeno una voce 1diversa da zero vengono trasformate in , altrimenti 0. p*m*()moltiplica il vettore p*mtrasformando così tutti i 1-s in p*m. [__,r]parentesi quadre concatenano il risultato ottenuto con la precedente area massima memorizzata in r. Infine, max()trova il valore massimo nel vettore risultante.

Matlab (222)(209)

In realtà, questa soluzione mi fa vergognare di essere doppiamente la soluzione nella stessa lingua ma ... blime, ci avevo pensato per 6 ore! e il trucco è leggermente diverso dalle risposte di Dennis e 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

• La funzione si chiama come

  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,
  

• Potrei risparmiare più byte se introdotta la lunghezza della matrice nelle dimensioni della funzione, anche se è in corso un maggior golf.

• Come procede?

  Questo algoritmo aggiunge la matrice effettiva a se stessa spostata nella direzione sinistra, con un po 'di rotazione (&). in ogni fase la matrice risultante viene impostata come iniziale e aggiunta a se stessa spostata ripetutamente verso l'alto, quindi ricaricare dall'inizio con la nuova matrice. Tutti i sottoelementi di tutte le matrici generate da questa operazione (original_matrix+shifted_matrix)&shifted_and_original_matrices)sono massimizzati all'output.

esempio:

     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

Prova tutti i casi di test

Circa un porto della risposta Jelly di Dennis. I casi di test sono semplicemente matrici 2D di numeri, convertite dal formato della domanda usando questo .

Spiegazione:

®      Ã                          #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"$)]

Provalo online!

Come

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