Related Articles

# Generate an array consisting of most frequent greater elements present on the right side of each array element

• Difficulty Level : Medium
• Last Updated : 28 Jun, 2021

Given an array A[] of size N, the task is to generate an array B[] based on the following conditions:

• For every array element A[i], find the most frequent element greater than A[i] present on the right of A[i]. Insert that element into B[].
• If more than one such element is present on the right, choose the element having the smallest value.
• If no element greater than A[i] is present on the right of A[i] then insert -1 into B[].

Finally, print the array B[] that is obtained.

Examples:

Input: A[] = {4, 5, 2, 25, 10, 5, 10, 3, 10, 5}
Output: 5, 10, 10, -1, -1, 10, -1, 5, -1, -1
Explanation:
A (= 4): Array elements greater than 4 are {5, 25, 10}. Since 5 occurs maximum number of times, set B = 5.
A (= 5): Array elements greater than 5 are {25, 10}. Since 10 occurs maximum number of times, set B = 10.
A (= 2): Array elements greater than 2 are {5, 25, 10}. Since 10 occurs maximum number of times, set B = 10.
A (= 25): No element greater than A found on its right. Therefore, set B = -1.
A (= 10): No element greater than A found on its right. Therefore, set B = -1.
Similarly, set B = 10, B = -1, B = 5, B = -1, B = -1.
Therefore, the obtained array is B[] = {5, 10, 10, -1, -1, 10, -1, 5, -1, -1}.

Input: A[] = {1, 1, 3, 3, 2, 2}
Output: 2, 2, -1, -1, -1, -1

Naive Approach: Follow the steps below to solve the problem:

• Initialize an array,  say V,  to store the resultant array elements.
• Traverse the array A[] using a variable, say i, and perform the following operations:
• Initialize variables ans as -1 and freq as 0, to store the result for the current index and its frequency.
• Iterate over the range [i+1, N-1] using a variable, say j, and perform the following operations:
• If the frequency of A[j] ≤ A[i], then continue.
• Otherwise, check if the frequency of A[j] > freq. If found to be true, then update ans to A[j] and freq to the frequency of A[j].
• Otherwise, if the frequency of A[j] is equal to freq, then update ans to a smaller value among A[j] and ans.
• Insert the value of ans to the array, V.
• Print the array, V as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to generate an array containing``// the most frequent greater element on the``// right side of each array element``void` `findArray(``int` `arr[], ``int` `n)``{``    ``// Stores the generated array``    ``vector<``int``> v;` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Store the result for the``        ``// current index and its frequency``        ``int` `ans = -1, old_c = 0;` `        ``// Iterate over the right subarray``        ``for` `(``int` `j = i + 1; j < n; j++) {` `            ``if` `(arr[j] > arr[i]) {` `                ``// Store the frequency of``                ``// the current array element``                ``int` `curr_c``                    ``= count(&arr[j], &arr[n], arr[j]);` `                ``// If the frequencies are equal``                ``if` `(curr_c == old_c) {` `                    ``// Update ans to smaller``                    ``// of the two elements``                    ``if` `(arr[j] < ans)``                        ``ans = arr[j];``                ``}` `                ``// If count of new element``                ``// is more than count of ans``                ``if` `(curr_c > old_c) {``                    ``ans = arr[j];``                    ``old_c = curr_c;``                ``}``            ``}``        ``}` `        ``// Insert answer in the array``        ``v.push_back(ans);``    ``}` `    ``// Print the resultant array``    ``for` `(``int` `i = 0; i < v.size(); i++)``        ``cout << v[i] << ``" "``;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `arr[] = { 4, 5, 2, 25, 10, 5,``                  ``10, 3, 10, 5 };``    ``int` `size = ``sizeof``(arr)``               ``/ ``sizeof``(arr);` `    ``findArray(arr, size);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{` `// Function to generate an array containing``// the most frequent greater element on the``// right side of each array element``static` `void` `findArray(``int` `arr[], ``int` `n)``{``    ` `    ``// Stores the generated array``    ``Vector v = ``new` `Vector();``    ` `    ``// Traverse the array arr[]``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ` `        ``// Store the result for the``        ``// current index and its frequency``        ``int` `ans = -``1``, old_c = ``0``;``        ` `        ``// Iterate over the right subarray``        ``for``(``int` `j = i + ``1``; j < n; j++)``        ``{``            ``if` `(arr[j] > arr[i])``            ``{``                ` `                ``// Store the frequency of``                ``// the current array element``                ``int` `curr_c = ``0``;``                ``for``(``int` `k = j; k < n; k++)``                ``{``                    ``if` `(arr[k] == arr[j])``                    ``{``                        ``curr_c++;``                    ``}``                ``};``                ` `                ``// If the frequencies are equal``                ``if` `(curr_c == old_c)``                ``{``                    ` `                    ``// Update ans to smaller``                    ``// of the two elements``                    ``if` `(arr[j] < ans)``                        ``ans = arr[j];``                ``}``                ` `                ``// If count of new element``                ``// is more than count of ans``                ``if` `(curr_c > old_c)``                ``{``                    ``ans = arr[j];``                    ``old_c = curr_c;``                ``}``            ``}``        ``}``        ` `        ``// Insert answer in the array``        ``v.add(ans);``    ``}``    ` `    ``// Print the resultant array``    ``for``(``int` `i = ``0``; i < v.size(); i++)``        ``System.out.print(v.get(i) + ``" "``);``}` `// Driver Code``public` `static` `void` `main (String[] args)``{` `    ``// Given Input``    ``int` `arr[] = { ``4``, ``5``, ``2``, ``25``, ``10``,``                  ``5``, ``10``, ``3``, ``10``, ``5` `};``    ``int` `size = arr.length;``    ` `    ``findArray(arr, size);``}``}` `// This code is contributed by jana_sayantan`

