Count the number of operations required to reduce the given number

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: 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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach 
  
#include <bits/stdc++.h>
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[0]); 
        int k = 100000; 
  
        cout << operations(op, n, k) << endl; 
}
// This code is contributed by Ryuga

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach 
function operations($op, $n, $k
    $count = 0; 
  
    // To store the normalized value 
    // of all the operations 
    $nVal = 0; 
  
    // Minimum possible value for 
    // a series of operations 
    $minimum = PHP_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 
    $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
?>

chevron_right


Output:

71391


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.