Choose n elements such that their mean is maximum

Given an array of 2 * n elements, the task is to construct and print an array of n elements such that the mean of the new array is maximum. Here n is even.

Examples:

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

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

Approach: Mean of an array is the average of the elements of the same array i.e (?arr[i]) / n. So, in order for the mean of the array to be maximum, choose the maximum n elements from the array, this can be done by first sorting the array and then choosing the elements starting from the maximum.

Below is the implementation of the above approach: 

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Utility function to print the contents
// of an array
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}

// Function to print the array with
// maximum mean
void printMaxMean(int arr[], int n)
{
    int newArr[n];

    // Sort the original array
    sort(arr, arr + 2 * n);

    // Construct new array
    for (int i = 0; i < n; i++)
        newArr[i] = arr[i + n];

    // Print the resultant array
    printArray(newArr, n);
}

// Driver code
int main()
{
    int arr[] = { 4, 8, 3, 1, 3, 7, 0, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printMaxMean(arr, n / 2);

    return 0;
}

Java

// Java implementation of the approach
import java.util.Arrays;

class GfG{

    // Utility function to print the
    // contents of an array
    static void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }

    // Function to print the array
    // with maximum mean
    static void printMaxMean(int arr[], int n)
    {
        int newArr[] = new int[n];

        // Sort the original array
        Arrays.sort(arr, 0, 2 * n);

        // Construct new array
        for (int i = 0; i < n; i++)
            newArr[i] = arr[i + n];

        // Print the resultant array
        printArray(newArr, n);
    }

    // Driver code
    public static void main(String []args)
    {
        int arr[] = { 4, 8, 3, 1, 3, 7, 0, 4 };
        int n = arr.length;
        printMaxMean(arr, n / 2);
    }
}

// This code is contributed by
// Rituraj Jain

Python3

# Python3 implementation of the approach

# Utility function to print the contents
# of an array
def printArray(arr, n) :
    for i in range(n) :
        print(arr[i], end = " ")

# Function to print the array with
# maximum mean
def printMaxMean(arr, n) :
    newArr = [0] * n

    # Sort the original array
    arr.sort()

    # Construct new array
    for i in range(n) :
        newArr[i] = arr[i + n]

    # Print the resultant array
    printArray(newArr, n)

