Arka fon

Bir arsa almak ve evimi üzerine inşa etmek istiyorum. Evim dikdörtgen olmalı ve mümkün olduğunca büyük olmalıdır; ancak, mevcut araziler üzerine inşa edemediğim çok fazla kayalık alan var ve ben arazilerdeki potansiyel bir evi yerleştirmekte zorlanıyorum. Benim için arazileri analiz eden bir program yazmanı istiyorum.

Giriş ve çıkış

Girişiniz, herhangi bir makul formatta, en az 1 × 1 boyutunda dikdörtgen bir 2D bit dizisidir. Dizi bir arsa temsil eder; 1evimi inşa edebileceğim "iyi" bölgeler ve evin inşa edilemeyeceği 0"kayalık" bölgeler.

Çıktınız, 1giriş dizisindeki katı bir dikdörtgenin maksimum alanı olacaktır . Arsaya yapabileceğim en büyük evin alanını temsil ediyor. 1Girişte s yoksa , çıkışın olduğunu unutmayın 0.

Örnek

Girişi düşünün

101
011
111

S'nin en büyük dikdörtgeni 1sağ alt köşedeki 2 × 2 dikdörtgendir. Bu doğru çıktı olduğu anlamına gelir 4.

Kurallar ve puanlama

Tam bir program veya bir fonksiyon yazabilirsiniz. En düşük bayt sayısı kazanır ve standart boşluklar izin verilmez.

Test durumları

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

Jelly , 21 20 18 17 bayt

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

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Arka fon

M gibi bitlerin matrisi olsun

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

Her M sütunundaki 1 bit sayısını sayarak, 0 biti her karşılaştığımızda sayımı sıfırlayarak başlıyoruz .

Örnek matrisimiz için bu,

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

Sonra, her satırın bitişik tüm alt listelerini hesaplıyoruz. Bunu tüm uzunluk dilimlerini oluşturarak başarırız. , k'nin her satırdaki giriş sayısı ile 1 arasında değiştiği k başarırız.

Sondaki sıra için, bu

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

Sonra, her dilimi minimum ve uzunluğunun ürünüyle eşleştireceğiz. Her dilim için bu , verilen dilimi alt satırda olan maksimum bitlik 1 bitlik bir dikdörtgenin alanını hesaplar .

Uzunluk dilimleri için Örnek matrisimizin sondan bir önceki satırının 3 için bu,

3 3 3 3 12 6 6

Yapması gereken tek şey, tüm satırların bütün dilimlerinde en üst düzeye çıkarmaktır.

Örnek matrisimiz için bu, 12 .

Nasıl çalışır

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

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

Bu, kaba kuvvet 2B evrişim tabanlı bir yaklaşım kullanır. Tüm olası dikdörtgen boyutları arazi ile oluşturulmuş ve sarılmıştır. Tüm evrişimin maksimum sonucu, maksimum dikdörtgen alandır.

Bu son derece verimsiz bir çözüm çünkü baytları kurtarmak için arasındaki tüm dikdörtgenler için çekirdekler oluşturuyorum [1, 1] ve [numel(input) numel(input)]oldukça aslında satır sayısını belirlemek yerine / giriş sütunlar uygun dikdörtgen boyut aralıkları tespit etmek.

Kullanımını öneren @Luis için teşekkürler M ve ihmal etmek .]] .

Çevrimiçi Deneyin!

açıklama

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

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

Çevrimiçi deneyin!Son test olayı TIO'nun zaman sınırını aşıyor, ancak yerel olarak doğruladım.

Nasıl çalışır

İlk önce ! matris argümanının M tamamen 1 'den ibaret olup olmadığını kontrol eder .

• Eğer öyleyse ! M'nin girişine, alanına eşit olan toplamı döndürür .

• Eğer değilse ! aşağıdakileri yapar:

  1. Döndürme M ile , 0 ° , 90 ° , 180 ° ve 270 ° saat yönünde döndürür.

  2. Dört dönüşün her birinin ilk sırasını kaldırın, en üst sıra, alt sıra, en soldaki sütun ve en sağdaki M sütununu etkin biçimde kaldırın .

  3. Her alt materisteki özyinelemeli kendisini arayın.

  4. Özyinelemeli aramalardan dönüş değerlerinin maksimumunu döndür.

