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 8Input: 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++ 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 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 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# 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 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 |
<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> |
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:
#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 |
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);
}
} |
# 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 |
// 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); |
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);
}
} |
4 4 7 8
Time Complexity: O(n)
Auxiliary Space: O(n)