कम से कम (अधिकतम (ए [i], बी [जे], सी [के]) - न्यूनतम (ए [i], बी [जे], सी [के])) सी ++ में तीन अलग-अलग क्रमबद्ध सरणी

अवधारणा

दिए गए तीन क्रमबद्ध सरणियों ए, बी, और सी के संबंध में जरूरी नहीं कि समान आकार के हों, किसी भी ट्रिपल ए [i], बी [जे], सी [के] की अधिकतम और न्यूनतम संख्या के बीच न्यूनतम यानी न्यूनतम पूर्ण अंतर की गणना करें। कि वे क्रमशः ए, बी और सी सरणी के अंतर्गत हैं, यानी, न्यूनतम (अधिकतम (ए [i], बी [जे], सी [के]) - न्यूनतम (ए [i], बी [जे], सी [के] ))।

इनपुट -

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

आउटपुट -

स्पष्टीकरण

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

इनपुट -

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

आउटपुट -

स्पष्टीकरण -

जब हम A[i] =11 , b[j] =10, C[k] =11 का चयन करते हैं। हमें न्यूनतम अंतर अधिकतम (A[i], B[j], C[k]) - min( ए [i], बी [जे], सी [के])) =|11-10| =1

विधि

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

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

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

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

उदाहरण(C++)

// उपरोक्त दृष्टिकोण के लिए C++ कोड

#include<bits/stdc++.h>
usingnamespacestd;
intsolve(intA1[], intB1[], intC1[], inti1, intj1, intk1) {
intmin_diff, current_diff, max_term;
// calculating min difference from last
// index of lists
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])));
   // checking condition
   if(current_diff < min_diff)
      min_diff = current_diff;
      // calculating max term from list
      max_term = max(A1[i1], max(B1[j1], C1[k1]));
      if(A1[i1] == max_term)
         i1 -= 1;
      elseif(B1[j1] == max_term)
         j1 -= 1;
      else
         k1 -= 1;
   }
   returnmin_diff;
}
intmain() {
   intD1[] = { 5, 8, 10, 15 };
   intE1[] = { 6, 9, 15, 78, 89 };
   intF1[] = { 2, 3, 6, 6, 8, 8, 10 };
   intnD = sizeof(D1) / sizeof(D1[0]);
   intnE = sizeof(E1) / sizeof(E1[0]);
   intnF = sizeof(F1) / sizeof(F1[0]);
   cout << solve(D1, E1, F1, nD-1, nE-1, nF-1);
   return0;
}