# Minimum count of indices to be skipped for every index of Array to keep sum till that index at most T

Given an array, **arr[] **of size **N** and an integer** T**.** **The task is to find for each index the minimum number of indices that should be skipped if the sum till the **ith **index should not exceed **T**.

**Examples:**

Input:N = 7, T = 15, arr[] = {1, 2, 3, 4, 5, 6, 7}Output:0 0 0 0 0 2 3Explanation:No indices need to be skipped for the first 5 indices: {1, 2, 3, 4, 5}, since their sum is 15 and <= T.

For the sixth index, indices 3 and 4 can be skipped, that makes its sum = (1+2+3+6) = 12.

For the seventh, indices 3, 4 and 5 can be skipped which makes its sum = (1+2+3+7) = 13.

Input:N =2, T = 100, arr[] = {100, 100}Output:0 1

**Approach: **The idea is to use a map to store the visited elements in increasing order while traversing. Follow the steps below to solve the problem:

- Create an ordered map,
**M**to keep a count of the elements before the**ith**index. - Initialize a variable
**sum**as**0**to store the prefix sum. - Traverse the array,
**arr[]**using the variable**i**- Store the difference of
**sum+arr[i]**and**T**in a variable,**d**. - If the value of
**d>0**, traverse the map from the end and select the indices with the largest elements until the sum becomes less than**T**. Store the number of elements required in a variable**k**. - Add
**arr[i]**to sum and increment**A[i]**in**M**by**1**. - Print the value of
**k**.

- Store the difference of

Below is the implementation of the above approach:

## C++

`// C++ approach for above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to calculate minimum indices to be skipped` `// so that sum till i remains smaller than T` `void` `skipIndices(` `int` `N, ` `int` `T, ` `int` `arr[])` `{` ` ` `// Store the sum of all indices before i` ` ` `int` `sum = 0;` ` ` `// Store the elements that can be skipped` ` ` `map<` `int` `, ` `int` `> count;` ` ` `// Traverse the array, A[]` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// Store the total sum of elements that` ` ` `// needs to be skipped` ` ` `int` `d = sum + arr[i] - T;` ` ` `// Store the number of elements need` ` ` `// to be removed` ` ` `int` `k = 0;` ` ` `if` `(d > 0) {` ` ` `// Traverse from the back of map so` ` ` `// as to take bigger elements first` ` ` `for` `(` `auto` `u = count.rbegin(); u != count.rend();` ` ` `u++) {` ` ` `int` `j = u->first;` ` ` `int` `x = j * count[j];` ` ` `if` `(d <= x) {` ` ` `k += (d + j - 1) / j;` ` ` `break` `;` ` ` `}` ` ` `k += count[j];` ` ` `d -= x;` ` ` `}` ` ` `}` ` ` `// Update sum` ` ` `sum += arr[i];` ` ` `// Update map with the current element` ` ` `count[arr[i]]++;` ` ` `cout << k << ` `" "` `;` ` ` `}` `}` `// Driver code` `int` `main()` `{` ` ` `// Given Input` ` ` `int` `N = 7;` ` ` `int` `T = 15;` ` ` `int` `arr[] = { 1, 2, 3, 4, 5, 6, 7 };` ` ` `// Function Call` ` ` `skipIndices(N, T, arr);` ` ` `return` `0;` `}` |

## Java

