バックグラウンド

土地を購入して、その上に家を建てたいです。私の家は長方形で、できるだけ大きくなければなりません。しかし、利用可能なプロットには、私が構築できない岩の多いエリアがたくさんあり、プロットに潜在的な家を当てるのに苦労しています。私にプロットを分析するプログラムを書いてほしい。

入出力

入力は、妥当な形式の、少なくとも1×1サイズの長方形の2Dビット配列です。配列は土地のプロットを表します。1sは家を建てることができる「良い」エリアであり、0sは家を建てることができない「岩だらけの」エリアです。

出力は1、入力配列内のsの塗りつぶされた長方形の最大領域になります。それは、私がプロット上で構築できる最大の家の面積を表しています。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Ṁ

オンラインでお試しください！または、すべてのテストケースを確認します。

バックグラウンド

ましょMは、のようなビットの行列であります

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

Mの各列の1ビットの数をカウントすることから始め、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と各行のエントリ数の間で変化します。

最後から2番目の行については、これにより

[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のスライスの場合例のマトリックスの最後から2番目の行の場合、これは

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>

これは、ブルートフォース2D畳み込みベースのアプローチを使用します。可能なすべての長方形サイズが作成され、地形と畳み込まれます。すべての畳み込みの最大結果は、長方形の最大面積です。

バイトを節約するために、私は間の全ての長方形のためのカーネルを作成するので、これは非常に非効率的な解決策である[1, 1]と[numel(input) numel(input)]、むしろ実際の行の数を決定するよりも/入力の列が適切な長方形の寸法範囲を決定します。

の使用方法を提案し、M省略した@Luisに感謝し]]ます。

オンラインでお試しください！

説明

        % 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. 4つの回転のそれぞれの最初の行を削除し、Mの一番上の行、一番下の行、一番左の列、一番右の列のいずれかを効果的に削除します。

  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

少しいじることはまだ勝ちます。整数の配列の配列を受け入れます。ゴルフをしていない：

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

配列は、他の回答に従って行ごとにスライスされるため、可能な各行範囲がループオーバーされます。行の範囲が与えられたら、次のステップは使用可能な長方形を測定することです。これは、行をビット単位でAND結合することにより実現されます。結果は、行の範囲全体に設定されたビットのリストです。次に、行内の設定ビットの最大長を見つけ、それに範囲の高さを掛けます。@ 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>

パイソン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`)

入力はタプルのリストです。ここで小さいテストケースを確認し、ここで大きいテストケースを確認します。

彼らが必要とするメモ化せずに、最後の2つのテストケースは、Ideoneの時間制限を超えて、RESP。、1530831935と2848806121の呼び出しFとり、39と72私のマシン上で分。

アルゴリズム

与えられた行列Mに対して、一般的な考えは、最上行を削除し、反時計回りに4分の1回転させて、Mのすべての部分行列を反復し、1ビットのみで構成される遭遇した部分行列のサイズを追跡することです。

上記のアイデアを簡単に再帰的に実装すると、次のことを行う関数f（M）になります。

1. Mに0ビットが含まれていない場合、1ビットの数を返します。

2. Mを既に2回回転させており、1ビットが含まれていない場合は、0を返します。

3. Mをすでに5回回転している場合、0を返します。

4. Mの最上行なしで再帰的にfを呼び出します。

5. 反時計回りに1/4回転したMで再帰的にfを呼び出します。

6. 再帰呼び出しからの戻り値の最大値を返します。

コード

実装では、デフォルトで1に設定される追加の関数引数tを使用して、この特定の行列を既に回転させた回数を追跡します。これにより、テストが失敗した場合にテストして戻り、ステップ1から3を1つのステップにまとめることができます。​`t/3`in`M`​​`M`.count(`t`)​

1. t = 1の場合、このブランチで以前にこの特定のサブマトリックスを回転していません。

   t / 3 = 0なので、Mの文字列表現に文字0が含まれている場合にTrue​`t/3`in`M`​を返します。

   そうでない場合は、我々は戻る​`M`.count(`t`)​、回数文字1つの文字列表現に表示されますM。

   0ビットのない行列は、t = 1の場合にのみ発生することに注意してください。この場合は再帰しないためです。

2. 3≤t≤5の場合、このブランチでこの特定の部分行列を少なくとも2回回転させました。

   t / 3 = 1なので、Mの文字列表現に文字1が含まれている場合にTrue​`t/3`in`M`​を返します。

   そうでない場合は、我々は返す0として計算​`M`.count(`t`)​、回数の文字列表現トン（すなわち、文字3、4または5）の文字列表現に表示されますM。

3. t = 6の場合、このブランチでこの特定の部分行列を5回回転させました。

   t / 3 = 2の場合、Mの文字列表現には文字2が含まれないため、False​`t/3`in`M`​が返されます。

   我々は返す0として計算​`M`.count(`t`)​、回数が文字6つの文字列表現に表示されますM。

fがまだ戻っていない場合、残りのステップが実行されます。

4. f(M[1:])fを呼び出すMの最上行なしで。tは指定されていないため、デフォルトで1になります。これは、fがこのブランチでこの特定の部分行列に遭遇するのが初めてであることを示しています。

5. f(zip(*M)[::-1],t+1)Mでfを反時計回りに4分の1回転させて呼び出し、tをインクリメントして、このブランチのこの特定のサブマトリックスを回転させた時間を追跡します。

   クォーターターンは、 Mをの対応する要素の互いに、復帰タプルとM従って転置、の行Mを次に行（すなわち、底部の上部の行を配置し、その逆の順序を逆に、 ）。

6. 最後に max、再帰呼び出しからの戻り値の最大値を返します。

JavaScript（ES6）、154 176

編集は少し短くしようとしましたが、@ Neilのソリューションと競合することはできません

可能なすべての長方形を試して、最大サイズを返します。おそらくMatlの答えと同じアルゴリズムで、わずか6倍長くなります。
整数の2D配列として入力

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

少ないゴルフ

これは元のアルゴリズムです。ゴルフバージョンでは、forループの代わりに多くの配列移動関数を乱用します

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バイト

Adámおよびngnによる-3バイト

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

Brachylog、20 17 15バイト

2バイトのKroppebに感謝

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

スタックス、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

ゴルフをしていない：

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()入力配列と1のp*m配列の2D畳み込みから始まります。==p*m結果の配列にに等しい要素が含まれているかどうかを確認しp*mます。対応する要素はになり1、他のすべての要素はになり0ます。any()配列をベクトルに変換します。1それ以外の場合、少なくとも1つの非ゼロエントリを含む列が有効になります0。これにより、すべての-s をに変えることでp*m*()ベクトルを乗算します。角括弧は、取得された結果を、に保存された以前の最大領域と連結します。最後に、結果のベクトルの最大値を見つけます。p*m1p*m[__,r]rmax()

Matlab （222）（209）

実際、このソリューションは、実際の同じ言語のソリューションを2倍にしたことに対して恥ずかしい思いをしましたが、...気の毒ですが、私は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

すべてのテストケースを試す

ほぼデニスのジェリーの回答のポート。テストケースは、単純に2Dの数値配列であり、質問の形式から変換されますこれ。

説明：

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