Skip to content
Related Articles

Related Articles

Improve Article
Array Manipulation and Sum
  • Difficulty Level : Basic
  • Last Updated : 06 May, 2021

Given an array arr[] of N integers and an integer S. The task is to find an element K in the array such that if all the elements from the array > K are made equal to K then the sum of all the elements of the resultant array becomes equal to S. If it is not possible to find such an element then print -1 .
Examples: 
 

Input: M = 15, arr[] = {12, 3, 6, 7, 8} 
Output: 3 
Resultant array = {3, 3, 3, 3, 3} 
Sum of the array elements = 15 = S
Input: M = 5, arr[] = {1, 3, 2, 5, 8} 
Output: 1 
 

 

Approach: Sort the array. Traverse the array considering that the value of K is equal to the current element and then check if sum of the previous elements + (K * number of remaining elements) = S. If yes then print the value of K, if no such element found then print -1 in the end.
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the required element
int getElement(int a[], int n, int S)
{
    // Sort the array
    sort(a, a + n);
 
    int sum = 0;
 
    for (int i = 0; i < n; i++) {
 
        // If current element
        // satisfies the condition
        if (sum + (a[i] * (n - i)) == S)
            return a[i];
        sum += a[i];
    }
 
    // No element found
    return -1;
}
 
// Driver code
int main()
{
    int S = 5;
    int a[] = { 1, 3, 2, 5, 8 };
    int n = sizeof(a) / sizeof(a[0]);
 
    cout << getElement(a, n, S);
 
    return 0;
}
Java



//Java implementation of the approach
import java.util.Arrays;
 
class GFG
{
    // Function to return the required element
    static int getElement(int a[], int n, int S)
    {
        // Sort the array
        Arrays.sort(a);
     
        int sum = 0;
     
        for (int i = 0; i < n; i++)
        {
     
            // If current element
            // satisfies the condition
            if (sum + (a[i] * (n - i)) == S)
                return a[i];
            sum += a[i];
        }
     
        // No element found
        return -1;
    }
     
    // Driver code
    public static void main(String[] args)
    {
        int S = 5;
        int a[] = { 1, 3, 2, 5, 8 };
        int n = a.length;
     
        System.out.println(getElement(a, n, S));
    }
}
 
// This code is contributed by Mukul singh.
Python 3



# Python3 implementation of the approach
 
# Function to return the required element
def getElement(a, n, S) :
     
    # Sort the array
    a.sort();
 
    sum = 0;
 
    for i in range(n) :
         
        # If current element
        # satisfies the condition
        if (sum + (a[i] * (n - i)) == S) :
            return a[i];
             
        sum += a[i];
 
    # No element found
    return -1;
 
# Driver Code
if __name__ == "__main__" :
     
    S = 5;
    a = [ 1, 3, 2, 5, 8 ];
    n = len(a) ;
 
    print(getElement(a, n, S)) ;
     
# This code is contributed by Ryuga
C#



// C# implementation of the approach
using System;
 
class GFG
{
    // Function to return the required element
    static int getElement(int[] a, int n, int S)
    {
        // Sort the array
        Array.Sort(a);
     
        int sum = 0;
     
        for (int i = 0; i < n; i++)
        {
     
            // If current element
            // satisfies the condition
            if (sum + (a[i] * (n - i)) == S)
                return a[i];
            sum += a[i];
        }
     
        // No element found
        return -1;
    }
     
    // Driver code
    public static void Main()
    {
        int S = 5;
        int[] a = { 1, 3, 2, 5, 8 };
        int n = a.Length;
     
        Console.WriteLine(getElement(a, n, S));
    }
}
 
// This code is contributed by Mukul singh.
PHP



<?php
// PHP implementation of the approach
 
// Function to return the required element
function getElement($a, $n, $S)
{
    // Sort the array
    sort($a, 0);
 
    $sum = 0;
 
    for ($i = 0; $i < $n; $i++)
    {
 
        // If current element
        // satisfies the condition
        if ($sum + ($a[$i] *
           ($n - $i)) == $S)
            return $a[$i];
        $sum += $a[$i];
    }
 
    // No element found
    return -1;
}
 
// Driver code
$S = 5;
$a = array(1, 3, 2, 5, 8);
$n = sizeof($a);
 
echo getElement($a, $n, $S);
 
// This code is contributed
// by Akanksha Rai
?>
Javascript



<script>
 //Javascript implementation of the approach
 
// Function to return the required element
function getElement(a, n, S)
{
    // Sort the array
    a.sort();
 
    var sum = 0;
 
    for (var i = 0; i < n; i++) {
 
        // If current element
        // satisfies the condition
        if (sum + (a[i] * (n - i)) == S)
            return a[i];
        sum += a[i];
    }
 
    // No element found
    return -1;
}
 
var S = 5;
var a = [ 1, 3, 2, 5, 8 ];
var n = a.length;
document.write(getElement(a, n, S));
 
 
// This code is contributed by SoumikMondal
</script>
Output: 
1
 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with industry experts, please refer Geeks Classes Live



My Personal Notes
arrow_drop_up
Previous
Determine the count of Leaf nodes in an N-ary tree
Next

Program to implement Run Length Encoding using Linked Lists
Recommended Articles
Page :
Maximize the expression (A AND X) * (B AND X) | Bit Manipulation
29, Oct 19
Maximize the Expression | Bit Manipulation
09, Oct 19
Modify array to another given array by replacing array elements with the sum of the array
12, Feb 21
Reduce array to longest sorted array possible by removing either half of given array in each operation
17, Nov 20
Find original array from encrypted array (An array of sums of other elements)
12, Apr 17
Find an element in array such that sum of left array is equal to sum of right array
07, Sep 17
Array obtained by repeatedly reversing array after every insertion from given array
01, Oct 20
Convert an array into Bitonic array by right shifting array elements
03, May 21
Check whether an array can be fit into another array rearranging the elements in the array
09, Jul 18
Sum of Bitwise OR of each array element of an array with all elements of another array
21, Dec 20
Find Array formed by adding each element of given array with largest element in new array to its left
24, Mar 20
Maximize product of array by replacing array elements with its sum or product with element from another array
27, Oct 20
Sum of array elements possible by appending arr[i] / K to the end of the array K times for array elements divisible by K
19, Apr 21
Rearrange Array to maximize number having Array elements as digits based on given conditions
21, Aug 20
Smallest prefix to be deleted such that remaining array can be rearranged to form a sorted array
22, Sep 20
Generate an N-length array having maximum element minimized and sum of array elements divisible by K
10, May 21
Count remaining array elements after reversing binary representation of each array element
16, Feb 21
Count of array elements that can be found using Randomized Binary Search on every array element
13, Jan 21
Minimum score possible for a player by selecting one or two consecutive array elements from given binary array
16, Nov 20
Maximize length of longest non-decreasing array possible by the elements present in either ends of the given array
11, Nov 20
Minimum prefix increments required to make all elements of an array multiples of another array
31, Jan 21
Count array elements whose highest power of 2 less than or equal to that number is present in the given array
17, Jun 21
Smallest indexed array element required to be flipped to make sum of array equal to 0
28, Dec 20
Check if array can be sorted by swapping pairs having GCD equal to the smallest element in the array
16, Sep 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ayushgoyal
@ayushgoyal
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox