Задний план

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

Вход и выход

Ваш ввод представляет собой прямоугольный двумерный массив битов размером не менее 1 × 1 в любом приемлемом формате. Массив представляет собой участок земли; 1Это «хорошие» районы, где я мог бы построить свой дом, и 0это «скалистые» районы, где дом не может быть построен.

Ваш вывод должен быть максимальной площадью сплошного прямоугольника 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Ṁ

Попробуйте онлайн! или проверьте все контрольные примеры .

Задний план

Пусть м будет матрицей битов, такой как

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>

При этом используется метод грубой силы на основе двухмерной свертки. Все возможные размеры прямоугольника созданы и свернуты с ландшафтом. Максимальным результатом всех сверток является максимальная площадь прямоугольника.

Это крайне неэффективное решение, потому что для сохранения байтов я создаю ядра для всех прямоугольников между [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 .

• Если так, то ! возвращает сумму записей M , которая равна его площади.

• Если нет, то ! делает следующее:

  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

Оказывается, немного вертеться все еще выигрывает. Принимает массив массив целых чисел. 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;
}

Массив разделен по строкам в соответствии с другими ответами, поэтому каждый возможный диапазон строк циклически повторяется. Учитывая диапазон строк, следующий шаг должен измерить доступные прямоугольники. Это достигается путем объединения строк по битам; Результатом является список битов, которые были установлены во всем диапазоне строк. Затем остается найти максимальную длину установленных битов в строке и умножить ее на высоту диапазона. Тест бесстыдно украден у @ 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, так как они требуют, соответственно, 1 530 831 935 и 2 848 806 121 звонков на 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, если строковое представление M содержит символ 1 .

   Если этого не произойдет , мы возвращаем 0 , вычисленный , как ​`M`.count(`t`)​, сколько раз строковое представление т (т.е. символ 3 , 4 или 5 ) появляется в строке представления М .

3. Если т = 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)звонит ф на М повернуты на четверть оборота против часовой стрелки, увеличивая t чтобы отследить время, когда мы повернули эту конкретную подматрицу в этой ветви.

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

6. Наконец, maxвозвращает максимум возвращаемых значений из рекурсивных вызовов.

JavaScript (ES6), 154 176

Редактировать попытался немного сократить, но не может конкурировать с решением @ Neil

Попробуйте все возможные прямоугольники, верните максимальный размер. Вероятно, тот же алгоритм ответа Matl, только в 6 раз дольше.
Ввод как двумерный массив целых

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

Спасибо Kroppeb за 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
      }
}

Stax , 14 байт

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

Запустите и отладьте его

Matlab 106 байт

x=input('');[n,k]=size(x);r=0;for p=1:n;for m=1:k;r=max([p*m*(any(conv2(x,ones(p,m))==p*m)),r]);end;end;r

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

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

Matlab (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.