Fondo

Quiero comprar un terreno y construir mi casa en él. Mi casa debe ser rectangular y lo más grande posible; sin embargo, las parcelas disponibles tienen muchas áreas rocosas en las que no puedo construir, y tengo problemas para instalar una casa potencial en las parcelas. Quiero que escribas un programa que analice las tramas por mí.

Entrada y salida

Su entrada es una matriz rectangular 2D de bits, de un tamaño de al menos 1 × 1, en cualquier formato razonable. La matriz representa una parcela de tierra; 1s son áreas "buenas" donde podría construir mi casa, y 0s son áreas "rocosas" donde no se puede construir la casa.

Su salida será el área máxima de un rectángulo sólido de 1s en la matriz de entrada. Representa el área de la casa más grande que podría construir en la parcela. Tenga en cuenta que si no hay 1s en la entrada, entonces la salida es 0.

Ejemplo

Considere la entrada

101
011
111

El rectángulo más grande de 1s es el rectángulo 2 × 2 en la esquina inferior derecha. Esto significa que la salida correcta es 4.

Reglas y puntaje

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Casos de prueba

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

Jalea , 21 20 18 17 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba .

Fondo

Sea M una matriz de bits como

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

Comenzamos contando el número de 1 bits en cada columna de M , restableciendo el recuento cada vez que encontramos un bit 0 .

Para nuestra matriz de ejemplo, esto da

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

A continuación, calculamos todas las sublistas contiguas de cada fila. Logramos esto generando todos los cortes de longitud k , donde k varía entre 1 y el número de entradas en cada fila.

Para la penúltima fila, esto da

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

A continuación, asignamos cada segmento al producto de su mínimo y su longitud. Para cada corte, esto calcula el área del rectángulo de 1 bits de altura máxima que tiene el corte dado como fila inferior.

Para los cortes de longitud 3 de la penúltima fila de nuestra matriz de ejemplo, esto da

3 3 3 3 12 6 6

Todo lo que queda por hacer es tomar el máximo en todos los segmentos de todas las filas.

Para nuestra matriz de ejemplo, esto da 12 .

Cómo funciona

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

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

Esto utiliza un enfoque basado en convolución 2D de fuerza bruta. Todos los tamaños de rectángulo posibles se crean y se relacionan con el terreno. El resultado máximo de todas las convoluciones es el área del rectángulo máximo.

Esta es una solución extremadamente ineficiente porque para ahorrar bytes, creo núcleos para todos los rectángulos entre [1, 1]y en [numel(input) numel(input)]lugar de determinar realmente el número de filas / columnas en la entrada para determinar los rangos de dimensión de rectángulo adecuados.

Gracias a @Luis por sugerir el uso My omitir el ]].

Pruébalo en línea!

Explicación

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

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

Pruébalo en línea! El último caso de prueba excede el límite de tiempo de TIO, pero lo he verificado localmente.

Cómo funciona

Primero ! comprueba si su argumento de matriz M consiste completamente en 1 's.

• Si es así ! devuelve la suma de las entradas de M , que es igual a su área.

• Si no ,! hace lo siguiente:

  1. Gire M en 0 ° , 90 ° , 180 ° y 270 ° en sentido horario.

  2. Eliminar la primera fila de cada una de las cuatro rotaciones, eliminando de forma eficaz uno de la fila superior, fila inferior, columna de la izquierda y la columna más a la derecha de M .

  3. Se llama recursivamente en cada una de las submatrices.

  4. Devuelve el máximo de los valores de retorno de las llamadas recursivas.

JavaScript (ES6), 97 bytes

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

Resulta que el twiddling todavía gana. Acepta una matriz de matriz de enteros. Sin golf:

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

El conjunto se divide en filas según las otras respuestas, por lo que cada posible rango de filas se repite. Dado un rango de filas, el siguiente paso es medir los rectángulos disponibles. Esto se logra ANDing las filas juntas bit a bit; el resultado es una lista de bits que se establecieron en todo el rango de filas. Luego queda encontrar la longitud máxima de los bits establecidos en la fila y multiplicarla por la altura del rango. Prueba descaradamente robada de @ 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 bytes

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

La entrada es una lista de tuplas. Verifique los casos de prueba más pequeños aquí y los casos de prueba más grandes aquí .

Sin memoria, los dos últimos casos de prueba exceden el límite de tiempo de Ideone, ya que requieren, respectivamente, 1,530,831,935 y 2,848,806,121 llamadas a f , lo que toma 39 y 72 minutos en mi máquina.

Algoritmo

Para una matriz M dada , la idea general es iterar sobre todas las submatrices de M eliminando las filas superiores y girando los cuartos de vuelta en sentido contrario a las agujas del reloj, haciendo un seguimiento de los tamaños de las submatrices encontradas que consisten completamente en 1 bit.

Jugar una implementación recursiva directa de la idea anterior conduce a una función f (M) que hace lo siguiente.

1. Si M no contiene ningún 0 bits, devuelve su número de 1 bits.

2. Si ya hemos rotado M dos veces y no contiene ningún 1 bit, devuelve 0 .

3. Si ya hemos rotado M cinco veces, devuelve 0 .

4. Llama recursivamente f a M sin su fila superior.

5. Recurrentemente, la llamada f en M gira un cuarto de vuelta en sentido antihorario.

