सरणी को इस तरह पुनर्व्यवस्थित करें कि एआर [i]> =एआर [जे] अगर मैं भी हूं और एआर [i] <=एआर [जे] अगर मैं अजीब हूं और जे

हमें एक पूर्णांक सरणी दी जाती है जिसमें विषम और सम पूर्णांक मान होते हैं। कार्य एक सरणी को इस तरह से पुनर्व्यवस्थित करना है कि एआर [i] गिरफ्तारी [जे] से अधिक या बराबर होना चाहिए, इस शर्त के आधार पर कि इंडेक्स एआर [i] पर मूल्य सम होना चाहिए और अगर एआर पर मूल्य [i] विषम है तो arr[i] arr[j] के बराबर से कम होना चाहिए।

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

इनपुट - int arr[] ={5, 9, 10, 12, 32, 35, 67, 89}

आउटपुट - तत्वों को पुनर्व्यवस्थित करने के बाद सरणी हैं:12 32 10 35 9 67 5 89

स्पष्टीकरण - हमें विषम और सम पूर्णांकों वाली एक सरणी दी गई है। अब, हम arr[i] स्थिति से arr[j] स्थिति के विरुद्ध ट्रैवर्सिंग शुरू करेंगे और IF arr[i] की जांच करेंगे, फिर भी सुनिश्चित करें कि arr[i] arr[j] और IF arr[i] से बड़ा होना चाहिए। विषम है तो सुनिश्चित करें कि arr[i], arr[j] के बराबर से कम होना चाहिए।

इनपुट - int arr[] ={4, 5, 1, 2, 9, 10}

आउटपुट - तत्वों को पुनर्व्यवस्थित करने के बाद सरणी हैं:4 5 2 9 1 10

स्पष्टीकरण - हमें विषम और सम पूर्णांकों वाली एक सरणी दी गई है। अब, हम arr[i] स्थिति से arr[j] स्थिति के विरुद्ध ट्रैवर्सिंग शुरू करेंगे और IF arr[i] की जांच करेंगे, फिर भी सुनिश्चित करें कि arr[i] arr[j] और IF arr[i] से बड़ा होना चाहिए। विषम है तो सुनिश्चित करें कि arr[i], arr[j] के बराबर से कम होना चाहिए।

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

• पूर्णांक प्रकारों की एक सरणी घोषित करें। किसी सरणी के आकार की गणना size =sizeof(arr) / sizeof(arr[0]) के रूप में करें।

• किसी फ़ंक्शन को array_rearrange(arr, size) के रूप में कॉल करें और डेटा को पैरामीटर के रूप में पास करें।

  • एक वैरिएबल को सम घोषित करें और इसे सम =आकार / 2 पर सेट करें और दूसरे चर को विषम घोषित करें और इसे आकार - सम पर सेट करें।

  • एक चर को अस्थायी घोषित करें और इसे विषम पर सेट करें - 1. arr_1[] के आकार के साथ एक array_2[] घोषित करें।

  • I से 0 के लिए लूप प्रारंभ करें और मैं आकार से कम हूं। लूप के अंदर, इसे arr_2[i] से arr[i] पर सेट करें।

  • किसी फ़ंक्शन को सॉर्ट (arr_2, arr_2 + size) के रूप में कॉल करें।

  • I से 0 तक के लिए लूप प्रारंभ करें जब तक कि i आकार से कम न हो। लूप के अंदर, arr[i] को arr_2[temp] पर सेट करें और वेरिएबल टेम्प को 1 से घटाएं।

  • अस्थायी को विषम पर सेट करें। I से 1 तक के लिए लूप प्रारंभ करें जब तक कि i आकार से कम न हो। लूप के अंदर, arr[i] को arr_2[temp] पर सेट करें और टेम्परेचर को 1 से बढ़ाएँ।

  • I से 0 तक के लिए लूप प्रारंभ करें जब तक कि i आकार से कम न हो। गिरफ्तारी प्रिंट करें [i]।

उदाहरण

#include <bits/stdc++.h>

using namespace std;
void array_rearrange(int arr[], int size){
   int even = size / 2;
   int odd = size - even;
   int temp = odd - 1;
   int arr_2[size];
   for(int i = 0; i < size; i++){
      arr_2[i] = arr[i];
   }
   sort(arr_2, arr_2 + size);
   for(int i = 0; i < size; i += 2){
      arr[i] = arr_2[temp];
      temp--;
   }
   temp = odd;
   for(int i = 1; i < size; i += 2){
      arr[i] = arr_2[temp];
      temp++;
   }
   cout<<"Array after rearranging elements are: ";
   for (int i = 0; i < size; i++){
      cout << arr[i] << " ";
   }
}
int main(){
   int arr[] = {5, 9, 10, 12, 32, 35, 67, 89};
   int size = sizeof(arr) / sizeof(arr[0]);
   array_rearrange(arr, size);
   return 0;
}

आउटपुट

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

Array after rearranging elements are: 12 32 10 35 9 67 5 89