सी ++ का उपयोग करके ऐरे रोटेशन के लिए रिवर्सल एल्गोरिदम

दी गई समस्या में, हमें एक सरणी दी गई है, और हमें एक उलट एल्गोरिथम का उपयोग करके d तत्वों द्वारा सरणी को घुमाने की आवश्यकता है, उदाहरण के लिए -

Input : arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2
Output : arr[] = [3, 4, 5, 6, 7, 1, 2]
Explanation : As you can see we have to rotate this array by d = 2 but our main task is to achieve this by using a reversal technique.

हम उत्क्रमण तकनीक द्वारा सरणी के घूर्णन के लिए कुछ गणना करते हैं, और हम यह निष्कर्ष निकालते हैं कि -

• सबसे पहले, हम सरणी के पहले d तत्वों को उलट देते हैं।
• दूसरा, हम शेष तत्वों को उलट देते हैं।
• तीसरा, हम पूरे ऐरे को उलट देते हैं।

और इन तीन चरणों को लागू करके, हम अपने घुमाए गए सरणी को प्राप्त कर सकते हैं।

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

इस समस्या में, सबसे पहले, हम तत्वों को उलटने के लिए एक फ़ंक्शन बनाने जा रहे हैं; अब हम ऊपर दिए गए चरणों का पालन करते हैं

उदाहरण

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

void reverseArray(int arr[], int start, int end) { // our reversal algorithm
   while (start < end) { // if start becomes equal to end we break the loop
      int temp = arr[start];
      arr[start] = arr[end];
      arr[end] = temp;
      start++;
      end--;
   }
   return ;
}
void Rotate(int arr[], int d, int n) { // rotation function
   if (d == 0) // no rotation required
      return;
   d = d % n; // when d becomes equal to n so our array comes to its original form
   reverseArray(arr, 0, d - 1); // reversing first d elements
   reverseArray(arr, d, n - 1); // reversing the remaining elements
   reverseArray(arr, 0, n - 1); // reversing the whole array

   return ;
}
int main() {
   int arr[] = { 1, 2, 3, 4, 5, 6, 7 }; // given array
   int n = sizeof(arr) / sizeof(arr[0]); // size of our array
   int d = 2;
   Rotate(arr, d, n);
   for(int i = 0; i < n; i++) // printing the array
      cout << arr[i] << " ";
   cout << "\n";
   return 0;
}

आउटपुट

3 4 5 6 7 1 2

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

उपरोक्त दृष्टिकोण में, हम पहले अपनी उत्क्रमण तकनीक बनाते हैं, जो तीन पैरामीटर, यानी, सरणी, प्रारंभिक अनुक्रमणिका, और समाप्ति अनुक्रमणिका लेगी, और हमारे सरणी को प्रारंभ से अंत तक उलट देगी। जैसा कि हमने पहले अपना एल्गोरिदम विकसित किया था, हम इस फ़ंक्शन का उपयोग करके उस एल्गोरिदम को लागू करने जा रहे हैं। हम सबसे पहले पहले d तत्वों को उलटते हैं। अब दूसरी बात, हम शेष तत्वों को उलट देते हैं, और अंत में, हम पूरे सरणी को उलट देते हैं। नतीजतन, हमारे सरणी को d द्वारा घुमाया जाता है। रोटेट फंक्शन में, हम d =d% n बना रहे हैं। ऐसा इसलिए है क्योंकि यदि हम किसी सरणी के पहले n तत्वों को घुमाते हैं, तो हमें जो उत्तर मिलता है वह पहले जैसा ही होगा, इसलिए हम n के साथ d का एक मॉड बनाते हैं।

निष्कर्ष

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