Count the number of operations required to reduce the given number

• Difficulty Level : Medium
• Last Updated : 09 Jun, 2022

Given an integer k and an array op[], in a single operation op[0] will be added to k and then in the second operation k = k + op[1] and so on in a circular manner until k > 0. The task is to print the operation number in which k will be reduced to â‰¤ 0. If it impossible to reduce k with the given operations then print -1.
Examples:

Input: op[] = {-60, 10, -100}, k = 100
Output:
Operation 1: 100 – 60 = 40
Operation 2: 40 + 10 = 50
Operation 3: 50 – 100 = -50
Input: op[] = {1, 1, -1}, k = 10
Output: -1
Input: op[] = {-60, 65, -1, 14, -25}, k = 100000
Output: 71391

Approach: Count the number of times all the operations can be performed on the number k without actually reducing it to get the result. Then update count = times * n where n is the number of operations. Now, for the remaining operations perform each of the operation one by one and increment count. The first operation when k is reduced to â‰¤ 0, print the count.
Below is the implementation of the above approach:

C++

 // C++ implementation of the approach #include using namespace std;  int operations(int op[], int n, int k)    {        int i, count = 0;         // To store the normalized value        // of all the operations        int nVal = 0;         // Minimum possible value for        // a series of operations        int minimum = INT_MAX;        for (i = 0; i < n; i++)        {            nVal += op[i];            minimum  = min(minimum , nVal);             // If k can be reduced with            // first (i + 1) operations            if ((k + nVal) <= 0)                return (i + 1);        }         // Impossible to reduce k        if (nVal >= 0)            return -1;         // Number of times all the operations        // can be performed on k without        // reducing it to <= 0        int times = (k - abs(minimum )) / abs(nVal);         // Perform operations        k = (k - (times * abs(nVal)));        count = (times * n);         // Final check        while (k > 0) {            for (i = 0; i < n; i++) {                k = k + op[i];                count++;                if (k <= 0)                    break;            }        }         return count;    } // Driver codeint main() {             int op[] = { -60, 65, -1, 14, -25 };        int n = sizeof(op)/sizeof(op[0]);        int k = 100000;         cout << operations(op, n, k) << endl;}// This code is contributed by Ryuga

Java

 // Java implementation of the approachclass GFG {     static int operations(int op[], int n, int k)    {        int i, count = 0;         // To store the normalized value        // of all the operations        int nVal = 0;         // Minimum possible value for        // a series of operations        int min = Integer.MAX_VALUE;        for (i = 0; i < n; i++) {            nVal += op[i];            min = Math.min(min, nVal);             // If k can be reduced with            // first (i + 1) operations            if ((k + nVal) <= 0)                return (i + 1);        }         // Impossible to reduce k        if (nVal >= 0)            return -1;         // Number of times all the operations        // can be performed on k without        // reducing it to <= 0        int times = (k - Math.abs(min)) / Math.abs(nVal);         // Perform operations        k = (k - (times * Math.abs(nVal)));        count = (times * n);         // Final check        while (k > 0) {            for (i = 0; i < n; i++) {                k = k + op[i];                count++;                if (k <= 0)                    break;            }        }         return count;    }     // Driver code    public static void main(String[] args)    {        int op[] = { -60, 65, -1, 14, -25 };        int n = op.length;        int k = 100000;         System.out.print(operations(op, n, k));    }}

Python3

 # Python3 implementation of the approachdef operations(op, n, k):     i, count = 0, 0     # To store the normalized value    # of all the operations    nVal = 0     # Minimum possible value for    # a series of operations    minimum = 10**9    for i in range(n):        nVal += op[i]        minimum = min(minimum , nVal)         # If k can be reduced with        # first (i + 1) operations        if ((k + nVal) <= 0):            return (i + 1)     # Impossible to reduce k    if (nVal >= 0):        return -1     # Number of times all the operations    # can be performed on k without    # reducing it to <= 0    times = (k - abs(minimum )) // abs(nVal)     # Perform operations    k = (k - (times * abs(nVal)))    count = (times * n)     # Final check    while (k > 0):        for i in range(n):            k = k + op[i]            count += 1            if (k <= 0):                break     return count # Driver codeop = [-60, 65, -1, 14, -25]n = len(op)k = 100000 print(operations(op, n, k)) # This code is contributed# by mohit kumar

C#

 // C# implementation of the approachusing System; class GFG{     static int operations(int []op, int n, int k)    {        int i, count = 0;         // To store the normalized value        // of all the operations        int nVal = 0;         // Minimum possible value for        // a series of operations        int min = int.MaxValue;        for (i = 0; i < n; i++)        {            nVal += op[i];            min = Math.Min(min, nVal);             // If k can be reduced with            // first (i + 1) operations            if ((k + nVal) <= 0)                return (i + 1);        }         // Impossible to reduce k        if (nVal >= 0)            return -1;         // Number of times all the operations        // can be performed on k without        // reducing it to <= 0        int times = (k - Math.Abs(min)) / Math.Abs(nVal);         // Perform operations        k = (k - (times * Math.Abs(nVal)));        count = (times * n);         // Final check        while (k > 0)        {            for (i = 0; i < n; i++)            {                k = k + op[i];                count++;                if (k <= 0)                    break;            }        }         return count;    }     // Driver code    static void Main()    {        int []op = { -60, 65, -1, 14, -25 };        int n = op.Length;        int k = 100000;         Console.WriteLine(operations(op, n, k));    }} // This code is contributed by mits

PHP

 = 0)        return -1;     // Number of times all the operations    // can be performed on k without    // reducing it to <= 0    \$times = round((\$k - abs(\$minimum )) /                         abs(\$nVal));     // Perform operations    \$k = (\$k - (\$times * abs(\$nVal)));    \$count = (\$times * \$n);     // Final check    while (\$k > 0)    {        for (\$i = 0; \$i < \$n; \$i++)        {            \$k = \$k + \$op[\$i];            \$count++;            if (\$k <= 0)                break;        }    }     return \$count;} // Driver code\$op = array(-60, 65, -1, 14, -25 );\$n = sizeof(\$op);\$k = 100000; echo operations(\$op, \$n, \$k); // This code is contributed by ihritik?>

Javascript



Output:

71391

Time Complexity: O(n*k)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up