Dada una array de algún tipo de datos en particular, queremos encontrar la frecuencia (número de ocurrencias) de los elementos en la array. Podemos hacerlo con la ayuda de mapas en Golang . Al crear un mapa de tipo de datos específico con un número entero, podemos iterar sobre la array dada y agregar el recuento a la clave como la frecuencia de ese elemento en la array.
Array de enteros
Digamos que tenemos una array de enteros definida de n elementos, simplemente queremos mapear los elementos con su frecuencia en la array usando un mapa. En primer lugar, definiremos una array, puede ser generada o ingresada por el usuario según el uso del programa. Aquí completaremos manualmente la array solo para comprender la implementación. Después de tener una array de números enteros, podemos crear un mapa que asigne un número entero a un número entero, ya que tenemos una array de números enteros, las claves en el mapa serían elementos de la array y el valor como la frecuencia/recuento del elemento.
freq := make(mapa[int]int)
Podemos usar make para crear un mapa. Simplemente escriba el tipo de clave y el tipo de valor para el mapa que desea crear.
Después de crear un mapa vacío, podemos iterar sobre la array de enteros y establecer su clave como la frecuencia. De forma predeterminada, la frecuencia de la primera vez que aparece la clave se establece en cero, por lo que podemos incrementarla en uno la primera vez que visitamos un elemento en la array.
for _ , num := range arr {
frecuencia[numero] = frecuencia[numero]+1
}
El identificador en blanco (_) es simplemente el índice de la array y num es el elemento en ese índice, por lo que podemos iterar sobre el rango de la array, es decir, el número de elementos de la array. Usamos el num como la clave que es el elemento en la array y map[num] como el valor de la clave num. Así incrementamos el valor en uno para cada elemento único como clave.
A continuación se muestra el programa completo.
Go
// Go program to find the frequency of an integer array
package main
import "fmt"
func main(){
arr := []int{90, 70, 30, 30, 10, 80, 40, 50, 40, 30}
freq := make(map[int]int)
for _ , num := range arr {
freq[num] = freq[num]+1
}
fmt.Println("Frequency of the Array is : ", freq)
}
Producción:
Frequency of the array is: map[10:1 30:3 40:2 50:1 70:1 80:1 90:1]
Entonces, como podemos ver, se creó el mapa de frecuencia que asigna los elementos en la array a su frecuencia de ocurrencia.
Convertir en una función
Incluso podemos convertir la lógica en una función para crear un mapa de frecuencia para una array dada de enteros. Simplemente necesitamos analizar la array como un parámetro y el tipo de retorno como un mapa de un número entero con el número entero como cabeza de función. La lógica sigue siendo la misma para crear un mapa de frecuencias y llenarlo con claves y valores con elementos y sus frecuencias.
Go
// Go program to convert logic into function
package main
import "fmt"
func main(){
arr := []int{90, 70, 30, 30, 10, 80, 40, 50, 40, 30}
freq_map := frequency_map(arr)
fmt.Println("Frequency of the Array is : ", freq_map)
}
func frequency_map( arr []int) map[int]int{
freq := make(map[int]int)
for _ , num := range arr {
freq[num] = freq[num]+1
}
return freq
}
Producción:
Frequency of Array is : map [10:1 30:3 40:2 50:1 70:1 80:1 90:1]
Por lo tanto, pudimos crear un mapa de frecuencia para una array de enteros usando un mapa en Go lang.
Cuerda
Digamos que tenemos una string y queremos crear un recuento de frecuencia para cada carácter de la string. En este caso, crearemos un mapa de string a un entero, almacenaremos cada carácter de la string como una string porque es conveniente mostrar el contenido y almacenar el recuento de ese carácter de string como valor en el mapa.
Nota: Incluso podemos usar el tipo de runa o byte en lugar de una clave de string, el problema es que muestra el código Unicode/ASCII como la clave y no la string en sí.
Primero definiremos una string. Similar al mapa de enteros, crearemos un mapa que mapee una string a un entero así:
freq := make(mapa[string]int)
Después de crear un mapa, simplemente iteramos sobre la string carácter por carácter e incrementamos el valor de la clave, aquí la clave es el carácter de la string. Concatenaremos el tipo de carácter (byte/runa) como una string solo porque es conveniente leer el mapa como humano. Pero puede mantenerlo como está, entonces es posible que deba cambiar el tipo de clave del mapa a:
freq := make(map[byte]int) OR freq := make(map[rune]int)
Esto creará un mapa que almacena las claves como valores Unicode del carácter en la string.
Luego iteramos sobre la string e incrementamos el valor de la clave de carácter en la string de la siguiente manera:
for _ , char := rango palabra {
frecuencia[string(caracter)] = frecuencia[(caracter)]+1
}
Entonces, finalmente combinando las piezas, tenemos un script que toma una string y mapea cada carácter (tipo de string) como la clave y su frecuencia en la string como su valor en el mapa.
Go
// Go program to that takes string and map each character
package main
import "fmt"
func main(){
arr := "geeksforgeeks"
freq := make(map[string]int)
for _ , char := range arr {
freq[string(char)] = freq[string(char)]+1
}
fmt.Println("Frequency of Array is : ", freq)
}
Producción:
Frequency of Array is : map[e:4 f:1 g:2 k:2 0:1 r:1 s:2]
Por lo tanto, podemos ver que obtenemos el mapa de cada carácter único en la string dada con su frecuencia o el recuento de su aparición en toda la string.
Usando runa/byte como claves en el mapa
Además, si usamos el tipo de datos de ejecución/byte para crear el mapa sin concatenar el carácter en una string, obtendremos el siguiente resultado:
Go
// Go program using rune/byte as keys in the map
package main
import "fmt"
func main(){
arr := "geeksforgeeks"
freq := make(map[rune]int)
for _ , char := range arr {
freq[char] = freq[char]+1
}
fmt.Println("Frequency of Array is : ", freq)
}
Producción:
Frequency of Array is : map[101:4 102:1 103:2 107:2 111:1 114:1 115:2]
Lo mismo es la salida por byte, excepto que no aceptará los caracteres que no estén en códigos ASCII (0 a 255) y, por lo tanto, bastante limitados en los conjuntos de caracteres. El byte daría un error de compilación si el valor está fuera de los límites de su rango para un byte. El valor predeterminado seleccionado si no se especifica para un personaje es una runa en Go lang. Aún así, si desea usar byte como clave en el mapa, puede especificarlo en la declaración como una runa y, por lo tanto, también debe concatenarlo con un byte.
Go
package main
import "fmt"
func main(){
arr := "geeksforgeeks"
freq := make(map[byte]int)
for _ , char := range arr {
freq[byte(char)] = freq[byte(char)]+1
}
fmt.Println("Frequency of Array is : ", freq)
}
Producción:
Frequency of Array is : map[101:4 102:1 103:2 107:2 111:1 114:1 115:2]
Convirtiendo a una función
Además, aquí podemos convertir el código de procedimiento en un enfoque funcional mediante la creación de una función para crear el conteo de frecuencia de los caracteres en la string.
Go
// Go program to converting into function
package main
import "fmt"
func main(){
arr := "geeksforgeeks"
freq_map := frequency_map(arr)
fmt.Println("Frequency of Array is : ", freq_map)
}
func frequency_map(arr string) map[string]int{
freq := make(map[string]int)
for _ , char := range arr {
freq[string(char)] = freq[string(char)]+1
}
return freq
}
Producción:
Frequency of Array is : map[e:4 f:1 g:2 k:2 o:1 r:1 s:2]
Por lo tanto, la función frecuencia_mapa devuelve el mapa, que es una string para el mapeo de enteros. Así que pudimos obtener un mapa de frecuencia de la string simplemente analizando la string en una función y almacenando la frecuencia en una variable.