1 এর সর্বাধিক আয়তক্ষেত্রটি সন্ধান করুন

Question

পটভূমি

আমি একটি প্লট জমি কিনতে এবং এটিতে আমার বাড়ি তৈরি করতে চাই। আমার বাড়িটি আয়তক্ষেত্রাকার এবং যতটা সম্ভব বড় হওয়া উচিত; তবে উপলব্ধ প্লটগুলির প্রচুর পাথুরে অঞ্চল রয়েছে যা আমি গড়ে তুলতে পারি না, এবং প্লটগুলির উপর একটি সম্ভাব্য ঘর ফিট করতে আমার সমস্যা হচ্ছে। আমি চাই আপনি এমন একটি প্রোগ্রাম লিখুন যা আমার জন্য প্লটগুলি বিশ্লেষণ করে।

ইনপুট এবং আউটপুট

আপনার ইনপুটটি কোনও যুক্তিসঙ্গত বিন্যাসে কমপক্ষে 1 × 1 আকারের বিটগুলির একটি আয়তক্ষেত্র 2D অ্যারে। অ্যারে জমি একটি প্লট প্রতিনিধিত্ব করে; 1গুলি হ'ল "ভাল" অঞ্চল যেখানে আমি নিজের বাড়িটি তৈরি করতে পারি এবং 0সেগুলি হল "পাথুরে" অঞ্চল যেখানে ঘরটি তৈরি করা যায় না।

আপনার আউটপুটটি 1ইনপুট অ্যারের মধ্যে একটি শক্ত আয়তক্ষেত্রের সর্বাধিক অঞ্চল হবে । এটি প্লটটিতে আমি যে বৃহত্তম বাড়িটি তৈরি করতে পেরেছিলাম তার ক্ষেত্রটিকে প্রতিনিধিত্ব করে। নোট করুন যদি ইনপুটটিতে কোনও 1গুলি না থাকে তবে আউটপুট হয়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

Comments

বুলডোজার, 4 বাইট: plow।

— কনর ও'ব্রায়েন

যদি আমার সমাধানটি কেবল 30 × 30 অবধি আয়তক্ষেত্রের জন্য কাজ করে তবে কি ঠিক আছে?

— নীল

@ নীল না, এটি আপনার ভাষা যতটা বড় পরিচালনা করতে পারে তার জন্য প্রায় (অন্তত তাত্ত্বিকভাবে) কাজ করা উচিত।

— জাগারব

আমি কিছু স্নিগ্ধ বিট টুইডলিংয়ের আশা করছিলাম তবে সে ক্ষেত্রে আমি বিরক্ত করব না।

— নীল

সমাধান ঘূর্ণন জন্য অ্যাকাউন্ট প্রয়োজন?

Answer 1

জেলি , 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 বিটের সংখ্যা গণনা দিয়ে শুরু করি , প্রতিবার 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

এরপরে, আমরা প্রতিটি সারির সমস্ত সংক্ষিপ্ত সাবলিস্টগুলি গণনা করি। আমরা দৈর্ঘ্যের কে এর সমস্ত স্লাইস তৈরি করে এটি অর্জন করি , যেখানে কে 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.

Comments

এই ধনী, ডেনিস, আমি তোমাকে জানতাম না। € $

— €€€

সবই টাকার কথা। $ এর জন্য chan এক্সচেঞ্জিং 2 বাইট সংরক্ষণ করা হয়েছে।

— ডেনিস

আমাদের মা পৃথিবীতে আপনি কীভাবে সর্বদা এই জাতীয় চালাক দৃষ্টিভঙ্গি নিয়ে আসেন?

— Leaky নুন

কারন ডেনিস কেবল আউটগল্ফ করে না!

— গ্রিফন - মনিকা

Answer 2

এমএটিএল, 32 31 27 বাইট

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

এটি একটি ব্রুট-ফোর্স 2 ডি কনভোলশন-ভিত্তিক পদ্ধতির ব্যবহার করে। সমস্ত সম্ভাব্য আয়তক্ষেত্রের আকারগুলি ভূখণ্ডের সাথে তৈরি এবং সংহত হয়। সমস্ত কনভোলিউশনের সর্বাধিক ফলাফল সর্বোচ্চ আয়তক্ষেত্র অঞ্চল area