JavaScript (ES6), 97 bayt

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

Bit twiddling hala kazanıyor çıkıyor. Bir tamsayı dizisini kabul eder. 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;
}

Dizi, diğer cevaplara göre sıralar halinde dilimlenir, bu nedenle olası her sıra aralığı ilmeklenir. Bir dizi satır göz önüne alındığında, bir sonraki adım mevcut dikdörtgenleri ölçmektir. Bu, satırları bitsel olarak ANDing yaparak elde edilir; Sonuç, tüm satır aralığında ayarlanan bitlerin bir listesidir. Daha sonra sıradaki set bitlerinin maksimum uzunluğunu bulmak için kalır ve bunu aralığın yüksekliğiyle çarpın. @ Ed65 den utanmadan çalınan testi yapın:

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 bayt

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

Giriş, bir kayıt listesidir. Daha küçük test durumları olun burada ve daha büyük test durumları burada .

Gereksinim duydukları olarak memoization olmadan, son iki test durumları, Ideone zamanı sınırını aşan solunum., 1530831935 ve 2848806121 için çağrılar f alır 39 ve 72 dakika .

Algoritma

Belirli bir M matrisi için , genel fikir, M'nin tüm alt matematiği üzerinde, üst sıraları çıkararak ve çeyrek dönüşleri saat yönünün tersine döndürerek yineleyerek, tamamen 1'den oluşan karşılaşılan alt matrislerin boyutlarını izlemektir. bitten .

Yukarıdaki fikrin basit bir özyinelemeli uygulamasını oynamak , aşağıdakileri yapan f (M) fonksiyonuna yol açar .

1. Eğer M bir içermez 0 bit sayısını geri 1 bit.

2. M'yi iki kez daha önce döndürdüysek ve 1 bit içermiyorsa , 0 döndür .

3. Biz döndürülmüş varsa M zaten beş kez, iade 0 .

4. Yinelemeli çağrı f üzerindeki M üst satırda olmadan.

5. Ardışık olarak M çağrısı f , saat yönünün tersine çeyrek tur döndürdü.

6. Özyinelemeli aramalardan dönüş değerlerinin maksimumunu döndür.

kod

Uygulamada, ek bir fonksiyon argümanı kullanmak t varsayılan o 1 zaten bu özel matris döndürülmüş kaç kez takip etmek. Bu , testin başarısız olması durumunda test edip ​`t/3`in`M`​ve geri döndürerek 1 ila 3 adımlarının tek bir adımda yoğunlaştırılmasını sağlar ​`M`.count(`t`)​.

1. Eğer t = 1 olarak , bu dalda daha önce bu özel submatrix döndürülmüş değil.

   t / 3 = 0 , yani True​`t/3`in`M`​ döndürür , M'nin dizgi gösterimi 0 karakterini içeriyorsa .

   Öyle değil, biz dönmek ​`M`.count(`t`)​kez numara, karakterini 1 görünür dize temsilinde M .

   0 bit içermeyen bir matrisin, yalnızca t = 1 olduğunda ortaya çıkabileceğini unutmayın , çünkü bu durumda yinelenmeziz.

2. Eğer 3 ≤ t ≤ 5 ise , bu alt matrisi bu dalda en az iki kere döndürmüştük.

   t / = 1 ila 3 , bu ​`t/3`in`M`​döner doğru dize temsil iff M karakteri içeren 1 .

   Eğer değilse, dönmek 0 olarak hesaplanan ​`M`.count(`t`)​, kaç kez dize temsil t (yani, karakter 3 , 4 ya da 5 ) bir dizi gösterimi görünür M .

3. Eğer t = 6 ise , bu alt sınıfı daha önce bu dalda beş kez döndürdük.

   t / 3 = 2 , False​`t/3`in`M`​ döndürür , çünkü M'nin dizgi gösterimi 2 karakterini içermez .

   Biz dönmek 0 olarak hesaplanır ​`M`.count(`t`)​, kaç kez karakteri 6 dize temsilinde göründüğünü M .

Eğer f zaten dönmedi, kalan adımlar yürütülür.

4. f(M[1:])çağrılar f üzerindeki M üst satırda olmadan. İtibaren t , varsayılan belirtilmemişse , 1 , bu ilk kez bu sinyal, ön karşılaştığında, bu dalda bu özel submatrix.

5. f(zip(*M)[::-1],t+1)çağrılar f üzerinde M artan, bir çeyrek tur yönünün döndürülmüş t döndürülerek bu daldaki bu özel alt matrisi döndürdüğümüz süreyi takip etmek için değerini arttırır.

   Çeyrek dönüş sıralarını sıkıştırma ile elde edilir M karşılık gelen elemanları dizilerini geri birbirleriyle M aktarılması bu nedenle, 'in satır M (yani, alt ve mengene üst satır yerleştirilmesi tersi o satır sırasını tersine çevrilmesi ).

6. Sonunda maxözyinelemeli aramalardan dönüş değerlerinin maksimumunu döndürür.

JavaScript (ES6), 154 176

Düzenle biraz kısaltmaya çalıştı, ancak @ Neil'in çözümüne karşı yarışamıyor

Mümkün olan her dikdörtgeni deneyin, maksimum boyutu döndürün. Muhtemelen Matl'ın aynı algoritması sadece 6 kat daha uzun.
2d tamsayı dizisi olarak giriş

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

Daha az golf oynadı

Bu orjinal algoritma, golf versiyonunun döngüler için bir çok dizi hareket işlevini kötüye kullanması

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
}

Ölçek

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 Genişletilmiş) , 27 23 20 bayt

Adám ve ngn tarafından -3 bayt

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

Çevrimiçi deneyin!

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

2 bayt için Kroppeb'e teşekkürler

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

Çevrimiçi deneyin!

açıklama

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

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}

Çevrimiçi deneyin!

Sade ve basit kaba kuvvet yaklaşımı.

Kontrolsüz kod ve açıklama:

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 bayt

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

Koş ve hata ayıkla

Matlab 106 bayt

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

Döngüdeki işlem conv2(), giriş dizisinin 2B evrişimi ile birlikte p*molanlar dizisi ile başlar . ==p*mSonuçta ortaya çıkan dizinin eşit bir eleman içerip içermediğini kontrol eder p*m. İlgili eleman çevrilir 1, diğer tüm elemanlar çevrilir 0. any()diziyi vektöre dönüştürür. En az bir sıfır olmayan giriş içeren sütunlar 1, aksi takdirde çevrilir 0. p*m*()vektörü p*mböylelikle all 1-s 'e çevirerek çoğaltır p*m. [__,r]köşeli parantezler, elde edilen sonucu, depolanan önceki maksimum alan ile birleştirir r. Son olarak, max()ortaya çıkan vektördeki maksimum değeri bulur.

Matlab (222)(209)

Aslında, bu çözüm bana aynı dil çözümünün iki katı büyüklüğünde olduğu için utanç veriyor ama ... blimey, 6 saattir düşünüyordum! İşin püf noktası Dennis ve Neil'in cevaplarından biraz farklı.

    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

• İşlev olarak adlandırılır

  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,
  

• Fonksiyonun boyutunda matris uzunluğu tanıtılırsa daha fazla bayt tasarruf edebilirim, bununla birlikte, daha fazla golf devam ediyor.

• Bu nasıl ilerler?

  Bu algoritma, asıl matrisi, biraz döndürerek (&), sola doğru kaydırmasını kendisine ekler. Herhangi bir aşamada ortaya çıkan matris başlangıç ​​olarak ayarlanır ve tekrar tekrar yukarı kaydırılır, sonra yeni matrisle baştan tekrar serbest bırakılır. Bu işlem tarafından oluşturulan tüm matrislerin tüm alt öğeleri (original_matrix+shifted_matrix)&shifted_and_original_matrices)çıktıya çıkarılır.

örnek:

     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 bayt

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

Tüm test durumlarını deneyin

Dennis'in Jelly cevabının bir limanı. Test senaryoları, 2B sayı dizisidir; bunu .

Açıklama:

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

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

Çevrimiçi deneyin!

Nasıl

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