Solve the "Compute the intersection of two sorted arrays" problem

Author: mrekucci

README.md

@@ -204,7 +204,7 @@ Sorting
 
 | Problem                                                                  | Test         | Implemented |
 |--------------------------------------------------------------------------|:------------:|:-----------:|
-| [Compute the intersection of two sorted arrays][244]                     | [tests][245] |             |
+| [Compute the intersection of two sorted arrays][244]                     | [tests][245] |      ✓      |
 | [Implement mergesort in-place][246]                                      | [tests][247] |             |
 | [Count the frequencies of characters in a sentence][248]                 | [tests][249] |             |
 | [Find unique elements][250]                                              | [tests][251] |             |
@@ -647,8 +647,8 @@ Honors Class
 [241]: in_progress.md
 [242]: in_progress.md
 [243]: in_progress.md
-[244]: in_progress.md
-[245]: in_progress.md
+[244]: sorting/intersection.go
+[245]: sorting/intersection_test.go
 [246]: in_progress.md
 [247]: in_progress.md
 [248]: in_progress.md

sorting/intersection.go

@@ -0,0 +1,24 @@
+// Copyright (c) 2015, Peter Mrekaj. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE.txt file.
+
+package sorting
+
+// IntersectSorted returns intersection of x and y without duplicated elements.
+// The time complexity is O(m+n). The O(1) additional space is needed.
+func IntersectSorted(x, y []int) (ixy []int) {
+	i, j := 0, 0
+	for i < len(x) && j < len(y) {
+		switch ex, ey := x[i], y[j]; {
+		case ex == ey && (i == 0 || x[i-1] != ex):
+			ixy = append(ixy, ex)
+			i++
+			j++
+		case ex <= ey:
+			i++
+		case ex > ey:
+			j++
+		}
+	}
+	return ixy
+}

sorting/intersection_test.go

@@ -0,0 +1,53 @@
+// Copyright (c) 2015, Peter Mrekaj. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE.txt file.
+
+package sorting
+
+import (
+	"math/rand"
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func TestIntersectSorted(t *testing.T) {
+	for _, test := range []struct {
+		x, y []int
+		want []int
+	}{
+		{[]int(nil), []int(nil), []int(nil)},
+		{[]int{0}, []int(nil), []int(nil)},
+		{[]int(nil), []int{0}, []int(nil)},
+		{[]int{0}, []int{1}, []int(nil)},
+		{[]int{0}, []int{0}, []int{0}},
+		{[]int{0, 1}, []int{2}, []int(nil)},
+		{[]int{0}, []int{0, 1}, []int{0}},
+		{[]int{0, 1}, []int{1}, []int{1}},
+		{[]int{0, 1}, []int{1, 2}, []int{1}},
+		{[]int{1, 1, 1}, []int{1, 1}, []int{1}},
+		{[]int{1, 1}, []int{1, 1, 1}, []int{1}},
+		{[]int{1, 1, 2, 3, 4}, []int{0, 0, 1}, []int{1}},
+		{[]int{0, 0, 1}, []int{1, 1, 2, 3, 4}, []int{1}},
+		{[]int{2, 3, 3, 5, 5, 6, 7, 7, 8, 12}, []int{5, 5, 6, 8, 8, 9, 10, 10}, []int{5, 6, 8}},
+	} {
+		if got := IntersectSorted(test.x, test.y); !reflect.DeepEqual(got, test.want) {
+			t.Errorf("IntersectSorted(%v, %v) = %v; want %v", test.x, test.y, got, test.want)
+		}
+	}
+}
+
+func benchIntersectSorted(b *testing.B, size int) {
+	b.StopTimer()
+	x := rand.New(rand.NewSource(int64(size))).Perm(size)
+	sort.Ints(x)
+	y := x[size-(size/2):]
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		IntersectSorted(x, y)
+	}
+}
+
+func BenchmarkIntersectSorted1e2(b *testing.B) { benchIntersectSorted(b, 1e2) }
+func BenchmarkIntersectSorted1e4(b *testing.B) { benchIntersectSorted(b, 1e4) }
+func BenchmarkIntersectSorted1e6(b *testing.B) { benchIntersectSorted(b, 1e6) }