Encuentre la diferencia de conteo de elementos iguales a la derecha y a la izquierda para cada elemento

Dada una array arr[] de tamaño N . La tarea es encontrar X – Y para cada uno de los elementos donde X es el conteo de j tal que arr[i] = arr[j] y j > i . Y es la cuenta de j tal que arr[i] = arr[j] y j < i .
Ejemplos: 
 

Entrada: arr[] = {1, 2, 3, 2, 1} 
Salida: 1 1 0 -1 -1 
Para índice 0, X – Y = 1 – 0 = 1 
Para índice 1, X – Y = 1 – 0 = 1 
Para el índice 2, X – Y = 0 – 0 = 0 
Para el índice 3, X – Y = 0 – 1 = -1 
Para el índice 4, X – Y = 0 – 1 = -1
Entrada: arr[] = { 1, 1, 1, 1, 1} 
Salida: 4 2 0 -2 -4 
 

Enfoque: Un enfoque eficiente es usar un mapa . Un mapa es para almacenar el recuento de cada elemento en la array y otro mapa para contar el número de elementos iguales que quedan en cada elemento.
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the count of equal
// elements to the right - count of equal
// elements to the left for each of the element
void right_left(int a[], int n)
{
 
    // Maps to store the frequency and same
    // elements to the left of an element
    unordered_map<int, int> total, left;
 
    // Count the frequency of each element
    for (int i = 0; i < n; i++)
        total[a[i]]++;
 
    for (int i = 0; i < n; i++) {
 
        // Print the answer for each element
        cout << (total[a[i]] - 1 - (2 * left[a[i]])) << " ";
 
        // Increment it's left frequency
        left[a[i]]++;
    }
}
 
// Driver code
int main()
{
    int a[] = { 1, 2, 3, 2, 1 };
    int n = sizeof(a) / sizeof(a[0]);
 
    right_left(a, n);
 
    return 0;
}

// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to find the count of equal
// elements to the right - count of equal
// elements to the left for each of the element
static void right_left(int a[], int n)
{
 
    // Maps to store the frequency and same
    // elements to the left of an element
    Map<Integer, Integer> total = new HashMap<>();
    Map<Integer, Integer> left = new HashMap<>();
 
    // Count the frequency of each element
    for (int i = 0; i < n; i++)
        total.put(a[i],
        total.get(a[i]) == null ? 1 :
        total.get(a[i]) + 1);
 
    for (int i = 0; i < n; i++)
    {
 
        // Print the answer for each element
        System.out.print((total.get(a[i]) - 1 -
                         (2 * (left.containsKey(a[i]) == true ?
                               left.get(a[i]) : 0))) + " ");
 
        // Increment it's left frequency
        left.put(a[i],
        left.get(a[i]) == null ? 1 :
        left.get(a[i]) + 1);
    }
}
 
// Driver code
public static void main(String[] args)
{
    int a[] = { 1, 2, 3, 2, 1 };
    int n = a.length;
 
    right_left(a, n);
}
}
 
// This code is contributed by Princi Singh

# Python3 implementation of the approach
 
# Function to find the count of equal
# elements to the right - count of equal
# elements to the left for each of the element
def right_left(a, n) :
 
    # Maps to store the frequency and same
    # elements to the left of an element
    total = dict.fromkeys(a, 0);
    left = dict.fromkeys(a, 0);
 
    # Count the frequency of each element
    for i in range(n) :
        if a[i] not in total :
            total[a[i]] = 1
        total[a[i]] += 1;
 
    for i in range(n) :
 
        # Print the answer for each element
        print(total[a[i]] - 1 - (2 * left[a[i]]),
                                      end = " ");
 
        # Increment it's left frequency
        left[a[i]] += 1;
 
# Driver code
if __name__ == "__main__" :
 
    a = [ 1, 2, 3, 2, 1 ];
    n = len(a);
 
    right_left(a, n);
 
# This code is contributed by AnkitRai01

// C# implementation of the approach
using System;
using System.Collections.Generic;
     
class GFG
{
 
// Function to find the count of equal
// elements to the right - count of equal
// elements to the left for each of the element
static void right_left(int []a, int n)
{
 
    // Maps to store the frequency and same
    // elements to the left of an element
    Dictionary<int, int> total = new Dictionary<int, int>();
    Dictionary<int, int> left = new Dictionary<int, int>();
 
    // Count the frequency of each element
    for (int i = 0; i < n; i++)
    {
        if(total.ContainsKey(a[i]))
        {
            total[a[i]] = total[a[i]] + 1;
        }
        else{
            total.Add(a[i], 1);
        }
    }
 
    for (int i = 0; i < n; i++)
    {
 
        // Print the answer for each element
        Console.Write((total[a[i]] - 1 -
                      (2 * (left.ContainsKey(a[i]) == true ?
                                   left[a[i]] : 0))) + " ");
 
        // Increment it's left frequency
        if(left.ContainsKey(a[i]))
        {
            left[a[i]] = left[a[i]] + 1;
        }
        else
        {
            left.Add(a[i], 1);
        }
    }
}
 
// Driver code
public static void Main(String[] args)
{
    int []a = { 1, 2, 3, 2, 1 };
    int n = a.Length;
 
    right_left(a, n);
}
}
 
// This code is contributed by Rajput-Ji

<script>
 
    // Javascript implementation of the approach
 
// Function to find the count of equal
// elements to the right - count of equal
// elements to the left for each of the element
function right_left(a, n)
{
   
    // Maps to store the frequency and same
    // elements to the left of an element
   let total = new Map();
    let left = new Map();
   
    // Count the frequency of each element
    for (let i = 0; i < n; i++)
        total.set(a[i],
        total.get(a[i]) == null ? 1 :
        total.get(a[i]) + 1);
   
    for (let i = 0; i < n; i++)
    {
   
        // Print the answer for each element
        document.write((total.get(a[i]) - 1 -
                         (2 * (left.has(a[i]) == true ?
                               left.get(a[i]) : 0))) + " ");
   
        // Increment it's left frequency
        left.set(a[i],
        left.get(a[i]) == null ? 1 :
        left.get(a[i]) + 1);
    }
}
     
    // Driver code
     
        let a = [ 1, 2, 3, 2, 1 ];
    let n = a.length;
   
    right_left(a, n);
     
    // This code is contributed by susmitakundugoaldanga.
</script>

1 1 0 -1 -1