พื้นหลัง

ฉันต้องการซื้อที่ดินและสร้างบ้านของฉันบนมัน บ้านของฉันควรเป็นรูปสี่เหลี่ยมผืนผ้าและมีขนาดใหญ่ที่สุด อย่างไรก็ตามพล็อตที่มีอยู่นั้นมีพื้นที่หินมากมายที่ฉันไม่สามารถสร้างได้และฉันมีปัญหากับการสร้างบ้านที่มีศักยภาพบนที่ดิน ฉันต้องการให้คุณเขียนโปรแกรมที่วิเคราะห์แปลงให้ฉัน

อินพุตและเอาต์พุต

ข้อมูลที่คุณป้อนเป็นบิต 2 มิติรูปสี่เหลี่ยมผืนผ้าขนาดอย่างน้อย 1 × 1 ในรูปแบบที่เหมาะสม อาร์เรย์แสดงให้เห็นถึงที่ดิน 1มีพื้นที่ "ดี" ที่ฉันสามารถสร้างบ้านของฉันและพื้นที่0เป็น "หิน" ที่ไม่สามารถสร้างบ้านได้

เอาต์พุตของคุณจะต้องเป็นพื้นที่สูงสุดของสี่เหลี่ยมทึบของ1s ในอาร์เรย์อินพุต มันหมายถึงพื้นที่ของบ้านที่ใหญ่ที่สุดที่ฉันสามารถสร้างบนที่ดิน โปรดทราบว่าถ้าไม่มี1s 0ในการป้อนข้อมูลแล้วส่งออกเป็น

ตัวอย่าง

พิจารณาอินพุต

101
011
111

สี่เหลี่ยมที่ใหญ่ที่สุดคือสี่เหลี่ยม12 × 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

เราเริ่มต้นด้วยการนับจำนวน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>

สิ่งนี้ใช้วิธีการโน้มน้าว 2D บนพื้นฐานของเดียรัจฉาน ขนาดสี่เหลี่ยมผืนผ้าที่เป็นไปได้ทั้งหมดจะถูกสร้างและโน้มน้าวกับภูมิประเทศ ผลลัพธ์สูงสุดของการโน้มน้าวใจทั้งหมดคือพื้นที่สี่เหลี่ยมผืนผ้าสูงสุด

นี่เป็นวิธีที่ไม่มีประสิทธิภาพอย่างยิ่งเพราะเพื่อประหยัดไบต์ฉันสร้างเมล็ดสำหรับสี่เหลี่ยมทุกรูปแบบระหว่าง[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.

Julia, 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. ลบแถวแรกของแต่ละการหมุนสี่อันออกหนึ่งแถวบนสุดแถวล่างคอลัมน์ด้านซ้ายสุดและคอลัมน์ขวาสุดของ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

ปรากฎว่ายังชนะเล็กน้อย ยอมรับอาร์เรย์ของอาร์เรย์ของจำนวนเต็ม 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;
}

อาร์เรย์จะถูกแบ่งตามแถวตามคำตอบอื่น ๆ ดังนั้นช่วงของแถวที่เป็นไปได้แต่ละอันจะวนเป็นวงกลม กำหนดช่วงของแถวขั้นตอนต่อไปคือการวัดสี่เหลี่ยมผืนผ้าที่มี นี่คือความสำเร็จโดย ANDing แถวกัน bitwise; ผลลัพธ์คือรายการของบิตที่ตั้งค่าในช่วงของแถวทั้งหมด จากนั้นจะยังคงพบความยาวสูงสุดของบิตการตั้งค่าในแถวและคูณด้วยความสูงของช่วง ทดสอบถูกขโมยลงคอจาก @ 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เราไม่ได้หมุนเมทริกซ์ย่อยนี้ก่อนหน้านี้ในสาขานี้

   ตัน / 3 = 0ดังนั้น​`t/3`in`M`​จะกลับมาทรู IFF แทนสตริงของMมีตัวละคร0

   ถ้ามันไม่ได้เรากลับ​`M`.count(`t`)​, จำนวนครั้งที่ตัวอักษรที่1ปรากฏในการแสดงสตริงของM

   โปรดทราบว่าเมทริกซ์ที่ไม่มี0บิตสามารถเกิดขึ้นได้ก็ต่อเมื่อt = 1เนื่องจากเราไม่ได้รับการชดเชยในกรณีนี้

