C++ . में उच्चतम स्कोर के साथ सबसे छोटा रोटेशन

मान लीजिए कि हमारे पास एक एरे ए है, हम इसे के द्वारा घुमा सकते हैं ताकि एरे ए [के], ए [के + 1], ए {के + 2], ... ए [ए। लम्बाई - 1] बन जाए। ए [0], ए [1], ..., ए [के -1]। फिर, कोई भी प्रविष्टि जो उनकी अनुक्रमणिका से कम या उसके बराबर है, 1 अंक के लायक है।

तो उदाहरण के लिए, हमारे पास एक सरणी [2, 4, 1, 3, 0] है, और हम के =2 से घुमाते हैं, यह [1, 3, 0, 2, 4] बन जाता है। यह 3 अंक के लायक है क्योंकि 1> 0 [लाभ नहीं], 3> 1 [लाभ नहीं], 0 <=2 [एक अंक हासिल करें], 2 <=3 [एक अंक हासिल करें], 4 <=4 [लाभ एक बिंदु]।

हमें K ज्ञात करना है, जिसके लिए हमें सर्वोच्च अंक प्राप्त होंगे। यदि एक से अधिक उत्तर हैं, तो ऐसा सबसे छोटा सूचकांक K लौटाएँ। इसलिए, यदि इनपुट K =2 जैसा है, तो उत्तर 5 होगा।

तो अगर इनपुट [2,3,1,5,1] जैसा है, तो आउटपुट 3 होगा, ऐसा इसलिए है क्योंकि -

<थेड>

K	सरणी	स्कोर
0	[2,3,1,5,1]	2
1	[3,1,5,1,2]	3
2	[1,5,1,2,4]	3
3	[5,1,2,4,1]	4
4	[1,2,4,1,3]	3

उत्तर 3 होगा।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

रिट:=0
n :=A का आकार
एक सरणी को परिभाषित करें जिसका आकार n है
इनिशियलाइज़ i :=0 के लिए, जब i करें
यदि A[i] <=i, तो −
- न्यूनतम:=0, (cnt[minI] 1 से बढ़ाएं)
- अधिकतम:=i - A[i]
- यदि अधिकतम I + 1
- cnt[maxI + कमी 1] 1 से
यदि i + 1
cnt[i + 1 की वृद्धि] 1 से

अन्यथा

यदि A[i]>=n, तो −
- निम्न भाग पर ध्यान न दें, अगले भाग पर जाएं
मिनी:=i + 1
(cnt[minI] 1 से बढ़ाएं)
मैक्सी :=i + (n - A[i])
यदि मैक्सी + 1 <एन, तो −
- cnt[मैक्सी + 1 घटाएं] 1 तक

maxCnt:=-1, अस्थायी:=0

इनिशियलाइज़ i :=0 के लिए, जब i करें

अस्थायी:=अस्थायी + सीएनटी[i]

अगर अस्थायी> मैक्ससीएनटी, तो −

maxCnt:=अस्थायी
रिट:=मैं

रिटर्न रिटर्न

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

उदाहरण

#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
   int bestRotation(vector<int>& A) {
      int ret = 0;
      int n = A.size();
      vector <int> cnt(n);
      for(int i = 0; i < n; i++){
         if(A[i] <= i){
            int minI = 0;
            cnt[minI]++;
            int maxI = i - A[i];
            if(maxI + 1 < n) cnt[maxI + 1]--;
            if(i + 1 < n) cnt[i + 1]++;
         }else{
            if(A[i] >= n) continue;
            int minI = i + 1;
            cnt[minI]++;
            int maxi = i + (n - A[i]);
            if(maxi + 1 < n)cnt[maxi + 1]--;
         }
      }
      int maxCnt = -1;
      int temp = 0;
      for(int i = 0; i < n; i++){
         temp += cnt[i];
         if(temp > maxCnt){
            maxCnt = temp;
            ret = i;
         }
      }
      return ret;
   }
};
main(){
   Solution ob;
   vector<int> v = {2,3,1,5,1};
   cout << (ob.bestRotation(v));
}

इनपुट

[2,3,1,5,1]