सी ++ एक सरणी का क्रमपरिवर्तन जिसमें किसी अन्य सरणी से छोटे मान होते हैं

इस ट्यूटोरियल में हमें दो एरे, ए और बी दिए गए हैं। उदाहरण के लिए, हमें A के किसी भी क्रमपरिवर्तन को आउटपुट करने की आवश्यकता है ताकि सूचकांक जिसके लिए A[ I ]> B[ I ] अधिकतम हो, उदाहरण के लिए

Input: A = [12, 22, 41, 13],
B = [1, 20, 10, 12]
Output: 12, 22, 41, 13

Input: A = [2, 5, 9, 7],
B = [1, 12, 4, 54]
Output: 2 7 5 9

Multiple answers can be present in that case we are simply going to print any one of the answers.

इस समस्या में, हमें उन सूचकांकों को अधिकतम करने की आवश्यकता है जहां A[ i ]> B[ i ], इसलिए हम इस समस्या को लालच से हल करने जा रहे हैं।

समाधान खोजने के लिए दृष्टिकोण

इस दृष्टिकोण में, हम पहले दोनों सरणियों को अब क्रमबद्ध करेंगे; हम एरे बी के प्रत्येक इंडेक्स के लिए लालच से जांच करते हैं कि ए [i] इससे अधिक महत्वपूर्ण है और फिर उस तत्व को वेक्टर में रखें।

उदाहरण

#include <bits/stdc++.h>
using namespace std;
int main(){
    int A[] = { 2, 5, 9, 7 };
    int B[] = { 1, 12, 4, 54 };
    int n = sizeof(A) / sizeof(int); // size of our arrays
    vector<pair<int, int> > A_pair, B_pair;
    /***********************We are linking element to its position***********/
    for (int i = 0; i < n; i++)
        A_pair.push_back({A[i], i});
    for (int i = 0; i < n; i++)
        B_pair.push_back({B[i], i});
    /***********************************************************************/
    /*****Sorting our pair vectors********************/
    sort(A_pair.begin(), A_pair.end());
    sort(B_pair.begin(), B_pair.end());
    int i = 0, j = 0, ans[n];
    memset(ans, -1, sizeof(ans)); // initializing all the elements with value -1
    vector<int> remaining; // this will store our elements which have lesser value than elemnt present in B.
    while (i < n && j < n) {
        // as our array is sorted then if we find any element in
        //current index which has less value than B of current index then
        // automatically it will have less value than other elements of B
        // that's why we push such indices in remaining otherwise we push element in ans
        if (A_pair[i].first > B_pair[j].first) {
            ans[B_pair[j].second] = A_pair[i].first;
            i++;
            j++;
        }
        else {
            remaining.push_back(i);
            i++;
        }
    }
    j = 0;
    for (int i = 0; i < n; ++i){
        // now if any index of answer is unchanged so that means
        //we need to fill that position with the remaining elements
        if (ans[i] == -1){
            ans[i] = A_pair[remaining[j]].first;
            j++;
        }
    }
    for (int i = 0; i < n; i++) // printing our answer
        cout << ans[i] << " ";
    return 0;
}

आउटपुट

2 7 5 9

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

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

निष्कर्ष

इस ट्यूटोरियल में, हम किसी अन्य सरणी से छोटे मानों वाले सरणी के क्रमपरिवर्तन को खोजने के लिए एक समस्या का समाधान करते हैं। हमने इस समस्या के लिए C++ प्रोग्राम और हमारे द्वारा हल किए गए संपूर्ण दृष्टिकोण को भी सीखा। हम उसी प्रोग्राम को अन्य भाषाओं जैसे सी, जावा, पायथन और अन्य भाषाओं में लिख सकते हैं। हमें उम्मीद है कि आपको यह ट्यूटोरियल मददगार लगा होगा।