Skip to content
Related Articles

Related Articles

Find the minimum and maximum sum of N-1 elements of the array
  • Difficulty Level : Easy
  • Last Updated : 04 Feb, 2021

Given an unsorted array A of size N, the task is to find the minimum and maximum values that can be calculated by adding exactly N-1 elements.

Examples:

Input: a[] = {13, 5, 11, 9, 7} 
Output: 32 40 
Explanation: Minimum sum is 5 + 7 + 9 + 11 = 32 and maximum sum is 7 + 9 + 11 + 13 = 40.
Input: a[] = {13, 11, 45, 32, 89, 21} 
Output: 122 200 
Explanation: Minimum sum is 11 + 13 + 21 + 32 + 45 = 122 and maximum sum is 13 + 21 + 32 + 45 + 89 = 200.
Input: a[] = {6, 3, 15, 27, 9} 
Output: 33 57 
Explanation: Minimum sum is 3 + 6 + 9 + 15 = 33 and maximum sum is 6 + 9 + 15 + 27 = 57.

Simple Approach:

  1. Sort the array in ascending order.
  2. Sum of the first N-1 elements in the array gives the minimum possible sum.
  3. Sum of the last N-1 elements in the array gives the maximum possible sum.

Below is the implementation of the above approach:



Java




// Java Implementation of the above approach
import java.util.*;
 
class GFG {
 
    static void minMax(int[] arr)
    {
        // Initialize the min_value
        // and max_value to 0
        long min_value = 0;
        long max_value = 0;
        int n = arr.length;
       
        // Sort array before calculating
        // min and max value
        Arrays.sort(arr);
                           
        for (int i = 0, j = n - 1;
             i < n - 1; i++, j--)
        {
            // All elements except
            // rightmost will be added
            min_value += arr[i];
           
            // All elements except
            // leftmost will be added
            max_value += arr[j];
        }
        
        // Output: min_value and max_value
        System.out.println(
            min_value + " "
            + max_value);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
 
        // Initialize your array elements here
        int[] arr = { 10, 9, 8, 7, 6, 5 };
        int[] arr1 = { 100, 200, 300, 400, 500 };
        minMax(arr);
        minMax(arr1);
    }
}

Output:

35 40
1000 1400

Time complexity: O(NlogN)

Efficient Approach:

  1. Find the minimum and maximum element of the array.
  2. Calculate the sum of all the elements in the array.
  3. Excluding maximum element from the sum gives the minimum possible sum.
  4. Excluding the minimum element from the sum gives the maximum possible sum.

Below is the implementation of the above approach:

C++




// C++ program to find the minimum and maximum
// sum from an array.
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate minimum and maximum sum
static void miniMaxSum(int arr[], int n)
{
 
    // Initialize the minElement, maxElement
    // and sum by 0.
    int minElement = 0, maxElement = 0, sum = 0;
 
    // Assigning maxElement, minElement
    // and sum as the first array element
    minElement = arr[0];
    maxElement = minElement;
    sum = minElement;
 
    // Traverse the entire array
    for(int i = 1; i < n; i++)
    {
         
        // Calculate the sum of
        // array elements
        sum += arr[i];
 
        // Keep updating the
        // minimum element
        if (arr[i] < minElement)
        {
            minElement = arr[i];
        }
 
        // Keep updating the
        // maximum element
        if (arr[i] > maxElement)
        {
            maxElement = arr[i];
        }
    }
 
    // print the minimum and maximum sum
    cout << (sum - maxElement) << " "
         << (sum - minElement) << endl;
}
 
// Driver Code
int main()
{
     
    // Test Case 1:
    int a1[] = { 13, 5, 11, 9, 7 };
    int n = sizeof(a1) / sizeof(a1[0]);
     
    // Call miniMaxSum()
    miniMaxSum(a1, n);
 
    // Test Case 2:
    int a2[] = { 13, 11, 45, 32, 89, 21 };
    n = sizeof(a2) / sizeof(a2[0]);
    miniMaxSum(a2, n);
 
    // Test Case 3:
    int a3[] = { 6, 3, 15, 27, 9 };
    n = sizeof(a3) / sizeof(a3[0]);
    miniMaxSum(a3, n);
}
 
// This code is contributed by chitranayal

Java




// Java program to find the minimum and maximum
// sum from an array.
class GFG {
 
