C++ में ऐरे के अधिकतम एलिमेंट्स गिनना जिनका निरपेक्ष अंतर K से अधिक नहीं है

हमें एक ऐरे दिया गया है मान लीजिए arr[] पूर्णांक एलिमेंट्स का किसी भी दिए गए आकार का और एक सकारात्मक पूर्णांक k और कार्य उन एलिमेंट जोड़ियों की संख्या की गणना करना है जिनका निरपेक्ष अंतर दिए गए पूर्णांक k से अधिक नहीं है।

ऐरे एक प्रकार की डेटा संरचना है जो एक ही प्रकार के एलिमेंट्स के निश्चित आकार के अनुक्रमिक संग्रह को स्टोर कर सकती है। एक ऐरे का उपयोग डेटा के संग्रह को स्टोर करने के लिए किया जाता है, लेकिन अक्सर एक ऐरे को एक ही प्रकार के वैरिएबल्स के संग्रह के रूप में सोचना अधिक उपयोगी होता है।

उदाहरण

इनपुट: int arr[] = {2, 3, 6, 12, 14}, k = 5 आउटपुट: count is: 3

व्याख्या: अधिकतम निरपेक्ष अंतर k यानी 5 से अधिक नहीं होने वाले जोड़े इस उदाहरण में बने जोड़े हैं: (2, 3), (2, 6), (3,6) यानी {2, 3, 6} इसलिए काउंट 3 है।

इनपुट: int arr[] = {2, 3, 6, 12, 14}, k = 10 आउटपुट: count is: 4

व्याख्या: अधिकतम निरपेक्ष अंतर k यानी 10 से अधिक नहीं होने वाले जोड़े इस उदाहरण में बने जोड़े हैं: (2, 3), (2, 6), (3,6), (2, 12), (3, 12), (6, 12) यानी {2, 3, 6, 12} इसलिए काउंट 4 है क्योंकि अधिकतम एलिमेंट्स 4 हैं।

इनपुट: int arr[] = {2, 3, 6, 12, 14}, k = 0 आउटपुट: count is: 0

व्याख्या: चूंकि अंतर 0 वाली कोई जोड़ी नहीं है इसलिए काउंट 0 है।

उपयोग किया गया दृष्टिकोण:

• एक ऐरे बनाएं मान लीजिए arr[] और एक सकारात्मक पूर्णांक k
• length() फ़ंक्शन का उपयोग करके ऐरे की लंबाई की गणना करें
• एलिमेंट्स की संख्या स्टोर करने के लिए एक अस्थायी वैरिएबल लें
• दो अस्थायी वैरिएबल घोषित करें मान लीजिए first और last और 0 से इनिशियलाइज़ करें
• सॉर्ट मेथड को कॉल करें ऐरे को सॉर्ट करने के लिए और ऐरे और ऐरे के आकार को फ़ंक्शन के तर्क के रूप में पास करें
• i के लिए 0 से लूप शुरू करें और i ऐरे के आकार से कम हो
  • लूप के अंदर, जब तक j < आकार && arr[j] <= arr[i] + k शुरू करें
    • जबकि के अंदर, जांचें यदि काउंट < j-i तो काउंट को j - i पर सेट करें और first को i और last को j पर सेट करें
• काउंट वापस करें
• परिणाम प्रिंट करें।

उदाहरण (C++ कोड)

#include <iostream> 
#include <algorithm> 
using namespace std; 
int countmax(int arr[], int size, int K){ 
    int result = 0; 
    int i = 0, j = 0; 
    int beg = 0; 
    int end = 0; 
    // ऐरे को सॉर्ट करें 
    sort(arr, arr + size); 
    // अधिकतम एलिमेंट्स ढूंढें 
    for (i = 0; i < size; i++) { 
        // उन सभी एलिमेंट्स को गिनें जो रेंज में हैं 
        while (j < size && arr[j] <= arr[i] + K) 
            j++; 
        if (result < (j - i)) { 
            result = (j - i); 
            beg = i; 
            end = j; 
        } 
    } 
    // अधिकतम काउंट वापस करें 
    return result; 
} 
// मुख्य फ़ंक्शन 
int main(){ 
    int arr[] = { 2, 3, 6, 12, 14 }; 
    int size = sizeof(arr) / sizeof(arr[0]); 
    int K = 5; 
    cout << "count is " << countmax(arr, size, K) << endl; 
    return 0; 
}

आउटपुट

count is 3