सी ++ में लगातार जोड़ी तत्वों के उत्पाद के योग को कम करने के लिए एक सरणी को पुनर्व्यवस्थित करें

हमें एक सकारात्मक पूर्णांक प्रकार सरणी दी गई है, मान लें, किसी भी आकार का arr[]। कार्य एक सरणी को इस तरह से पुनर्व्यवस्थित करना है कि जब हम किसी तत्व को उसके वैकल्पिक तत्व से गुणा करते हैं और फिर सभी परिणामी तत्वों को जोड़ते हैं तो उसे न्यूनतम योग वापस करना चाहिए।

आइए इसके लिए विभिन्न इनपुट आउटपुट परिदृश्य देखें -

इनपुट - int arr[] ={2, 5, 1, 7, 5, 0, 1, 0}

आउटपुट - क्रमागत युग्म तत्वों के गुणनफल के योग यानी 7 को न्यूनतम करने के लिए एक सरणी की पुनर्व्यवस्था है:7 0 5 0 5 1 2 1

स्पष्टीकरण - हमें आकार 8 का एक पूर्णांक सरणी दिया गया है। अब, हम सरणी को पुनर्व्यवस्थित करेंगे अर्थात 7 0 5 0 5 1 2 1. हम जांच करेंगे कि क्या इसका रिटर्निंग न्यूनतम योग यानी 7 * 0 + 5 * 0 + 5 * 1 + 2 है। * 1 =0 + 0 + 5 + 2 =7.

इनपुट - int arr[] ={1, 3, 7, 2, 4, 3}

आउटपुट - क्रमागत युग्म तत्वों के गुणनफल के योग यानी 24 को न्यूनतम करने के लिए एक सरणी की पुनर्व्यवस्था है:7 1 4 2 3 3

स्पष्टीकरण - हमें आकार 6 का एक पूर्णांक सरणी दिया गया है। अब, हम सरणी को पुनर्व्यवस्थित करेंगे अर्थात 7 1 4 2 3 3. हम जांच करेंगे कि क्या इसका रिटर्निंग न्यूनतम योग यानी 7 * 1 + 4 * 2 + 3 * 3 =7 + 8 है। + 9 =24.

नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है

• पूर्णांक प्रकार के तत्वों की एक सरणी इनपुट करें और एक सरणी के आकार की गणना करें।

• सॉर्ट फ़ंक्शन के लिए सरणी के आकार और सरणी को पास करके C++ STL की सॉर्ट विधि का उपयोग करके एक सरणी को सॉर्ट करें।

• एक पूर्णांक चर घोषित करें और इसे कॉल के साथ functionRearrange_min_sum(arr, size)

  पर सेट करें

• समारोह के अंदर Rearrange_min_sum(arr, size)

  • एक वेरिएबल बनाएं, मान लें, 'ईवन' और 'ऑड' टाइप वेक्टर जो इंटीजर वेरिएबल को स्टोर करता है।

  • एक चर को अस्थायी और कुल के रूप में घोषित करें और इसे 0 से प्रारंभ करें।

  • I से 0 तक के लिए लूप प्रारंभ करें जब तक कि i आकार से कम न हो। लूप के अंदर, जांचें कि क्या मैं आकार/2 से छोटा है, फिर गिरफ्तारी [i] को विषम वेक्टर ELSE पर पुश करें, गिरफ्तारी [i] को भी वेक्टर पर पुश करें

  • इवन.बेगिन (), इवन.एंड () और ग्रेटर().

    . पास करके सॉर्ट विधि को कॉल करें

  • I से 0 तक के लिए लूप प्रारंभ करें जब तक कि i से भी कम। आकार ()। लूप के अंदर, arr[temp++] से भी[j], arr[temp++] से विषम[j] और टोटल टू टोटल + इवन[j] * ऑड [j]

    सेट करें।

  • कुल वापसी

• परिणाम प्रिंट करें।

उदाहरण

#include <bits/stdc++.h>
using namespace std;
int Rearrange_min_sum(int arr[], int size){
   vector<int> even, odd;
   int temp = 0;
   int total = 0;
   for(int i = 0; i < size; i++){
      if (i < size/2){
         odd.push_back(arr[i]);
      }
      else{
         even.push_back(arr[i]);
      }
   }
   sort(even.begin(), even.end(), greater<int>());
   for(int j = 0; j < even.size(); j++){
      arr[temp++] = even[j];
      arr[temp++] = odd[j];
      total += even[j] * odd[j];
   }
   return total;
}
int main(){
   int arr[] = { 2, 5, 1, 7, 5, 0, 1, 0};
   int size = sizeof(arr)/sizeof(arr[0]);
   //sort an array
   sort(arr, arr + size);
   //call function
   int total = Rearrange_min_sum(arr, size);
   cout<<"Rearrangement of an array to minimize sum i.e. "<<total<<" of product of consecutive pair elements is: ";
   for(int i = 0; i < size; i++){
      cout << arr[i] << " ";
   }
   return 0;
}

आउटपुट

यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा

Rearrangement of an array to minimize sum i.e. 7 of product of consecutive pair elements is: 7 0 5 0 5 1 2 1