`import` `java.util.ArrayList;` `import` `java.util.Map;` `import` `java.util.TreeMap;` `// C++ approach for above approach` `class` `GFG {` ` ` `// Function to calculate minimum indices to be skipped` ` ` `// so that sum till i remains smaller than T` `public` `static` `void` `skipIndices(` `int` `N, ` `int` `T, ` `int` `arr[])` `{` ` ` `// Store the sum of all indices before i` ` ` `int` `sum = ` `0` `;` ` ` `// Store the elements that can be skipped` ` ` `TreeMap<Integer, Integer> count = ` `new` `TreeMap<Integer, Integer>();` ` ` `// Traverse the array, A[]` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) {` ` ` `// Store the total sum of elements that` ` ` `// needs to be skipped` ` ` `int` `d = sum + arr[i] - T;` ` ` `// Store the number of elements need` ` ` `// to be removed` ` ` `int` `k = ` `0` `;` ` ` `if` `(d > ` `0` `) {` ` ` `// Traverse from the back of map so` ` ` `// as to take bigger elements first` ` ` `for` `(Map.Entry<Integer, Integer> u : count.descendingMap().entrySet()) {` ` ` `int` `j = u.getKey();` ` ` `int` `x = j * count.get(j);` ` ` `if` `(d <= x) {` ` ` `k += (d + j - ` `1` `) / j;` ` ` `break` `;` ` ` `}` ` ` `k += count.get(j);` ` ` `d -= x;` ` ` `}` ` ` `}` ` ` `// Update sum` ` ` `sum += arr[i];` ` ` `// Update map with the current element` ` ` `if` `(count.containsKey(arr[i])){` ` ` `count.put(arr[i], count.get(arr[i]) + ` `1` `);` ` ` `}` `else` `{` ` ` `count.put(arr[i], ` `1` `);` ` ` `}` ` ` `System.out.print(k + ` `" "` `);` ` ` `}` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String args[])` ` ` `{` ` ` ` ` `// Given Input` ` ` `int` `N = ` `7` `;` ` ` `int` `T = ` `15` `;` ` ` `int` `arr[] = { ` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `, ` `6` `, ` `7` `};` ` ` `// Function Call` ` ` `skipIndices(N, T, arr);` ` ` `}` `}` `// This code is contributed by _saurabh_jaiswal.` |

## Python3

`# Python3 approach for above approach` `# Function to calculate minimum indices to be skipped` `# so that sum till i remains smaller than T` `def` `skipIndices(N, T, arr):` ` ` `# Store the sum of all indices before i` ` ` `sum` `=` `0` ` ` `# Store the elements that can be skipped` ` ` `count ` `=` `{}` ` ` `# Traverse the array, A[]` ` ` `for` `i ` `in` `range` `(N):` ` ` `# Store the total sum of elements that` ` ` `# needs to be skipped` ` ` `d ` `=` `sum` `+` `arr[i] ` `-` `T` ` ` `# Store the number of elements need` ` ` `# to be removed` ` ` `k ` `=` `0` ` ` `if` `(d > ` `0` `):` ` ` `# Traverse from the back of map so` ` ` `# as to take bigger elements first` ` ` `for` `u ` `in` `list` `(count.keys())[::` `-` `1` `]:` ` ` `j ` `=` `u` ` ` `x ` `=` `j ` `*` `count[j]` ` ` `if` `(d <` `=` `x):` ` ` `k ` `+` `=` `(d ` `+` `j ` `-` `1` `) ` `/` `/` `j` ` ` `break` ` ` `k ` `+` `=` `count[j]` ` ` `d ` `-` `=` `x` ` ` `# Update sum` ` ` `sum` `+` `=` `arr[i]` ` ` `# Update map with the current element` ` ` `count[arr[i]] ` `=` `count.get(arr[i], ` `0` `) ` `+` `1` ` ` `print` `(k, end ` `=` `" "` `)` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `# Given Input` ` ` `N ` `=` `7` ` ` `T ` `=` `15` ` ` `arr ` `=` `[` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `, ` `6` `, ` `7` `]` ` ` `# Function Call` ` ` `skipIndices(N, T, arr)` ` ` `# This code is contributed by mohit kumar 29.` |

## Javascript

`<script>` `// Javascript approach for above approach` `// Function to calculate minimum indices` `// to be skipped so that sum till i` `// remains smaller than T` `function` `skipIndices(N, T, arr)` `{` ` ` ` ` `// Store the sum of all indices before i` ` ` `let sum = 0;` ` ` `// Store the elements that can be skipped` ` ` `let count = ` `new` `Map();` ` ` `// Traverse the array, A[]` ` ` `for` `(let i = 0; i < N; i++)` ` ` `{` ` ` ` ` `// Store the total sum of elements that` ` ` `// needs to be skipped` ` ` `let d = sum + arr[i] - T;` ` ` `// Store the number of elements need` ` ` `// to be removed` ` ` `let k = 0;` ` ` `if` `(d > 0)` ` ` `{` ` ` ` ` `// Traverse from the back of map so` ` ` `// as to take bigger elements first` ` ` `for` `(let u of [...count.keys()].reverse())` ` ` `{` ` ` `let j = u;` ` ` `let x = j * count.get(j);` ` ` ` ` `if` `(d <= x)` ` ` `{` ` ` `k += Math.floor((d + j - 1) / j);` ` ` `break` `;` ` ` `}` ` ` `k += count.get(j);` ` ` `d -= x;` ` ` `}` ` ` `}` ` ` `// Update sum` ` ` `sum += arr[i];` ` ` `// Update map with the current element` ` ` `if` `(count.has(arr[i]))` ` ` `{` ` ` `count.set(arr[i], count.get(i) + 1)` ` ` `}` ` ` `else` ` ` `{` ` ` `count.set(arr[i], 1)` ` ` `}` ` ` `document.write(k + ` `" "` `);` ` ` `}` `}` `// Driver code` `// Given Input` `let N = 7;` `let T = 15;` `let arr = [ 1, 2, 3, 4, 5, 6, 7 ];` `// Function Call` `skipIndices(N, T, arr);` `// This code is contributed by _saurabh_jaiswal` `</script>` |

**Output**

0 0 0 0 0 2 3

**Time Complexity: **O(N^{2})**Auxiliary Space**: O(N)