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

Last Updated : 25 Jan, 2023

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 3
Explanation: 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.

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.

C#

using System;
using System.Collections.Generic;
using System.Linq;
 
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
        SortedDictionary<int, int> count = new SortedDictionary<int, int>();
     
        // 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
                foreach (KeyValuePair<int, int> u in count.Reverse())
                {
                    int j = u.Key;
                    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
            if (count.ContainsKey(arr[i]))
            {
                count[arr[i]] = count[arr[i]] + 1;
            }
            else
            {
                count[arr[i]] = 1;
            }
     
            Console.Write(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);
    }
}

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>