Find the indices which will hold the Array sum after given operations

• Difficulty Level : Hard
• Last Updated : 02 Dec, 2021

Given an array arr[], the task is to print the indices that have the highest probability of holding the entire sum of the array after performing the given operations:

• Choose any two elements say arr[i] and arr[j], store their sum in a variable K
• Assign K at index of max(arr[i], arr[j]) and assign 0 at index of min(arr[i], arr[j])

In this way, after choosing all elements, the last element left will store the sum of the whole array. The task is to return the indices of the array in the sequence of the highest possibility of holding the sum of the array.

Examples:

Input: arr[] = {2, 1, 4}
Output: {2}
Explanation: Choosing of elements can be done in the following ways:

Way 1:

• Choose elements at indices {0, 1}, so arr[] = {3, 0, 4}
• Choose elements at indices {0, 2}, so arr[] = {0, 0, 7}

Way 2:

• Choose elements at indices {0, 2}, so arr[] = {0, 1, 6}
• Choose elements at indices {1, 2}, so arr[] = {0, 0, 7}

Way 3:

• Choose elements at indices {1, 2}, so arr[] = {2, 0, 5}
• Choose elements at indices {0, 2}, so arr[] = {0, 0, 7}

In this case, output = {2}, index 0 and index 1 has zero possibility of holding the sum, so it is excluded.

Input: arr[] = {1, 2, 4, 3}
Output: {1, 2, 3}

Approach: The task can be solved by sorting the given array elements, and checking if the sum till i-1th is greater than the sum till ith element or not, if it is greater, then that index has a probability to be the valid index.

1. Take a vector of pair say v, store all the elements along with the respective indices in pair, also take a variable say sum that will store the sum of the entire array.
2. Sort the vector in ascending order and take a counter say c, initialize with 1 because one index will always have a possibility to hold the sum of the array.
3. Iterate over the vector from the second last element and check if the sum till the second last element is greater than the sum till the end(i.e the sum of the array), if it is greater, then increment the counter which means it has a possibility of holding the sum, else break the loop as it is not a valid index.
4. Take a vector say ans to store the valid indices and store the indices by iterating from the end till counter, then sort the ans vector and print it.

Below is the implementation of the above approach:

C++

 // C++ implementation for the above approach#include using namespace std; // Function to predict the indices which// will hold the sum of the given arrayvoid predictIndices(int arr[], int N){    // Variable for sum of the array    int sum = 0;     // Vector to store the elements along    // with the indices in pair    vector > v;    for (int i = 0; i < N; i++) {        v.push_back({ arr[i], i });        sum += arr[i];    }     // Sort the vector    sort(v.begin(), v.end());     // Take a counter c, initialize    // it with 1    int c = 1;     // Iterate over the vector from the end    // excluding the last element and each time    // update sum by decrementing its value    // by the element in the sorted vector    for (int i = N - 2; i >= 0; i--) {        sum -= v[i + 1].first;         // If element is greater than the sum        // break the loop        if (sum < v[i + 1].first) {            break;        }        // Else increment the counter c        else {            c++;        }    }     // Vector to store all the indices    // which can hold the sum    vector ans;     // Iterate the ans vector in reverse order    // till index is greater or equal to N - c    // and store the indices in ans vector    for (int i = N - 1; i >= N - c; i--) {        ans.push_back(v[i].second);    }     // Sort the ans vector    sort(ans.begin(), ans.end());     // Print the desired indices    for (int i = 0; i < ans.size(); i++) {        cout << ans[i] << " ";    }} // Driver Codeint main(){    int arr[] = { 1, 2, 4, 3 };    int N = sizeof(arr) / sizeof(arr);     predictIndices(arr, N);     return 0;}

