initial commit

Author: vfedorovatlas

remove-duplicates-from-sorted-array/Readme.md

@@ -0,0 +1,13 @@
+# Problem: Remove Duplicates from Sorted Array
+
+**Source:** <https://leetcode.com/problems/remove-duplicates-from-sorted-array/>
+
+Given a sorted array, remove the duplicates in-place such that each element appear only once and return the new length.
+
+Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
+```
+Given nums = [1,1,2],
+
+Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
+It does not matter what you leave beyond the new length.
+```

remove-duplicates-from-sorted-array/main.go

@@ -0,0 +1,18 @@
+package removedublicatesfromsortedarray
+
+func removeDuplicates(nums []int) int {
+	n := len(nums)
+	if n == 0 || n == 1 {
+		return n
+	}
+	j := 0
+	for i := 0; i < n-1; i++ {
+		if nums[i] != nums[i+1] {
+			nums[j] = nums[i]
+			j++
+		}
+	}
+	nums[j] = nums[n-1]
+	j++
+	return j
+}

remove-duplicates-from-sorted-array/main_test.go

@@ -0,0 +1,10 @@
+package removedublicatesfromsortedarray
+
+import "testing"
+
+func TestRemoveDuplicates(t *testing.T) {
+	res := removeDuplicates([]int{1, 1, 2})
+	if res != 2 {
+		t.Fail()
+	}
+}

remove-element/main.go

@@ -0,0 +1,16 @@
+package removeelement
+
+func removeElement(nums []int, val int) int {
+	n := len(nums)
+	if n == 0 {
+		return 0
+	}
+	j := 0
+	for i := 0; i < n; i++ {
+		if nums[i] != val {
+			nums[j] = nums[i]
+			j++
+		}
+	}
+	return j
+}

remove-element/main_test.go

@@ -0,0 +1,38 @@
+package removeelement
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestRemoveElement(t *testing.T) {
+	testCases := []struct {
+		Nums []int
+		Val  int
+		Len  int
+	}{
+		{
+			Nums: []int{3, 2, 2, 3},
+			Val:  3,
+			Len:  2,
+		},
+		{
+			Nums: []int{1},
+			Val:  1,
+			Len:  0,
+		},
+		{
+			Nums: []int{3, 3, 3},
+			Val:  3,
+			Len:  0,
+		},
+	}
+	for _, test := range testCases {
+		t.Run(fmt.Sprintf("nums=%v val=%d expected=%d", test.Nums, test.Val, test.Len), func(t *testing.T) {
+			res := removeElement(test.Nums, test.Val)
+			if res != test.Len {
+				t.Errorf("wanted %d, but got %d", test.Len, res)
+			}
+		})
+	}
+}

reverse-integer/main.go

@@ -0,0 +1,32 @@
+package reverseinteger
+
+import (
+	"math"
+)
+
+// Psevdo code:
+// a. Extract off the rightmost digit of your input number. (1234 % 10) = 4
+// b. Take that digit (4) and add it into a new reversedNum.
+// c. Multiply reversedNum by 10 (4 * 10) = 40, this exposes a zero to the right of your (4).
+// d. Divide the input by 10, (removing the rightmost digit). (1234 / 10) = 123
+// e. Repeat at step a with 123
+// Source: https://stackoverflow.com/questions/3806126/java-reverse-an-int-value-without-using-array
+func reverse(x int) int {
+	var n int
+	negative := x < 0
+	if negative {
+		x = -x
+	}
+	for x != 0 {
+		remainder := x % 10
+		n = n*10 + remainder
+		x = x / 10
+	}
+	if n > math.MaxInt32 {
+		return 0
+	}
+	if negative {
+		return -n
+	}
+	return n
+}

reverse-integer/main_test.go

@@ -0,0 +1,50 @@
+package reverseinteger
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestReverse(t *testing.T) {
+	testCases := []struct {
+		Input  int
+		Output int
+	}{
+		{
+			Input:  123,
+			Output: 321,
+		},
+		{
+			Input:  11,
+			Output: 11,
+		},
+		{
+			Input:  -1,
+			Output: -1,
+		},
+		{
+			Input:  -123,
+			Output: -321,
+		},
+		{
+			Input:  120,
+			Output: 21,
+		},
+		{
+			Input:  1534236469,
+			Output: 0,
+		},
+		{
+			Input:  0,
+			Output: 0,
+		},
+	}
+	for _, test := range testCases {
+		t.Run(fmt.Sprintf("input=%d output=%d", test.Input, test.Output), func(t *testing.T) {
+			res := reverse(test.Input)
+			if res != test.Output {
+				t.Errorf("wanted %d, but got %d", test.Output, res)
+			}
+		})
+	}
+}

two-sum/Readme.md

@@ -0,0 +1,16 @@
+# Problem: Two Sum
+
+**Source:** <https://leetcode.com/problems/two-sum/description/>
+
+Given an array of integers, return indices of the two numbers such that they add up to a specific target.
+
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+
+**Example:**
+
+```go
+Given nums = [2, 7, 11, 15], target = 9,
+
+Because nums[0] + nums[1] = 2 + 7 = 9,
+return [0, 1].
+```

two-sum/main.go

@@ -0,0 +1,14 @@
+package twosum
+
+func twoSum(nums []int, target int) []int {
+	m := map[int]int{}
+	for i, v := range nums {
+		complement := target - v
+		c, ok := m[complement]
+		if ok {
+			return []int{c, i}
+		}
+		m[v] = i
+	}
+	panic("no solution")
+}

two-sum/main_test.go

@@ -0,0 +1,17 @@
+package twosum
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestTwoSum(t *testing.T) {
+	nums := []int{2, 7, 11, 15}
+	target := 9
+	expected := []int{0, 1}
+	res := twoSum(nums, target)
+	t.Logf("res: %#v", res)
+	if !reflect.DeepEqual(expected, res) {
+		t.Fail()
+	}
+}