# Driver code
if __name__ == "__main__" :

    arr = [ 4, 8, 3, 1, 3, 7, 0, 4 ]
    n = len(arr)
    printMaxMean(arr, n // 2)

# This code is contributed by Ryuga

C#

// C# implementation of the approach
using System;

class GfG
{

    // Utility function to print the
    // contents of an array
    static void printArray(int[] arr, int n)
    {
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }

    // Function to print the array
    // with maximum mean
    static void printMaxMean(int[] arr, int n)
    {
        int[] newArr = new int[n];

        // Sort the original array
        Array.Sort(arr, 0, 2 * n);

        // Construct new array
        for (int i = 0; i < n; i++)
            newArr[i] = arr[i + n];

        // Print the resultant array
        printArray(newArr, n);
    }

    // Driver code
    public static void Main()
    {
        int[] arr = { 4, 8, 3, 1, 3, 7, 0, 4 };
        int n = arr.Length;
        printMaxMean(arr, n / 2);
    }
}

// This code is contributed by Ita_c.

PHP

<?php
// PHP implementation of the approach

// Utility function to print the contents
// of an array
function printArray($arr, $n)
{
    for ($i = 0; $i < $n; $i++)
        echo $arr[$i] . " ";
}

// Function to print the array with
// maximum mean
function printMaxMean($arr, $n)
{
    $newArr[$n] = array();

    // Sort the original array
    sort($arr,0);

    // Construct new array
    for ($i = 0; $i < $n; $i++)
        $newArr[$i] = $arr[$i + $n];

    // Print the resultant array
    printArray($newArr, $n);
}

// Driver code
$arr = array(4, 8, 3, 1, 3, 7, 0, 4);
$n = sizeof($arr);
printMaxMean($arr, $n / 2);

// This code is contributed
// by Akanksha Rai

Javascript

<script>
// javascript implementation of the approach


    // Utility function to print the
    // contents of an array
    function printArray(arr , n) {
        for (i = 0; i < n; i++)
            document.write(arr[i] + " ");
    }

    // Function to print the array
    // with maximum mean
    function printMaxMean(arr , n) {
        var newArr = Array(n).fill(0);

        // Sort the original array
        arr.sort((a,b)=>a-b);

        // Construct new array
        for (i = 0; i < n; i++)
            newArr[i] = arr[i + n];

        // Print the resultant array
        printArray(newArr, n);
    }

    // Driver code

        var arr = [ 4, 8, 3, 1, 3, 7, 0, 4 ];
        var n = arr.length;
        printMaxMean(arr, n / 2);

// This code contributed by gauravrajput1
</script>

Output

4 4 7 8 

Complexity Analysis:

• Time Complexity: O(n logn)
• Auxiliary Space: O(1) 

Another Efficient Approach using the MAP STL:

In this approach we will using the map data structure because map itself stores the elements in increasing order or sorted order. So, first we will be storing the array elements in the map and then will print the elements from the last to get the maximum mean. 

Implementation of Above Approach is given below:

C++

#include <bits/stdc++.h>
using namespace std;
vector<int> findNelements(vector<int> vec, int n){
  map<int, int> count;
  for(int i = 0; i < 2*n; i++){
    count[vec[i]]++;
  }
  vector<int> result;
  int last = count.rbegin()->first;
  while(n > 0){
    if(count[last] == 0) last--;
    else{
      result.push_back(last);
      count[last]--;
      --n;
     }
  }
  return result;
}

void printElements(vector<int> output){
    for(int i = output.size()-1; i >= 0; i--){
        cout << output[i] << " ";
    }
}
int main() {
  vector<int> vec = { 4, 8, 3, 1, 3, 7, 0, 4 };
  int n = vec.size()/2;
  vector<int> output = findNelements(vec, n);
  printElements(output);
  return 0;
}

// This code is contributed by Prince Kumar

Java

import java.util.*;

// Defining the Main class
public class Main { // Defining a function to find n largest
  // elements in the given list
  public static List<Integer>
    findNelements(List<Integer> vec, int n)
  {

    // Creating a map to store the count of each element
    // in the list
    Map<Integer, Integer> count = new HashMap<>();
    for (int i = 0; i < vec.size(); i++)
    {

      // Updating the count of the element in the map
      count.put(vec.get(i),
                count.getOrDefault(vec.get(i), 0)
                + 1);
    }

    // Creating a list to store the n largest elements
    List<Integer> result = new ArrayList<>();

    // Finding the n largest elements
    int last = Collections.max(count.keySet());
    while (n > 0) {
      if (count.get(last) == null
          || count.get(last) == 0)
        last--;
      else {
        result.add(last);
        count.put(last, count.get(last) - 1);
        n--;
      }
    }
    // Returning the list of n largest elements
    return result;
  }

  // Defining a function to print the list of elements in
  // reverse order
  public static void printElements(List<Integer> output)
  {
    for (int i = output.size() - 1; i >= 0; i--) {
      System.out.print(output.get(i) + " ");
    }
  }

  // Defining the main function
  public static void main(String[] args)
  {
    // Creating a list of integers
    List<Integer> vec
      = Arrays.asList(4, 8, 3, 1, 3, 7, 0, 4);
    // Defining the value of n as half of the list size
    int n = vec.size() / 2;
    List<Integer> output = findNelements(vec, n);
    printElements(output);
  }
}

Python3

# Python code for the above approach

from collections import defaultdict

# Function for finding the
# n elements
def findNelements(vec, n):
    count = defaultdict(int)
    for i in range(2*n):
        count[vec[i]] += 1
    result = []
    last = max(count.keys())
    while n > 0:
        if count[last] == 0:
            last -= 1
        else:
            result.append(last)
            count[last] -= 1
            n -= 1
    return result

# Function to print the
# selected n elements
def printElements(output):
    for i in range(len(output)-1, -1, -1):
        print(output[i], end=' ')
    print()

# Driver code
if __name__ == '__main__':
    vec = [4, 8, 3, 1, 3, 7, 0, 4]
    n = len(vec) // 2
    output = findNelements(vec, n)
    printElements(output)

# This code is contributed by princekumaras

Javascript

// Function for finding the
// n elements
function findNelements(vec, n) {
    let count = new Map();
    for (let i = 0; i < 2*n; i++) {
        count.set(vec[i], (count.get(vec[i]) || 0) + 1);
    }
    let result = [];
    let keys = Array.from(count.keys()).sort((a, b) => b - a);
    for (let i = 0; i < keys.length && n > 0; i++) {
        let key = keys[i];
        let freq = count.get(key);
        while (freq > 0 && n > 0) {
            result.push(key);
            freq--;
            n--;
        }
    }
    return result;
}

// Function to print the
// selected n elements
function printElements(output) {
    for (let i = output.length - 1; i >= 0; i--) {
        process.stdout.write(output[i] + ' ');
    }
    console.log();
}

// Driver code
let vec = [4, 8, 3, 1, 3, 7, 0, 4];
let n = vec.length / 2;
let output = findNelements(vec, n);
printElements(output);

C#

using System;
using System.Collections.Generic;
using System.Linq;

class Program {
    // Defining a function to find n largest
    // elements in the given list
    public static List<int> FindNelements(List<int> vec,
                                          int n)
    {

        // Creating a dictionary to store the count of each
        // element in the list
        Dictionary<int, int> count
            = new Dictionary<int, int>();
        for (int i = 0; i < vec.Count; i++) {

            // Updating the count of the element in the
            // dictionary
            if (count.ContainsKey(vec[i])) {
                count[vec[i]]++;
            }
            else {
                count[vec[i]] = 1;
            }
        }

        // Creating a list to store the n largest elements
        List<int> result = new List<int>();

        // Finding the n largest elements
        int last = count.Keys.Max();
        while (n > 0) {
            if (!count.ContainsKey(last)
                || count[last] == 0) {
                last--;
            }
            else {
                result.Add(last);
                count[last]--;
                n--;
            }
        }
        // Returning the list of n largest elements
        return result;
    }

    // Defining a function to print the list of elements in
    // reverse order
    public static void PrintElements(List<int> output)
    {
        for (int i = output.Count - 1; i >= 0; i--) {
            Console.Write(output[i] + " ");
        }
    }

    // Defining the main function
    public static void Main(string[] args)
    {
        // Creating a list of integers
        List<int> vec
            = new List<int>{ 4, 8, 3, 1, 3, 7, 0, 4 };
        // Defining the value of n as half of the list size
        int n = vec.Count / 2;
        List<int> output = FindNelements(vec, n);
        PrintElements(output);
    }
}

Output

4 4 7 8 

Time Complexity: O(n)

Auxiliary Space: O(n)