Calculate Median in Go (Golang) utilizing Generics

To search out the median of a slice in Go, you’ll want to write a customized perform that kinds the enter slice and will get the center component. If the slice measurement is even, the perform calculates the imply (common) of the 2 center values. Within the following examples, we’ll present two variations of this perform: a daily one which takes a float64 slice as enter, and a Generics model, that may work for any numeric sort.

In case you are not already accustomed to the fundamentals of Generics in Go, try our sequence of articles: Introduction to Go Generics by instance.

Additionally, try our tutorial on find out how to calculate the arithmetic imply in Go.

To calculate the median within the basic manner, we have to create a brand new median() perform and begin with the enter information copy. Calculating the median requires sorting the information first, so to keep away from modifying the unique slice order, we’d like a duplicate of the enter slice. We then take the center worth from this sorted slice. That is our median. If the information measurement is an odd quantity, the center component would be the worth at index <slice_length>/2. If the information measurement is even, it will likely be the arithmetic common of the 2 center parts.

package deal fundamental

import (
    "fmt"
    "kind"
)

func median(information []float64) float64 {
    dataCopy := make([]float64, len(information))
    copy(dataCopy, information)

    kind.Float64s(dataCopy)

    var median float64
    l := len(dataCopy)
    if l == 0 {
        return 0
    } else if l%2 == 0 {
        median = (dataCopy[l/2-1] + dataCopy[l/2]) / 2
    } else {
        median = dataCopy[l/2]
    }

    return median
}

func fundamental() {
    fmt.Println(median([]float64{1, 3, 2}))
    fmt.Println(median([]float64{1}))
    fmt.Println(median([]float64{3, 3, 3, 3, 2, 22, 2, 2, 2, 2, 1, 1, 1, 1, 1, 111}))
}

Output:

For the reason that launch of Generics in Go 1.18, it’s potential to jot down the median() perform that works for a slice of any numeric sort. Merely outline the Quantity constraint which is a union of constraints.Float and constraints.Integer to restrict the enter sorts to numeric. For extra particulars, see the instance on find out how to calculate the arithmetic imply utilizing Generics, the place we additionally used the Quantity constraint.

One other distinction is that, within the generic model, we use the slices.Type() perform from the brand new /x/exp/slices package deal to kind the slice. It permits for generic sorting of slices of any sort.

package deal fundamental

import (
    "fmt"

    "golang.org/x/exp/constraints"
    "golang.org/x/exp/slices"
)

sort Quantity interface  constraints.Integer


func median[T Number](information []T) float64 {
    dataCopy := make([]T, len(information))
    copy(dataCopy, information)

    slices.Type(dataCopy)

    var median float64
    l := len(dataCopy)
    if l == 0 {
        return 0
    } else if l%2 == 0 {
        median = float64((dataCopy[l/2-1] + dataCopy[l/2]) / 2.0)
    } else {
        median = float64(dataCopy[l/2])
    }

    return median
}

func fundamental() {
    fmt.Println(median([]float64{1, 3, 2}))
    fmt.Println(median([]int{1}))
    fmt.Println(median([]int32{3, 3, 3, 3, 2, 22, 2, 2, 2, 2, 1, 1, 1, 1, 1, 111}))
}

The result’s a perform that works seamlessly for a slice of sort int, int64, float64, and many others., with out having to repeat code, or create particular variations for every sort.

Output: