#include    #include  using namespace std; vector<int> findSurpasser(vector<int> &arr) {  int n = arr.size();    // array to store surpasser counts  vector<int> res(n 0);    for (int i = 0; i < n; i++) {    // Find surpasser for arr[i]  int count = 0;  for (int j = i + 1; j < n; j++) {  if (arr[j] > arr[i])  count++;  }    res[i] = count;   }  return res; } int main() {  vector<int> arr = {2 7 5 3 8 1};  vector<int> res = findSurpasser(arr);   for (int count : res)   cout << count << ' ';    return 0; } 

#include  #include  int* findSurpasser(int arr[] int n) {    // Array to store surpasser counts  int* res = (int*)malloc(n * sizeof(int));    for (int i = 0; i < n; i++) {  // Find surpasser for arr[i]  int count = 0;  for (int j = i + 1; j < n; j++) {  if (arr[j] > arr[i])  count++;  }  res[i] = count;  }    return res; } int main() {  int arr[] = {2 7 5 3 8 1};  int n = sizeof(arr) / sizeof(arr[0]);  int* res = findSurpasser(arr n);  for (int i = 0; i < n; i++)  printf('%d ' res[i]);    return 0; } 

import java.util.ArrayList; class GfG {  static ArrayList<Integer> findSurpasser(int[] arr) {  int n = arr.length;    // List to store surpasser counts  ArrayList<Integer> res = new ArrayList<>();    for (int i = 0; i < n; i++) {    // Find surpasser for arr[i]  int count = 0;  for (int j = i + 1; j < n; j++) {  if (arr[j] > arr[i])  count++;  }    res.add(count);  }  return res;  }  public static void main(String[] args) {  int[] arr = {2 7 5 3 8 1};  ArrayList<Integer> res = findSurpasser(arr);   for (int count : res)  System.out.print(count + ' ');  } } 

def findSurpasser(arr): n = len(arr) # List to store surpasser counts res = [0] * n for i in range(n): # Find surpasser for arr[i] count = 0 for j in range(i + 1 n): if arr[j] > arr[i]: count += 1 res[i] = count return res if __name__ == '__main__': arr = [2 7 5 3 8 1] result = findSurpasser(arr) for val in result: print(val end=' ') 

using System; using System.Collections.Generic; class GfG {  static List<int> findSurpasser(int[] arr) {  int n = arr.Length;    // List to store surpasser counts  List<int> res = new List<int>();    for (int i = 0; i < n; i++) {    // Find surpasser for arr[i]  int count = 0;  for (int j = i + 1; j < n; j++) {  if (arr[j] > arr[i])  count++;  }    res.Add(count);   }  return res;  }  static void Main(string[] args) {  int[] arr = { 2 7 5 3 8 1 };  List<int> result = findSurpasser(arr);   foreach (int count in result)  Console.Write(count + ' ');  } } 

function findSurpasser(arr) {  const n = arr.length;    // array to store surpasser counts  let res = new Array(n).fill(0);    for (let i = 0; i < n; i++) {    // Find surpasser for arr[i]  let count = 0;  for (let j = i + 1; j < n; j++) {  if (arr[j] > arr[i])  count++;  }    res[i] = count;  }  return res; } // Driver Code const arr = [2 7 5 3 8 1]; const result = findSurpasser(arr); console.log(result.join(' ')); 

#include    #include  #include  using namespace std; // Merge function to sort the array and update surpasser counts int merge(vector<int> &arr int lo int mid int hi   unordered_map<int int> &m) {    int n1 = mid - lo + 1;  int n2 = hi - mid;  vector<int> left(n1) right(n2);     // Copy data into temporary arrays left[] and right[]  for (int i = 0; i < n1; i++)  left[i] = arr[lo + i];     for (int j = 0; j < n2; j++)  right[j] = arr[mid + 1 + j];   int i = 0 j = 0 k = lo;    // Merging two halves  while (i < n1 && j < n2) {    // All elements in right[j..n2] are greater than left[i]  // So add n2 - j in surpasser count of left[i]  if (left[i] < right[j]) {  m[left[i]] += n2 - j;   arr[k++] = left[i++];  }   else {  arr[k++] = right[j++];  }  }  // Copy remaining elements of left[] if any  while (i < n1)  arr[k++] = left[i++];  // Copy remaining elements of right[] if any  while (j < n2)  arr[k++] = right[j++]; } void mergeSort(vector<int> &arr int lo int hi   unordered_map<int int> &m) {  if (lo < hi) {  int mid = lo + (hi - lo) / 2;    // Sort left and right half  mergeSort(arr lo mid m);   mergeSort(arr mid + 1 hi m);    // Merge them  merge(arr lo mid hi m);   } } vector<int> findSurpasser(vector<int>& arr) {  int n = arr.size();    // Map to store surpasser counts  unordered_map<int int> m;    // Duplicate array to perform merge Sort  // so that orginial array is not modified  vector<int> dup = arr;   mergeSort(dup 0 n - 1 m);   // Store surpasser counts in result array  // in the same order as given array  vector<int> res(n);  for (int i = 0; i < n; i++)  res[i] = m[arr[i]];     return res; } int main() {  vector<int> arr = {2 7 5 3 8 1};  vector<int> res = findSurpasser(arr);   for (int count : res)  cout << count << ' ';  return 0; } 

import java.util.List; import java.util.Map; import java.util.HashMap; import java.util.ArrayList; class GfG {  // Merge function to sort the array   // and update surpasser counts  static void merge(int[] arr int lo int mid int hi   Map<Integer Integer> m) {  int n1 = mid - lo + 1;  int n2 = hi - mid;  int[] left = new int[n1];  int[] right = new int[n2];  // Copy data into temporary arrays left[] and right[]  for (int i = 0; i < n1; i++)  left[i] = arr[lo + i];  for (int j = 0; j < n2; j++)  right[j] = arr[mid + 1 + j];  int i = 0 j = 0 k = lo;  // Merging two halves  while (i < n1 && j < n2) {  // All elements in right[j..n2] are greater than left[i]  // So add n2 - j to surpasser count of left[i]  if (left[i] < right[j]) {  m.put(left[i] m.getOrDefault(left[i] 0) + n2 - j);  arr[k++] = left[i++];  }   else {  arr[k++] = right[j++];  }  }  // Copy remaining elements of left[] if any  while (i < n1)  arr[k++] = left[i++];  // Copy remaining elements of right[] if any  while (j < n2)  arr[k++] = right[j++];  }  static void mergeSort(int[] arr int lo int hi   Map<Integer Integer> m) {  if (lo < hi) {  int mid = lo + (hi - lo) / 2;  // Sort left and right halves  mergeSort(arr lo mid m);   mergeSort(arr mid + 1 hi m);  // Merge them  merge(arr lo mid hi m);  }  }  static ArrayList<Integer> findSurpasser(int[] arr) {  int n = arr.length;  // Map to store surpasser counts  Map<Integer Integer> m = new HashMap<>();  // Duplicate array to perform merge sort  int[] dup = arr.clone();  mergeSort(dup 0 n - 1 m);  // Store surpasser counts in result list  ArrayList<Integer> res = new ArrayList<>();  for (int i = 0; i < n; i++)  res.add(m.getOrDefault(arr[i] 0));  return res;  }  public static void main(String[] args) {  int[] arr = {2 7 5 3 8 1};  ArrayList<Integer> res = findSurpasser(arr);  for (int count : res)  System.out.print(count + ' ');  } } 

def merge(arr lo mid hi m): n1 = mid - lo + 1 n2 = hi - mid left = arr[lo:lo+n1] right = arr[mid+1:mid+1+n2] i = j = 0 k = lo # Merging two halves while i < n1 and j < n2: # All elements in right[j..n2] are greater than left[i] # So add n2 - j in surpasser count of left[i] if left[i] < right[j]: m[left[i]] += n2 - j arr[k] = left[i] i += 1 else: arr[k] = right[j] j += 1 k += 1 # Copy remaining elements of left[] if any while i < n1: arr[k] = left[i] i += 1 k += 1 # Copy remaining elements of right[] if any while j < n2: arr[k] = right[j] j += 1 k += 1 def mergeSort(arr lo hi m): if lo < hi: mid = lo + (hi - lo) // 2 # Sort left and right half mergeSort(arr lo mid m) mergeSort(arr mid + 1 hi m) # Merge them merge(arr lo mid hi m) def findSurpasser(arr): n = len(arr) # Map to store surpasser counts m = {key: 0 for key in arr} # Duplicate array to perform merge Sort # so that original array is not modified dup = arr[:] mergeSort(dup 0 n - 1 m) # Store surpasser counts in result array # in the same order as given array res = [m[arr[i]] for i in range(n)] return res if __name__ == '__main__': arr = [2 7 5 3 8 1] result = findSurpasser(arr) for val in result: print(val end=' ') 

using System; using System.Collections.Generic; class GfG {  // Merge function to sort the array   // and update surpasser counts  static void merge(int[] arr int lo int mid int hi   Dictionary<int int> m) {  int n1 = mid - lo + 1;  int n2 = hi - mid;  int[] left = new int[n1];  int[] right = new int[n2];  // Copy data into temporary arrays  for (int i = 0; i < n1; i++)  left[i] = arr[lo + i];  for (int j = 0; j < n2; j++)  right[j] = arr[mid + 1 + j];  int i1 = 0 j1 = 0 k = lo;  // Merge the two halves  while (i1 < n1 && j1 < n2) {  // Count surpassers  if (left[i1] < right[j1]) {  if (!m.ContainsKey(left[i1]))  m[left[i1]] = 0;  m[left[i1]] += n2 - j1;  arr[k++] = left[i1++];  }  else {  arr[k++] = right[j1++];  }  }  // Copy remaining elements  while (i1 < n1)  arr[k++] = left[i1++];  while (j1 < n2)  arr[k++] = right[j1++];  }  static void mergeSort(int[] arr int lo int hi   Dictionary<int int> m) {  if (lo < hi) {  int mid = lo + (hi - lo) / 2;  // Recursive sort  mergeSort(arr lo mid m);  mergeSort(arr mid + 1 hi m);  // Merge sorted halves  merge(arr lo mid hi m);  }  }  static List<int> findSurpasser(int[] arr) {  int n = arr.Length;  Dictionary<int int> m = new Dictionary<int int>();  int[] dup = new int[n];  Array.Copy(arr dup n);  mergeSort(dup 0 n - 1 m);  List<int> res = new List<int>();  for (int i = 0; i < n; i++) {  res.Add(m.ContainsKey(arr[i]) ? m[arr[i]] : 0);  }  return res;  }  static void Main() {  int[] arr = {2 7 5 3 8 1};  List<int> res = findSurpasser(arr);  foreach (int count in res)  Console.Write(count + ' ');  } } 

function merge(arr lo mid hi m) {  const n1 = mid - lo + 1;  const n2 = hi - mid;  const left = [];  const right = [];  // Copy data into temporary arrays left[] and right[]  for (let i = 0; i < n1; i++)  left[i] = arr[lo + i];  for (let j = 0; j < n2; j++)  right[j] = arr[mid + 1 + j];  let i = 0 j = 0 k = lo;  // Merging two halves  while (i < n1 && j < n2) {  // All elements in right[j..n2] are greater than left[i]  // So add n2 - j in surpasser count of left[i]  if (left[i] < right[j]) {  m[left[i]] = (m[left[i]] || 0) + n2 - j;  arr[k++] = left[i++];  }   else {  arr[k++] = right[j++];  }  }  // Copy remaining elements of left[] if any  while (i < n1)  arr[k++] = left[i++];  // Copy remaining elements of right[] if any  while (j < n2)  arr[k++] = right[j++]; } function mergeSort(arr lo hi m) {  if (lo < hi) {  const mid = Math.floor(lo + (hi - lo) / 2);  // Sort left and right half  mergeSort(arr lo mid m);  mergeSort(arr mid + 1 hi m);  // Merge them  merge(arr lo mid hi m);  } } function findSurpasser(arr) {  const n = arr.length;  // Map to store surpasser counts  const m = {};  // Duplicate array to perform merge Sort  // so that original array is not modified  const dup = arr.slice();  mergeSort(dup 0 n - 1 m);  // Store surpasser counts in result array  // in the same order as given array  const res = [];  for (let i = 0; i < n; i++)  res.push(m[arr[i]] || 0);  return res; } // Driver Code const arr = [2 7 5 3 8 1]; const res = findSurpasser(arr); console.log(res.join(' '));