Modo en una secuencia de enteros (enteros en ejecución)

Dado que los enteros se leen de un flujo de datos. Encuentre la moda de todos los elementos leídos hasta el momento desde el primer entero hasta el último entero.

La moda se define como el elemento que ocurre el tiempo máximo. Si dos o más elementos tienen la misma frecuencia máxima, entonces tome el que tenga la última ocurrencia. 

Ejemplos:

Entrada: corriente[] = {2, 7, 3, 2, 5}
Salida: 2 7 3 2 2 
Explicación: 
El modo de corriente en ejecución se calcula de la siguiente manera: 
Modo({2}) = 2 
Modo({2, 7} ) = 7 
Modo({2, 7, 3}) = 3 
Modo({2, 7, 3, 2}) = 2 
Modo({2, 7, 3, 2, 2}) = 2

Entrada: stream[] = {3, 5, 9, 9, 2, 3, 3, 4}
Salida: 3 5 9 9 9 3 3 3

Enfoque : La idea es usar un Hash-map para mapear elementos a su frecuencia . Mientras lee los elementos uno por uno, actualice las frecuencias de los elementos en el mapa y también actualice el modo, que será el modo del flujo de los números enteros en ejecución.

A continuación se muestra la implementación del enfoque anterior:

// C++ program to implement
// the above approach
#include<bits/stdc++.h>
using namespace std;
  
// Function that prints
// the Mode values
void findMode(int a[], int n)
{
      
    // Map used to mp integers
    // to its frequency
    map<int, int> mp; 
  
    // To store the maximum frequency
    int max = 0;
  
    // To store the element with
    // the maximum frequency
    int mode = 0;
      
    // Loop used to read the
    // elements one by one
    for(int i = 0; i < n; i++) 
    {
          
        // Updates the frequency of
        // that element
        mp[a[i]]++;
      
        // Checks for maximum Number
        // of occurrence
        if (mp[a[i]] >= max) 
        {
      
            // Updates the maximum frequency
            max = mp[a[i]];
      
            // Updates the Mode
            mode = a[i];
        }
        cout << mode << " ";
    }
}
      
// Driver Code
int main()
{
    int arr[] = { 2, 7, 3, 2, 5 };
    int n = sizeof(arr)/sizeof(arr[0]);
  
    // Function call
    findMode(arr, n);
  
    return 0;
} 
  
// This code is contributed by rutvik_56

// Java implementation of the
// above approach
  
import java.util.*;
  
public class GFG {
  
    // Function that prints
    // the Mode values
    public static void findMode(int[] a, int n)
    {
        // Map used to map integers
        // to its frequency
        Map<Integer, Integer> map
            = new HashMap<>();
  
        // To store the maximum frequency
        int max = 0;
  
        // To store the element with
        // the maximum frequency
        int mode = 0;
  
        // Loop used to read the
        // elements one by one
        for (int i = 0; i < n; i++) {
  
            // Updates the frequency of
            // that element
            map.put(a[i],
                    map.getOrDefault(a[i], 0) + 1);
  
            // Checks for maximum Number
            // of occurrence
            if (map.get(a[i]) >= max) {
  
                // Updates the maximum frequency
                max = map.get(a[i]);
  
                // Updates the Mode
                mode = a[i];
            }
  
            System.out.print(mode);
            System.out.print(" ");
        }
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 2, 7, 3, 2, 5 };
  
        int n = arr.length;
  
        // Function Call
        findMode(arr, n);
    }
}

# Python3 implementation of the 
# above approach
  
# Function that prints 
# the Mode values 
def findMode(a, n):
      
    # Map used to mp integers 
    # to its frequency 
    mp = {}
      
    # To store the maximum frequency 
    max = 0
      
    # To store the element with 
    # the maximum frequency 
    mode = 0
      
    # Loop used to read the 
    # elements one by one 
    for i in range(n):
        if a[i] in mp:
            mp[a[i]] += 1
        else:
            mp[a[i]] = 1
          
        # Checks for maximum Number 
        # of occurrence     
        if (mp[a[i]] >= max):
              
            # Updates the maximum 
            # frequency 
            max = mp[a[i]]
              
            # Updates the Mode 
            mode = a[i]
              
        print(mode, end = " ")
  
# Driver Code
arr = [ 2, 7, 3, 2, 5 ]
n = len(arr)
  
# Function call 
findMode(arr,n)
  
# This code is contributed by divyeshrabadiya07

// C# implementation of the
// above approach
using System;
using System.Collections.Generic;
class GFG{
  
    // Function that prints
    // the Mode values
    public static void findMode(int[] a, int n)
    {
        // Map used to map integers
        // to its frequency
        Dictionary<int, int> map = new Dictionary<int, int>();
  
        // To store the maximum frequency
        int max = 0;
  
        // To store the element with
        // the maximum frequency
        int mode = 0;
  
        // Loop used to read the
        // elements one by one
        for (int i = 0; i < n; i++) 
        {
          
            // Updates the frequency of
            // that element
            if (map.ContainsKey(a[i])) 
            {
                map[a[i]] = map[a[i]] + 1;
            }
            else
            {
                map.Add(a[i], 1);
            }
  
            // Checks for maximum Number
            // of occurrence
            if (map[a[i]] >= max) 
            {
  
                // Updates the maximum frequency
                max = map[a[i]];
  
                // Updates the Mode
                mode = a[i];
            }
            Console.Write(mode);
            Console.Write(" ");
        }
    }
  
    // Driver Code
    public static void Main(String[] args)
    {
        int[] arr = {2, 7, 3, 2, 5};
        int n = arr.Length;
  
        // Function Call
        findMode(arr, n);
    }
}
  
// This code is contributed by Amit Katiyar

2 7 3 2 2

Análisis de rendimiento: 

• Complejidad de tiempo: O(N)
• Espacio Auxiliar: O(N)