Go ElementsEqual()

1 개요[ | ]

Go ElementsEqual()

2 추천[ | ]

Go

Copy

func elementsEqual[T comparable](s1, s2 []T) bool {
	if len(s1) != len(s2) {
		return false
	}
	// Create maps to count occurrences of each element.
	counts1 := make(map[T]int)
	for _, v := range s1 {
		counts1[v]++
	}
	counts2 := make(map[T]int)
	for _, v := range s2 {
		counts2[v]++
	}

	// Compare the element counts in both maps.
	for key, count := range counts1 {
		if counts2[key] != count {
			return false
		}
	}
	for key, count := range counts2 {
		if counts1[key] != count {
			return false
		}
	}

	return true
}

Go

Copy

func TestElementsEqual(t *testing.T) {
	t.Run("strings", func(t *testing.T) {
		tests := []struct {
			name string
			a    []string
			b    []string
			want bool
		}{
			{
				name: "equal",
				a:    []string{"apple", "banana", "cherry"},
				b:    []string{"banana", "cherry", "apple"},
				want: true,
			},
			{
				name: "not equal",
				a:    []string{"apple", "banana", "cherry"},
				b:    []string{"banana", "cherry", "orange"},
				want: false,
			},
			{
				name: "empty",
				a:    []string{},
				b:    []string{},
				want: true,
			},
			{
				name: "nil",
				a:    nil,
				b:    []string{"apple", "banana", "cherry"},
				want: false,
			},
			{
				name: "different length",
				a:    []string{"apple", "banana"},
				b:    []string{"apple", "banana", "cherry"},
				want: false,
			},
			{
				name: "same element different order",
				a:    []string{"apple", "banana", "cherry"},
				b:    []string{"cherry", "apple", "banana"},
				want: true,
			},
		}

		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				got := elementsEqual(tt.a, tt.b)
				assert.Equal(t, tt.want, got)
			})
		}
	})

	t.Run("integers", func(t *testing.T) {
		tests := []struct {
			name string
			a    []int
			b    []int
			want bool
		}{
			{
				name: "equal",
				a:    []int{1, 2, 3},
				b:    []int{3, 2, 1},
				want: true,
			},
			{
				name: "not equal",
				a:    []int{1, 2, 3},
				b:    []int{3, 2, 4},
				want: false,
			},
			{
				name: "empty",
				a:    []int{},
				b:    []int{},
				want: true,
			},
			{
				name: "different length",
				a:    []int{1, 2},
				b:    []int{1, 2, 3},
				want: false,
			},
			{
				name: "same element different order",
				a:    []int{1, 2, 3},
				b:    []int{3, 1, 2},
				want: true,
			},
		}

		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				got := elementsEqual(tt.a, tt.b)
				assert.Equal(t, tt.want, got)
			})
		}
	})

	t.Run("floats", func(t *testing.T) {
		tests := []struct {
			name string
			a    []float64
			b    []float64
			want bool
		}{
			{
				name: "equal",
				a:    []float64{1.1, 2.2, 3.3},
				b:    []float64{3.3, 2.2, 1.1},
				want: true,
			},
			{
				name: "not equal",
				a:    []float64{1.1, 2.2, 3.3},
				b:    []float64{3.3, 2.2, 4.4},
				want: false,
			},
			{
				name: "empty",
				a:    []float64{},
				b:    []float64{},
				want: true,
			},
			{
				name: "different length",
				a:    []float64{1.1, 2.2},
				b:    []float64{1.1, 2.2, 3.3},
				want: false,
			},
			{
				name: "same element different order",
				a:    []float64{1.1, 2.2, 3.3},
				b:    []float64{3.3, 1.1, 2.2},
				want: true,
			},
		}

		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				got := elementsEqual(tt.a, tt.b)
				assert.Equal(t, tt.want, got)
			})
		}
	})

	t.Run("structs", func(t *testing.T) {
		type Person struct {
			Name string
			Age  int
		}

		tests := []struct {
			name string
			a    []Person
			b    []Person
			want bool
		}{
			{
				name: "equal",
				a:    []Person{{Name: "Alice", Age: 30}, {Name: "Bob", Age: 25}},
				b:    []Person{{Name: "Bob", Age: 25}, {Name: "Alice", Age: 30}},
				want: true,
			},
			{
				name: "not equal",
				a:    []Person{{Name: "Alice", Age: 30}, {Name: "Bob", Age: 25}},
				b:    []Person{{Name: "Bob", Age: 30}, {Name: "Alice", Age: 25}},
				want: false,
			},
			{
				name: "empty",
				a:    []Person{},
				b:    []Person{},
				want: true,
			},
		}

		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				got := elementsEqual(tt.a, tt.b)
				assert.Equal(t, tt.want, got)
			})
		}
	})
}

3 간단히[ | ]

Go

Copy

package main

import (
	"fmt"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
)

func main() {
	a := []int{1, 2, 11, 12}
	b := []int{12, 2, 1, 11}
	fmt.Println(intElementsEqual(a, b)) // true

	x := []string{"a", "b", "c"}
	y := []string{"a", "c", "b"}
	fmt.Println(stringElementsEqual(x, y)) // true

}

func intElementsEqual(a, b []int) bool {
	return cmp.Diff(a, b, cmpopts.SortSlices(func(x, y int) bool { return x < y })) == ""
}

func stringElementsEqual(a, b []string) bool {
	return cmp.Diff(a, b, cmpopts.SortSlices(func(x, y string) bool { return x < y })) == ""
}

Loading

4 같이 보기[ | ]

5 참고[ | ]

https://stackoverflow.com/questions/36000487/check-for-equality-on-slices-without-order