Skip to content
Related Articles
Open in App
Not now

Related Articles

Generate original array from an array that store the counts of greater elements on right

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 09 Nov, 2022
Improve Article
Save Article

Given an array of integers greater[] in which every value of array represents how many elements are greater to its right side in an unknown array arr[]. Our task is to generate original array arr[]. It may be assumed that the original array contains elements in range from 1 to n and all elements are unique 

Examples: 

Input: greater[] = { 6, 3, 2, 1, 0, 0, 0 }
Output: arr[] = [ 1, 4, 5, 6, 7, 3, 2 ]

 Input: greater[] = { 0, 0, 0, 0, 0 }
Output: arr[] = [ 5, 4, 3, 2, 1 ]  

We consider an array of elements temp[] = {1, 2, 3, 4, .. n}. We know value of greater[0] indicates count of elements greater than arr[0]. We can observe that (n – greater[0])-th element of temp[] can be put at arr[0]. So we put this at arr[0] and remove this from temp[]. We repeat above process for remaining elements. For every element greater[i], we put (n – greater[i] – i)-th element of temp[] in arr[i] and remove it from temp[].

Below is the implementation of the above idea 

C++




// C++ program to generate original array
// from an array that stores counts of
// greater elements on right.
#include <bits/stdc++.h>
using namespace std;
 
void originalArray(int greater[], int n)
{
    // Array that is used to include every
    // element only once
    vector<int> temp;
    for (int i = 0; i <= n; i++)
        temp.push_back(i);
 
    // Traverse the array element
    int arr[n];
    for (int i = 0; i < n; i++) {
 
        // find the K-th (n-greater[i]-i)
        // smallest element in Include_Array
        int k = n - greater[i] - i;
 
        arr[i] = temp[k];
 
        // remove current k-th element
        // from Include array
        temp.erase(temp.begin() + k);
    }
 
    // print resultant array
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
 
// driver program to test above function
int main()
{
    int Arr[] = { 6, 3, 2, 1, 0, 1, 0 };
    int n = sizeof(Arr) / sizeof(Arr[0]);
    originalArray(Arr, n);
    return 0;
}

Java




// Java program to generate original array
// from an array that stores counts of
// greater elements on right.
import java.util.Vector;
 
class GFG {
 
    static void originalArray(int greater[], int n)
    {
        // Array that is used to include every
        // element only once
        Vector<Integer> temp = new Vector<Integer>();
        for (int i = 0; i <= n; i++)
            temp.add(i);
 
        // Traverse the array element
        int arr[] = new int[n];
        for (int i = 0; i < n; i++) {
 
            // find the K-th (n-greater[i]-i)
            // smallest element in Include_Array
            int k = n - greater[i] - i;
 
            arr[i] = temp.get(k);
 
            // remove current k-th element
            // from Include array
            temp.remove(k);
        }
 
        // print resultant array
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int Arr[] = { 6, 3, 2, 1, 0, 1, 0 };
        int n = Arr.length;
        originalArray(Arr, n);
    }
}
 
// This code is contributed by Rajput-Ji

Python3




# Python3 program original array from an
# array that stores counts of greater
# elements on right
 
 
def originalArray(greater, n):
 
    # array that is used to include
    # every element only once
    temp = []
 
    for i in range(n + 1):
        temp.append(i)
 
    # traverse the array element
    arr = [0 for i in range(n)]
 
    for i in range(n):
 
        # find the Kth (n-greater[i]-i)
        # smallest element in Include_array
        k = n - greater[i] - i
 
        arr[i] = temp[k]
 
        # remove current kth element
        # from include array
        del temp[k]
 
    for i in range(n):
        print(arr[i], end=" ")
 
 
# Driver code
arr = [6, 3, 2, 1, 0, 1, 0]
n = len(arr)
originalArray(arr, n)
 
# This code is contributed
# by Mohit Kumar

C#




// C# program to generate original array
// from an array that stores counts of
// greater elements on right.
using System;
using System.Collections.Generic;
 
class GFG {
 
    static void originalArray(int[] greater, int n)
    {
        // Array that is used to include every
        // element only once
        List<int> temp = new List<int>();
        for (int i = 0; i <= n; i++)
            temp.Add(i);
 
        // Traverse the array element
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
 
            // find the K-th (n-greater[i]-i)
            // smallest element in Include_Array
            int k = n - greater[i] - i;
 
            arr[i] = temp[k];
 
            // remove current k-th element
            // from Include array
            temp.RemoveAt(k);
        }
 
        // print resultant array
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }
 
    // Driver code
    public static void Main()
    {
        int[] Arr = { 6, 3, 2, 1, 0, 1, 0 };
        int n = Arr.Length;
        originalArray(Arr, n);
    }
}
 
/* This code contributed by PrinciRaj1992 */

Javascript




<script>
 
// JavaScript program to generate original array
// from an array that stores counts of
// greater elements on right.
     
    function originalArray(greater,n)
    {
        // Array that is used to include every
    // element only once
    let temp = [];
    for (let i = 0; i <= n; i++)
        temp.push(i);
   
    // Traverse the array element
    let arr = new Array(n);
    for (let i = 0; i < n; i++)
    {
   
        // find the K-th (n-greater[i]-i)
        // smallest element in Include_Array
        let k = n - greater[i] - i;
   
        arr[i] = temp[k];
   
        // remove current k-th element
        // from Include array
        temp.splice(k,1);
    }
   
    // print resultant array
    for (let i = 0; i < n; i++)
            document.write(arr[i] + " ");
    }
     
    // Driver code
    let Arr=[6, 3, 2, 1, 0, 1, 0 ];
    let n = Arr.length;
    originalArray(Arr, n);
     
 
// This code is contributed by patel2127
 
</script>

Output

1 4 5 6 7 2 3 

Time Complexity: (n2) (Erase operation takes O(n) in vector).
Auxiliary Space: O(n), extra space is required for temp and res arrays.


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!