2. ถ้า3 ≤ t ≤ 5ก่อนหน้านี้เราได้หมุนเมทริกซ์ย่อยนี้อย่างน้อยสองครั้งในสาขานี้

   t / 3 = 1ดังนั้น​`t/3`in`M`​จะส่งคืนTrueถ้าการแทนสตริงของMมีอักขระ1 1

   ถ้ามันไม่ได้เรากลับ0คำนวณ​`M`.count(`t`)​จำนวนครั้งที่แสดงสตริงของT (เช่นตัวละคร3 , 4หรือ5 ) ปรากฏขึ้นในการเป็นตัวแทนสตริงของM

3. ถ้าt = 6เราได้หมุนเมทริกซ์ย่อยนี้ห้าครั้งในสาขานี้

   ตัน / 3 = 2ดังนั้น​`t/3`in`M`​จะกลับเท็จเพราะการเป็นตัวแทนสตริงของเอ็มไม่ได้มีตัวละคร2

   เรากลับ0คำนวณ​`M`.count(`t`)​จำนวนครั้งตัวละคร6ปรากฏในการแสดงสตริงของM

หากfไม่ได้กลับมาแล้วขั้นตอนที่เหลือจะถูกดำเนินการ

4. f(M[1:])เรียกfบนMโดยไม่มีแถวบนสุด เนื่องจากtไม่ได้ระบุมันจะมีค่าเริ่มต้นที่1เพื่อส่งสัญญาณว่านี่เป็นครั้งแรกที่fพบเมทริกซ์ย่อยนี้ในสาขานี้

5. f(zip(*M)[::-1],t+1)เรียกfบนMหมุนหนึ่งรอบในหนึ่งรอบทวนเข็มนาฬิกาเพิ่มค่าtเพื่อติดตามเวลาที่เราหมุนเมทริกซ์ย่อยนี้ในสาขานี้

   การหมุนของไตรมาสนั้นทำได้โดยการซิปแถวของMด้วยกันแล้วส่งคืน tuples ขององค์ประกอบที่สอดคล้องกันของแถวของ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

น้อย golfed

นี่เป็นอัลกอริธึมดั้งเดิมการละเมิดเวอร์ชันอาร์คิเทชั่นจำนวนมากที่มีฟังก์ชั่นการสำรวจอาเรย์มากมายสำหรับลูป

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.

Brachylog , 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

การดำเนินการในลูปเริ่มต้นด้วยการสังวัตนาแบบ 2 มิติconv2()ของอินพุตอาเรย์กับp*mอาเรย์ของสิ่งนั้น ตรวจสอบว่าอาร์เรย์ส่งผลให้มีองค์ประกอบเท่ากับ==p*m p*mองค์ประกอบที่สอดคล้องกันจะหันไป1องค์ประกอบอื่น ๆ 0ทั้งหมดจะหันไป any()เปลี่ยนอาร์เรย์เป็นเวกเตอร์ คอลัมน์ที่มีรายการที่ไม่ใช่ศูนย์อย่างน้อยหนึ่งจะหันไปมิฉะนั้น1 คูณเวกเตอร์ด้วย0p*m*()p*mจึงเปลี่ยนทุก1-s p*mเข้า [__,r]วงเล็บ concatenate rผลที่ได้รับกับพื้นที่มากที่สุดก่อนหน้านี้เก็บไว้ใน สุดท้ายmax()หาค่าสูงสุดในเวกเตอร์ที่ได้

Matlab (222)(209)

ที่จริงแล้ววิธีแก้ปัญหานี้ทำให้ฉันรู้สึกละอายใจที่ได้เป็นสองเท่าของโซลูชันภาษาเดียวกันจริง ๆ แต่ ... blimey ฉันคิดถึงมันเป็นเวลา 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

ลองกรณีทดสอบทั้งหมด

ประมาณพอร์ตของคำตอบ Jelly ของ Dennis กรณีทดสอบเป็นเพียงอาร์เรย์ 2 มิติของตัวเลขซึ่งแปลงจากรูปแบบของคำถามโดยใช้สิ่งนี้นี้

คำอธิบาย:

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