move problem description for arrays

array/add_two_numbers.go

@@ -2,8 +2,7 @@ package array
 
 import "math"
 
-// AddTwoNumbers adds two numbers which are represented as an array and returns the results
-// In the same format. For example [2,5], and [3,5] would add up to[6,0] because 25 + 35 = 60.
+// AddTwoNumbers solves the problem in O(n) time and O(1) space.
 func AddTwoNumbers(num1, num2 []int) []int {
 	num1, num2 = equalizeLengths(num1, num2)
 	carry := false

array/add_two_numbers_test.go

@@ -5,6 +5,14 @@ import (
 	"testing"
 )
 
+/*
+TestAddTwoNumbers tests solution(s) with the following signature and problem description:
+
+	AddTwoNumbers(num1, num2 []int) []int
+
+Adds two numbers which are represented as an array and returns the results
+In the same format. For example [2,5], and [3,5] would add up to[6,0] because 25 + 35 = 60.
+*/
 func TestAddTwoNumbers(t *testing.T) {
 	tests := []struct {
 		num1, num2, sum []int

array/bubble_sort.go

@@ -1,6 +1,6 @@
 package array
 
-// BubbleSort implements the Bubble Sort algorithm.
+// BubbleSort solves the problem in O(n^2) time and O(1) space.
 func BubbleSort(input []int) {
 	for i := range input {
 		for j := range input {

array/bubble_sort_test.go

@@ -5,6 +5,13 @@ import (
 	"testing"
 )
 
+/*
+TestBubbleSort tests solution(s) with the following signature and problem description:
+
+	BubbleSort(input []int)
+
+Implements the Bubble Sort algorithm.
+*/
 func TestBubbleSort(t *testing.T) {
 	tests := []struct {
 		input, sorted []int

array/equal_sum_subarrays.go

@@ -1,7 +1,6 @@
 package array
 
-// EqualSubArrays given a list of integers returns two sub arrays that have
-// equal sums without changing the order of the items in the list.
+// EqualSubArrays solves the problem in O(n^2) time and O(1) space.
 func EqualSubArrays(list []int) [][]int {
 	output := make([][]int, 0)
 	if len(list) < 2 {

array/equal_sum_subarrays_test.go

@@ -5,6 +5,14 @@ import (
 	"testing"
 )
 
+/*
+TestEqualSumSubArrays tests solution(s) with the following signature and problem description:
+
+	func EqualSubArrays(list []int) [][]int {
+
+Given a list of integers returns two sub arrays that have equal sums without changing the
+order of the items in the list.
+*/
 func TestEqualSumSubArrays(t *testing.T) {
 	tests := []struct {
 		list      []int

array/find_duplicate_in_array.go

@@ -1,6 +1,6 @@
 package array
 
-// FindDuplicate Finds the duplicate in a list of integers (1,n).
+// FindDuplicate solves the problem in O(n) time and O(1) space.
 func FindDuplicate(list []int) int {
 	for _, item := range list {
 		itemIndex := item - 1

array/find_duplicate_in_array_test.go

@@ -4,6 +4,13 @@ import (
 	"testing"
 )
 
+/*
+TestFindDuplicate tests solution(s) with the following signature and problem description:
+
+	FindDuplicate(list []int) int
+
+Finds the duplicate in a list of integers (1,n).
+*/
 func TestFindDuplicate(t *testing.T) {
 	tests := []struct {
 		list      []int

array/product_of_all_other_elements.go

@@ -1,7 +1,6 @@
 package array
 
-// ProductOfAllOtherElements returns an array such that n[i] is the product of all
-// elements of the array except n[i]. Division operation is not allowed.
+// ProductOfAllOtherElements solves the problem in O(n) time and O(1) space.
 func ProductOfAllOtherElements(list []int) []int {
 	if len(list) == 0 {
 		return list

array/product_of_all_other_elements_test.go

@@ -5,6 +5,14 @@ import (
 	"testing"
 )
 
+/*
+TestProductOfAllOtherElements tests solution(s) with the following signature and problem description:
+
+	ProductOfAllOtherElements(list []int) []int
+
+Returns an array such that n[i] is the product of all elements of the array except n[i].
+Division operation is not allowed.
+*/
 func TestProductOfAllOtherElements(t *testing.T) {
 	tests := []struct {
 		list     []int

array/reverse_inplace.go

@@ -1,8 +1,8 @@
 package array
 
-// ReverseInplace reverses parts of the array in place.
-func ReverseInplace(nums []int, start, end int) {
+// ReverseInPlace solves the problem in O(n) time and O(1) space.
+func ReverseInPlace(list []int, start, end int) {
 	for i := start; i <= start+end/2 && i < end-i+start; i++ {
-		nums[i], nums[end-i+start] = nums[end-i+start], nums[i]
+		list[i], list[end-i+start] = list[end-i+start], list[i]
 	}
 }

array/reverse_inplace_test.go

@@ -5,7 +5,14 @@ import (
 	"testing"
 )
 
-func TestReverseInplace(t *testing.T) {
+/*
+TestReverseInPlace tests solution(s) with the following signature and problem description:
+
+	ReverseInPlace(list []int, start, end int)
+
+Reverses parts of the array in place.
+*/
+func TestReverseInPlace(t *testing.T) {
 	tests := []struct {
 		list     []int
 		start    int
@@ -22,7 +29,7 @@ func TestReverseInplace(t *testing.T) {
 	}
 
 	for i, test := range tests {
-		ReverseInplace(test.list, test.start, test.end)
+		ReverseInPlace(test.list, test.start, test.end)
 		if !reflect.DeepEqual(test.list, test.reversed) {
 			t.Fatalf("Failed test case #%d. Want %#v got %#v", i, test.reversed, test.list)
 		}

array/rotate_k_steps.go

@@ -1,8 +1,8 @@
 package array
 
-// RotateKSteps rotates a given array k steps.
-func RotateKSteps(nums []int, k int) {
-	ReverseInplace(nums, 0, len(nums)-k-1)
-	ReverseInplace(nums, 0, len(nums)-1)
-	ReverseInplace(nums, 0, k-1)
+// RotateKSteps solves problem in O(n) time and O(1) space.
+func RotateKSteps(list []int, k int) {
+	ReverseInPlace(list, 0, len(list)-k-1)
+	ReverseInPlace(list, 0, len(list)-1)
+	ReverseInPlace(list, 0, k-1)
 }

array/rotate_k_steps_test.go

@@ -5,6 +5,13 @@ import (
 	"testing"
 )
 
+/*
+TestRotateKSteps tests solution(s) with the following signature and problem description:
+
+	RotateKSteps(list []int, k int)
+
+Rotates a given array k steps.
+*/
 func TestRotateKSteps(t *testing.T) {
 	tests := []struct {
 		list        []int

array/zero_sum_triplets.go

@@ -2,6 +2,7 @@ package array
 
 import "sort"
 
+// ZeroSumTriplets solves the problem in O(n^2) time and O(1) space.
 func ZeroSumTriplets(list []int) [][]int {
 	output := make([][]int, 0)
 	if len(list) < 3 {

array/zero_sum_triplets_test.go

@@ -5,6 +5,13 @@ import (
 	"testing"
 )
 
+/*
+TestZeroSumTriplets tests solution(s) with the following signature and problem description:
+
+	ZeroSumTriplets(list []int) [][]int
+
+Finds all triplets in a list that sum to zero.
+*/
 func TestZeroSumTriplets(t *testing.T) {
 	tests := []struct {
 		list     []int