এটি একটি অত্যন্ত অকার্যকর সমাধান কারণ বাইটগুলি সংরক্ষণ করার জন্য, আমি সঠিক আয়তক্ষেত্রের মাত্রা সীমা নির্ধারণের জন্য ইনপুটটিতে সারি / কলামগুলির সংখ্যা নির্ধারণের চেয়ে [1, 1]এবং এর মধ্যে সমস্ত আয়তক্ষেত্রের জন্য কার্নেল তৈরি করি [numel(input) numel(input)]।

এর ব্যবহার 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.

Answer 3

জুলিয়া, 83 60 57 53 বাইট

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

এটি অনলাইন চেষ্টা করুন! শেষ পরীক্ষার কেস টিআইওর সময়সীমা অতিক্রম করেছে, তবে আমি স্থানীয়ভাবে এটি যাচাই করেছি।

কিভাবে এটা কাজ করে

প্রথম ,! এটির ম্যাট্রিক্স আর্গুমেন্ট এম সম্পূর্ণ 1 এর সমন্বিত কিনা তা পরীক্ষা করে ।

• যদি তাই হয় ! এম এর এন্ট্রিগুলির যোগফল প্রদান করে , যা এর ক্ষেত্রফলের সমান।

• না হলে ! নিম্নলিখিতগুলি করে:

  1. ঘোরান এম দ্বারা 0 ° , 90 ° , 180 ° এবং 270 ° ঘড়ির কাঁটার দিকে।

  2. উপরের সারি, নীচের সারি, বামতম স্তম্ভ এবং এম এর ডানদিকের কলামটি কার্যকরভাবে মুছে ফেলা প্রতিটি চারটি ঘূর্ণনের প্রতিটি প্রথম সারি সরান ।

  3. প্রতিটি সাবমেট্রিকগুলিতে নিজেকে পুনরাবৃত্তভাবে কল করুন।

  4. পুনরাবৃত্তির কল থেকে সর্বাধিক রিটার্ন মানগুলি প্রদান করুন।

Answer 4

জাভাস্ক্রিপ্ট (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>

Comments

আমি উত্সাহ দিতে হবে, তবে আপনার খ্যাতি হ'ল 10000000000000 বাইনারি হিসাবে, আমি মনে করি আমি এটি কিছুক্ষণ রেখে দেব।

— স্তর নদী সেন্ট

আমি

— এলোমেলো করে ফেলি

Answer 5

পাইথন 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`)

ইনপুট টিপলগুলির একটি তালিকা। এখানে ছোট পরীক্ষার কেসগুলি এবং বৃহত্তর পরীক্ষার কেসগুলি এখানে যাচাই করুন ।

স্মৃতিচারণ ছাড়াই, শেষ দুটি পরীক্ষার কেস আইডিয়নের সময়সীমা ছাড়িয়ে গেছে, যেমন তাদের প্রয়োজন, শ্রেনী । 1,530,831,935 এবং f তে 2,848,806,121 কল , যা 39 এবং 72 নেয় আমার মেশিনে মিনিট ।

অ্যালগরিদম

প্রদত্ত ম্যাট্রিক্স এম এর জন্য , সাধারণ ধারণাটি হ'ল এম এর সমস্ত সাবম্যাট্রিকগুলি উপরের সারিগুলি সরিয়ে এবং ঘড়ির কাঁটার বিপরীত দিকে ঘুরিয়ে ঘুরিয়ে ঘুরিয়ে ঘুরিয়ে ঘুরিয়ে ঘুরিয়ে ঘুরিয়ে ঘুরিয়ে দেওয়া হয়, সম্পূর্ণরূপে 1 টির সমন্বিত সাবম্যাট্রিকগুলির আকারের ট্র্যাক রেখে বিট দ্বারা

উপরের ধারণার একটি প্রত্যক্ষ পুনরাবৃত্তিমূলক বাস্তবায়ন গল্ফ করা নিম্নলিখিত ফাংশন এফ (এম) এর দিকে পরিচালিত করে।

1. যদি এমতে কোনও 0 বিট না থাকে তবে এর 1 বিট সংখ্যাটি ফিরিয়ে দিন ।

2. আমরা ইতিমধ্যে দু'বার এম ঘোরালে এবং এতে কোনও 1 বিট না থাকলে 0 ফিরে আসুন ।

3. আমরা ইতিমধ্যে এম পাঁচবার ঘোরানো হলে 0 ফিরে ।

4. Recursively কল চ উপর এম তার শীর্ষ সারিতে ছাড়া।

5. Recursively কল চ উপর এম এক চতুর্থাংশ পালা ঘড়ির কাঁটার বিপরীতে ঘুরেছে।

6. পুনরাবৃত্তির কল থেকে সর্বাধিক রিটার্ন মানগুলি প্রদান করুন।

কোড

বাস্তবায়নে আমরা একটি অতিরিক্ত ফাংশন আর্গুমেন্ট টি ব্যবহার করি যা এই নির্দিষ্ট ম্যাট্রিক্সটি ইতিমধ্যে আমরা কতবার ঘুরিয়ে রেখেছি তা ট্র্যাক রাখতে 1 এ ডিফল্ট হয় । এটি পরীক্ষা ব্যর্থ হলে পরীক্ষার মাধ্যমে ​`t/3`in`M`​এবং ফিরে আসার মাধ্যমে 1 থেকে 3 পদক্ষেপকে একক পদক্ষেপে ঘনীভূত করতে দেয় ​`M`.count(`t`)​।

1. যদি টি = 1 , আমরা এই শাখায় আগে এই নির্দিষ্ট সাবম্যাট্রিক্স ঘোরানো হয়নি।

   টি / 3 = 0 , তাই ​`t/3`in`M`​ফিরে আসবে সত্য এর স্ট্রিং উপস্থাপনা iff এম অক্ষর আছে 0 ।

   যদি না হয়, আমরা ফিরে ​`M`.count(`t`)​, যতবার চরিত্র 1 এর স্ট্রিং উপস্থাপনা দেখা এম ।

   মনে রাখবেন যে 0 বিট ছাড়াই ম্যাট্রিক্স কেবলমাত্র টি = 1 হলেই ঘটতে পারে , যেহেতু আমরা এই ক্ষেত্রে পুনরাবৃত্তি করি না।

2. যদি 3 ≤ t ≤ 5 হয় , আমরা পূর্বে এই শাখায় এই নির্দিষ্ট সাবম্যাট্রিক্সকে কমপক্ষে দু'বার ঘোরালাম।

   t / 3 = 1 , সুতরাং এম এর স্ট্রিং উপস্থাপনায় অক্ষর 1 থাকে যদি সত্য​`t/3`in`M`​ ফিরে আসবে ।

   যদি না হয়, আমরা ফিরে 0 হিসেবে নির্ণিত ​`M`.count(`t`)​, বার সংখ্যা স্ট্রিং উপস্থাপনা টি (অর্থাত, চরিত্র 3 , 4 বা 5 ) এর স্ট্রিং উপস্থাপনা দেখা এম ।

3. যদি টি = 6 , আমরা পূর্বে এই শাখায় এই বিশেষ সাবম্যাট্রিক্স পাঁচবার ঘোরালাম।

   t / 3 = 2 , সুতরাং মিথ্যা​`t/3`in`M`​ ফিরিয়ে দেবে , কারণ এম এর স্ট্রিং প্রতিনিধিত্বতে অক্ষর 2 থাকে না ।

   আমরা ফিরে 0 হিসেবে নির্ণিত ​`M`.count(`t`)​, যতবার চরিত্র 6 এর স্ট্রিং উপস্থাপনা দেখা এম ।

যদি f ইতিমধ্যে ফিরে না আসে, তবে বাকি পদক্ষেপগুলি কার্যকর করা হবে।

4. f(M[1:])কল চ উপর এম তার শীর্ষ সারিতে ছাড়া। যেহেতু টি থেকে নির্দিষ্ট করা না হয়, তাহলে অক্ষমতা 1 , সংকেত যে, এই প্রথমবার চ এনকাউন্টার এই শাখায় এই বিশেষ submatrix।

5. f(zip(*M)[::-1],t+1)কল চ উপর এম এক চতুর্থাংশ পালা ঘড়ির কাঁটার বিপরীতে ঘুরেছে, বৃদ্ধিশীল টি সময় আমরা এই শাখায় এই বিশেষ submatrix আবর্তিত করেছেন তার খোঁজ রাখুন।

   কোয়ার্টার পালা সারি zip করা দ্বারা প্রাপ্ত হয় এম একে অপরের সাথে, এর সংশ্লিষ্ট উপাদানের tuples ফেরার এম এর সারি, এইভাবে পক্ষান্তরিত করে এম , তারপর সারি ক্রম reversing (অর্থাত, বিপরীতভাবে নীচে এবং ভাইস এ শীর্ষ সারিতে স্থাপন )।

6. অবশেষে maxপুনরাবৃত্তিকারী কলগুলি থেকে সর্বাধিক রিটার্ন মানগুলি প্রদান করে।

Comments

হুম এই সমস্ত জমাটি কি আলাদা ধারণা? বেশ আকর্ষণীয়, জিপ ফাংশনটি কী করে?

— Abr001am

zipএর যুক্তিগুলির সংশ্লিষ্ট উপাদানগুলির টিপলগুলির একটি তালিকা প্রদান করে। একটি প্যাকযুক্ত 2D তালিকা (ম্যাট্রিক্স) সহ *M, এটি মূলত সারি এবং কলামগুলি স্থানান্তর zip(*M[::-1])করে , তাই 90 ° ঘূর্ণনটি ঘড়ির কাঁটার দিকে সম্পাদন করে।

— ডেনিস

থেক্স, পাইথন একটি আকর্ষণীয়, আমি এটি কোনও দিন শিখব।

— Abr001am

Answer 6

জাভাস্ক্রিপ্ট (ES6), 154 176

সম্পাদনাটি কিছুটা ছোট করার চেষ্টা করেছিল, তবে @ নীলের সমাধানের বিরুদ্ধে প্রতিযোগিতা করতে পারে না

প্রতিটি সম্ভাব্য আয়তক্ষেত্র চেষ্টা করে দেখুন, সর্বোচ্চ আকারটি ফিরিয়ে দিন। সম্ভবত ম্যাটের উত্তরের একই অ্যালগরিদম, মাত্র 6 গুণ বেশি।
পূর্ণসংখ্যার 2 ডি অ্যারে হিসাবে ইনপুট

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>

Answer 7

এপিএল (ডায়ালগ প্রসারিত) , 27 23 20 বাইট

অ্যাডাম এবং এনএনজি দ্বারা -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.

Comments

{⌈/,(×/×1∊⍵⍷⍨⍴∘1)¨⍳⍴⍵}সংক্ষিপ্ত এবং সহজ (এমনকি বর্ধিত প্রয়োজন হয় না)।

— অ্যাডাম

@lirtosiast @ আদম{⌈/∊(×/×⍵⍷⍨⍴∘1)¨⍳⍴⍵}

— ngn

Answer 8

ব্র্যাচল্যাগ , 20 17 15 বাইট

ক্রপপ্যাবকে 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

Comments

aas অনলাইনে চেষ্টা করে

— ক্রপ্পেব

Answer 9

আর , 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
      }
}

Answer 10

স্ট্যাক্স , 14 বাইট

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

এটি চালান এবং এটি ডিবাগ করুন

Answer 11

মতলব 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()ইনপুট অ্যারের 2 ডি কনভোলজেশন দিয়ে শুরু হয় p*mones ==p*mফলাফলের অ্যারেতে সমান উপাদান রয়েছে কিনা তা পরীক্ষা করে p*m। সংশ্লিষ্ট উপাদানটি পরিণত হয় 1, অন্য সমস্ত উপাদানগুলিতে পরিণত হয় 0। any()অ্যারেটিকে ভেক্টরে পরিণত করে। কমপক্ষে একটি ননজারো এন্ট্রি থাকা কলামগুলি 1অন্যথায় পরিণত হয় 0। p*m*()এর p*mফলে সমস্ত 1-গুলিকে রূপান্তর করে ভেক্টরকে গুণিত করে p*m। [__,r]বর্গাকার বন্ধনীগুলি পূর্ববর্তী সর্বাধিক সঞ্চিত অঞ্চলে প্রাপ্ত ফলাফলকে একত্রিত করেr । পরিশেষে, max()ফলাফল ভেক্টরের সর্বাধিক মান সন্ধান করে।

Comments

ফাংশনটি কি করে?

— Abr001am

@ Agawa001 2D অ্যারের মধ্যে প্রতিটি কলামের জন্য any()আয় 1যদি কলামটি একটি অশূন্য উপাদান রয়েছে এবং 0অন্যথায়।

— brainkz

Answer 12

মতলব (222)(209)

প্রকৃতপক্ষে, এই সমাধানটি আসল ভাষার ভাষার দ্বিগুণ আকারের হয়ে যাওয়ার জন্য আমার লজ্জা এনে দিয়েছে তবে ... ব্লিমি, আমি এটি 6 ঘন্টা ধরে ভাবছিলাম! এবং কৌশলটি ডেনিস এবং নীলের উত্তর থেকে কিছুটা আলাদা build

    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

Answer 13

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

Answer 14

জে , 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.