6. Devuelve el máximo de los valores de retorno de las llamadas recursivas.

Código

En la implementación, usamos un argumento de función adicional t que por defecto es 1 para realizar un seguimiento de cuántas veces hemos rotado esta matriz en particular. Esto permite condensar los pasos 1 a 3 en un solo paso probando ​`t/3`in`M`​y devolviendo ​`M`.count(`t`)​si la prueba falla.

1. Si t = 1 , no hemos rotado esta submatriz particular en esta rama.

   t / 3 = 0 , por ​`t/3`in`M`​lo que devolverá True si la representación de cadena de M contiene el carácter 0 .

   Si no es así, volvemos ​`M`.count(`t`)​, el número de veces que los caracteres 1 aparece en la representación de cadena H .

   Tenga en cuenta que una matriz sin 0 bits solo puede ocurrir si t = 1 , ya que no recurrimos en este caso.

2. Si 3 ≤ t ≤ 5 , hemos rotado previamente esta submatriz particular al menos dos veces en esta rama.

   t / 3 = 1 , por ​`t/3`in`M`​lo que devolverá True si la representación de cadena de M contiene el carácter 1 .

   Si no es así, volvemos 0 calculada como ​`M`.count(`t`)​el número de veces que la representación de cadena de t (es decir, el carácter 3 , 4 o 5 ) aparece en la representación de cadena H .

3. Si t = 6 , previamente hemos rotado esta submatriz particular cinco veces en esta rama.

   t / 3 = 2 , por ​`t/3`in`M`​lo que devolverá False , porque la representación de cadena de M no contiene el carácter 2 .

   Volvemos 0 calculada como ​`M`.count(`t`)​, el número de veces que los caracteres 6 aparece en la representación de cadena H .

Si f no regresó ya, se ejecutan los pasos restantes.

4. f(M[1:])llama a f en M sin su fila superior. Como t no se especifica, el valor predeterminado es 1 , lo que indica que es la primera vez que f encuentra esta submatriz particular en esta rama.

5. f(zip(*M)[::-1],t+1)las llamadas f en M giraron un cuarto de vuelta en sentido antihorario, incrementando t para realizar un seguimiento del tiempo que hemos rotado esta submatriz particular en esta rama.

   El cuarto de vuelta se obtiene por comprimir las filas de M entre sí, volviendo tuplas de los elementos correspondientes de M filas 's, por lo que la transposición de M , a continuación, invirtiendo el orden de filas (es decir, la colocación de la fila superior en la parte inferior y viceversa )

6. Finalmente maxdevuelve el máximo de los valores de retorno de las llamadas recursivas.

JavaScript (ES6), 154176

Edit intentó acortar un poco, pero no puede competir contra la solución de @ Neil

Pruebe todos los rectángulos posibles, devuelva el tamaño máximo. Probablemente el mismo algoritmo de la respuesta de Matl, solo 6 veces más.
Ingresar como una matriz 2D de enteros

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

Menos golf

Este es el algoritmo original, la versión de golf abusa de muchas funciones de desplazamiento de matriz en lugar de bucles

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
}

Prueba

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 bytes

-3 bytes por Adám y ngn

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

Pruébalo en línea!

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

Gracias a Kroppeb por 2 bytes.

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

Pruébalo en línea!

Explicación

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

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}

Pruébalo en línea!

Enfoque simple y simple de la fuerza bruta.

Código desenrollado y explicación:

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 bytes

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

Ejecutar y depurarlo

Matlab 106 bytes

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

Sin golf:

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

La operación en el bucle comienza con la convolución 2D conv2()de la matriz de entrada con la p*mmatriz de unos. ==p*mcomprueba si la matriz resultante contiene un elemento igual a p*m. El elemento correspondiente se activa 1, todos los demás elementos se activan 0. any()convierte la matriz en vector. Las columnas que contienen al menos una entrada distinta de cero se activan 1, de lo contrario 0. p*m*()multiplica el vector p*mconvirtiendo todo 1-s en p*m. [__,r]los corchetes concatenan el resultado obtenido con el área máxima anterior almacenada en r. Finalmente, max()encuentra el valor máximo en el vector resultante.

Matlab (222)(209)

En realidad, esta solución me da vergüenza por tener el doble de tamaño que la solución real del mismo idioma, pero ... ¡caramba, había estado pensando en ella durante 6 horas! y el truco es una construcción ligeramente diferente de las respuestas de Dennis y 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 función se llama como

  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,
  

• Podría ahorrar más bytes si se introdujera la longitud de la matriz en las dimensiones de la función, a pesar de que hay más golf en curso.

• ¿Cómo procede esto?

  Este algoritmo agrega la matriz real a sí misma desplazada hacia la izquierda, con un poco de giro (&). En cualquier etapa, la matriz resultante se establece como inicial y se agrega a sí misma desplazada hacia arriba repetidamente, luego se reubica desde el principio con la nueva matriz. Todos los subelementos de todas las matrices generadas por esta operación (original_matrix+shifted_matrix)&shifted_and_original_matrices)se maximizan a la salida.

ejemplo:

     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 bytes

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

Pruebe todos los casos de prueba

Aproximadamente un puerto de Dennis's Jelly responde. Los casos de prueba son simplemente matrices 2D de números, convertidos del formato de la pregunta usando esto .

Explicación:

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

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

Pruébalo en línea!

cómo

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