# 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 array``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``    ``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<``int``> 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 Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 4, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``predictIndices(arr, N);` `    ``return` `0;``}`

## Java

 `// Java implementation for the above approach``import` `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 array``def` `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``][``0``]` `        ``# If element is greater than the sum``        ``# break the loop``        ``if` `(``sum` `< v[i ``+` `1``][``0``]):``            ``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][``1``])` `    ``# Sort the ans vector``    ``ans.sort()` `    ``# Print the desired indices``    ``for` `i ``in` `range``(``len``(ans)):``        ``print``(ans[i], end``=``" "``)` `# Driver Code``if` `__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 approach``using` `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<``int``> ans = ``new` `List<``int``>();` `        ``// 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