# Golangで集合の演算

何も使わずに実装する

和集合

package main

import "fmt"

func main() {
	a := []int{1, 2, 3}
	b := []int{2, 3, 4}
	c := []int{3}

	result := func(array ...[]int) []int {
		m := make(map[int]struct{})
		for _, arr := range array {
			for _, v := range arr {
				m[v] = struct{}{}
			}
		}
		tmp := []int{}
		for k := range m {
			tmp = append(tmp, k)
		}
		return tmp
	}(a, b, c)

	fmt.Println(result)
}

// [3 4 1 2]

積集合

package main

import "fmt"

func main() {
	a := []int{1, 2, 3}
	b := []int{2, 3, 4}
	c := []int{3}

	result := func(array ...[]int) []int {
		m := make(map[int]struct{})
		tmp1 := []int{}
		tmp2 := []int{}
		for _, v := range array[0] {
			m[v] = struct{}{}
		}
		for _, v := range array[1] {
			if _, ok := m[v]; !ok {
				continue
			}
			tmp1 = append(tmp1, v)
		}

		for i := 0; i < len(array)-2; i++ {
			func(arr1, arr2 []int) {
				m := make(map[int]struct{})
				for _, v := range arr1 {
					m[v] = struct{}{}
				}
				for _, v := range arr2 {
					if _, ok := m[v]; !ok {
						continue
					}
					tmp2 = append(tmp2, v)
				}
			}(tmp1, array[i+2])
		}
		return tmp2
	}(a, b, c)

	uniqueResult := func(arr []int) []int {
		m := make(map[int]struct{})
		tmp := make([]int, 0)
		for _, v := range arr {
			if _, ok := m[v]; !ok {
				m[v] = struct{}{}
				tmp = append(tmp, v)
			}
		}
		return tmp
	}(result)

	fmt.Println(uniqueResult)
}

// [3]

差集合を実装してみる

package main

import "fmt"

func main() {
	a := []int{1, 2, 3}
	b := []int{2, 3}

	result := func(arr1, arr2 []int) []int {
		m := make(map[int]struct{})
		for _, v := range arr2 {
			m[v] = struct{}{}
		}

		tmp := []int{}
		for _, v := range arr1 {
			if _, ok := m[v]; ok {
				continue
			}
			tmp = append(tmp, v)
		}
		return tmp
	}(a, b)

	fmt.Println(result)
}

// [1]

github.com/golang-collections/collections を使って実装する

和集合

package main

import (
	"fmt"

	"github.com/golang-collections/collections/set"
)

func main() {
	a := []int{1, 2, 3}
	b := []int{2, 3, 4}
	c := []int{3}
	aSet := set.New()
	bSet := set.New()
	cSet := set.New()

	for _, v := range a {
		aSet.Insert(v)
	}
	for _, v := range b {
		bSet.Insert(v)
	}
	for _, v := range c {
		cSet.Insert(v)
	}

	result := aSet.Union(bSet).Union(cSet)
	resultArr := []int{}
	result.Do(func(i interface{}) { resultArr = append(resultArr, i.(int)) })
	fmt.Println(resultArr)
}

// [1 2 3 4]

積集合

package main

import (
	"fmt"

	"github.com/golang-collections/collections/set"
)

func main() {
	a := []int{1, 2, 3}
	b := []int{2, 3, 4}
	c := []int{3}
	aSet := set.New()
	bSet := set.New()
	cSet := set.New()

	for _, v := range a {
		aSet.Insert(v)
	}
	for _, v := range b {
		bSet.Insert(v)
	}
	for _, v := range c {
		cSet.Insert(v)
	}

	result := aSet.Intersection(bSet).Intersection(cSet)
	resultArr := []int{}
	result.Do(func(i interface{}) { resultArr = append(resultArr, i.(int)) })
	fmt.Println(resultArr)
}

// [3]

差集合を実装してみる

package main

import (
	"fmt"

	"github.com/golang-collections/collections/set"
)

func main() {
	a := []int{1, 2, 3}
	b := []int{2, 3}
	aSet := set.New()
	bSet := set.New()

	for _, v := range a {
		aSet.Insert(v)
	}
	for _, v := range b {
		bSet.Insert(v)
	}

	result := aSet.Difference(bSet)
	resultArr := []int{}
	result.Do(func(i interface{}) { resultArr = append(resultArr, i.(int)) })

	fmt.Println(resultArr)
}

// [1]