Move problem description to test files (spring1843#80)

Author: spring1843

backtracking/generate_parenthesis.go

@@ -1,6 +1,6 @@
 package backtracking
 
-// GenerateParenthesis returns all possible variation of n pairs of valid parenthesis.
+// GenerateParenthesis solves the problem in O(2^n) time and O(n) space.
 func GenerateParenthesis(n int) []string {
 	return generateParenthesisRecursive([]string{}, "", 0, 0, n)
 }

backtracking/generate_parenthesis_test.go

@@ -6,6 +6,13 @@ import (
 	"testing"
 )
 
+/*
+TestGenerateParenthesis tests solution(s) with the following signature and problem description:
+
+	GenerateParenthesis(n int) []string
+
+Returns all possible variation of n pairs of valid parenthesis.
+*/
 func TestGenerateParenthesis(t *testing.T) {
 	tests := []struct {
 		n                int

backtracking/n_queens.go

@@ -8,8 +8,7 @@ const (
 // Chessboard represents a chessboard.
 type Chessboard [][]int
 
-// NQueens returns possible solutions to the n-queen puzzle in an n x n chessboard
-// where n queens are placed on the chessboard such that none attacks another.
+// NQueens solves the problem in O(n!) time and O(n) space.
 func NQueens(n int) []Chessboard {
 	output := nQueensRecursive(0, n, make([]int, n), make(Chessboard, 0))
 	return toPrettyChessboard(output, n)

backtracking/n_queens_test.go

@@ -5,6 +5,14 @@ import (
 	"testing"
 )
 
+/*
+TestNQueens tests solution(s) with the following signature and problem description:
+
+	func NQueens(n int) []Chessboard
+
+Returns possible solutions to the n-queen puzzle in an n x n chessboard
+where n queens are placed on the chessboard such that none attacks another.
+*/
 func TestNQueens(t *testing.T) {
 	tests := []struct {
 		n         int

backtracking/permutations.go

@@ -1,7 +1,6 @@
 package backtracking
 
-// Permutations intakes a list of numbers and returns all possible permutations of their orders
-// For example for {1,2} it would return {1,2}, {2,1}.
+// Permutations solves the problem in O(n!) time and O(n) space.
 func Permutations(input []int) [][]int {
 	permutations := make([][]int, 0)
 	permutationsRecursive(input, 0, &permutations)

backtracking/permutations_test.go

@@ -5,6 +5,14 @@ import (
 	"testing"
 )
 
+/*
+TestPermutations tests solution(s) with the following signature and problem description:
+
+	func Permutations(input []int) [][]int {
+
+Intakes a list of numbers and returns all possible permutations of their orders
+For example for {1,2} it would return {1,2}, {2,1}.
+*/
 func TestPermutations(t *testing.T) {
 	tests := []struct {
 		nums         []int

backtracking/phone_letter_combinations.go

@@ -11,8 +11,7 @@ var phone = map[byte]string{
 	'9': "wxyz",
 }
 
-// PhoneLetterCombinations intakes the digits from 2 to 9 that represent phone buttons
-// and returns all possible combinations of letters that could be generated from those.
+// PhoneLetterCombinations solves the problem in O(3^n) time and O(3^n) space.
 func PhoneLetterCombinations(digits string) []string {
 	combinations := []string{}
 	if len(digits) > 0 {

backtracking/phone_letter_combinations_test.go

@@ -6,6 +6,14 @@ import (
 	"testing"
 )
 
+/*
+TestPhoneLetterCombinations tests solution(s) with the following signature and problem description:
+
+	func PhoneLetterCombinations(digits string) []string
+
+Intakes the digits from 2 to 9 that represent phone buttons
+and returns all possible combinations of letters that could be generated from those.
+*/
 func TestPhoneLetterCombinations(t *testing.T) {
 	tests := []struct {
 		digits       string

backtracking/sudoku.go

@@ -1,8 +1,6 @@
 package backtracking
 
-// Sudoku solves a given partially filled or empty 9x9 Soduku board by placing
-// integers between 1 and 9 in empty spot designated by 0 such that
-// In each row, column, and 3x3 sub square the values are unique.
+// Sudoku solves the problem in O(9^(n*n)) time and O(n*n) space.
 func Sudoku(board [][]int) bool {
 	for i := 0; i < len(board); i++ {
 		for j := 0; j < len(board[0]); j++ {

backtracking/sudoku_test.go

@@ -10,6 +10,15 @@ type boardAndSolution struct {
 	solution [][]int
 }
 
+/*
+TestSudoku tests solution(s) with the following signature and problem description:
+
+	func Sudoku(board [][]int) bool {
+
+Solves a given partially filled or empty 9x9 Sudoku board by placing integers
+between 1 and 9 in empty spot designated by 0 such that In each row, column, and
+3x3 sub square the values are unique.
+*/
 func TestSudoku(t *testing.T) {
 	tests := []boardAndSolution{
 		testBoard1(),

bit/addition_without_operators.go

@@ -1,6 +1,6 @@
 package bit
 
-// Add adds to numbers without using any arithmetic operators.
+// Add solves the problem in O(1) time and O(1) space.
 func Add(x, y int) int {
 	for y != 0 {
 		sum := x ^ y

bit/addition_without_operators_test.go

@@ -2,6 +2,13 @@ package bit
 
 import "testing"
 
+/*
+TestAdd tests solution(s) with the following signature and problem description:
+
+	func Add(x, y int) int
+
+Adds to numbers without using any arithmetic operators.
+*/
 func TestAdd(t *testing.T) {
 	tests := []struct {
 		a, b int

bit/division_without_operators.go

@@ -1,6 +1,6 @@
 package bit
 
-// Divide divides two numbers without using division or multiplication symbols.
+// Divide solves the problem in O(1) time and O(1) space.
 func Divide(x, y int) int {
 	quotient := 0
 	power := uint64(32)

bit/division_without_operators_test.go

@@ -2,6 +2,13 @@ package bit
 
 import "testing"
 
+/*
+TestDivision tests solution(s) with the following signature and problem description:
+
+	func Divide(x, y int) int {
+
+Divides two numbers without using division or multiplication symbols.
+*/
 func TestDivision(t *testing.T) {
 	tests := []struct {
 		a, b int

bit/find_anagrams.go

@@ -1,6 +1,6 @@
 package bit
 
-// Max returns the maximum of two numbers without using if conditions.
+// Max solves the problem in O(1) time and O(1) space.
 func Max(x, y int) int {
 	k := 1 ^ (((x - y) >> 31) & 0x1)
 	q := 1 ^ k

bit/find_anagrams_test.go

@@ -2,6 +2,13 @@ package bit
 
 import "testing"
 
+/*
+TestMax tests solution(s) with the following signature and problem description:
+
+	func Max(x, y int) int
+
+Returns the maximum of two numbers without using if conditions.
+*/
 func TestMax(t *testing.T) {
 	tests := []struct {
 		a, b, max int

bit/max_function_without_conditions.go

@@ -1,6 +1,6 @@
 package bit
 
-// MiddleWithoutDivision finds the middle integer between two integers.
+// MiddleWithoutDivision solves the problem in O(1) time and O(1) space.
 func MiddleWithoutDivision(min, max int) int {
 	return (min + max) >> 1
 }

bit/max_function_without_conditions_test.go

@@ -2,6 +2,13 @@ package bit
 
 import "testing"
 
+/*
+TestMiddleWithoutDivision tests solution(s) with the following signature and problem description:
+
+	func MiddleWithoutDivision(min, max int)
+
+Finds the middle integer between two integers.
+*/
 func TestMiddleWithoutDivision(t *testing.T) {
 	tests := []struct {
 		a, b, mid int

bit/middle_without_division.go

@@ -1,7 +1,6 @@
 package bit
 
-// OddlyRepeatedNumber repeated number finds an element in a given array that is
-// repeated an odd number of times.
+// OddlyRepeatedNumber solves the problem in O(n) time and O(1) space.
 func OddlyRepeatedNumber(list []int) int {
 	if len(list) == 0 {
 		return -1

bit/middle_without_division_test.go

@@ -4,6 +4,14 @@ import (
 	"testing"
 )
 
+/*
+TestOddlyRepeatedNumber tests solution(s) with the following signature and problem description:
+
+	func OddlyRepeatedNumber(list []int) int
+
+Repeated number finds an element in a given array that is repeated an
+odd number of times.
+*/
 func TestOddlyRepeatedNumber(t *testing.T) {
 	tests := []struct {
 		list          []int

bit/oddly_repeated_number.go

@@ -1,7 +1,6 @@
 package dnc
 
-// BinarySearch finds the index a given number in an ordered slice of sorted integers
-// using Binary Search.
+// BinarySearch solves the problem in O(log n) time and O(1) space.
 func BinarySearch(list []int, search int) int {
 	return binarySearchRecursive(list, 0, len(list), search)
 }

bit/oddly_repeated_number_test.go

@@ -4,6 +4,14 @@ import (
 	"testing"
 )
 
+/*
+TestBinarySearch tests solution(s) with the following signature and problem description:
+
+	func BinarySearch(list []int, search int) int
+
+Finds the index a given number in an ordered slice of sorted integers
+using Binary Search.
+*/
 func TestBinarySearch(t *testing.T) {
 	tests := []struct {
 		sortedNumbers    []int

dnc/binary_search.go

@@ -1,6 +1,6 @@
 package dnc
 
-// MergeSort sorts a list of integers using Merge Sort.
+// MergeSort solves the problem in O(n log n) time and O(n) space.
 func MergeSort(list []int) []int {
 	if len(list) <= 1 {
 		return list

dnc/binary_search_test.go

@@ -5,6 +5,13 @@ import (
 	"testing"
 )
 
+/*
+TestMergeSort tests solution(s) with the following signature and problem description:
+
+	func MergeSort(list []int) []int
+
+Sorts a list of integers using Merge Sort.
+*/
 func TestMergeSort(t *testing.T) {
 	tests := []struct {
 		list   []int

dnc/merge_sort.go

@@ -6,6 +6,7 @@ import (
 
 var rateLimitEvents []int64
 
+// IsAllowed solves the problem in O(1) time and O(n) space.
 func IsAllowed(limitPerSecond int) bool {
 	now := time.Now().Unix()
 	removeOldERateLimitEvents(now)

dnc/merge_sort_test.go

@@ -6,6 +6,15 @@ import (
 	"time"
 )
 
+/*
+TestRateLimiter tests solution(s) with the following signature and problem description:
+
+	IsAllowed(limitPerSecond int) bool
+
+Returns wether or not the caller is allowed to perform an action. The caller is allowed
+to perform an action if the number of actions performed in the last second is less than
+or equal to limitPerSecond.
+*/
 func TestRateLimiter(t *testing.T) {
 	tests := []struct {
 		limitPerSecond  int

dnc/rate_limit.go

@@ -1,6 +1,6 @@
 package dnc
 
-// SquareRoot binary search to find the square root of a number up to a precision point.
+// SquareRoot solves the problem in O(log n) time and O(1) space.
 func SquareRoot(number, precision int) float64 {
 	start := 0
 	end := number

dnc/rate_limit_test.go

@@ -5,6 +5,13 @@ import (
 	"testing"
 )
 
+/*
+TestSquareRoot tests solution(s) with the following signature and problem description:
+
+	func SquareRoot(number, precision int) float64
+
+Uses Binary search to find the square root of a number up to a precision point.
+*/
 func TestSquareRoot(t *testing.T) {
 	tests := []struct {
 		number    int

dnc/square_root.go

@@ -2,11 +2,7 @@ package dnc
 
 type moves [][2]int
 
-// TowerOfHanoi will return the moves it takes to move all disks from start to end with respect
-// to the rules of the Tower of Hanoi game where:
-// n is the number of disks stacked on top of each other
-// heavier disks can never be placed on a lighter disk
-// There are 3 towers, all disks are initially places at the start tower.
+// TowerOfHanoi solves the problem in O(2^n) time and O(n) space.
 func TowerOfHanoi(n, start, end int) [][2]int {
 	m := make(moves, 0)
 	towerOfHanoiRecursive(n, start, end, &m)

dnc/square_root_test.go

@@ -5,6 +5,17 @@ import (
 	"testing"
 )
 
+/*
+TestTowerOfHanoi tests solution(s) with the following signature and problem description:
+
+	func TowerOfHanoi(n, start, end int) [][2]int {
+
+Returns the moves it takes to move all disks from start to end with respect
+to the rules of the Tower of Hanoi game where:
+n is the number of disks stacked on top of each other
+heavier disks can never be placed on a lighter disk
+There are 3 towers, all disks are initially places at the start tower.
+*/
 func TestTowerOfHanoi(t *testing.T) {
 	tests := []struct {
 		n, start, end int

dnc/towers_of_hanoi.go

@@ -1,8 +1,6 @@
 package dp
 
-// MaxHouseRobber given an array representing the amount of wealth inside a house
-// and given that the robber can steal only non-consecutive houses
-// returns the maximum amount of wealth the robber can steal.
+// MaxHouseRobber solves the problem in O(n) time and O(1) space.
 func MaxHouseRobber(wealth []int) int {
 	if len(wealth) == 0 {
 		return 0

dnc/towers_of_hanoi_test.go

@@ -4,6 +4,15 @@ import (
 	"testing"
 )
 
+/*
+TestMaxHouseRobber tests solution(s) with the following signature and problem description:
+
+	func MaxHouseRobber(wealth []int) int
+
+given an array representing the amount of wealth inside a house
+and given that the robber can steal only non-consecutive houses
+returns the maximum amount of wealth the robber can steal.
+*/
 func TestMaxHouseRobber(t *testing.T) {
 	tests := []struct {
 		houses []int

dp/house_robber.go

@@ -1,7 +1,6 @@
 package dp
 
-// MinimumDeletionsToMakePalindrome returns how many deletions can be done in the input string
-// to make it a palindrome.
+// MinimumDeletionsToMakePalindrome solves the problem in O(n^2) time and O(n^2) space.
 func MinimumDeletionsToMakePalindrome(input string) int {
 	if len(input) <= 1 {
 		return 0