La moda es el valor que ocurre con mayor frecuencia en un conjunto de observaciones. Por ejemplo, {6, 3, 9, 6, 6, 5, 9, 3} la Moda es 6, ya que ocurre con más frecuencia.
Hecho sobre el modo:
- A veces puede haber más de un modo. Tener dos modos se llama bimodal . Tener más de dos modos se llama multimodal .
- Existe una relación empírica entre la media, la mediana y la moda.
Media – Moda = 3 [ Media – Mediana ]
Python3
import numpy as np
from scipy import stats
l1 = [12, 15, 12, 78, 54, 56, 45, 45, 18, 19, 12, 35, 67, 48, 9, 2, 45, 68]
print(f"List: {l1}")
print(f"Mean: {np.mean(l1)}")
print(f"Median: {np.median(l1)}")
print(f"Mode: {stats.mode(l1)[0]}")
lhs = np.mean(l1) - stats.mode(l1)[0]
rhs = 3 * (np.mean(l1) - np.median(l1))
print(f"LHS == RHS: {lhs == rhs}")
- La moda puede ser útil para datos cualitativos.
- El modo se puede ubicar gráficamente.
- La moda se puede calcular en una tabla de frecuencia abierta.
- El modo no se ve afectado por valores extremadamente grandes o pequeños.
Fórmula para el modo de datos agrupados:
¿Cómo encontrar el modo?
Solución ingenua:
dada una array sin clasificar de tamaño n , encuentre la mediana y el modo usando la técnica de clasificación por conteo . Esto puede ser útil cuando los elementos de la array están en un rango limitado.
Ejemplos:
Input : array a[] = {1, 1, 1, 2, 7, 1}
Output : Mode = 1
Input : array a[] = {9, 9, 9, 9, 9}
Output : Mode = 9
- Array auxiliar (recuento) antes de sumar sus recuentos anteriores, c[]:
Índice: 0 1 2 3 4 5 6 7 8 9 10
recuento: 0 4 1 0 0 0 0 1 0 0 0 - Moda = índice con valor máximo de cuenta.
Modo = 1 (para el ejemplo anterior)
Enfoque:
Suponiendo que el tamaño de la array de entrada es n :
Paso #1: Tome la array de conteo antes de sumar sus conteos anteriores en el siguiente índice.
Paso #2: El índice con el valor máximo almacenado es la moda de los datos dados.
Paso #3: En caso de que haya más de un índice con un valor máximo, todos son resultados para el modo, por lo que podemos tomar cualquiera.
Paso #4: almacene el valor en ese índice en una variable separada llamada modo.
A continuación se muestra la implementación:
C++
// C++ Program for Mode using
// Counting Sort technique
#include <bits/stdc++.h>
using namespace std;
// Function that sort input array a[] and
// calculate mode and median using counting
// sort.
void printMode(int a[], int n)
{
// The output array b[] will
// have sorted array
int b[n];
// variable to store max of
// input array which will
// to have size of count array
int max = *max_element(a, a + n);
// auxiliary(count) array to
// store count. Initialize
// count array as 0. Size
// of count array will be
// equal to (max + 1).
int t = max + 1;
int count[t];
for (int i = 0; i < t; i++)
count[i] = 0;
// Store count of each element
// of input array
for (int i = 0; i < n; i++)
count[a[i]]++;
// mode is the index with maximum count
int mode = 0;
int k = count[0];
for (int i = 1; i < t; i++) {
if (count[i] > k) {
k = count[i];
mode = i;
}
}
cout << "mode = " << mode;
}
// Driver Code
int main()
{
int a[] = { 1, 4, 1, 2, 7, 1, 2, 5, 3, 6 };
int n = sizeof(a) / sizeof(a[0]);
printMode(a, n);
return 0;
}
Java
// Java Program for Mode using
// Counting Sort technique
import java.util.Arrays;
class GFG
{
// Function that sort input array a[] and
// calculate mode and median using counting
// sort.
static void printMode(int[] a, int n)
{
// The output array b[] will
// have sorted array
//int []b = new int[n];
// variable to store max of
// input array which will
// to have size of count array
int max = Arrays.stream(a).max().getAsInt();
// auxiliary(count) array to
// store count. Initialize
// count array as 0. Size
// of count array will be
// equal to (max + 1).
int t = max + 1;
int[] count = new int[t];
for (int i = 0; i < t; i++)
{
count[i] = 0;
}
// Store count of each element
// of input array
for (int i = 0; i < n; i++)
{
count[a[i]]++;
}
// mode is the index with maximum count
int mode = 0;
int k = count[0];
for (int i = 1; i < t; i++)
{
if (count[i] > k)
{
k = count[i];
mode = i;
}
}
System.out.println("mode = " + mode);
}
// Driver Code
public static void main(String[] args)
{
int[] a = {1, 4, 1, 2, 7, 1, 2, 5, 3, 6};
int n = a.length;
printMode(a, n);
}
}
// This code is contributed by Rajput-Ji
Python3
# Python3 Program for Mode using
# Counting Sort technique
# Function that sort input array a[] and
# calculate mode and median using counting
# sort.
def printMode(a, n) :
# variable to store max of
# input array which will
# to have size of count array
max_element = max(a)
# auxiliary(count) array to store count.
# Initialize count array as 0. Size
# of count array will be equal to (max + 1).
t = max_element + 1
count = [0] * t
for i in range(t) :
count[i] = 0
# Store count of each element
# of input array
for i in range(n) :
count[a[i]] += 1
# mode is the index with maximum count
mode = 0
k = count[0]
for i in range(1, t) :
if (count[i] > k) :
k = count[i]
mode = i
print("mode = ", mode)
# Driver Code
if __name__ == "__main__" :
a = [ 1, 4, 1, 2, 7,
1, 2, 5, 3, 6 ]
n = len(a)
printMode(a, n)
# This code is contributed by Ryuga
C#
// C# Program for Mode using
// Counting Sort technique
using System;
using System.Linq;
public class GFG{
// Function that sort input array a[] and
// calculate mode and median using counting
// sort.
static void printMode(int []a, int n)
{
// The output array b[] will
// have sorted array
//int []b = new int[n];
// variable to store max of
// input array which will
// to have size of count array
int max =a.Max();
// auxiliary(count) array to
// store count. Initialize
// count array as 0. Size
// of count array will be
// equal to (max + 1).
int t = max + 1;
int []count = new int[t];
for (int i = 0; i < t; i++)
count[i] = 0;
// Store count of each element
// of input array
for (int i = 0; i < n; i++)
count[a[i]]++;
// mode is the index with maximum count
int mode = 0;
int k = count[0];
for (int i = 1; i < t; i++) {
if (count[i] > k) {
k = count[i];
mode = i;
}
}
Console.WriteLine( "mode = " + mode);
}
// Driver Code
static public void Main (){
int []a = { 1, 4, 1, 2, 7, 1, 2, 5, 3, 6 };
int n =a.Length;
printMode(a, n);
}
}
// This code is contributed by inder_verma
Javascript
<script>
// Javascript Program for Mode using Counting Sort technique
// Function that sort input array a[] and
// calculate mode and median using counting
// sort.
function printMode(a, n)
{
// The output array b[] will
// have sorted array
//int []b = new int[n];
// variable to store max of
// input array which will
// to have size of count array
let max = Number.MIN_VALUE;
for (let i = 0; i < a.length; i++)
{
max = Math.max(max, a[i]);
}
// auxiliary(count) array to
// store count. Initialize
// count array as 0. Size
// of count array will be
// equal to (max + 1).
let t = max + 1;
let count = new Array(t);
for (let i = 0; i < t; i++)
count[i] = 0;
// Store count of each element
// of input array
for (let i = 0; i < n; i++)
count[a[i]]++;
// mode is the index with maximum count
let mode = 0;
let k = count[0];
for (let i = 1; i < t; i++) {
if (count[i] > k) {
k = count[i];
mode = i;
}
}
document.write( "mode = " + mode);
}
let a = [ 1, 4, 1, 2, 7, 1, 2, 5, 3, 6 ];
let n =a.length;
printMode(a, n);
// This code is contributed by surehs07.
</script>
Producción:
mode = 1
Complejidad de tiempo = O (N + P), donde N es el tamaño de la array de entrada y P es el tamaño de la array de recuento o el valor máximo en la array de entrada.
Espacio auxiliar = O(P), donde el valor de P es el tamaño de la array auxiliar.
Las soluciones anteriores funcionan bien cuando los valores de los elementos de la array son pequeños. Consulte la publicación a continuación para obtener soluciones eficientes.
Elemento más frecuente en una array
Programa básico relacionado con el modo:
- Encontrar media, mediana, modo en Python sin bibliotecas
- Mediana y moda usando la ordenación por conteo
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA