C++ में ऐरे से चार पक्ष चुनकर अधिकतम क्षेत्रफल वाला आयत

आयत का क्षेत्रफल उसकी भुजाओं के गुणनफल के रूप में गणना किया जाता है। सभी आयतों में चार भुजाएं होती हैं जिनमें विपरीत भुजाएं समान होती हैं। क्षेत्रफल की गणना के लिए हमें लंबाई और चौड़ाई के रूप में दो भुजाओं की आवश्यकता होती है। ताकि हम वांछित परिणाम प्राप्त कर सकें:

आयत का क्षेत्रफल = लंबाई × चौड़ाई

हमें एक ऐरे दिया गया है जिसमें आयत की भुजाएं होती हैं। ऐरे में चारों भुजाओं के मान रैंडम ऑर्डर में होते हैं। यहां कार्य ऐरे से भुजाओं के दो उच्चतम जोड़े ढूंढना है ताकि आयत के लिए अधिकतम संभव क्षेत्रफल प्राप्त किया जा सके।

इनपुट

Arr[] = { 1,2,1,3,4,4,2,3,5,7 }

आउटपुट - ऐरे से चार पक्ष चुनकर अधिकतम क्षेत्रफल वाला आयत: 12

व्याख्या - यदि हम दिए गए ऐरे को अवरोही क्रम में सॉर्ट करते हैं तो हमें मिलता है:

Arr[] = { 7,5,4,4,3,3,2,1,1 }

यहां भुजाओं के दो जोड़े (कुल चार भुजाएं) जो अधिकतम हैं: { (4,4), (3,3) }। इसलिए वांछित अधिकतम संभव क्षेत्रफल 12 वर्ग इकाई है।

इनपुट

Arr[] = { 8,2,5,3,4,9,8,3,5,7 }

आउटपुट - ऐरे से चार पक्ष चुनकर अधिकतम क्षेत्रफल वाला आयत: 40

व्याख्या - यदि हम दिए गए ऐरे को अवरोही क्रम में सॉर्ट करते हैं तो हमें मिलता है:

Arr[] = { 9,8,8,7,5,5,4,3,3,2 }

यहां भुजाओं के दो जोड़े (कुल चार भुजाएं) जो अधिकतम हैं: { (8,8), (5,5) }। इसलिए वांछित अधिकतम संभव क्षेत्रफल 40 वर्ग इकाई है।

नीचे दिए गए प्रोग्राम में उपयोग किया गया दृष्टिकोण

• एक पूर्णांक ऐरे घोषित करें जिसमें आयत की भुजाओं के जोड़े हों (Arr[])
• ऐरे का आकार संग्रहीत करने के लिए एक वेरिएबल बनाएं (n)
• फंक्शन maxArea(int arr[], int n) का उपयोग आयत के लिए अधिकतम क्षेत्रफल की गणना के लिए किया जाता है। यह इनपुट ऐरे और उसके आकार को आर्गुमेंट्स के रूप में लेता है।
• maxArea() के अंदर हम एक ऐरे Dim[2] घोषित करते हैं जो सॉर्ट किए गए ऐरे (अवरोही क्रम में) arr[] को पार करने के बाद मिली दो उच्चतम भुजाओं को संग्रहीत करता है।
• चूंकि arr[] अवरोही क्रम में सॉर्ट है, इसलिए उच्चतम 4 भुजाएं शुरुआत में होनी चाहिए। हम arr[] को इस तरह पार करते हैं कि भुजाओं का एक जोड़ा मिले।
• Dim[] को पहले 0 से इनिशियलाइज़ करें।
• व्हाइल लूप के अंदर हम शर्त रखते हैं कि यह तब तक जारी रहे जब तक j < 2 (यानी dim[0] और dim[1] के लिए कोई मान नहीं मिला) या arr[] का अंत नहीं पहुंच जाता (i < n)।
• यदि भुजाओं का ऐसा जोड़ा मिलता है (if(arr[i] == arr[i+1])) तो इसे dim[j] में संग्रहीत करें और अगली भुजा के लिए j को बढ़ाएं।
• परिणाम को dim[0] और dim[1] के गुणनफल के रूप में रिटर्न करें।
• नोट - sort(arr, n) माना जाता है कि arr को अवरोही क्रम में सॉर्ट करता है।

उदाहरण

#include <iostream>
#include <algorithm>
using namespace std;

// आयत के लिए अधिकतम क्षेत्रफल खोजने का फंक्शन
int maxArea(int arr[], int n) {
    int dim[2] = {0};
    int i = 0, j = 0;
    // अवरोही क्रम में सॉर्ट करें
    sort(arr, arr + n, greater<int>());
    
    while (j < 2 && i < n - 1) {
        if (arr[i] == arr[i + 1]) {
            dim[j++] = arr[i];
            i += 2; // जोड़ा मिल गया, अगले जोड़े पर जाएं
        } else {
            ++i;
        }
    }
    return dim[0] * dim[1];
}

// ड्राइवर फंक्शन
int main() {
    int arr[] = { 1, 8, 5, 1, 8, 2, 5, 3 };
    int n = 8;
    cout << "Maximum area of rectangle by picking four sides from array: " << maxArea(arr, n);
    return 0;
}

आउटपुट

Maximum area of rectangle by picking four sides from array: 40