 Open in App
Not now

# 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 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:
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 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``?>`

## Javascript

 ``

Output:

`71391`

Time Complexity: O(n*k)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up