हमें एक धनात्मक पूर्णांक K और एक सरणी Ops[] दी गई है जिसमें पूर्णांक हैं। लक्ष्य K को कम करने के लिए आवश्यक ऑपरेशन्स की संख्या ढूंढना है ताकि यह 0 से कम हो जाए। ऑपरेशन्स हैं -
पहला ऑपरेशन K + Ops[0] है, पहला तत्व K में जोड़ा जाता है।
इसके बाद Ops[i] को K में तब तक जोड़ते हैं जब तक K < 0 न हो जाए। जहां इंडेक्स i एक गोलाकार तरीके से बदलता रहता है। 0 <= i < N। N Ops[] में पूर्णांकों की संख्या है।
नोट - Ops[i] को तब तक जोड़ते रहें जब तक K < 0 न हो जाए। यदि i अंतिम तत्व 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
व्याख्या - K 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. ........
यदि हम जल्दी ops[] के सभी तत्वों का योग जांचते हैं = 5+5+3-2=11 और 11+10 हमेशा +ve है। इसलिए K को 0 से कम नहीं किया जा सकता।
नीचे दिए गए प्रोग्राम में उपयोग किया गया दृष्टिकोण
हम यादृच्छिक पूर्णांकों से आरंभ एक पूर्णांक सरणी ops[] लेते हैं।
वेरिएबल K को एक धनात्मक मान दिया जाता है।
फंक्शन countOperations(int op[], int n, int k) K, सरणी Ops[] और उसकी लंबाई को पैरामीटर के रूप में लेता है और K को 0 से कम करने के लिए आवश्यक ऑपरेशन्स लौटाता है।
प्रारंभिक ऑपरेशन्स की संख्या को count में 0 के रूप में लेते हैं।
ops[] के तत्वों का योग निकालते हैं और sum में स्टोर करते हैं। यदि sum >= 0 तो -1 लौटाते हैं।
यदि नहीं तो जब तक k > 0, ops[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=0) { return -1; } //संख्या k को कभी कम नहीं किया जा सकता क्योंकि sum-k हमेशा धनात्मक या 0 है while(k>0){ for(i=0;i0){ 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 को कम नहीं किया जा सकता!!"; } else { cout<<"ऑपरेशन्स की संख्या: "<<ans; } return 0; } आउटपुट
यदि हम उपरोक्त कोड चलाते हैं तो यह निम्नलिखित आउटपुट उत्पन्न करेगा -
ऑपरेशन्स की संख्या: 8