style: code block syntax 적용

Author: Invidam

climbing-stairs/invidam.go.md

@@ -24,24 +24,24 @@ DP has two methods: tabulation and memoization. I'll introduce both methods.
 
 (n is value of `n`)
 # Code
-```
+```go
 func climbStairsV1(n int) int {
-    climbData := make([]int, n+2, n+2)
-    climbData[0], climbData[1] = 1, 1
-    for s := 0; s < n; s++ {
-        climbData[s+2] = climbData[s] + climbData[s+1]
-    }
+	climbData := make([]int, n+2, n+2)
+	climbData[0], climbData[1] = 1, 1
+	for s := 0; s < n; s++ {
+		climbData[s+2] = climbData[s] + climbData[s+1]
+	}
 
-    return climbData[n]
+	return climbData[n]
 }
 
 func climbStairsV2(n int) int {
-    prev, curr := 1, 1
-    for s := 1; s < n; s++ {
-        prev, curr = curr, prev + curr
-    }
+	prev, curr := 1, 1
+	for s := 1; s < n; s++ {
+		prev, curr = curr, prev+curr
+	}
 
-    return curr
+	return curr
 }
 ```
 
@@ -65,7 +65,7 @@ func climbStairsV2(n int) int {
 <!-- Add your space complexity here, e.g. $$O(n)$$ -->
 (n is value of `n`)
 # Code
-```
+```go
 var cache map[int]int = map[int]int{}
 func climbStairs(n int) int {
 	if n == 0 || n == 1 {

maximum-depth-of-binary-tree/invidam.go.md

@@ -48,26 +48,26 @@ Implement Queue can be troublesome, but it is effective to problem that require
 # Code
 ```
 func maxDepth(root *TreeNode) int {
-    if root == nil {
-        return 0
-    }
-    depth := 0
-    currLevel := []*TreeNode{root}
-    
-    for len(currLevel) != 0 {
-        depth++
-        for _, curr := range currLevel {
-            if curr.Left != nil {
-                currLevel = append(currLevel, curr.Left)
-            }
-            if curr.Right != nil {
-                currLevel = append(currLevel, curr.Right)
-            }
-            currLevel = currLevel[1:]
-        }
-    }
+	if root == nil {
+		return 0
+	}
+	depth := 0
+	currLevel := []*TreeNode{root}
+
+	for len(currLevel) != 0 {
+		depth++
+		for _, curr := range currLevel {
+			if curr.Left != nil {
+				currLevel = append(currLevel, curr.Left)
+			}
+			if curr.Right != nil {
+				currLevel = append(currLevel, curr.Right)
+			}
+			currLevel = currLevel[1:]
+		}
+	}
 
-    return depth
+	return depth
 }
 ```
 

same-tree/invidam.go.md

@@ -16,13 +16,13 @@ Recursion is natural method to iterate trees. (Particularly, multiple trees!)
 
 (n and m are number of nodes in trees p and q. $$h_n$$ and $$h_m$$ are their heights.)
 # Code
-```
+```go
 func isSameTree(p *TreeNode, q *TreeNode) bool {
-    if p == nil || q == nil {
-        return p == nil && q == nil
-    }
+	if p == nil || q == nil {
+		return p == nil && q == nil
+	}
 
-    return p.Val == q.Val && isSameTree(p.Left, q.Left) && isSameTree(p.Right, q.Right)
+	return p.Val == q.Val && isSameTree(p.Left, q.Left) && isSameTree(p.Right, q.Right)
 }
 ```
 - - -
@@ -40,7 +40,7 @@ func isSameTree(p *TreeNode, q *TreeNode) bool {
 
 (n and m are number of nodes in trees p and q.)
 # Code
-```
+```go
 func updateQueue(node *TreeNode, queue []*TreeNode) []*TreeNode {
 	queue = append(queue, node.Left)
 	queue = append(queue, node.Right)

subtree-of-another-tree/invidam.go.md

@@ -48,58 +48,58 @@ func isSubtree(root *TreeNode, subRoot *TreeNode) bool {
   (This complexity is determined. because the maximun sizes of the queues (`q`, `q1`, `q2`), which doesn't exceed the sum of sizes of both trees.)
 <!-- Add your space complexity here, e.g. $$O(n)$$ -->
 # Code
-```
+```go
 func isEqualTree(root *TreeNode, subRoot *TreeNode) bool {
-    q1 := []*TreeNode{root}
-    q2 := []*TreeNode{subRoot}
+	q1 := []*TreeNode{root}
+	q2 := []*TreeNode{subRoot}
 
-    for len(q1) != 0 {
-        f1 := q1[0]
-        f2 := q2[0]
+	for len(q1) != 0 {
+		f1 := q1[0]
+		f2 := q2[0]
 
-        q1 = q1[1:]
-        q2 = q2[1:]
+		q1 = q1[1:]
+		q2 = q2[1:]
 
-        if (f1 == nil) && (f2 == nil) {
-            continue
-        }
-        if (f1 == nil) || (f2 == nil) || (f1.Val != f2.Val) {
-            return false
-        }
+		if (f1 == nil) && (f2 == nil) {
+			continue
+		}
+		if (f1 == nil) || (f2 == nil) || (f1.Val != f2.Val) {
+			return false
+		}
 
-        q1 = append(q1, f1.Left)
-        q1 = append(q1, f1.Right)
+		q1 = append(q1, f1.Left)
+		q1 = append(q1, f1.Right)
 
-        q2 = append(q2, f2.Left)
-        q2 = append(q2, f2.Right)
-    }
-    
-    return true
+		q2 = append(q2, f2.Left)
+		q2 = append(q2, f2.Right)
+	}
+
+	return true
 }
 
 func isSubtree(root *TreeNode, subRoot *TreeNode) bool {
-    if root == nil {
-        //assert subRoot != nil
-        return false
-    }
+	if root == nil {
+		//assert subRoot != nil
+		return false
+	}
 
-    q := []*TreeNode{root}
+	q := []*TreeNode{root}
 
-    for len(q) != 0 {
-        node := q[0]
-        q = q[1:]
+	for len(q) != 0 {
+		node := q[0]
+		q = q[1:]
 
-        if node == nil {
-            continue
-        }
-        if isEqualTree(node, subRoot) {
-            return true
-        }
+		if node == nil {
+			continue
+		}
+		if isEqualTree(node, subRoot) {
+			return true
+		}
 
-        q = append(q, node.Left)
-        q = append(q, node.Right)
-    }
+		q = append(q, node.Left)
+		q = append(q, node.Right)
+	}
 
-    return false
+	return false
 }
 ```