Related Articles
Count the number of operations required to reduce the given number
• Difficulty Level : Medium
• Last Updated : 10 Apr, 2019

Given an integer k and an array op[], in a single operation op will be added to k and then in the second operation k = k + op 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: 3
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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 code``int` `main() {``     ` `        ``int` `op[] = { -60, 65, -1, 14, -25 }; ``        ``int` `n = ``sizeof``(op)/``sizeof``(op); ``        ``int` `k = 100000; `` ` `        ``cout << operations(op, n, k) << endl; ``}``// This code is contributed by Ryuga`

## Java

 `// Java implementation of the approach``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 = 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 approach ``def` `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 code``op ``=` `[``-``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 approach``using` `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``?>`
Output:
```71391
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up