हमें एक धनात्मक पूर्णांक K और एक सरणी Ops[] दी गई है जिसमें पूर्णांक हैं। लक्ष्य K को कम करने के लिए आवश्यक संचालन की संख्या का पता लगाना है ताकि यह 0 से कम हो जाए। संचालन हैं -
-
पहला ऑपरेशन K + Ops[0] है, पहला तत्व K में जोड़ा गया है
-
1 के बाद Ops[i] को K से K<0 तक जोड़ें। जहां सूचकांक I एक गोलाकार तरीके से बदलता रहता है। 0<=i
नोट - Ops[i] को K<0 तक जोड़ते रहें। यदि मैं अंतिम तत्व Ops[N-1] तक पहुँचता हूँ तो फिर से i=0 से शुरू करें। एक गोलाकार तरीके से।
हम पहले जांचेंगे कि क्या सरणी Ops[]>0 के सभी तत्वों का योग है। यदि हाँ तो K को कभी भी कम नहीं किया जा सकता है। वापसी -1। अन्यथा Ops[i] को K में जोड़ते रहें और जांचें कि क्या K<0 यदि हां लूप तोड़ता है।
जोड़ने के बाद संचालन की वृद्धि संख्या:K+Ops[i].
आइए उदाहरणों से समझते हैं।
इनपुट -
ops[]= { -4,2,-3,0,2 }, K=5 आउटपुट − संख्या घटाने के लिए आवश्यक संचालनों की संख्या − 3
स्पष्टीकरण - के 5 है। संचालन हैं -
1. K+ops[0]= 5+(-4) = 1 2. K+ops[1]= 1+2 = 3 3. K+ops[2]= 3+(-3) = 0
इनपुट -
ops[]= { 5,5,3,-2 }, K=10 आउटपुट - K को कम नहीं किया जा सकता !!
स्पष्टीकरण −K 10 है। संचालन हैं -
1. K+ops[0]= 10+5= 15 2. K+ops[1]= 15+5= 20 3. K+ops[2]= 20+3= 23 4. K+ops[3]= 23+-2= 22 5. K+ops[0]= 22+5= 27 6. K+ops[1]= 27+5=32 7. …………………
यदि हम जल्दी से ऑप्स के सभी तत्वों के योग की जांच करें []=5+5+3-2=11 और 11+10 हमेशा +ve होता है। अतः K को −0 तक कम नहीं किया जा सकता।
नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है
-
हम एक पूर्णांक सरणी लेते हैं ops[] यादृच्छिक पूर्णांकों के साथ आरंभ किया गया।
-
चर K को धनात्मक मान दिया गया है।
-
फ़ंक्शन काउंटऑपरेशंस (int op [], int n, int k) K सरणी Ops [] और इसकी लंबाई को मापदंडों के रूप में लेता है और K को 0 से कम करने के लिए आवश्यक रिटर्न ऑपरेशन करता है।
-
संचालन की प्रारंभिक संख्या को गिनती में 0 के रूप में लें।
-
ops [] के तत्वों के योग की गणना करें और योग में संग्रहीत करें। अगर योग> =0 तो -1 लौटें।
-
यदि नहीं तो k>0 ऑप्स [i] और इंक्रीमेंट काउंट जोड़ते रहें। यदि k<0 लूप को तोड़ता है।
-
परिणाम के रूप में वापसी की गिनती।
उदाहरण
#include <bits/stdc++.h>
using namespace std;
long countOperations(int op[], int n, int k){
long count = 0;
int sum=0;
int i=0;
for(int i=0;i<n;i++){
sum+=op[i];
}
if(sum-k>=0)
{ return -1; } //number k can never be reduced as sum-k is always positive or 0
while(k>0){
for(i=0;i<n;i++){
if(k>0){
count++;
k+=op[i];
}
else
{ break; }
}
}
return count;
}
int main(){
int Ops[] = { 1,-1,5,-11};
int len= sizeof(Ops) / sizeof(Ops[0]);
int K=10;
long ans=countOperations(Ops,len,K);
if(ans==-1)
{ cout<<"K cannot be reduced!!"; }
else
{ cout<<"Number of operations : "<<ans; }
return 0;
} आउटपुट
यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा -
Number of operations : 8