    // Function to calculate minimum and maximum sum
    static void miniMaxSum(int[] arr)
    {
 
        // Initialize the minElement, maxElement
        // and sum by 0.
        int minElement = 0, maxElement = 0, sum = 0;
 
        // Assigning maxElement, minElement
        // and sum as the first array element
        minElement = arr[0];
        maxElement = minElement;
        sum = minElement;
 
        // Traverse the entire array
        for (int i = 1; i < arr.length; i++) {
 
            // calculate the sum of
            // array elements
            sum += arr[i];
 
            // Keep updating the
            // minimum element
            if (arr[i] < minElement) {
                minElement = arr[i];
            }
 
            // Keep updating the
            // maximum element
            if (arr[i] > maxElement) {
                maxElement = arr[i];
            }
        }
 
        // print the minimum and maximum sum
        System.out.println((sum - maxElement) + " "
                        + (sum - minElement));
    }
 
    // Driver Code
    public static void main(String args[])
    {
 
        // Test Case 1:
        int a1[] = { 13, 5, 11, 9, 7 };
        // Call miniMaxSum()
        miniMaxSum(a1);
 
        // Test Case 2:
        int a2[] = { 13, 11, 45, 32, 89, 21 };
        miniMaxSum(a2);
 
        // Test Case 3:
        int a3[] = { 6, 3, 15, 27, 9 };
        miniMaxSum(a3);
    }
}

Python3




# Python3 program to find the minimum and
# maximum sum from a list.
 
# Function to calculate minimum and maximum sum
def miniMaxSum(arr, n):
 
    # Initialize the minElement, maxElement
    # and sum by 0.
    minElement = 0
    maxElement = 0
    sum = 0
 
    # Assigning maxElement, minElement
    # and sum as the first list element
    minElement = arr[0]
    maxElement = minElement
    sum = minElement
 
    # Traverse the entire list
    for i in range(1, n):
 
        # Calculate the sum of
        # list elements
        sum += arr[i]
 
        # Keep updating the
        # minimum element
        if (arr[i] < minElement):
            minElement = arr[i]
 
        # Keep updating the
        # maximum element
        if (arr[i] > maxElement):
            maxElement = arr[i]
 
    # Print the minimum and maximum sum
    print(sum - maxElement,
          sum - minElement)
 
# Driver Code
 
# Test Case 1:
a1 = [ 13, 5, 11, 9, 7 ]
n = len(a1)
 
# Call miniMaxSum()
miniMaxSum(a1, n)
 
# Test Case 2:
a2 = [ 13, 11, 45, 32, 89, 21 ]
n = len(a2)
miniMaxSum(a2, n)
 
# Test Case 3:
a3 = [ 6, 3, 15, 27, 9 ]
n = len(a3)
miniMaxSum(a3, n)
 
# This code is contributed by vishu2908

C#




// C# program to find the minimum and maximum
// sum from an array.
using System;
 
class GFG{
 
// Function to calculate minimum and maximum sum
static void miniMaxSum(int[] arr)
{
     
    // Initialize the minElement, maxElement
    // and sum by 0.
    int minElement = 0, maxElement = 0, sum = 0;
 
    // Assigning maxElement, minElement
    // and sum as the first array element
    minElement = arr[0];
    maxElement = minElement;
    sum = minElement;
 
    // Traverse the entire array
    for(int i = 1; i < arr.Length; i++)
    {
         
        // Calculate the sum of
        // array elements
        sum += arr[i];
 
        // Keep updating the
        // minimum element
        if (arr[i] < minElement)
        {
            minElement = arr[i];
        }
 
        // Keep updating the
        // maximum element
        if (arr[i] > maxElement)
        {
            maxElement = arr[i];
        }
    }
 
    // Print the minimum and maximum sum
    Console.WriteLine((sum - maxElement) + " " +
                      (sum - minElement));
}
 
// Driver Code
public static void Main()
{
     
    // Test Case 1:
    int[] a1 = new int[]{ 13, 5, 11, 9, 7 };
     
    // Call miniMaxSum()
    miniMaxSum(a1);
 
    // Test Case 2:
    int[] a2 = new int[]{ 13, 11, 45, 32, 89, 21 };
    miniMaxSum(a2);
 
    // Test Case 3:
    int[] a3 = new int[]{ 6, 3, 15, 27, 9 };
    miniMaxSum(a3);
}
}
 
// This code is contributed by sanjoy_62
Output
32 40
122 200
33 57

Time complexity: O(N)

 

competitive-programming-img

My Personal Notes arrow_drop_up
Recommended Articles
Page :