Up to game-of-life

alien-dictionary.go

@@ -0,0 +1,178 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+func slicesMatch(a, b []rune) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	for i := 0; i < len(a); i++ {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
+
+func runeExists(runes []rune, r rune) bool {
+	for _, c := range runes {
+		if c == r {
+			return true
+		}
+	}
+
+	return false
+}
+
+func topologicalOrder(starting rune, adjMat map[rune][]rune, visitedInPriorTraversal, visited map[rune]bool, orderSoFar string) (string, error) {
+	if visited[starting] {
+		return "", errors.New("already visited " + string(starting))
+	}
+
+	visited[starting] = true
+
+	adjs := adjMat[starting]
+
+	// if !ok || len(adjs) == 0 {
+	// 	return orderSoFar + string(starting), nil
+	// }
+
+	for _, a := range adjs {
+		if !visitedInPriorTraversal[a] {
+			var err error
+			orderSoFar, err = topologicalOrder(a, adjMat, visitedInPriorTraversal, visited, orderSoFar)
+
+			if err != nil {
+				return "", err
+			}
+		}
+	}
+
+	return orderSoFar + string(starting), nil
+}
+
+func reverse(s string) string {
+	runes := []rune(s)
+	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
+		runes[i], runes[j] = runes[j], runes[i]
+	}
+	return string(runes)
+}
+
+func alienOrder(words []string) string {
+	inEdges := make(map[rune]int)
+	alphabet := make(map[rune]bool)
+	wordChars := make([][]rune, len(words))
+	maxWordLen := 0
+
+	for i, str := range words {
+		wordChars[i] = []rune(str)
+
+		if len(str) > maxWordLen {
+			maxWordLen = len(str)
+		}
+
+		for _, c := range wordChars[i] {
+			inEdges[c] = 0
+			alphabet[c] = true
+		}
+	}
+
+	adjMat := make(map[rune][]rune)
+
+	for letterOffset := 0; letterOffset < maxWordLen; letterOffset++ {
+		for wordOffset := 0; wordOffset < len(words); wordOffset++ {
+			if len(words[wordOffset]) <= letterOffset {
+				continue
+			}
+
+			wordChar := wordChars[wordOffset][letterOffset]
+			_, ok := adjMat[wordChar]
+
+			if !ok {
+				adjMat[wordChar] = []rune{}
+			}
+
+			if wordOffset == 0 {
+				continue
+			}
+
+			if letterOffset > 0 && (letterOffset >= len(wordChars[wordOffset-1]) || !slicesMatch(wordChars[wordOffset][0:letterOffset], wordChars[wordOffset-1][0:letterOffset])) {
+				continue
+			}
+
+			preChar := wordChars[wordOffset-1][letterOffset]
+
+			if !runeExists(adjMat[preChar], wordChar) && preChar != wordChar {
+				adjMat[preChar] = append(adjMat[preChar], wordChar)
+				inEdges[wordChar]++
+			}
+		}
+	}
+
+	// for k, v := range adjMat {
+	// 	fmt.Printf("%c -> %s\n", k, string(v))
+	// }
+
+	visitedInPriorTraversal := make(map[rune]bool)
+	orderSoFar := ""
+
+	for k, _ := range alphabet {
+		if inEdges[k] > 0 {
+			// We only want to start traversing from root characters
+			continue
+		}
+
+		if !visitedInPriorTraversal[k] {
+			var err error
+			visited := map[rune]bool{}
+			orderSoFar, err = topologicalOrder(k, adjMat, visitedInPriorTraversal, visited, orderSoFar)
+
+			for visitedK, visitedV := range visited {
+				visitedInPriorTraversal[visitedK] = visitedV
+			}
+
+			if orderSoFar == "" || err != nil {
+				return ""
+			}
+		}
+	}
+
+	return reverse(orderSoFar)
+}
+
+func tests() {
+	testCases := [][]string{
+		[]string{"z", "x"},
+		[]string{"wrt", "wrf", "er", "ett", "rftt"},
+		[]string{"wrt", "wrfb", "wrff", "er", "ett", "rftt"},
+		[]string{"z", "x", "z"},
+		[]string{"abc"},
+		[]string{"a"},
+		[]string{""},
+		[]string{"ab", "d", "b"},
+	}
+
+	for i, tc := range testCases {
+		result := alienOrder(tc)
+
+		fmt.Printf("testcase %d: result: %s\n", i, result)
+	}
+}
+
+func main() {
+	tests()
+}

