C++ में तीन अलग-अलग क्रमबद्ध सरणियों के लिए (max(A[i], B[j], C[k]) – min(A[i], B[j], C[k])) को न्यूनतम करें

अवधारणा

दिए गए तीन क्रमबद्ध सरणियों A, B, और C के संबंध में जो आवश्यक रूप से समान आकार के नहीं हैं, किसी भी ट्रिपलेट A[i], B[j], C[k] के अधिकतम और न्यूनतम संख्या के बीच न्यूनतम निरपेक्ष अंतर की गणना करें जैसे कि वे क्रमशः सरणियों A, B और C के अंतर्गत हैं, यानी minimize (max(A[i], B[j], C[k]) – min(A[i], B[j], C[k]))।

उदाहरण

इनपुट

A : [ 2, 5, 6, 9, 11 ] B : [ 7, 10, 16 ] C : [ 3, 4, 7, 7 ]

आउटपुट

1

व्याख्या

जब हम A[i] = 6, B[j] = 7, C[k] = 7 चुनते हैं, तो हमें न्यूनतम अंतर मिलता है: max(A[i], B[j], C[k]) - min(A[i], B[j], C[k])) = |7-6| = 1

इनपुट

A = [ 6, 9, 11, 16 ] B = [ 7, 10, 16, 79, 90 ] C = [ 3, 4, 7, 7, 9, 9, 11 ]

आउटपुट

1

व्याख्या

जब हम A[i] = 11, B[j] = 10, C[k] = 11 चुनते हैं, तो हमें न्यूनतम अंतर मिलता है: max(A[i], B[j], C[k]) - min(A[i], B[j], C[k])) = |11-10| = 1

विधि

सरणियों A, B और C में प्रत्येक के सबसे बड़े तत्वों से शुरू करें। प्रत्येक चरण में उत्तर को अपडेट करने के लिए एक चर ट्रैक करें।

प्रत्येक चरण के लिए, अंतर को कम करने का एकमात्र संभावित तरीका तीन तत्वों में से अधिकतम तत्व को कम करना है।

परिणामस्वरूप, इस चरण के लिए अधिकतम तत्व वाले सरणी में अगले सबसे बड़े तत्व पर जाएं और उत्तर चर को अपडेट करें।

इस चरण को तब तक दोहराएं जब तक कि अधिकतम तत्व वाली सरणी समाप्त न हो जाए।

C++ कार्यान्वयन

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

int solve(int A1[], int B1[], int C1[], int i1, int j1, int k1) {
    int min_diff, current_diff, max_term;
    min_diff = abs(max(A1[i1], max(B1[j1], C1[k1])) - min(A1[i1], min(B1[j1], C1[k1])));
    while(i1 != -1 && j1 != -1 && k1 != -1) {
        current_diff = abs(max(A1[i1], max(B1[j1], C1[k1])) - min(A1[i1], min(B1[j1], C1[k1])));
        if(current_diff < min_diff)
            min_diff = current_diff;
        max_term = max(A1[i1], max(B1[j1], C1[k1]));
        if(A1[i1] == max_term)
            i1 -= 1;
        else if(B1[j1] == max_term)
            j1 -= 1;
        else
            k1 -= 1;
    }
    return min_diff;
}

int main() {
    int D1[] = { 5, 8, 10, 15 };
    int E1[] = { 6, 9, 15, 78, 89 };
    int F1[] = { 2, 3, 6, 6, 8, 8, 10 };
    int nD = sizeof(D1) / sizeof(D1[0]);
    int nE = sizeof(E1) / sizeof(E1[0]);
    int nF = sizeof(F1) / sizeof(F1[0]);
    cout << solve(D1, E1, F1, nD-1, nE-1, nF-1);
    return 0;
}

आउटपुट

1