fundo

Quero comprar um terreno e construir minha casa. Minha casa deve ser retangular e o maior possível; no entanto, os lotes disponíveis têm muitas áreas rochosas nas quais não posso construir e estou tendo problemas para instalar uma casa em potencial nos lotes. Quero que você escreva um programa que analise as parcelas para mim.

Entrada e saída

Sua entrada é uma matriz 2D retangular de bits, com tamanho de pelo menos 1 × 1, em qualquer formato razoável. A matriz representa um lote de terra; 1s são áreas "boas" onde eu poderia construir minha casa 0es são áreas "rochosas" onde a casa não pode ser construída.

Sua saída deve ser a área máxima de um retângulo sólido de 1s na matriz de entrada. Representa a área da maior casa que pude construir no terreno. Observe que, se não houver 1s na entrada, a saída será 0.

Exemplo

Considere a entrada

101
011
111

O maior retângulo de 1s é o retângulo 2 × 2 no canto inferior direito. Isso significa que a saída correta é 4.

Regras e pontuação

Você pode escrever um programa completo ou uma função. A menor contagem de bytes vence e as brechas padrão não são permitidas.

Casos de teste

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

Geléia , 21 20 18 17 bytes

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

Experimente online! ou verifique todos os casos de teste .

fundo

Seja M uma 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

Começamos contando o número de 1 bits em cada coluna de M , redefinindo a contagem toda vez que encontramos um 0 .

Para nosso exemplo de matriz, isso fornece

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

Em seguida, calculamos todas as sublistas contíguas de cada linha. Conseguimos isso gerando todas as fatias de comprimento k , onde k varia entre 1 e o número de entradas em cada linha.

Para a penúltima linha, isso 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]

Em seguida, mapeamos cada fatia para o produto de seu mínimo e seu comprimento. Para cada fatia, calcula a área do retângulo de 1 bit de altura máxima que possui a fatia especificada como linha inferior.

Para as fatias de comprimento 3 da penúltima linha da nossa matriz de exemplo, isso fornece

3 3 3 3 12 6 6

Tudo o que resta a fazer é levar o máximo em todas as fatias de todas as linhas.

Para nossa matriz de exemplo, isso fornece 12 .

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

Isso usa uma abordagem baseada em convolução 2D de força bruta. Todos os tamanhos possíveis de retângulos são criados e convoluídos com o terreno. O resultado máximo de todas as convoluções é a área máxima do retângulo.

Esta é uma solução extremamente ineficiente porque, para salvar bytes, eu crio kernels para todos os retângulos entre [1, 1]e, em [numel(input) numel(input)]vez de realmente determinar o número de linhas / colunas na entrada para determinar os intervalos de dimensão de retângulo adequados.

Obrigado a @Luis por sugerir o uso Me omitir o ]].

Experimente Online!

Explicação

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

Experimente online! O último caso de teste excede o limite de tempo do TIO, mas eu o verifiquei localmente.

Como funciona

Primeiro ! verifica se o argumento da matriz M consiste inteiramente de 1 's.

• Se sim ,! retorna a soma das entradas de M , que é igual à sua área.

• Se não ,! faz o seguinte:

  1. Gire M em 0 ° , 90 ° , 180 ° e 270 ° no sentido horário.

  2. Remover a primeira fila de cada uma das quatro rotações, removendo eficazmente uma linha de topo, fila inferior, coluna mais à esquerda e mais à direita da coluna M .

  3. Chame-se recursivamente em cada uma das submatrizes.

  4. Retorne o máximo dos valores de retorno das chamadas 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

Acontece que um pouco de manobras ainda ganha. Aceita uma matriz de matriz de números inteiros. 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;
}

