计算减少给定数量所需的操作数

给定一个整数k和一个数组op [] ，将在单个操作中将op [0]添加到k ，然后在第二个操作中将k = k + op [1]依此类推，直到循环> k> 0为止。任务是打印将k减小到≤0的操作号。如果无法通过给定的操作减少k ，则打印-1 。

例子：

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

方法：计算可以对数字k执行所有运算的次数，而无需实际减少就可以得到结果。然后更新计数=次* n ，其中n是操作数。现在，对于其余的操作，一个接一个地执行每个操作，然后递增计数。当k减小到≤0时，第一个操作将打印计数。

下面是上述方法的实现：

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[0]); 
        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
?>

输出：

71391