## Python3

 `# Python3 program for the above approach` `# Function to generate an array containing``# the most frequent greater element on the``# right side of each array element``def` `findArray(arr, n):``    ` `    ``# Stores the generated array``    ``v ``=` `[]` `    ``# Traverse the array arr[]``    ``for` `i ``in` `range``(n):``        ` `        ``# Store the result for the``        ``# current index and its frequency``        ``ans ``=` `-``1``        ``old_c ``=` `0` `        ``# Iterate over the right subarray``        ``for` `j ``in` `range``(i ``+` `1``, n):``            ``if` `(arr[j] > arr[i]):` `                ``# Store the frequency of``                ``# the current array element``                ``curr_c ``=` `arr[j : n ``+` `1``].count(arr[j])` `                ``# If the frequencies are equal``                ``if` `(curr_c ``=``=` `old_c):` `                    ``# Update ans to smaller``                    ``# of the two elements``                    ``if` `(arr[j] < ans):``                        ``ans ``=` `arr[j]` `                ``# If count of new element``                ``# is more than count of ans``                ``if` `(curr_c > old_c):``                    ``ans ``=` `arr[j]``                    ``old_c ``=` `curr_c` `        ``# Insert answer in the array``        ``v.append(ans)` `    ``# Print the resultant array``    ``for` `i ``in` `range``(``len``(v)):``        ``print``(v[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given Input``    ``arr ``=` `[ ``4``, ``5``, ``2``, ``25``, ``10``,``            ``5``, ``10``, ``3``, ``10``, ``5` `]``    ``size ``=` `len``(arr)` `    ``findArray(arr, size)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `// Function to generate an array containing``// the most frequent greater element on the``// right side of each array element``static` `void` `findArray(``int``[] arr, ``int` `n)``{``    ` `    ``// Stores the generated array``    ``List<``int``> v = ``new` `List<``int``>();``    ` `    ``// Traverse the array arr[]``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// Store the result for the``        ``// current index and its frequency``        ``int` `ans = -1, old_c = 0;``        ` `        ``// Iterate over the right subarray``        ``for``(``int` `j = i + 1; j < n; j++)``        ``{``            ``if` `(arr[j] > arr[i])``            ``{``                ` `                ``// Store the frequency of``                ``// the current array element``                ``int` `curr_c = 0;``                ``for``(``int` `k = j; k < n; k++)``                ``{``                    ``if` `(arr[k] == arr[j])``                    ``{``                        ``curr_c++;``                    ``}``                ``};``                ` `                ``// If the frequencies are equal``                ``if` `(curr_c == old_c)``                ``{``                    ` `                    ``// Update ans to smaller``                    ``// of the two elements``                    ``if` `(arr[j] < ans)``                        ``ans = arr[j];``                ``}``                ` `                ``// If count of new element``                ``// is more than count of ans``                ``if` `(curr_c > old_c)``                ``{``                    ``ans = arr[j];``                    ``old_c = curr_c;``                ``}``            ``}``        ``}``        ` `        ``// Insert answer in the array``        ``v.Add(ans);``    ``}``    ` `    ``// Print the resultant array``    ``for``(``int` `i = 0; i < v.Count; i++)``        ``Console.Write(v[i] + ``" "``);``}` `// Driver Code``public` `static` `void` `Main()``{``    ` `    ``// Given Input``    ``int``[] arr= { 4, 5, 2, 25, 10,``                 ``5, 10, 3, 10, 5 };``    ``int` `size = arr.Length;``    ` `    ``findArray(arr, size);``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``
Output:
`5 10 10 -1 -1 10 -1 5 -1 -1`

Time Complexity: O(N2)
Auxiliary Space: O(N)

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up