diff --git a/Easy.md b/Easy.md
index 77bf533..540a506 100644
--- a/Easy.md
+++ b/Easy.md
@@ -147,3 +147,33 @@
 |[744](https://leetcode.com/problems/find-smallest-letter-greater-than-target/)|  Find Smallest Letter Greater Than Target|
 |[530](https://leetcode.com/problems/minimum-absolute-difference-in-bst/)|  Minimum Absolute Difference in BST|
 |[111](https://leetcode.com/problems/minimum-depth-of-binary-tree/)|  Minimum Depth of Binary Tree|
+|[191](https://leetcode.com/problems/number-of-1-bits/)|  Number of 1 Bits|
+|[2264](https://leetcode.com/problems/largest-3-same-digit-number-in-string/)|  Largest 3-Same-Digit Number in String|
+|[1266](https://leetcode.com/problems/minimum-time-visiting-all-points/)|  Minimum Time Visiting All Points|
+|[1903](https://leetcode.com/problems/largest-odd-number-in-string/)|  Largest Odd Number in String|
+|[1716](https://leetcode.com/problems/calculate-money-in-leetcode-bank/)|  Calculate Money in Leetcode Bank|
+|[606](https://leetcode.com/problems/construct-string-from-binary-tree/)|  Construct String from Binary Tree|
+|[94](https://leetcode.com/problems/binary-tree-inorder-traversal/)|  Binary Tree Inorder Traversal|
+|[1287](https://leetcode.com/problems/element-appearing-more-than-25-in-sorted-array/)|  Element Appearing More Than 25% In Sorted Array|
+|[1582](https://leetcode.com/problems/special-positions-in-a-binary-matrix/)|  Special Positions in a Binary Matrix|
+|[1436](https://leetcode.com/problems/destination-city/)|  Destination City|
+|[1512](https://leetcode.com/problems/number-of-good-pairs/)|  Number of Good Pairs|
+|[661](https://leetcode.com/problems/image-smoother/)|  Image Smoother|
+|[1913](https://leetcode.com/problems/maximum-product-difference-between-two-pairs/)|  Maximum Product Difference Between Two Pairs|
+|[2706](https://leetcode.com/problems/buy-two-chocolates/)|  Buy Two Chocolates|
+|[1422](https://leetcode.com/problems/maximum-score-after-splitting-a-string/)|  Maximum Score After Splitting a String|
+|[1758](https://leetcode.com/problems/minimum-changes-to-make-alternating-binary-string/)|  Minimum Changes To Make Alternating Binary String|
+|[1496](https://leetcode.com/problems/path-crossing/)|  Path Crossing|
+|[1897](https://leetcode.com/problems/redistribute-characters-to-make-all-strings-equal/)| Redistribute Characters to Make All Strings Equal|
+|[1624](https://leetcode.com/problems/largest-substring-between-two-equal-characters/)| Largest Substring Between Two Equal Characters|
+|[455](https://leetcode.com/problems/assign-cookies/)|  Assign Cookies|
+|[501](https://leetcode.com/problems/find-mode-in-binary-search-tree/)|  Find Mode in Binary Search Tree|
+|[872](https://leetcode.com/problems/leaf-similar-trees/)|  Leaf-Similar Trees|
+|[119](https://leetcode.com/problems/pascals-triangle-ii/)|  Pascal's Triangle II|
+|[1700](https://leetcode.com/problems/number-of-students-unable-to-eat-lunch/)|  Number of Students Unable to Eat Lunch|
+|[678](https://leetcode.com/problems/valid-parenthesis-string/)|  Valid Parenthesis String|
+|[2000](https://leetcode.com/problems/reverse-prefix-of-word/)|  Reverse Prefix of Word|
+|[2441](https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/)|  Largest Positive Integer That Exists With Its Negative|
+|[2373](https://leetcode.com/problems/largest-local-values-in-a-matrix/)|  Largest Local Values in a Matrix|
+|[2331](https://leetcode.com/problems/evaluate-boolean-binary-tree/)|  Evaluate Boolean Binary Tree|
+|[860](https://leetcode.com/problems/lemonade-change/)|  Lemonade Change|
diff --git a/Easy/L1160.go b/Easy/L1160.go
index 98e1960..bca44ba 100644
--- a/Easy/L1160.go
+++ b/Easy/L1160.go
@@ -1,25 +1,31 @@
 package Easy
 
 func countCharacters(words []string, chars string) int {
-    	res, cnt := 0, make([]int, 26)
+	var isMatch func(s string) bool
+	res := 0
 
-	for i := range chars {
-		cnt[chars[i]-'a']++
-	}
+	isMatch = func(s string) bool {
+		mp := make(map[byte]int)
 
-	for _, w := range words {
-		match, tmp := true, make([]int, 26)
-		copy(tmp, cnt)
+		for _, c := range chars {
+			mp[byte(c)]++
+		}
 
-		for i := range w {
-			tmp[w[i]-'a']--
-			if tmp[w[i]-'a'] < 0 {
-				match = false
-				break
+		for _, c := range s {
+			if _, ok := mp[byte(c)]; !ok {
+				return false
+			}
+			mp[byte(c)]--
+			if mp[byte(c)] < 0 {
+				return false
 			}
 		}
 
-		if match {
+		return true
+	}
+
+	for _, w := range words {
+		if isMatch(w) {
 			res += len(w)
 		}
 	}
diff --git a/Easy/L119.go b/Easy/L119.go
new file mode 100644
index 0000000..323d63e
--- /dev/null
+++ b/Easy/L119.go
@@ -0,0 +1,14 @@
+package Easy
+
+func getRow(rowIndex int) []int {
+	res := make([]int, rowIndex+1)
+	res[0] = 1
+
+	for i := 1; i < rowIndex+1; i++ {
+		for j := i; j >= 1; j-- {
+			res[j] += res[j-1]
+		}
+	}
+
+	return res
+}
diff --git a/Easy/L1266.go b/Easy/L1266.go
new file mode 100644
index 0000000..d1a4122
--- /dev/null
+++ b/Easy/L1266.go
@@ -0,0 +1,30 @@
+package Easy
+
+func minTimeToVisitAllPoints(points [][]int) int {
+	cnt := 0
+
+	for i := 1; i < len(points); i++ {
+		x := abs(points[i - 1][0] - points[i][0])
+		y := abs(points[i - 1][1] - points[i][1])
+		
+		cnt += max(x, y)
+	}
+	
+	return cnt
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
+
+func abs(a int) int {
+	if a < 0 {
+		return -a
+	}
+
+	return a
+}
diff --git a/Easy/L1287.go b/Easy/L1287.go
new file mode 100644
index 0000000..3af0d0a
--- /dev/null
+++ b/Easy/L1287.go
@@ -0,0 +1,13 @@
+package Easy
+
+func findSpecialInteger(arr []int) int {
+	n, t := len(arr), len(arr)/4
+
+	for i := 0; i < n-t; i++ {
+		if arr[i] == arr[i+t] {
+			return arr[i]
+		}
+	}
+
+	return -1
+}
diff --git a/Easy/L1422.go b/Easy/L1422.go
new file mode 100644
index 0000000..4aeeecd
--- /dev/null
+++ b/Easy/L1422.go
@@ -0,0 +1,27 @@
+package Easy
+
+func maxScore(s string) int {
+	zeroes, ones, maximum := 0, 0, math.MinInt32
+
+	for i := 0; i < len(s); i++ {
+		if s[i] == '0' {
+			zeroes++
+		} else {
+			ones++
+		}
+
+		if i != len(s)-1 {
+			maximum = max(maximum, zeroes-ones)
+		}
+	}
+
+	return maximum + ones
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
diff --git a/Easy/L1436.go b/Easy/L1436.go
new file mode 100644
index 0000000..9c86773
--- /dev/null
+++ b/Easy/L1436.go
@@ -0,0 +1,18 @@
+package Easy
+
+func destCity(paths [][]string) string {
+	inDeg, outDeg := make(map[string]int), make(map[string]int)
+
+	for _, p := range paths {
+		outDeg[p[0]] += 1
+		inDeg[p[1]] += 1
+	}
+
+	for k, v := range inDeg {
+		if v == 1 && outDeg[k] == 0 {
+			return k
+		}
+	}
+
+	return ""
+}
diff --git a/Easy/L1496.go b/Easy/L1496.go
new file mode 100644
index 0000000..fe3b7c3
--- /dev/null
+++ b/Easy/L1496.go
@@ -0,0 +1,33 @@
+package Easy
+
+func isPathCrossing(path string) bool {
+	var (
+		getNextPoint func(b byte) ([]int, string)
+		key          string
+	)
+	visited, curr := make(map[string]bool), []int{0, 0}
+	visited[fmt.Sprintf("%d#%d", curr[0], curr[1])] = true
+
+	getNextPoint = func(b byte) ([]int, string) {
+		mp := map[byte][]int{
+			'N': {0, 1},
+			'S': {0, -1},
+			'E': {1, 1},
+			'W': {-1, -1},
+		}
+
+		nextPoint := []int{curr[0] + mp[b][0], curr[1] + mp[b][1]}
+		return nextPoint, fmt.Sprintf("%d#%d", nextPoint[0], nextPoint[1])
+	}
+
+	for _, p := range path {
+		curr, key = getNextPoint(byte(p))
+
+		if _, ok := visited[key]; ok {
+			return true
+		}
+		visited[key] = true
+	}
+
+	return false
+}
diff --git a/Easy/L1512.go b/Easy/L1512.go
new file mode 100644
index 0000000..7c9a395
--- /dev/null
+++ b/Easy/L1512.go
@@ -0,0 +1,15 @@
+package Medium
+
+func numIdenticalPairs(nums []int) int {
+	cnt := 0
+
+	for i := 0; i < len(nums); i++ {
+		for j := i + 1; j < len(nums); j++ {
+			if nums[i] == nums[j] {
+				cnt++
+			}
+		}
+	}
+
+	return cnt
+}
diff --git a/Easy/L1582.go b/Easy/L1582.go
new file mode 100644
index 0000000..05bafc4
--- /dev/null
+++ b/Easy/L1582.go
@@ -0,0 +1,23 @@
+package Easy
+
+func numSpecial(mat [][]int) int {
+	m, n, res, col, row := len(mat), len(mat[0]), 0, make([]int, len(mat[0])), make([]int, len(mat))
+
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if mat[i][j] == 1 {
+				col[j], row[i] = col[j]+1, row[i]+1
+			}
+		}
+	}
+
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if mat[i][j] == 1 && row[i] == 1 && col[j] == 1 {
+				res++
+			}
+		}
+	}
+
+	return res
+}
diff --git a/Easy/L1624.go b/Easy/L1624.go
new file mode 100644
index 0000000..9216099
--- /dev/null
+++ b/Easy/L1624.go
@@ -0,0 +1,19 @@
+package Easy
+
+func maxLengthBetweenEqualCharacters(s string) int {
+	indexes, dist := make(map[byte]int), -1
+
+	for i := 0; i < len(s); i++ {
+		if v, ok := indexes[s[i]-'a']; ok {
+			dist = max(dist, i-v+1)
+		} else {
+			indexes[s[i]-'a'] = i
+		}
+	}
+
+	if dist == -1 {
+		return dist
+	}
+	
+	return dist - 2
+}
diff --git a/Easy/L1700.go b/Easy/L1700.go
new file mode 100644
index 0000000..da13a4d
--- /dev/null
+++ b/Easy/L1700.go
@@ -0,0 +1,29 @@
+package Easy
+
+func countStudents(students []int, sandwiches []int) int {
+	ones, zeroes := 0, 0
+
+	for _, student := range students {
+		if student == 0 {
+			zeroes++
+		} else {
+			ones++
+		}
+	}
+
+	for _, sandwich := range sandwiches {
+		if sandwich == 0 {
+			if zeroes == 0 {
+				return ones
+			}
+			zeroes--
+		} else {
+			if ones == 0 {
+				return zeroes
+			}
+			ones--
+		}
+	}
+
+	return 0
+}
diff --git a/Easy/L1716.go b/Easy/L1716.go
new file mode 100644
index 0000000..f70f12f
--- /dev/null
+++ b/Easy/L1716.go
@@ -0,0 +1,19 @@
+package Easy
+
+func totalMoney(n int) int {
+	sum, prev, tot, cnt := 0, 1, 0, 0
+
+	for i := 1; i <= n; i++ {
+		if cnt == 7 {
+			cnt, tot = 0, prev+1
+			prev = tot
+		} else {
+			tot++
+		}
+
+		sum += tot
+		cnt++
+	}
+
+	return sum
+}
diff --git a/Easy/L1758.go b/Easy/L1758.go
new file mode 100644
index 0000000..76d5330
--- /dev/null
+++ b/Easy/L1758.go
@@ -0,0 +1,18 @@
+package Easy
+
+func minOperations(s string) int {
+	swaps := 0
+	for i := 0; i < len(s); i++ {
+		if i %2 == 0 {
+			if s[i] != '0' {
+				swaps++
+			}
+		} else {
+			if s[i] != '1' {
+				swaps++
+			}
+		}
+	}
+	
+	return min(swaps, len(s) - swaps)
+}
diff --git a/Easy/L1897.go b/Easy/L1897.go
new file mode 100644
index 0000000..31fa2f9
--- /dev/null
+++ b/Easy/L1897.go
@@ -0,0 +1,19 @@
+package Easy
+
+func makeEqual(words []string) bool {
+	counts := make(map[byte]int)
+	for _, w := range words {
+		for i := 0; i < len(w); i++ {
+			counts[w[i] - 'a']++
+		}
+	}
+	
+	n := len(words)
+	for _, v := range counts {
+		if v % n != 0 {
+			return false
+		}
+	}
+	
+	return true
+}
diff --git a/Easy/L1903.go b/Easy/L1903.go
new file mode 100644
index 0000000..4d2589f
--- /dev/null
+++ b/Easy/L1903.go
@@ -0,0 +1,11 @@
+package Easy
+
+func largestOddNumber(num string) string {
+	for i := len(num) - 1; i >= 0; i-- {
+		if ((num[i] - '0') % 2) > 0 {
+			return num[0 : i+1]
+		}
+	}
+
+	return ""
+}
diff --git a/Easy/L191.go b/Easy/L191.go
new file mode 100644
index 0000000..0f5c33f
--- /dev/null
+++ b/Easy/L191.go
@@ -0,0 +1,12 @@
+package Easy
+
+func hammingWeight(num uint32) int {
+	cnt := 0
+
+	for num != 0 {
+		num = num & (num - 1)
+		cnt++
+	}
+
+	return cnt
+}
diff --git a/Easy/L1913.go b/Easy/L1913.go
new file mode 100644
index 0000000..f8b65a0
--- /dev/null
+++ b/Easy/L1913.go
@@ -0,0 +1,20 @@
+package Easy
+
+func maxProductDifference(nums []int) int {
+	largest, secondLargest, smallest, secondSmallest := 0, 0, math.MaxInt32, math.MaxInt32
+	for i := 0; i < len(nums); i++ {
+		if nums[i] >= largest {
+			secondLargest, largest = largest, nums[i]
+		} else if nums[i] > secondLargest {
+			secondLargest = nums[i]
+		}
+
+		if nums[i] <= smallest {
+			secondSmallest, smallest = smallest, nums[i]
+		} else if nums[i] < secondSmallest {
+			secondSmallest = nums[i]
+		}
+	}
+
+	return largest*secondLargest - smallest*secondSmallest
+}
diff --git a/Easy/L2000.go b/Easy/L2000.go
new file mode 100644
index 0000000..333db46
--- /dev/null
+++ b/Easy/L2000.go
@@ -0,0 +1,21 @@
+package Easy
+
+func reversePrefix(word string, ch byte) string {
+	for i := 0; i < len(word); i++ {
+		if word[i] == ch {
+			return reverse(word[:i+1]) + word[i+1:]
+		}
+	}
+
+	return word
+}
+
+func reverse(s string) string {
+	n := len(s)
+	runes := make([]rune, n)
+	for _, ch := range s {
+		n--
+		runes[n] = ch
+	}
+	return string(runes)
+}
diff --git a/Easy/L2264.go b/Easy/L2264.go
new file mode 100644
index 0000000..213b404
--- /dev/null
+++ b/Easy/L2264.go
@@ -0,0 +1,24 @@
+package Easy
+
+func largestGoodInteger(num string) string {
+	res := -1
+	for i := 0; i+2 < len(num); i++ {
+		if num[i] == num[i+1] && num[i+1] == num[i+2] {
+			res = max(res, int(num[i]-'0'))
+		}
+	}
+
+	if res == -1 {
+		return ""
+	}
+
+	return fmt.Sprintf("%d%d%d", res, res, res)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
diff --git a/Easy/L2331.go b/Easy/L2331.go
new file mode 100644
index 0000000..0a895c1
--- /dev/null
+++ b/Easy/L2331.go
@@ -0,0 +1,39 @@
+package Easy
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func evaluateTree(root *TreeNode) bool {
+	var solve func(root *TreeNode) bool
+	mp := map[int]bool{
+		0: false,
+		1: true,
+	}
+
+	solve = func(node *TreeNode) bool {
+		if node.Right == nil && node.Left == nil {
+			return mp[node.Val]
+		}
+		
+		var left, right bool
+		if node.Left != nil {
+			left = solve(node.Left)
+		}
+		if node.Right != nil {
+			right = solve(node.Right)
+		}
+		
+		if node.Val == 2 {
+			return left || right
+		}
+		
+		return left && right
+	}
+	
+	return solve(root)
+}
diff --git a/Easy/L2373.go b/Easy/L2373.go
new file mode 100644
index 0000000..188b7cc
--- /dev/null
+++ b/Easy/L2373.go
@@ -0,0 +1,25 @@
+package Easy
+
+func largestLocal(grid [][]int) [][]int {
+	n := len(grid)
+	res := make([][]int, n-2)
+	for i := 0; i < len(res); i++ {
+		res[i] = make([]int, n-2)
+	}
+
+	for i := 1; i < n-1; i++ {
+		for j := 1; j < n-1; j++ {
+			tmp := 0
+
+			for k := i - 1; k <= i + 1; k++ {
+				for l := j - 1; l <= j + 1; l++ {
+					tmp = max(tmp, grid[k][l])
+				}
+			}
+
+			res[i-1][j-1] = tmp
+		}
+	}
+
+	return res
+}
diff --git a/Easy/L2441.go b/Easy/L2441.go
new file mode 100644
index 0000000..5a9abef
--- /dev/null
+++ b/Easy/L2441.go
@@ -0,0 +1,22 @@
+package Easy
+
+func findMaxK(nums []int) int {
+	mp, res := make(map[int]bool), -1
+	
+	for _, n := range nums {
+		if mp[-n] {
+			res = max(res, abs(n))
+		}
+		mp[n] = true
+	}
+	
+	return res
+}
+
+func abs(a int) int {
+	if a < 0 {
+		return -a
+	}
+	
+	return a
+}
diff --git a/Easy/L2706.go b/Easy/L2706.go
new file mode 100644
index 0000000..76f10bb
--- /dev/null
+++ b/Easy/L2706.go
@@ -0,0 +1,23 @@
+package Easy
+
+func buyChoco(prices []int, money int) int {
+	if len(prices) < 2 {
+		return money
+	}
+	
+	first, second := math.MaxInt32, math.MaxInt32
+	
+	for _, p := range prices {
+		if p < first {
+			second, first = first, p
+		}else if p < second {
+			second = p
+		}
+	}
+	
+	if first + second > money {
+		return money
+	}
+	
+	return money - (first + second)
+}
diff --git a/Easy/L455.go b/Easy/L455.go
new file mode 100644
index 0000000..3ef58ed
--- /dev/null
+++ b/Easy/L455.go
@@ -0,0 +1,15 @@
+package Easy
+
+func findContentChildren(children []int, cookies []int) int {
+	sort.Ints(children)
+	sort.Ints(cookies)
+
+	child := 0
+	for cookie := 0; child < len(children) && cookie < len(cookies); cookie++ {
+		if cookies[cookie] >= children[child] {
+			child++
+		}
+	}
+	
+	return child
+}
diff --git a/Easy/L501.go b/Easy/L501.go
new file mode 100644
index 0000000..6823db0
--- /dev/null
+++ b/Easy/L501.go
@@ -0,0 +1,35 @@
+package Easy
+
+func findMode(root *TreeNode) []int {
+	var (
+		modes []int
+		solve func(node *TreeNode, count *int)
+	)
+	prev, cnt, maxCnt := root, 0, math.MinInt32
+
+	solve = func(node *TreeNode, count *int) {
+		if node == nil {
+			return
+		}
+		solve(node.Left, count)
+		if prev.Val == node.Val {
+			*count++
+		} else {
+			*count = 1
+		}
+
+		if *count == maxCnt {
+			modes = append(modes, node.Val)
+		} else if *count > maxCnt {
+			modes = nil
+			modes = append(modes, node.Val)
+			maxCnt = *count
+		}
+
+		prev = node
+		solve(node.Right, count)
+	}
+
+	solve(root, &cnt)
+	return modes
+}
diff --git a/Easy/L606.go b/Easy/L606.go
new file mode 100644
index 0000000..7b07fd0
--- /dev/null
+++ b/Easy/L606.go
@@ -0,0 +1,45 @@
+package Easy
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func tree2str(root *TreeNode) string {
+	var (
+		sb strings.Builder
+		solve func(root *TreeNode)
+	)
+	if root == nil {
+		return ""
+	}
+	
+	solve = func(root *TreeNode) {
+		sb.WriteString(fmt.Sprintf("%d", root.Val))
+		if root.Left == nil && root.Right == nil {
+			return
+		}
+		
+		if root.Left != nil {
+			sb.WriteString("(")
+			solve(root.Left)
+			sb.WriteString(")")
+		}
+		
+		if root.Right != nil {
+			if root.Left == nil {
+				sb.WriteString("()")
+			}
+			
+			sb.WriteString("(")
+			solve(root.Right)
+			sb.WriteString(")")
+		}
+	}
+	
+	solve(root)
+	return sb.String()
+}
diff --git a/Easy/L661.go b/Easy/L661.go
new file mode 100644
index 0000000..c59cab8
--- /dev/null
+++ b/Easy/L661.go
@@ -0,0 +1,37 @@
+package Easy
+
+func imageSmoother(img [][]int) [][]int {
+	if len(img) == 0 {
+		return [][]int{}
+	}
+
+	dirs := [][]int{{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 0}, {0, 1}, {1, -1}, {1, 0}, {1, 1}}
+	rows, cols := len(img), len(img[0])
+	var isValid func(x, y int) bool
+
+	isValid = func(x, y int) bool {
+		return x >= 0 && x < rows && y >= 0 && y < cols
+	}
+
+	res := make([][]int, rows)
+	for i := 0; i < rows; i++ {
+		res[i] = make([]int, cols)
+	}
+
+	for row := 0; row < rows; row++ {
+		for col := 0; col < cols; col++ {
+			cnt, sum := 0, 0
+			for _, d := range dirs {
+				newRow, newCol := row+d[0], col+d[1]
+				if isValid(newRow, newCol) {
+					cnt++
+					sum += img[newRow][newCol]
+				}
+			}
+
+			res[row][col] = sum / cnt
+		}
+	}
+
+	return res
+}
diff --git a/Easy/L678.go b/Easy/L678.go
new file mode 100644
index 0000000..237fa12
--- /dev/null
+++ b/Easy/L678.go
@@ -0,0 +1,22 @@
+package Easy
+
+func checkValidString(s string) bool {
+	cMin, cMax := 0, 0
+	for i := 0; i < len(s); i++ {
+		if s[i] == '(' {
+			cMax, cMin = cMax+1, cMin+1
+		} else if s[i] == ')' {
+			cMax, cMin = cMax-1, cMin-1
+		} else if s[i] == '*' {
+			cMax, cMin = cMax+1, cMin-1
+		}
+
+		if cMax < 0 {
+			return false
+		}
+
+		cMin = max(cMin, 0)
+	}
+
+	return cMin == 0
+}
diff --git a/Easy/L860.py b/Easy/L860.py
new file mode 100644
index 0000000..5473705
--- /dev/null
+++ b/Easy/L860.py
@@ -0,0 +1,17 @@
+class Solution:
+    def lemonadeChange(self, bills):
+        five = ten = 0
+        for num in bills:
+            if num == 5:
+                five += 1
+            elif num == 10 and five:
+                ten += 1
+                five -= 1
+            elif num == 20 and five and ten:
+                five -= 1
+                ten -= 1
+            elif num == 20 and five >= 3:
+                five -= 3
+            else:
+                return False
+        return True
diff --git a/Easy/L872.go b/Easy/L872.go
new file mode 100644
index 0000000..76a6cb8
--- /dev/null
+++ b/Easy/L872.go
@@ -0,0 +1,32 @@
+package Easy
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func leafSimilar(root1 *TreeNode, root2 *TreeNode) bool {
+	var (
+		root1Leaves, root2Leaves string
+		solve                    func(root *TreeNode, rootLeaves *string)
+	)
+
+	solve = func(root *TreeNode, rootLeaves *string) {
+		if root == nil {
+			return
+		}
+		if root.Left == nil && root.Right == nil {
+			*rootLeaves = fmt.Sprintf("%s%d#", *rootLeaves, root.Val)
+		}
+		solve(root.Left, rootLeaves)
+		solve(root.Right, rootLeaves)
+	}
+
+	solve(root1, &root1Leaves)
+	solve(root2, &root2Leaves)
+
+	return root1Leaves == root2Leaves
+}
diff --git a/Easy/L94.go b/Easy/L94.go
new file mode 100644
index 0000000..f0fd539
--- /dev/null
+++ b/Easy/L94.go
@@ -0,0 +1,29 @@
+package Easy
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func inorderTraversal(root *TreeNode) []int {
+	var (
+		res   []int
+		solve func(root *TreeNode)
+	)
+
+	solve = func(root *TreeNode) {
+		if root == nil {
+			return
+		}
+
+		solve(root.Left)
+		res = append(res, root.Val)
+		solve(root.Right)
+	}
+
+	solve(root)
+	return res
+}
diff --git a/Hard.md b/Hard.md
index 2bb3e9a..8d0115c 100644
--- a/Hard.md
+++ b/Hard.md
@@ -78,3 +78,8 @@
 |[664](https://leetcode.com/problems/strange-printer/)|  Strange Printer|
 |[239](https://leetcode.com/problems/sliding-window-maximum/)|  Sliding Window Maximum|
 |[68](https://leetcode.com/problems/text-justification/)|  Text Justification|
+|[1611](https://leetcode.com/problems/minimum-one-bit-operations-to-make-integers-zero/)|  Minimum One Bit Operations to Make Integers Zero|
+|[1458](https://leetcode.com/problems/max-dot-product-of-two-subsequences/)|  Max Dot Product of Two Subsequences|
+|[1793](https://leetcode.com/problems/maximum-score-of-a-good-subarray/)|  Maximum Score of a Good Subarray|
+|[514](https://leetcode.com/problems/freedom-trail/)|  Freedom Trail|
+|[834](https://leetcode.com/problems/sum-of-distances-in-tree/)|  Sum of Distances in Tree|
diff --git a/Hard/L1458.go b/Hard/L1458.go
new file mode 100644
index 0000000..61f3071
--- /dev/null
+++ b/Hard/L1458.go
@@ -0,0 +1,33 @@
+package Hard
+
+func maxDotProduct(nums1 []int, nums2 []int) int {
+	dp := make(map[string]int)
+	var solve func(n, m int) int
+
+	solve = func(n, m int) int {
+		key := fmt.Sprintf("%d#%d", n, m)
+		if v, ok := dp[key]; ok {
+			return v
+		}
+
+		p1 := nums1[n] * nums2[m]
+		ans := p1
+
+		if (n < len(nums1)-1) && (m < len(nums2)-1) {
+			p1 += solve(n+1, m+1)
+		}
+
+		if n < len(nums1)-1 {
+			ans = max(ans, solve(n+1, m))
+		}
+
+		if m < len(nums2)-1 {
+			ans = max(ans, solve(n, m+1))
+		}
+
+		dp[key] = max(ans, p1)
+		return dp[key]
+	}
+
+	return solve(0, 0)
+}
diff --git a/Hard/L1611.go b/Hard/L1611.go
new file mode 100644
index 0000000..577045f
--- /dev/null
+++ b/Hard/L1611.go
@@ -0,0 +1,19 @@
+package Medium
+
+func minimumOneBitOperations(n int) int {
+	var solve func(n, res int) int
+	
+	solve = func(n, res int) int {
+		if n == 0 {
+			return res
+		}
+		b := 1
+		for (b << 1) <= n {
+			b = b << 1
+		}
+		
+		return solve((b >> 1) ^ b ^ n, res + b)
+	}
+	
+	return solve(n, 0)
+}
diff --git a/Hard/L1793.go b/Hard/L1793.go
new file mode 100644
index 0000000..cd55da3
--- /dev/null
+++ b/Hard/L1793.go
@@ -0,0 +1,23 @@
+package Hard
+
+func maximumScore(nums []int, k int) int {
+	maxScore, minValue := nums[k], nums[k]
+	left, right := k, k
+
+	for left >= 0 && right < len(nums) {
+		minValue = min(minValue, min(nums[left], nums[right]))
+		maxScore = max(minValue*(right-left+1), maxScore)
+
+		if left == 0 && right < len(nums) {
+			right++
+		} else if right == len(nums)-1 && left >= 0 {
+			left--
+		} else if nums[right+1] > nums[left-1] {
+			right++
+		} else {
+			left--
+		}
+	}
+
+	return maxScore
+}
diff --git a/Hard/L514.go b/Hard/L514.go
new file mode 100644
index 0000000..a9ff544
--- /dev/null
+++ b/Hard/L514.go
@@ -0,0 +1,43 @@
+package Hard
+
+func findRotateSteps(ring string, key string) int {
+	var solve func(keyIdx, ringIdx int) int
+	mp := make(map[string]int)
+
+	solve = func(keyIdx, ringIdx int) int {
+		if keyIdx == len(key) {
+			return 0
+		}
+
+		mpKey := fmt.Sprintf("%s%d", keyIdx, ringIdx)
+		if v, ok := mp[mpKey]; ok {
+			return v
+		}
+
+		size, stepsReq, tmp, cnt := len(ring), 1000000000, ringIdx, 0
+
+		for cnt < size {
+			if key[keyIdx] == ring[tmp] {
+				stepsReq = min(stepsReq, 1+cnt+solve(keyIdx+1, tmp))
+			}
+			cnt, tmp = cnt+1, tmp+1
+			
+			tmp %= size
+		}
+
+		cnt, tmp = 0, ringIdx
+		for cnt < size {
+			if key[keyIdx] == ring[tmp] {
+				stepsReq = min(stepsReq, 1+cnt+solve(keyIdx+1, tmp))
+			}
+			cnt, tmp = cnt+1, tmp-1
+			tmp += size
+			tmp %= size
+		}
+
+		mp[mpKey] = stepsReq
+		return stepsReq
+	}
+
+	return solve(0, 0)
+}
diff --git a/Hard/L834.go b/Hard/L834.go
new file mode 100644
index 0000000..288194c
--- /dev/null
+++ b/Hard/L834.go
@@ -0,0 +1,43 @@
+package Hard
+
+func sumOfDistancesInTree(n int, edges [][]int) []int {
+	var (
+		dfs1 func(node, parent int)
+		dfs2 func(node, parent, dpVal int)
+	)
+	adjList, sz, val, ans := make([][]int, n), make([]int, n), make([]int, n), make([]int, n)
+	for i := 0; i < n; i++ {
+		adjList[i] = make([]int, 0)
+	}
+
+	for _, edge := range edges {
+		adjList[edge[0]] = append(adjList[edge[0]], edge[1])
+		adjList[edge[1]] = append(adjList[edge[1]], edge[0])
+	}
+
+	dfs1 = func(node, parent int) {
+		for _, c := range adjList[node] {
+			if c != parent {
+				dfs1(c, node)
+				sz[node] += sz[c]
+				val[node] += val[c] + sz[c]
+			}
+		}
+		sz[node]++
+	}
+
+	dfs2 = func(node, parent, dpVal int) {
+		ans[node] = val[node] + dpVal + (n - sz[node])
+
+		for _, c := range adjList[node] {
+			if c != parent {
+				dfs2(c, node, ans[node]-val[c]-sz[c])
+			}
+		}
+	}
+
+	dfs1(0, 0)
+	dfs2(0, 0, 0)
+
+	return ans
+}
diff --git a/Medium.md b/Medium.md
index ee0ebcc..b14a62e 100644
--- a/Medium.md
+++ b/Medium.md
@@ -314,3 +314,37 @@
 |[542](https://leetcode.com/problems/01-matrix/)|   01 Matrix|
 |[1615](https://leetcode.com/problems/maximal-network-rank/)|   Maximal Network Rank|
 |[767](https://leetcode.com/problems/reorganize-string/)|   Reorganize String|
+|[1424](https://leetcode.com/problems/diagonal-traverse-ii/)|   Diagonal Traverse II|
+|[1814](https://leetcode.com/problems/count-nice-pairs-in-an-array/)|   Count Nice Pairs in an Array|
+|[1561](https://leetcode.com/problems/maximum-number-of-coins-you-can-get/)|   Maximum Number of Coins You Can Get|
+|[1630](https://leetcode.com/problems/arithmetic-subarrays/)|   Arithmetic Subarrays|
+|[1685](https://leetcode.com/problems/sum-of-absolute-differences-in-a-sorted-array/)|   Sum of Absolute Differences in a Sorted Array|
+|[1727](https://leetcode.com/problems/largest-submatrix-with-rearrangements/)|   Largest Submatrix With Rearrangements|
+|[2849](https://leetcode.com/problems/determine-if-a-cell-is-reachable-at-a-given-time/)|   Determine if a Cell Is Reachable at a Given Time|
+|[2842](https://leetcode.com/problems/difference-between-ones-and-zeros-in-row-and-column/)|   Difference Between Ones and Zeroes in Row and Column|
+|[2038](https://leetcode.com/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color/)|   Remove Colored Pieces if Both Neighbors are the Same Color |
+|[1637](https://leetcode.com/problems/widest-vertical-area-between-two-points-containing-no-points/)|   Widest Vertical Area Between Two Points Containing No Points |
+|[2610](https://leetcode.com/problems/convert-an-array-into-a-2d-array-with-conditions/)|   Convert an Array Into a 2D Array With Conditions |
+|[907](https://leetcode.com/problems/sum-of-subarray-minimums/)|  Sum of Subarray Minimums |
+|[2125](https://leetcode.com/problems/number-of-laser-beams-in-a-bank/)|   Number of Laser Beams in a Bank |
+|[2870](https://leetcode.com/problems/minimum-number-of-operations-to-make-array-empty/)|   Minimum Number of Operations to Make Array Empty |
+|[2385](https://leetcode.com/problems/amount-of-time-for-binary-tree-to-be-infected/)|   Amount of Time for Binary Tree to Be Infected |
+|[1347](https://leetcode.com/problems/minimum-number-of-steps-to-make-two-strings-anagram/)|   Minimum Number of Steps to Make Two Strings Anagram |
+|[1657](https://leetcode.com/problems/determine-if-two-strings-are-close/)|   Determine if Two Strings Are Close |
+|[2966](https://leetcode.com/problems/divide-array-into-arrays-with-max-difference/)|   Divide Array Into Arrays With Max Difference |
+|[988](https://leetcode.com/problems/smallest-string-starting-from-leaf/)|   Smallest String Starting From Leaf |
+|[200](https://leetcode.com/problems/number-of-islands/)|   Number of Islands |
+|[1992](https://leetcode.com/problems/find-all-groups-of-farmland/)|   Find All Groups of Farmland |
+|[752](https://leetcode.com/problems/open-the-lock/)|   Open the Lock |
+|[2997](https://leetcode.com/problems/minimum-number-of-operations-to-make-array-xor-equal-to-k/)|   Minimum Number of Operations to Make Array XOR Equal to K |
+|[1915](https://leetcode.com/problems/number-of-wonderful-substrings/)|   Number of Wonderful Substrings |
+|[165](https://leetcode.com/problems/compare-version-numbers/)|   Compare Version Numbers |
+|[1492](https://leetcode.com/problems/the-kth-factor-of-n/)|   The kth Factor of n |
+|[861](https://leetcode.com/problems/score-after-flipping-matrix/)|   Score After Flipping Matrix |
+|[1219](https://leetcode.com/problems/path-with-maximum-gold/)|   Path with Maximum Gold |
+|[1325](https://leetcode.com/problems/delete-leaves-with-a-given-value/)|   Delete Leaves With a Given Value |
+|[1382](https://leetcode.com/problems/balance-a-binary-search-tree/)|   Balance a Binary Search Tree |
+|[2390](https://leetcode.com/problems/removing-stars-from-a-string/)|   Removing Stars From a String |
+|[1834](https://leetcode.com/problems/single-threaded-cpu/)|   Single-Threaded CPU |
+|[2](https://leetcode.com/problems/add-two-numbers/)|   Add Two Numbers |
+|[874](https://leetcode.com/problems/walking-robot-simulation/)|   Walking Robot Simulation |
diff --git a/Medium/L1143.go b/Medium/L1143.go
index f49c154..58589cd 100644
--- a/Medium/L1143.go
+++ b/Medium/L1143.go
@@ -1,40 +1,30 @@
 package Medium
 
 func longestCommonSubsequence(text1 string, text2 string) int {
+	var (
+		solve func(m, n int) int
+	)
 	m, n := len(text1), len(text2)
-	memo := make([][]int, m+1)
-	for i := 0; i < m+1; i++ {
-		memo[i] = make([]int, n+1)
-		for j := 0; j < n+1; j++ {
-			memo[i][j] = -1
-		}
-	}
-
-	return lcs(text1, text2, m, n, &memo)
-}
-
-func lcs(s1, s2 string, m, n int, memo *[][]int) int {
-	if m == 0 || n == 0 {
-		return 0
-	}
+	mp := make(map[string]int)
 
-	if (*memo)[m][n] != -1 {
-		return (*memo)[m][n]
-	}
+	solve = func(m, n int) int {
+		if m == 0 || n == 0 {
+			return 0
+		}
 
-	if s1[m-1] == s2[n-1] {
-		(*memo)[m][n] = 1 + lcs(s1, s2, m-1, n-1, memo)
-	} else {
-		(*memo)[m][n] = max(lcs(s1, s2, m-1, n, memo), lcs(s1, s2, m, n-1, memo))
-	}
+		key := fmt.Sprintf("%d#%d", m, n)
+		if v, ok := mp[key]; ok {
+			return v
+		}
 
-	return (*memo)[m][n]
-}
+		if text1[m-1] == text2[n-1] {
+			mp[key] = 1 + solve(m-1, n-1)
+		} else {
+			mp[key] = max(solve(m-1, n), solve(m, n-1))
+		}
 
-func max(a, b int) int {
-	if a > b {
-		return a
+		return mp[key]
 	}
 
-	return b
+	return solve(m, n)
 }
diff --git a/Medium/L1219.go b/Medium/L1219.go
new file mode 100644
index 0000000..476733c
--- /dev/null
+++ b/Medium/L1219.go
@@ -0,0 +1,40 @@
+package Medium
+
+func getMaximumGold(grid [][]int) int {
+	var (
+		isValid func(x, y int) bool
+		solve   func(x, y int) int
+	)
+	m, n, res := len(grid), len(grid[0]), 0
+	dirs := [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}
+
+	isValid = func(x, y int) bool {
+		return x >= 0 && x < m && y >= 0 && y < n && grid[x][y] != 0
+	}
+
+	solve = func(x, y int) int {
+		if !isValid(x, y) {
+			return 0
+		}
+
+		curr := grid[x][y]
+		grid[x][y] = 0
+		maxGold := 0
+		for _, d := range dirs {
+			maxGold = max(maxGold, solve(x+d[0], y+d[1]))
+		}
+
+		grid[x][y] = curr
+		return curr + maxGold
+	}
+
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] != 0 {
+				res = max(res, solve(i, j))
+			}
+		}
+	}
+
+	return res
+}
diff --git a/Medium/L1325.go b/Medium/L1325.go
new file mode 100644
index 0000000..bf87c90
--- /dev/null
+++ b/Medium/L1325.go
@@ -0,0 +1,24 @@
+package Medium
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func removeLeafNodes(root *TreeNode, target int) *TreeNode {
+	if root.Left != nil {
+		root.Left = removeLeafNodes(root.Left, target)
+	}
+	if root.Right != nil {
+		root.Right = removeLeafNodes(root.Right, target)
+	}
+	
+	if root.Left == root.Right && root.Val == target {
+		return nil
+	}
+	
+	return root
+}
diff --git a/Medium/L1347.go b/Medium/L1347.go
new file mode 100644
index 0000000..22ba933
--- /dev/null
+++ b/Medium/L1347.go
@@ -0,0 +1,19 @@
+package Medium
+
+func minSteps(s string, t string) int {
+	cnt := make([]int, 26)
+
+	for i := 0; i < len(s); i++ {
+		cnt[s[i]-'a']++
+		cnt[t[i]-'a']--
+	}
+
+	steps := 0
+	for _, count := range cnt {
+		if count > 0 {
+			steps += count
+		}
+	}
+
+	return steps
+}
diff --git a/Medium/L1382.go b/Medium/L1382.go
new file mode 100644
index 0000000..e320fd9
--- /dev/null
+++ b/Medium/L1382.go
@@ -0,0 +1,32 @@
+package Medium
+
+func balanceBST(root *TreeNode) *TreeNode {
+	var (
+		sortedLst []*TreeNode
+		inorder func(node *TreeNode) 
+		createTree func(start, end int) *TreeNode
+	)
+	
+	inorder = func(node *TreeNode) {
+		if node == nil {
+			return
+		}
+		inorder(node.Left)
+		sortedLst = append(sortedLst, node)
+		inorder(node.Right)
+	}
+	
+	createTree = func(start, end int) *TreeNode {
+		if start > end {
+			return nil
+		}
+		mid := start + (end-start)/2
+		newRoot := sortedLst[mid]
+		newRoot.Left = createTree(start, mid - 1)
+		newRoot.Right = createTree(mid + 1, end)
+		return newRoot
+	}
+	
+	inorder(root)
+	return createTree(0, len(sortedLst) - 1)
+}
diff --git a/Medium/L1424.go b/Medium/L1424.go
new file mode 100644
index 0000000..179bb83
--- /dev/null
+++ b/Medium/L1424.go
@@ -0,0 +1,46 @@
+package Medium
+
+func findDiagonalOrder(nums [][]int) []int {
+	size, mp := 0, make(map[int][]int)
+	for i := 0; i < len(nums); i++ {
+		numList := make([]int, len(nums[i]))
+		copy(numList, nums[i])
+		for j := 0; j < len(numList); j++ {
+			var lst []int
+			index := i + j
+			if _, ok := mp[index]; ok {
+				lst = mp[index]
+			}
+			lst = append([]int{numList[j]}, lst...)
+			mp[index] = lst
+			size++
+		}
+	}
+
+	maxLen := getMaxLen(mp)
+	var resultList []int
+	for i := 0; i <= maxLen; i++ {
+		diagVal := mp[i]
+		resultList = append(resultList, diagVal...)
+	}
+
+	return resultList
+}
+
+func getMaxLen(mp map[int][]int) int {
+	maxLen := math.MinInt32
+
+	for k, _ := range mp {
+		maxLen = max(maxLen, k)
+	}
+
+	return maxLen
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
diff --git a/Medium/L1492.go b/Medium/L1492.go
new file mode 100644
index 0000000..ce11cd8
--- /dev/null
+++ b/Medium/L1492.go
@@ -0,0 +1,25 @@
+package Medium
+
+func kthFactor(n int, k int) int {
+	root := math.Sqrt(float64(n))
+
+	for i := 1; i < int(math.Ceil(root)); i++ {
+		if n%i == 0 {
+			k--
+			if k == 0 {
+				return i
+			}
+		}
+	}
+
+	for i := int(root); i > 0; i-- {
+		if n%i == 0 {
+			k--
+			if k == 0 {
+				return n / i
+			}
+		}
+	}
+
+	return -1
+}
diff --git a/Medium/L1561.go b/Medium/L1561.go
new file mode 100644
index 0000000..a6bcd38
--- /dev/null
+++ b/Medium/L1561.go
@@ -0,0 +1,12 @@
+package Medium
+
+func maxCoins(piles []int) int {
+	sort.Ints(piles)
+	n, maximum := len(piles), 0
+
+	for i := n / 3; i < n-1; i += 2 {
+		maximum += piles[i]
+	}
+
+	return maximum
+}
diff --git a/Medium/L1630.go b/Medium/L1630.go
new file mode 100644
index 0000000..f5e5aed
--- /dev/null
+++ b/Medium/L1630.go
@@ -0,0 +1,61 @@
+package Medium
+
+func checkArithmeticSubarrays(nums []int, l []int, r []int) []bool {
+	var res []bool
+	for i := 0; i < len(l); i++ {
+		res = append(res, isArithmetic(nums, l[i], r[i]))
+	}
+
+	return res
+}
+
+func isArithmetic(nums []int, l, r int) bool {
+	maximum, minimum := math.MinInt32, math.MaxInt32
+
+	for i := l; i <= r; i++ {
+		maximum = max(nums[i], maximum)
+		minimum = min(nums[i], minimum)
+	}
+
+	length := r - l + 1
+	visited := make([]bool, length)
+	if (maximum-minimum)%(length-1) != 0 {
+		return false
+	}
+
+	diff := (maximum - minimum) / (length - 1)
+	if diff == 0 {
+		return true
+	}
+
+	for i := l; i <= r; i++ {
+		val := nums[i]
+		if (val-minimum)%diff != 0 {
+			return false
+		} else {
+			pos := (val - minimum) / diff
+			if visited[pos] {
+				return false
+			}
+			visited[pos] = true
+		}
+	}
+
+	return true
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
diff --git a/Medium/L1637.go b/Medium/L1637.go
new file mode 100644
index 0000000..dd45e2f
--- /dev/null
+++ b/Medium/L1637.go
@@ -0,0 +1,33 @@
+package Medium
+
+func maxWidthOfVerticalArea(points [][]int) int {
+	xCoordMap := make(map[int]bool)
+	maxDiff, prevX := 0, math.MinInt32
+
+	for _, p := range points {
+		xCoordMap[p[0]] = true
+	}
+
+	var keys []int
+	for k, _ := range xCoordMap {
+		keys = append(keys, k)
+	}
+
+	sort.Ints(keys)
+	for _, k := range keys {
+		if prevX != math.MinInt32 {
+			maxDiff = max(maxDiff, k-prevX)
+		}
+		prevX = k
+	}
+
+	return maxDiff
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
diff --git a/Medium/L165.go b/Medium/L165.go
new file mode 100644
index 0000000..34e005c
--- /dev/null
+++ b/Medium/L165.go
@@ -0,0 +1,27 @@
+package Medium
+
+func compareVersion(version1 string, version2 string) int {
+	tmp1, tmp2, len1, len2 := 0, 0, len(version1), len(version2)
+	i, j := 0, 0
+
+	for i < len1 || j < len2 {
+		tmp1, tmp2 = 0, 0
+		for i < len1 && version1[i] != '.' {
+			tmp1 = tmp1*10 + int(version1[i]-'0')
+			i++
+		}
+		for j < len2 && version2[j] != '.' {
+			tmp2 = tmp2*10 + int(version2[j]-'0')
+			j++
+		}
+		if tmp1 > tmp2 {
+			return 1
+		} else if tmp1 < tmp2 {
+			return -1
+		} else {
+			i, j = i+1, j+1
+		}
+	}
+
+	return 0
+}
diff --git a/Medium/L1657.go b/Medium/L1657.go
new file mode 100644
index 0000000..fc7508d
--- /dev/null
+++ b/Medium/L1657.go
@@ -0,0 +1,45 @@
+package Medium
+
+func closeStrings(word1 string, word2 string) bool {
+	if len(word1) != len(word2) {
+		return false
+	}
+	
+	solve := func(s string) []int{
+		arr := make([]int, 26)
+		
+		for _, c := range s {
+			arr[c - 'a']++
+		}
+		
+		return arr
+	}
+
+	charCnt1, charCnt2 := solve(word1), solve(word2)
+	n := len(word1)
+	freqCnt1, freqCnt2 := make([]int, n + 1), make([]int, n + 1)
+	
+	for i := 0; i < 26; i++ {
+		if charCnt1[i] > 0 {
+			freqCnt1[charCnt1[i]]++
+			if charCnt2[i] == 0 {
+				return false
+			}
+		}
+		
+		if charCnt2[i] > 0 {
+			freqCnt2[charCnt2[i]]++
+			if charCnt1[i] == 0 {
+				return false
+			}
+		}
+	}
+
+	for i := 0; i < n + 1; i++ {
+		if freqCnt1[i] != freqCnt2[i] {
+			return false
+		}
+	}
+
+	return true
+}
diff --git a/Medium/L1685.go b/Medium/L1685.go
new file mode 100644
index 0000000..0e1eabb
--- /dev/null
+++ b/Medium/L1685.go
@@ -0,0 +1,19 @@
+package Medium
+
+func getSumAbsoluteDifferences(nums []int) []int {
+	result, prefixSum, suffixSum := make([]int, len(nums)), make([]int, len(nums)), make([]int, len(nums))
+
+	prefixSum[0], suffixSum[len(nums)-1] = nums[0], nums[len(nums)-1]
+
+	for i := 1; i < len(nums); i++ {
+		prefixSum[i] = prefixSum[i-1] + nums[i]
+		suffixSum[len(nums)-i-1] = suffixSum[len(nums)-i] + nums[len(nums)-i-1]
+	}
+
+	for i := 0; i < len(nums); i++ {
+		currAbsDiff := ((nums[i] * i) - prefixSum[i]) + (suffixSum[i] - (nums[i] * (len(nums) - i - 1)))
+		result[i] = currAbsDiff
+	}
+	
+	return result
+}
diff --git a/Medium/L1727.go b/Medium/L1727.go
new file mode 100644
index 0000000..3bce886
--- /dev/null
+++ b/Medium/L1727.go
@@ -0,0 +1,31 @@
+package Medium
+
+func largestSubmatrix(matrix [][]int) int {
+	rn, cn := len(matrix), len(matrix[0])
+
+	for i := 1; i < rn; i++ {
+		for j := 0; j < cn; j++ {
+			if matrix[i][j] == 1 {
+				matrix[i][j] += matrix[i-1][j]
+			}
+		}
+	}
+	
+	res := 0
+	for i := 0; i < rn; i++ {
+		sort.Ints(matrix[i])
+		for j := 0; j < cn; j++ {
+			res = max(res, matrix[i][j] * (cn - j))
+		}
+	}
+	
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
diff --git a/Medium/L1814.go b/Medium/L1814.go
new file mode 100644
index 0000000..80013d7
--- /dev/null
+++ b/Medium/L1814.go
@@ -0,0 +1,31 @@
+package Medium
+
+func countNicePairs(nums []int) int {
+	mp := make(map[int]int)
+	for i := 0; i < len(nums); i++ {
+		rev := revInt(nums[i])
+		diff := nums[i] - rev
+		mp[diff]++
+	}
+
+	res, mod := 0, 1000000007
+	for _, v := range mp {
+		if v == 1 {
+			continue
+		}
+		res = (res + v*(v-1)/2) % mod
+	}
+
+	return res
+}
+
+func revInt(n int) int {
+	newInt := 0
+	for n > 0 {
+		remainder := n % 10
+		newInt *= 10
+		newInt += remainder
+		n /= 10
+	}
+	return newInt
+}
diff --git a/Medium/L1834.go b/Medium/L1834.go
new file mode 100644
index 0000000..69e9408
--- /dev/null
+++ b/Medium/L1834.go
@@ -0,0 +1,58 @@
+type Task struct {
+	processTime int
+	index       int
+}
+
+type TaskHeap []Task
+
+func (h TaskHeap) Len() int           { return len(h) }
+func (h TaskHeap) Less(i, j int) bool { return h[i].processTime < h[j].processTime || (h[i].processTime == h[j].processTime && h[i].index < h[j].index) }
+func (h TaskHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+
+func (h *TaskHeap) Push(x interface{}) {
+	*h = append(*h, x.(Task))
+}
+
+func (h *TaskHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	item := old[n-1]
+	*h = old[0 : n-1]
+	return item
+}
+
+func getOrder(tasks [][]int) []int {
+	dic := make(map[int][]Task)
+	for i := 0; i < len(tasks); i++ {
+		dic[tasks[i][0]] = append(dic[tasks[i][0]], Task{tasks[i][1], i})
+	}
+
+	ans := []int{}
+	keys := []int{}
+	for k := range dic {
+		keys = append(keys, k)
+	}
+	sort.Ints(keys)
+
+	for len(keys) > 0 {
+		k := keys[0]
+		keys = keys[1:]
+		pq := TaskHeap(dic[k])
+		heap.Init(&pq)
+		time := k
+
+		for pq.Len() > 0 {
+			task := heap.Pop(&pq).(Task)
+			ans = append(ans, task.index)
+			time += task.processTime
+			for len(keys) > 0 && keys[0] <= time {
+				for _, item := range dic[keys[0]] {
+					heap.Push(&pq, item)
+				}
+				keys = keys[1:]
+			}
+		}
+	}
+
+	return ans
+}
diff --git a/Medium/L1915.go b/Medium/L1915.go
new file mode 100644
index 0000000..2d9376f
--- /dev/null
+++ b/Medium/L1915.go
@@ -0,0 +1,21 @@
+package Medium
+
+func wonderfulSubstrings(word string) int64 {
+	var (
+		res int64
+		mask int
+	)
+	cnt := make([]int64, 1024)
+	cnt[0] = 1
+	
+	for i := 0; i < len(word); i++ {
+		mask ^= 1 << (word[i] - 'a')
+		res += cnt[mask]
+		for i := 0; i < 10; i++ {
+			res += cnt[mask ^ (1 << i)]
+		}
+		cnt[mask]++
+	}
+	
+	return res
+}
diff --git a/Medium/L1992.go b/Medium/L1992.go
new file mode 100644
index 0000000..adf482c
--- /dev/null
+++ b/Medium/L1992.go
@@ -0,0 +1,41 @@
+package Medium
+
+func findFarmland(land [][]int) [][]int {
+	var (
+		lst   [][]int
+		solve func(x, y int)
+	)
+	row, col := len(land), len(land[0])
+
+	solve = func(x, y int) {
+		endX, endY := x, y
+
+		for endY+1 < len(land[0]) && land[x][endY+1] == 1 {
+			land[x][endY+1] = 0
+			endY++
+		}
+
+		for endX+1 < len(land) && land[endX+1][y] == 1 {
+			land[endX+1][y] = 0
+			endX++
+		}
+
+		for i := x; i <= endX; i++ {
+			for j := y; j <= endY; j++ {
+				land[i][j] = 0
+			}
+		}
+
+		lst = append(lst, []int{x, y, endX, endY})
+	}
+
+	for i := 0; i < row; i++ {
+		for j := 0; j < col; j++ {
+			if land[i][j] == 1 {
+				solve(i, j)
+			}
+		}
+	}
+
+	return lst
+}
diff --git a/Medium/L2.go b/Medium/L2.go
new file mode 100644
index 0000000..9a9135b
--- /dev/null
+++ b/Medium/L2.go
@@ -0,0 +1,24 @@
+package Meidum
+
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+	dummy := &ListNode{}
+	current := dummy
+	carry := 0
+
+	for l1 != nil || l2 != nil || carry != 0 {
+		sum := carry
+		if l1 != nil {
+			sum += l1.Val
+			l1 = l1.Next
+		}
+		if l2 != nil {
+			sum += l2.Val
+			l2 = l2.Next
+		}
+		current.Next = &ListNode{Val: sum % 10}
+		current = current.Next
+		carry = sum / 10
+	}
+
+	return dummy.Next
+}
diff --git a/Medium/L200.go b/Medium/L200.go
new file mode 100644
index 0000000..3d1ff24
--- /dev/null
+++ b/Medium/L200.go
@@ -0,0 +1,48 @@
+package Medium
+
+func numIslands(grid [][]byte) int {
+	dirs := [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}
+	cnt, m, n, mp := 0, len(grid), len(grid[0]), make(map[string]bool)
+	var (
+		getKey  func(i, j int) string
+		isValid func(x, y int) bool
+		solve   func(i, j int)
+	)
+
+	getKey = func(i, j int) string {
+		return fmt.Sprintf("%d,%d", i, j)
+	}
+
+	isValid = func(x, y int) bool {
+		return x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == '1'
+	}
+
+	solve = func(i, j int) {
+		if !isValid(i, j) {
+			return
+		}
+
+		key := getKey(i, j)
+		if mp[key] {
+			return
+		}
+		mp[key] = true
+
+		for _, d := range dirs {
+			solve(i+d[0], j+d[1])
+		}
+	}
+
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == '1' {
+				if _, ok := mp[getKey(i, j)]; !ok {
+					cnt++
+					solve(i, j)
+				}
+			}
+		}
+	}
+
+	return cnt
+}
diff --git a/Medium/L2038.go b/Medium/L2038.go
new file mode 100644
index 0000000..e4dd2cf
--- /dev/null
+++ b/Medium/L2038.go
@@ -0,0 +1,17 @@
+package Medium
+
+func winnerOfGame(colors string) bool {
+	a, b := 0, 0
+
+	for i := 1; i < len(colors)-1; i++ {
+		if colors[i] == colors[i-1] && colors[i] == colors[i+1] {
+			if colors[i] == 'A' {
+				a++
+			} else {
+				b++
+			}
+		}
+	}
+
+	return a > b
+}
diff --git a/Medium/L2125.go b/Medium/L2125.go
new file mode 100644
index 0000000..1f74491
--- /dev/null
+++ b/Medium/L2125.go
@@ -0,0 +1,20 @@
+package Medium
+
+func numberOfBeams(bank []string) int {
+	res, prev := 0, 0
+
+	for _, s := range bank {
+		cnt := 0
+		for i := 0; i < len(s); i++ {
+			if s[i] == '1' {
+				cnt++
+			}
+		}
+		if cnt > 0 {
+			res += prev * cnt
+			prev = cnt
+		}
+	}
+
+	return res
+}
diff --git a/Medium/L2385.go b/Medium/L2385.go
new file mode 100644
index 0000000..6a6f53c
--- /dev/null
+++ b/Medium/L2385.go
@@ -0,0 +1,45 @@
+package Medium
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func amountOfTime(root *TreeNode, start int) int {
+	var (
+		amount int
+		solve  func(node *TreeNode, res *int) int
+	)
+
+	solve = func(node *TreeNode, res *int) int {
+		if node == nil {
+			return 0
+		}
+
+		left, right := solve(node.Left, res), solve(node.Right, res)
+
+		if node.Val == start {
+			*res = max(left, right)
+			return -1
+		} else if left >= 0 && right >= 0 {
+			return max(left, right) + 1
+		}
+
+		*res = max(*res, abs(left-right))
+		return min(left, right) - 1
+	}
+
+	solve(root, &amount)
+	return amount
+}
+
+func abs(a int) int {
+	if a < 0 {
+		return -a
+	}
+
+	return a
+}
diff --git a/Medium/L2390.py b/Medium/L2390.py
new file mode 100644
index 0000000..4b085dd
--- /dev/null
+++ b/Medium/L2390.py
@@ -0,0 +1,15 @@
+package Medium
+
+func removeStars(s string) string {
+	st := []rune{}
+
+	for _, c := range s {
+		if c != '*' {
+			st = append(st, c)
+		} else if len(st) > 0 {
+			st = st[:len(st)-1]
+		}
+	}
+
+	return string(st)
+}
diff --git a/Medium/L2482.go b/Medium/L2482.go
new file mode 100644
index 0000000..3b6db3b
--- /dev/null
+++ b/Medium/L2482.go
@@ -0,0 +1,25 @@
+package Medium
+
+func onesMinusZeros(grid [][]int) [][]int {
+	m, n := len(grid), len(grid[0])
+	diff, rows, cols := make([][]int, m), make([]int, m), make([]int, n)
+
+	for i := 0; i < m; i++ {
+		diff[i] = make([]int, n)
+	}
+
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			rows[i] += grid[i][j]
+			cols[j] += grid[i][j]
+		}
+	}
+
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			diff[i][j] = rows[i] + cols[j] - (n - rows[i]) - (m - cols[j])
+		}
+	}
+	
+	return diff
+}
diff --git a/Medium/L2610.go b/Medium/L2610.go
new file mode 100644
index 0000000..43ec419
--- /dev/null
+++ b/Medium/L2610.go
@@ -0,0 +1,17 @@
+package Medium
+
+func findMatrix(nums []int) [][]int {
+	var ans [][]int
+	freq := make([]int, len(nums) + 1)
+	
+	for _, n := range nums {
+		if freq[n] >= len(ans) {
+			ans = append(ans, []int{n})
+		} else {
+			ans[freq[n]] = append(ans[freq[n]], n)
+		}
+		freq[n]++
+	}
+	
+	return ans
+}
diff --git a/Medium/L2849.go b/Medium/L2849.go
new file mode 100644
index 0000000..1543919
--- /dev/null
+++ b/Medium/L2849.go
@@ -0,0 +1,19 @@
+package Medium
+
+func isReachableAtTime(sx int, sy int, fx int, fy int, t int) bool {
+	xDist, yDist := abs(sx-fx), abs(sy-fy)
+
+	if xDist == 0 && yDist == 0 {
+		return t != 1
+	}
+
+	return xDist <= t && yDist <= t
+}
+
+func abs(a int) int {
+	if a < 0 {
+		return -a
+	}
+
+	return a
+}
diff --git a/Medium/L2870.go b/Medium/L2870.go
new file mode 100644
index 0000000..e7e62c8
--- /dev/null
+++ b/Medium/L2870.go
@@ -0,0 +1,22 @@
+package Medium
+
+func minOperations(nums []int) int {
+	mp, cnt := make(map[int]int), 0
+
+	for _, n := range nums {
+		mp[n]++
+	}
+
+	for _, v := range mp {
+		if v == 1 {
+			return -1
+		}
+
+		cnt += v / 3
+		if v%3 != 0 {
+			cnt++
+		}
+	}
+
+	return cnt
+}
diff --git a/Medium/L2966.go b/Medium/L2966.go
new file mode 100644
index 0000000..7a28841
--- /dev/null
+++ b/Medium/L2966.go
@@ -0,0 +1,21 @@
+package Medium
+
+func divideArray(nums []int, k int) [][]int {
+	var res [][]int
+	if len(nums)%3 != 0 {
+		return res
+	}
+
+	sort.Ints(nums)
+	groupIdx := 0
+	for i := 0; i < len(nums); i += 3 {
+		if i+2 < len(nums) && nums[i+2]-nums[i] <= k {
+			res = append(res, []int{nums[i], nums[i+1], nums[i+2]})
+			groupIdx++
+		} else {
+			return [][]int{}
+		}
+	}
+
+	return res
+}
diff --git a/Medium/L2997.go b/Medium/L2997.go
new file mode 100644
index 0000000..3846a53
--- /dev/null
+++ b/Medium/L2997.go
@@ -0,0 +1,20 @@
+package Medium
+
+func minOperations(nums []int, k int) int {
+	finalXor := 0
+	for _, n := range nums {
+		finalXor ^= n
+	}
+	
+	cnt := 0
+	for k > 0 || finalXor > 0 {
+		if (k % 2) != (finalXor % 2) {
+			cnt++
+		}
+
+		k /= 2
+		finalXor /= 2
+	}
+	
+	return cnt
+}
diff --git a/Medium/L752.go b/Medium/L752.go
new file mode 100644
index 0000000..5efd4a3
--- /dev/null
+++ b/Medium/L752.go
@@ -0,0 +1,48 @@
+package Medium
+
+func openLock(deadends []string, target string) int {
+	var (
+		neighbors func(code string) []string
+		q         []string
+	)
+	deadSet := make(map[string]bool)
+	for _, dead := range deadends {
+		deadSet[dead] = true
+	}
+	if deadSet["0000"] {
+		return -1
+	}
+
+	neighbors = func(code string) []string {
+		var res []string
+		for i := 0; i < 4; i++ {
+			x := int(code[i] - '0')
+			for diff := -1; diff <= 1; diff += 2 {
+				y := (x + diff + 10) % 10
+				res = append(res, fmt.Sprintf("%s\"\"%d%s", code[:i], y, code[i+1:]))
+			}
+		}
+
+		return res
+	}
+
+	q = append(q, "0000")
+	for steps := 0; len(q) > 0; steps++ {
+		for i := len(q); i > 0; i-- {
+			curr := q[0]
+			q = q[1:]
+			if curr == target {
+				return steps
+			}
+			for _, nei := range neighbors(curr) {
+				if deadSet[nei] {
+					continue
+				}
+				deadSet[nei] = true
+				q = append(q, nei)
+			}
+		}
+	}
+
+	return -1
+}
diff --git a/Medium/L861.go b/Medium/L861.go
new file mode 100644
index 0000000..06c031a
--- /dev/null
+++ b/Medium/L861.go
@@ -0,0 +1,19 @@
+package Medium
+
+func matrixScore(grid [][]int) int {
+	m, n, res := len(grid), len(grid[0]), 0
+	
+	res += (1 << (n - 1)) * m
+	
+	for j := 1; j < n; j++ {
+		same := 0
+		for i := 0; i < m; i++ {
+			if grid[i][0] == grid[i][j] {
+				same++
+			}
+		}
+		res += (1 << (n - 1 - j))*max(same, m - same)
+	}
+	
+	return res
+}
diff --git a/Medium/L874.py b/Medium/L874.py
new file mode 100644
index 0000000..66f4f60
--- /dev/null
+++ b/Medium/L874.py
@@ -0,0 +1,25 @@
+class Solution:
+    def robotSim(self, commands, obstacles):
+        obstacle_set = set()
+        for obs in obstacles:
+            obstacle_set.add(f"{obs[0]} {obs[1]}")
+
+        directions = [[0, 1], [1, 0], [0, -1], [-1, 0]]  # north, east, south, west
+        d = 0  # direction index
+        x, y = 0, 0  # initial position
+        result = 0
+
+        for command in commands:
+            if command == -1:  # turn right
+                d = (d + 1) % 4
+            elif command == -2:  # turn left
+                d = (d - 1) % 4
+            else:
+                for _ in range(command):
+                    next_x = x + directions[d][0]
+                    next_y = y + directions[d][1]
+                    if f"{next_x} {next_y}" not in obstacle_set:
+                        x, y = next_x, next_y
+                        result = max(result, x * x + y * y)
+
+        return result
diff --git a/Medium/L907.go b/Medium/L907.go
new file mode 100644
index 0000000..9b51891
--- /dev/null
+++ b/Medium/L907.go
@@ -0,0 +1,32 @@
+package Medium
+
+func sumSubarrayMins(arr []int) int {
+	var (
+		res int64
+		st []int
+		mod = int64(1000000007)
+        
+	)
+	st = append(st, -1)
+	
+	for i := 0; i < len(arr) + 1; i++ {
+		currVal := 0
+		if i < len(arr) {
+			currVal = arr[i]
+		}
+		
+		for st[len(st) - 1] != -1 && currVal < arr[st[len(st) - 1]] {
+			index := st[len(st) - 1]
+			st = st[:len(st) - 1]
+			newTop := st[len(st) - 1]
+			left, right := index - newTop, i - index
+			add := int64(left * right * arr[index]) % mod
+			res += add
+			res %= mod
+		}
+		
+		st = append(st, i)
+	}
+	
+	return int(res)
+}
diff --git a/Medium/L931.go b/Medium/L931.go
index e326189..82b428a 100644
--- a/Medium/L931.go
+++ b/Medium/L931.go
@@ -1,36 +1,32 @@
 package Medium
 
 func minFallingPathSum(matrix [][]int) int {
-	rows, cols := len(matrix), len(matrix[0])
-	mp, ans := make(map[string]int), math.MaxInt32
+	var (
+		solve func(row, col int) int
+	)
+	cols, mp, res := len(matrix[0]), make(map[string]int), math.MaxInt32
 
-	for c := 0; c < cols; c++ {
-		ans = min(ans, solve(matrix, rows-1, c, mp))
-	}
+	solve = func(row, col int) int {
+		if col >= cols || col < 0 {
+			return math.MaxInt32
+		}
 
-	return ans
-}
+		key := fmt.Sprintf("%d#%d", row, col)
+		if v, ok := mp[key]; ok {
+			return v
+		}
 
-func solve(matrix [][]int, r, c int, mp map[string]int) int {
-	if r == 0 && c < len(matrix[0]) && c >= 0 {
-		return matrix[r][c]
-	}
-	if c >= len(matrix[0]) || c < 0 {
-		return math.MaxInt32
-	}
-	key := fmt.Sprintf("%d-%d", r, c)
-	if v, ok := mp[key]; ok {
-		return v
-	}
+		if row == len(matrix)-1 && col < cols {
+			return matrix[row][col]
+		}
 
-	mp[key] = matrix[r][c] + min(min(solve(matrix, r-1, c+1, mp), solve(matrix, r-1, c, mp)), solve(matrix, r-1, c-1, mp))
-	return mp[key]
-}
+		mp[key] = matrix[row][col] + min(solve(row+1, col-1), min(solve(row+1, col), solve(row+1, col+1)))
+		return mp[key]
+	}
 
-func min(a, b int) int {
-	if a < b {
-		return a
+	for i := 0; i < cols; i++ {
+		res = min(res, solve(0, i))
 	}
 
-	return b
+	return res
 }
diff --git a/Medium/L988.go b/Medium/L988.go
new file mode 100644
index 0000000..ac64e51
--- /dev/null
+++ b/Medium/L988.go
@@ -0,0 +1,37 @@
+package Medium
+
+func smallestFromLeaf(root *TreeNode) string {
+	var (
+		tmp    string
+		isLeaf func(node *TreeNode) bool
+		solve  func(node *TreeNode, s string) string
+	)
+
+	isLeaf = func(node *TreeNode) bool {
+		if node == nil {
+			return false
+		}
+
+		return node.Left == nil && node.Right == nil
+	}
+
+	solve = func(node *TreeNode, res string) string {
+		if node == nil {
+			return "|"
+		}
+
+		res = fmt.Sprintf("%c", byte('a'+node.Val)) + res
+		if isLeaf(node) {
+			return res
+		}
+
+		left, right := solve(node.Left, res), solve(node.Right, res)
+		if strings.Compare(left, right) < 0 {
+			return left
+		}
+
+		return right
+	}
+
+	return solve(root, tmp)
+}