A matriz é dividida por linhas, de acordo com as outras respostas, para que cada intervalo possível de linhas seja repetido. Dado um intervalo de linhas, o próximo passo é medir os retângulos disponíveis. Isso é conseguido ANDing as linhas juntas bit a bit; o resultado é uma lista de bits que foram definidos em todo o intervalo de linhas. Resta então encontrar o comprimento máximo dos bits definidos na linha e multiplicá-lo pela altura do intervalo. Teste descaradamente roubado 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`)

Entrada é uma lista de tuplas. Verifique os casos de teste menores aqui e os casos de teste maiores aqui .

Sem memorização, os dois últimos casos de teste excedem o limite de tempo da Ideone, pois exigem, respectivamente, 1.530.831.935 e 2.848.806.121 chamadas para f , que levam 39 e 72 minutos na minha máquina.

Algoritmo

Para uma dada matriz M , a idéia geral é iterar todas as submatrizes de M removendo as linhas superiores e girando os quartos de volta no sentido anti-horário, mantendo o controle dos tamanhos das submatrizes encontradas que consistem inteiramente de 1 bits.

Jogar golfe em uma implementação recursiva direta da idéia acima leva a uma função f (M) que faz o seguinte.

1. Se M não contiver 0 bits, retorne seu número de 1 bits.

2. Se já tivermos rotacionado M duas vezes e ele não contiver 1 bit, retorne 0 .

3. Se já tivermos rotacionado M cinco vezes, retorne 0 .

4. Chame recursivamente f em M sem a sua linha superior.

5. Recursivamente chamada f on M girado um sentido anti-horário um quarto de volta.

6. Retorne o máximo dos valores de retorno das chamadas recursivas.

Código

Na implementação, usamos um argumento de função adicional t cujo padrão é 1 para acompanhar quantas vezes já rotacionamos essa matriz específica. Isso permite condensar as etapas 1 a 3 em uma única etapa, testando ​`t/3`in`M`​e retornando ​`M`.count(`t`)​se o teste falhar.

1. Se t = 1 , não rotacionamos essa submatriz específica anteriormente neste ramo.

   t / 3 = 0 , ​`t/3`in`M`​retornará True se a representação em string de M contiver o caractere 0 .

   Se não, voltamos ​`M`.count(`t`)​, o número de vezes que o caráter 1 aparece na representação de cadeia de M .

   Observe que uma matriz sem 0 bits pode ocorrer apenas se t = 1 , pois não recessamos neste caso.

2. Se 3 ≤ t ≤ 5 , já rotacionamos essa submatriz específica pelo menos duas vezes neste ramo.

   t / 3 = 1 , ​`t/3`in`M`​retornará True se a representação em string de M contiver o caractere 1 .

   Se isso não acontecer, voltamos 0 computado como ​`M`.count(`t`)​, o número de vezes que a representação de cadeia de t (ou seja, o personagem 3 , 4 ou 5 ) aparece na representação de cadeia de M .

3. Se t = 6 , já rotacionamos essa submatriz específica cinco vezes neste ramo.

   t / 3 = 2 , ​`t/3`in`M`​retornará False , porque a representação em cadeia de caracteres de M não contém o caractere 2 .

   Voltamos 0 computado como ​`M`.count(`t`)​, o número de vezes que os caracteres 6 aparece na representação de cadeia de M .

Se f ainda não tiver retornado, as etapas restantes serão executadas.

4. f(M[1:])chama f em M sem sua linha superior. Como t não é especificado, o padrão é 1 , sinalizando que é a primeira vez que f encontra essa submatriz específica neste ramo.

5. f(zip(*M)[::-1],t+1)as chamadas f em M giraram um quarto de volta no sentido anti-horário, aumentando t para acompanhar o tempo em que rotacionamos essa submatriz específica neste ramo.

   O quarto de volta é obtido por fechando as linhas de H com cada outro, retornando os tuplos dos elementos correspondentes de M linhas de, assim transposição M , em seguida, invertendo a ordem de linhas (isto é, colocando a linha de cima, na parte inferior e vice-versa )

6. Finalmente, maxretorna o máximo dos valores de retorno das chamadas recursivas.

JavaScript (ES6), 154176

O Edit tentou diminuir um pouco, mas não pode competir com a solução da @ Neil

Tente todos os retângulos possíveis, retorne o tamanho máximo. Provavelmente o mesmo algoritmo da resposta do Matl, apenas 6 vezes mais.
Entrada como uma matriz 2D de números inteiros

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 golfe

Este é o algoritmo original, a versão golfista abuse de muitas funções de deslocamento de matriz, em vez de loops

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
}

Teste

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 e ngn

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

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

Obrigado ao Kroppeb por 2 bytes

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

Experimente online!

Explicação

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

Experimente online!

Abordagem pura e simples da força bruta.

Código desenrolado e explicação:

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

Execute e depure

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

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

A operação no loop começa com a convolução 2D conv2()da matriz de entrada com a p*mmatriz de unidades. ==p*mverifica se a matriz resultante contém um elemento igual a p*m. O elemento correspondente é ativado 1, todos os outros elementos são ativados 0. any()transforma a matriz em vetor. As colunas que contêm pelo menos uma entrada diferente de zero são ativadas 1, caso contrário 0. p*m*()multiplica o vetor p*mtransformando all 1-s em p*m. [__,r]colchetes concatenam o resultado obtido com a área máxima anterior armazenada em r. Finalmente, max()encontra o valor máximo no vetor resultante.

Matlab (222)(209)

Na verdade, essa solução me envergonha por ter o dobro do tamanho da solução de mesmo idioma, mas ... caramba, eu estava pensando nisso há 6 horas! e o truque é um pouco diferente das respostas de 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

• A função é chamada 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,
  

• Eu poderia economizar mais bytes se introduzisse o comprimento da matriz nas dimensões da função, apesar de o evento continuar em andamento.

• Como isso acontece?

  Este algoritmo adiciona a matriz real a ela própria deslocada para a direção esquerda, com um pouco de ajuste (&). em qualquer estágio, a matriz resultante é definida como inicial e adicionada a si mesma deslocada para cima repetidamente e, em seguida, recomeça desde o início com a nova matriz. Todos os subelementos de todas as matrizes geradas por esta operação (original_matrix+shifted_matrix)&shifted_and_original_matrices)são maximizados para a saída.

exemplo:

     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

Japonês , 30 bytes

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

Experimente todos os casos de teste

Aproximadamente um porto da resposta de Dennis's Jelly. Os casos de teste são simplesmente matrizes 2D de números, convertidas do formato da pergunta usando isso .

Explicação:

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

Experimente online!

quão

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