Java

 // Java implementation for the above approachimport java.util.ArrayList;import java.util.Collections;import java.util.Comparator; class GFG {   public static class Pair {    int first = 0;    int second = 0;     public Pair(int first, int second) {      this.first = first;      this.second = second;    }  }   // Function to predict the indices which  // will hold the sum of the given array  public static void predictIndices(int arr[], int N)  {         // Variable for sum of the array    int sum = 0;     // Vector to store the elements along    // with the indices in pair    ArrayList v = new ArrayList();    for (int i = 0; i < N; i++) {      v.add(new Pair(arr[i], i));      sum += arr[i];    }     // Sort the vector    Collections.sort(v, new Comparator() {      @Override      public int compare(Pair p1, Pair p2){        return p1.first - p2.first;      }    });     // Take a counter c, initialize    // it with 1    int c = 1;     // Iterate over the vector from the end    // excluding the last element and each time    // update sum by decrementing its value    // by the element in the sorted vector    for (int i = N - 2; i >= 0; i--) {      sum -= v.get(i + 1).first;       // If element is greater than the sum      // break the loop      if (sum < v.get(i + 1).first) {        break;      }      // Else increment the counter c      else {        c++;      }    }     // Vector to store all the indices    // which can hold the sum    ArrayList ans = new ArrayList();     // Iterate the ans vector in reverse order    // till index is greater or equal to N - c    // and store the indices in ans vector    for (int i = N - 1; i >= N - c; i--) {      ans.add(v.get(i).second);    }     // Sort the ans vector    Collections.sort(ans);     // Print the desired indices    for (int i = 0; i < ans.size(); i++) {      System.out.print(ans.get(i) + " ");    }  }   // Driver Code  public static void main(String args[]) {    int arr[] = { 1, 2, 4, 3 };    int N = arr.length;     predictIndices(arr, N);  } } // This code is contributed by saurabh_jaiswal.

Python3

 # python3  implementation for the above approach # Function to predict the indices which# will hold the sum of the given arraydef predictIndices(arr, N):       # Variable for sum of the array    sum = 0     # Vector to store the elements along    # with the indices in pair    v = []    for i in range(N):        v.append([arr[i], i])        sum += arr[i]     # Sort the vector    v.sort()     # Take a counter c, initialize    # it with 1    c = 1     # Iterate over the vector from the end    # excluding the last element and each time    # update sum by decrementing its value    # by the element in the sorted vector    for i in range(N - 2, -1, -1):        sum -= v[i + 1]         # If element is greater than the sum        # break the loop        if (sum < v[i + 1]):            break         # Else increment the counter c        else:            c += 1     # Vector to store all the indices    # which can hold the sum    ans = []     # Iterate the ans vector in reverse order    # till index is greater or equal to N - c    # and store the indices in ans vector    for i in range(N - 1, N - c-1, -1):        ans.append(v[i])     # Sort the ans vector    ans.sort()     # Print the desired indices    for i in range(len(ans)):        print(ans[i], end=" ") # Driver Codeif __name__ == "__main__":     arr = [1, 2, 4, 3]    N = len(arr)     predictIndices(arr, N)     # This code is contributed by ukasp.

C#

 // C# implementation for the above approachusing System;using System.Collections.Generic;public class GFG{     class Pair    {        public int first = 0;        public int second = 0;         public Pair(int first, int second)        {            this.first = first;            this.second = second;        }    }     // Function to predict the indices which    // will hold the sum of the given array    public static void predictIndices(int[] arr, int N)    {         // Variable for sum of the array        int sum = 0;         // Vector to store the elements along        // with the indices in pair        List v = new List();        for (int i = 0; i < N; i++)        {            v.Add(new Pair(arr[i], i));            sum += arr[i];        }         // Sort the vector        v.Sort((Pair x, Pair y) => x.first.CompareTo(y.first));         // Take a counter c, initialize        // it with 1        int c = 1;         // Iterate over the vector from the end        // excluding the last element and each time        // update sum by decrementing its value        // by the element in the sorted vector        for (int i = N - 2; i >= 0; i--)        {            sum -= v[i + 1].first;             // If element is greater than the sum            // break the loop            if (sum < v[i + 1].first)            {                break;            }            // Else increment the counter c            else            {                c++;            }        }         // Vector to store all the indices        // which can hold the sum        List ans = new List();         // Iterate the ans vector in reverse order        // till index is greater or equal to N - c        // and store the indices in ans vector        for (int i = N - 1; i >= N - c; i--)        {            ans.Add(v[i].second);        }         // Sort the ans vector        ans.Sort();         // Print the desired indices        for (int i = 0; i < ans.Count; i++)        {            Console.Write(ans[i] + " ");        }    }     // Driver Code    public static void Main()    {        int[] arr = { 1, 2, 4, 3 };        int N = arr.Length;         predictIndices(arr, N);    }} // This code is contributed by saurabh_jaiswal.

Javascript



Output
1 2 3

Time Complexity: O(NlogN)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up