# Minimum steps to change arr[K] to 0 by decrementing arr[0] and shifting to end repeatedly

Given an array **arr[]** of size **N** and an integer representing an index **K, **the task is to find the minimum number of operations in which **arr[K]** becomes **0.** In one operation, the value of the first array element decreases by **1** and goes to the end of the array. If at any time, **arr[i]** becomes **0, **then it is removed from the array and the operations are performed on the remaining elements.

**Examples:**

Input:arr[] = {2, 3, 2}, K = 2Output:6Explanation:For the first input,

After iteration-1, the array changes to [1, 2, 1]. Steps taken = 3 steps

After iteration-2, the array changes to [0, 1, 0]. Steps taken = 3 steps

Hence, for the element at index 2, it took 6 steps to become 0.

Input:arr[] = {5, 1, 1, 1}, K = 0Output:8

**Approach:** The idea is to keep traversing the array and decrease the value of **arr[i]** when it’s greater than **0** and calculate the answer. Follow the steps below to solve the problem:

- Initialize the variable
**time**as**0**to store the answer. - Traverse in a while loop till
**arr[k]**is not**0**and perform the following tasks:- Iterate over the range
**[0, N)**using the variable**i**and perform the following tasks:- If
**arr[i]**is greater than**0,**then reduce the value of**arr[i]**by**1,**then increase the value of**time**by**1.** - If
**arr[k]**becomes**0,**then break.

- If

- Iterate over the range
- After performing the above steps, print the value of
**time**as the answer.

Below is the implementation of the above approach.

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the minimum number` `// of steps` `void` `findMinimumNumberOfSteps(vector<` `int` `> arr,` ` ` `int` `K)` `{` ` ` `// Variable to store the answer` ` ` `int` `time` `= 0;` ` ` `// Traverse in the while loop` ` ` `while` `(arr[K] != 0) {` ` ` `// Iterate over the loop` ` ` `for` `(` `int` `i = 0; i < arr.size(); i++) {` ` ` `// Check the condition and` ` ` `// decrease the value` ` ` `if` `(arr[i] > 0) {` ` ` `arr[i] -= 1;` ` ` `time` `++;` ` ` `}` ` ` `// Break the loop` ` ` `if` `(arr[K] == 0)` ` ` `break` `;` ` ` `}` ` ` `}` ` ` `// Print the result` ` ` `cout << ` `time` `;` `}` `// Driver Code` `int` `main()` `{` ` ` `vector<` `int` `> arr = { 2, 3, 2 };` ` ` `int` `K = 2;` ` ` `findMinimumNumberOfSteps(arr, K);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;` `class` `GFG {` ` ` `// Function to find the minimum number` ` ` `// of steps` ` ` `static` `void` `findMinimumNumberOfSteps(` `int` `arr[],` ` ` `int` `K)` ` ` `{` ` ` `// Variable to store the answer` ` ` `int` `time = ` `0` `;` ` ` `// Traverse in the while loop` ` ` `while` `(arr[K] != ` `0` `) {` ` ` `// Iterate over the loop` ` ` `for` `(` `int` `i = ` `0` `; i < arr.length; i++) {` ` ` `// Check the condition and` ` ` `// decrease the value` ` ` `if` `(arr[i] > ` `0` `) {` ` ` `arr[i] -= ` `1` `;` ` ` `time++;` ` ` `}` ` ` `// Break the loop` ` ` `if` `(arr[K] == ` `0` `)` ` ` `break` `;` ` ` `}` ` ` `}` ` ` `// Print the result` ` ` `System.out.println(time);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main (String[] args) {` ` ` `int` `arr[] = { ` `2` `, ` `3` `, ` `2` `};` ` ` `int` `K = ` `2` `;` ` ` `findMinimumNumberOfSteps(arr, K);` ` ` `}` `}` `// This code is contributed by hrithikgarg03188.` |

## Python3

`# Python program to implement` `# the above approach` `# Function to find the minimum number` `# of steps` `def` `findMinimumNumberOfSteps(arr, K) :` ` ` `# Variable to store the answer` ` ` `time ` `=` `0` ` ` `# Traverse in the while loop` ` ` `while` `(arr[K] !` `=` `0` `) :` ` ` `# Iterate over the loop` ` ` `for` `i ` `in` `range` `(` `0` `, ` `len` `(arr)) :` ` ` ` ` `# Check the condition and` ` ` `# decrease the value` ` ` `if` `(arr[i] > ` `0` `) :` ` ` `arr[i] ` `-` `=` `1` ` ` `time ` `+` `=` `1` ` ` ` ` `# Break the loop` ` ` `if` `(arr[K] ` `=` `=` `0` `):` ` ` `break` ` ` `# Print the result` ` ` `print` `(time)` `# Driver Code` `arr ` `=` `[ ` `2` `, ` `3` `, ` `2` `]` `K ` `=` `2` `findMinimumNumberOfSteps(arr, K)` `# This code is contributed by sanjoy_62.` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG {` ` ` `// Function to find the minimum number` ` ` `// of steps` ` ` `static` `void` `findMinimumNumberOfSteps(` `int` `[]arr,` ` ` `int` `K)` ` ` `{` ` ` `// Variable to store the answer` ` ` `int` `time = 0;` ` ` `// Traverse in the while loop` ` ` `while` `(arr[K] != 0) {` ` ` `// Iterate over the loop` ` ` `for` `(` `int` `i = 0; i < arr.Length; i++) {` ` ` `// Check the condition and` ` ` `// decrease the value` ` ` `if` `(arr[i] > 0) {` ` ` `arr[i] -= 1;` ` ` `time++;` ` ` `}` ` ` `// Break the loop` ` ` `if` `(arr[K] == 0)` ` ` `break` `;` ` ` `}` ` ` `}` ` ` `// Print the result` ` ` `Console.WriteLine(time);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main () {` ` ` `int` `[]arr = { 2, 3, 2 };` ` ` `int` `K = 2;` ` ` `findMinimumNumberOfSteps(arr, K);` ` ` `}` `}` `// This code is contributed by Samim Hossain Mondal.` |

## Javascript

`<script>` ` ` `// JavaScript code for the above approach` ` ` `// Function to find the minimum number` ` ` `// of steps` ` ` `function` `findMinimumNumberOfSteps(arr,` ` ` `K) {` ` ` `// Variable to store the answer` ` ` `let time = 0;` ` ` `// Traverse in the while loop` ` ` `while` `(arr[K] != 0) {` ` ` `// Iterate over the loop` ` ` `for` `(let i = 0; i < arr.length; i++) {` ` ` `// Check the condition and` ` ` `// decrease the value` ` ` `if` `(arr[i] > 0) {` ` ` `arr[i] -= 1;` ` ` `time++;` ` ` `}` ` ` `// Break the loop` ` ` `if` `(arr[K] == 0)` ` ` `break` `;` ` ` `}` ` ` `}` ` ` `// Print the result` ` ` `document.write(time);` ` ` `}` ` ` `// Driver Code` ` ` `let arr = [2, 3, 2];` ` ` `let K = 2;` ` ` `findMinimumNumberOfSteps(arr, K);` ` ` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

6

* Time Complexity: O(N*X), where X is the *value

*of arr[K]*

**Auxiliary Space:**O(1)