C++ का उपयोग करके एरे में सभी तत्वों की रैंक ज्ञात करना

दिए गए समस्या में, हमें एरे के सभी दिए गए तत्वों को रैंक करने की आवश्यकता है, जिसमें सबसे छोटी संख्या की सबसे छोटी रैंक और सबसे बड़ी की सबसे बड़ी रैंक हो। हमें किसी संख्या की रैंक को उसकी आवृत्ति के आधार पर भी बदलना होगा। उदाहरण के लिए:

इनपुट: 20 30 10
आउटपुट: 2.0 3.0 1.0

इनपुट: 10 12 15 12 10 25 12
आउटपुट: 1.5, 4.0, 6.0, 4.0, 1.5, 7.0, 4.0
यहाँ 10 की रैंक 1.5 है क्योंकि दिए गए एरे में दो 10 मौजूद हैं। यदि हम मान लें कि वे अलग-अलग रैंक लेते हैं यानी 1 और 2, और हम इसे उनके बीच विभाजित करते हैं, तो उनकी रैंक 1.5 और 1.5 हो जाती है।

इनपुट: 1, 2, 5, 2, 1, 60, 3
आउटपुट: 1.5, 3.5, 6.0, 3.5, 1.5, 7.0, 5.0

समाधान का दृष्टिकोण

समाधान खोजने के दो अलग-अलग दृष्टिकोण हैं:

ब्रूट फोर्स दृष्टिकोण

इस दृष्टिकोण में, हम लूप करेंगे, किसी विशेष तत्व का चयन करेंगे, और उसकी रैंक निर्धारित करेंगे।

उदाहरण

#include <bits/stdc++.h>
using namespace std;

int main() {
    int arr[] = {1, 2, 5, 2, 1, 25, 2}; // दिया गया एरे
    int n = sizeof(arr) / sizeof(arr[0]); // हमारे दिए गए एरे का आकार
    float rank[n] = {0}; // हमारी रैंकिंग एरे
    
    for (int i = 0; i < n; i++) {
        int r = 1; // arr[i] से छोटे तत्वों की संख्या
        int s = 1; // arr[i] के बराबर तत्वों की संख्या
        
        for (int j = 0; j < n; j++) {
            if (j != i && arr[j] < arr[i])
                r += 1;
            if (j != i && arr[j] == arr[i])
                s += 1;
        }
        
        rank[i] = r + (float)(s - 1) / (float)2; // किसी विशेष तत्व की रैंक प्राप्त करने के लिए फॉर्मूला का उपयोग
    }
    
    for (int i = 0; i < n; i++) // रैंक आउटपुट करना
        cout << rank[i] << ' ';
    
    return 0;
}

आउटपुट

1.5 4 6 4 1.5 7 4

इस प्रोग्राम की समय जटिलता O(N*N) है जहां N दिए गए एरे का आकार है। जैसा कि आप देख सकते हैं, हमारी समय जटिलता अच्छी नहीं है, इसलिए हम इसकी दक्षता बढ़ाएंगे ताकि यह उच्च प्रतिबंधों के लिए अच्छा काम करे।

कुशल दृष्टिकोण

इस दृष्टिकोण में, हम एक नया एरे लेंगे और उसे सॉर्ट करेंगे। अब चूंकि एरे सॉर्ट हो गया है, हम जानते हैं कि समान रैंक वाले सभी तत्व एक साथ होंगे, इसलिए अब हम उन्हें सामान्य रूप से रैंक करते हैं और फिर किसी विशेष तत्व की रैंक की गणना करते हैं।

उदाहरण

#include <bits/stdc++.h>
using namespace std;

int main() {
    int arr[] = {1, 2, 5, 2, 1, 60, 3}; // दिया गया एरे
    int n = sizeof(arr) / sizeof(arr[0]); // हमारे दिए गए एरे का आकार
    float rank[n] = {0}; // हमारी रैंकिंग एरे
    int old[n];
    
    for(int i = 0; i < n; i++)
        old[i] = arr[i];
    
    sort(arr, arr+n); // एरे को सॉर्ट करना
    
    int prev = arr[0];
    int r = 1; // रैंक
    int s = 0; // आवृत्ति
    int tot = 0; // एक तत्व द्वारा समाहित सभी रैंक को स्टैक करेगा
    map<int, float> rrank;
    
    for (int i = 0; i < n; i++) {
        if(prev == arr[i]) {
            s++;
            tot += r;
        } else {
            float now = 0;
            now = (float)tot/s; // रैंक को समान रूप से विभाजित करना
            rrank[prev] = now;
            prev = arr[i];
            tot = r;
            s = 1;
        }
        r++;
    }
    
    rrank[arr[n-1]] = (float)tot/s;
    
    for (int i = 0; i < n; i++) // रैंक आउटपुट करना
        cout << rrank[old[i]] << " ";
    
    return 0;
}

आउटपुट

1.5 3.5 6 3.5 1.5 7 5

उपरोक्त कोड की व्याख्या

इस दृष्टिकोण में, हम अपने एरे को सॉर्ट करते हैं, और फिर हम प्रत्येक तत्व को शुरुआत से रैंक करते हैं (रैंक 1 से शुरू होती है)। अब, यदि हमारा पिछला तत्व हमारे वर्तमान तत्व के बराबर है, तो हम s बढ़ाते हैं और अपनी रैंक के योग को स्टैक करते हैं। जब हमारे तत्व बदलते हैं, तो हम पिछले तत्वों के बीच रैंक को विभाजित करते हैं, s और टोटल को रीफ्रेश करते हैं, और अपना कोड जारी रखते हैं।

निष्कर्ष

इस लेख में, हम एरे में सभी तत्वों की रैंक ज्ञात करने की समस्या को हल करते हैं। हमने इस समस्या के लिए C++ प्रोग्राम और इसे हल करने के पूर्ण दृष्टिकोण (सामान्य और कुशल) को भी सीखा। हम इसी प्रोग्राम को C, Java, Python और अन्य भाषाओं में लिख सकते हैं।