game-of-life.go

@@ -0,0 +1,97 @@
+package main
+
+import "fmt"
+
+func getOrig(n int) int {
+	if n < 10 {
+		return n
+	}
+
+	if n == 10 {
+		return 0
+	}
+
+	return 1
+}
+
+func getNew(n int) int {
+	if n < 10 {
+		return n
+	}
+
+	if n == 10 {
+		return 1
+	}
+
+	return 0
+}
+
+func countLiveNeighbors(board [][]int, atR, atC int) int {
+	dirR := []int{-1, -1, -1, 0, 0, 1, 1, 1}
+	dirC := []int{-1, 0, 1, -1, 1, -1, 0, 1}
+	numRows := len(board)
+	numCols := len(board[0])
+	numLiveNeighbors := 0
+
+	for i := 0; i < len(dirR); i++ {
+		nbrR, nbrC := atR+dirR[i], atC+dirC[i]
+
+		if nbrR < 0 || nbrR >= numRows || nbrC < 0 || nbrC >= numCols {
+			continue
+		}
+
+		numLiveNeighbors += getOrig(board[nbrR][nbrC])
+	}
+
+	return numLiveNeighbors
+}
+
+func gameOfLife(board [][]int) {
+	numRows := len(board)
+	numCols := len(board[0])
+
+	for i := 0; i < numRows; i++ {
+		for j := 0; j < numCols; j++ {
+			numLiveNeighbors := countLiveNeighbors(board, i, j)
+
+			if numLiveNeighbors < 2 {
+				if board[i][j] == 1 {
+					board[i][j] = 11
+				}
+			} else if numLiveNeighbors < 4 {
+				// 2 or 3
+				if numLiveNeighbors == 3 && getOrig(board[i][j]) == 0 {
+					board[i][j] = 10
+				}
+			} else {
+				// more than 3
+				if getOrig(board[i][j]) == 1 {
+					board[i][j] = 11
+				}
+			}
+		}
+	}
+
+	for i := 0; i < numRows; i++ {
+		for j := 0; j < numCols; j++ {
+			board[i][j] = getNew(board[i][j])
+		}
+	}
+}
+
+func test1() {
+	board := [][]int{
+		[]int{0, 1, 0},
+		[]int{0, 0, 1},
+		[]int{1, 1, 1},
+		[]int{0, 0, 0},
+	}
+
+	gameOfLife(board)
+
+	fmt.Printf("new board: %v\n", board)
+}
+
+func main() {
+	test1()
+}

minimum-insertions-to-form-a-palindrome.go

@@ -0,0 +1,71 @@
+package main
+
+import "fmt"
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+
+	return b
+}
+
+func findMinInsertions(str string) int {
+	chars := []rune(str)
+	n := len(str)
+	dp := make([][]int, n)
+
+	for i := 0; i < n; i++ {
+		dp[i] = make([]int, n)
+	}
+
+	for i := 0; i < n; i++ {
+	}
+
+	for l := 2; l <= n; l++ {
+		for lo := 0; lo <= n-l; lo++ {
+			hi := lo + l - 1
+
+			if chars[lo] == chars[hi] {
+				if hi == lo+1 {
+					dp[lo][hi] = 0
+				} else {
+					dp[lo][hi] = dp[lo+1][hi-1]
+				}
+			} else {
+				dp[lo][hi] = 1 + min(dp[lo+1][hi], dp[lo][hi-1])
+			}
+		}
+	}
+
+	return dp[0][n-1]
+}
+
+type testCase struct {
+	str            string
+	expectedResult int
+}
+
+func tests() {
+	testCases := []testCase{
+		testCase{str: "ab", expectedResult: 1},
+		testCase{str: "aa", expectedResult: 0},
+		testCase{str: "abcd", expectedResult: 3},
+		testCase{str: "abcda", expectedResult: 2},
+		testCase{str: "abcde", expectedResult: 4},
+	}
+
+	for i, tc := range testCases {
+		result := findMinInsertions(tc.str)
+
+		if result != tc.expectedResult {
+			fmt.Printf("Test %d FAILED. Expected %d, got %d\n", i, tc.expectedResult, result)
+		} else {
+			fmt.Printf("Test %d PASSED\n", i)
+		}
+	}
+}
+
+func main() {
+	tests()
+}