func intersectLoop[T comparable](a, b []T) []T {
	var res []T
	for _, x := range a {
		for _, y := range b {
			if x == y {
				res = append(res, x)
				break // 防止重復(fù)添加同一元素（若 a 有重復(fù)）
			}
		}
	}
	return res
}

func intersectMap[T comparable](a, b []T) []T {
	set := make(map[T]struct{}, len(a))
	for _, v := range a {
		set[v] = struct{}{}
	}

	var res []T
	for _, v := range b {
		if _, ok := set[v]; ok {
			res = append(res, v)
			delete(set, v) // ← 關(guān)鍵：防止 b 中重復(fù)導(dǎo)致結(jié)果重復(fù)
		}
	}
	return res
}

import "sort"

func intersectSorted[T comparable](a, b []T) []T {
	// 創(chuàng)建副本避免修改原 slice
	aa, bb := make([]T, len(a)), make([]T, len(b))
	copy(aa, a)
	copy(bb, b)

	sort.Slice(aa, func(i, j int) bool { return aa[i] < aa[j] })
	sort.Slice(bb, func(i, j int) bool { return bb[i] < bb[j] })

	var res []T
	i, j := 0, 0
	for i < len(aa) && j < len(bb) {
		switch {
		case aa[i] == bb[j]:
			res = append(res, aa[i])
			i++
			j++
		case aa[i] < bb[j]:
			i++
		default:
			j++
		}
	}
	return res
}

// Intersection returns the intersection of two slices.
// Result preserves the order of elements in `a`, and removes duplicates.
// T must be comparable.
func Intersection[T comparable](a, b []T) []T {
	if len(a) == 0 || len(b) == 0 {
		return nil
	}

	// Step 1: Build lookup set from b (smaller one for memory efficiency)
	if len(b) < len(a) {
		a, b = b, a // ensure `a` is the smaller slice
	}
	set := make(map[T]struct{}, len(a))
	for _, v := range a {
		set[v] = struct{}{}
	}

	// Step 2: Iterate b, collect matches while preserving order & dedup
	seen := make(map[T]struct{}) // track emitted items
	var res []T
	for _, v := range b {
		if _, inA := set[v]; inA {
			if _, emitted := seen[v]; !emitted {
				res = append(res, v)
				seen[v] = struct{}{}
			}
		}
	}
	return res
}

type User struct {
	ID   int
	Name string
}

// Key returns a comparable key for equality comparison
func (u User) Key() int { return u.ID }

// IntersectionBy extracts intersection using a key function
func IntersectionBy[T any, K comparable](a, b []T, key func(T) K) []T {
	keySet := make(map[K]struct{})
	for _, v := range a {
		keySet[key(v)] = struct{}{}
	}

	var res []T
	seen := make(map[K]struct{})
	for _, v := range b {
		k := key(v)
		if _, ok := keySet[k]; ok {
			if _, dup := seen[k]; !dup {
				res = append(res, v)
				seen[k] = struct{}{}
			}
		}
	}
	return res
}

// Usage
usersA := []User{{1, "Alice"}, {2, "Bob"}, {3, "Carol"}}
usersB := []User{{2, "Bob2"}, {4, "David"}, {1, "Alice2"}}

common := IntersectionBy(usersA, usersB, User.Key)
// → [{1 "Alice"}, {2 "Bob"}] （按 ID 匹配，保留 usersB 中的完整結(jié)構(gòu)）

func IntersectionMultiset[T comparable](a, b []T) []T {
	// Count frequency in a
	freqA := make(map[T]int)
	for _, v := range a {
		freqA[v]++
	}

	// For each in b, take min(count)
	var res []T
	for _, v := range b {
		if cnt, ok := freqA[v]; ok && cnt > 0 {
			res = append(res, v)
			freqA[v]-- // consume one occurrence
		}
	}
	return res
}

// Example:
a := []int{1, 1, 2, 3}
b := []int{1, 2, 2, 4}
fmt.Println(IntersectionMultiset(a, b)) // → [1, 2]

goos: linux
goarch: amd64
pkg: example
cpu: Intel(R) Core(TM) i7-10700K
BenchmarkIntersectLoop-16      	     3	 452,123,840 ns/op
BenchmarkIntersectMap-16       	  1000	   1,021,344 ns/op
BenchmarkIntersectSorted-16    	  1000	   1,241,892 ns/op
BenchmarkIntersectionGeneric-16	  1000	   1,045,217 ns/op