diff --git a/Easy.md b/Easy.md new file mode 100644 index 0000000..540a506 --- /dev/null +++ b/Easy.md @@ -0,0 +1,179 @@ +## Easy +|LC #|Description| +|:-:|:-| +|[1480](https://leetcode.com/problems/running-sum-of-1d-array/)| Running Sum of 1d Array| +|[1431](https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/)| Kids With the Greatest Number of Candies| +|[1](https://leetcode.com/problems/two-sum/)| Two Sum| +|[575](https://leetcode.com/problems/distribute-candies/)| Distribute Candies| +|[1365](https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/)| How Many Numbers Are Smaller Than the Current Number| +|[1773](https://leetcode.com/problems/count-items-matching-a-rule/)| Count Items Matching a Rule| +|[645](https://leetcode.com/problems/set-mismatch/)| Set Mismatch| +|[268](https://leetcode.com/problems/missing-number/)| Missing Number| +|[160](https://leetcode.com/problems/intersection-of-two-linked-lists/)| Intersection of Two Linked Lists| +|[637](https://leetcode.com/problems/average-of-levels-in-binary-tree/)| Average of Levels in Binary Tree| +|[559](https://leetcode.com/problems/maximum-depth-of-n-ary-tree/)| Maximum Depth of N-ary Tree| +|[690](https://leetcode.com/problems/employee-importance/)| Employee Importance| +|[993](https://leetcode.com/problems/cousins-in-binary-tree/)| Cousins in Binary Tree| +|[1748](https://leetcode.com/problems/sum-of-unique-elements/)| Sum of Unique Elements| +|[232](https://leetcode.com/problems/implement-queue-using-stacks/)| Implement Queue using Stacks| +|[1332](https://leetcode.com/problems/remove-palindromic-subsequences/)| Remove Palindromic Subsequences| +|[1678](https://leetcode.com/problems/goal-parser-interpretation/)| Goal Parser Interpretation| +|[1022](https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers/)| Sum of Root To Leaf Binary Numbers| +|[404](https://leetcode.com/problems/sum-of-left-leaves/)| Sum of Left Leaves| +|[112](https://leetcode.com/problems/path-sum/)| Path Sum| +|[535](https://leetcode.com/problems/encode-and-decode-tinyurl/)| Encode and Decode TinyURL| +|[1560](https://leetcode.com/problems/most-visited-sector-in-a-circular-track/)| Most Visited Sector in a Circular Track| +|[598](https://leetcode.com/problems/range-addition-ii/)| Range Addition II| +|[762](https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation/)| Prime Number of Set Bits in Binary Representation| +|[500](https://leetcode.com/problems/keyboard-row/)| Keyboard Row| +|[1656](https://leetcode.com/problems/design-an-ordered-stream/)| Design an Ordered Stream| +|[234](https://leetcode.com/problems/palindrome-linked-list/)| Palindrome Linked List| +|[1614](https://leetcode.com/problems/maximum-nesting-depth-of-the-parentheses/)| Maximum Nesting Depth of the Parentheses| +|[1668](https://leetcode.com/problems/maximum-repeating-substring/)| Maximum Repeating Substring| +|[1704](https://leetcode.com/problems/determine-if-string-halves-are-alike/)| Determine if String Halves Are Alike| +|[953](https://leetcode.com/problems/verifying-an-alien-dictionary/)| Verifying an Alien Dictionary| +|[509](https://leetcode.com/problems/fibonacci-number/)| Fibonacci Number| +|[589](https://leetcode.com/problems/n-ary-tree-preorder-traversal/)| N-ary Tree Preorder Traversal| +|[696](https://leetcode.com/problems/count-binary-substrings/)| Count Binary Substrings| +|[326](https://leetcode.com/problems/power-of-three/)| Power of Three| +|[703](https://leetcode.com/problems/kth-largest-element-in-a-stream/)| Kth Largest Element in a Stream| +|[204](https://leetcode.com/problems/count-primes/)| Count Primes| +|[453](https://leetcode.com/problems/minimum-moves-to-equal-array-elements/)| Minimum Moves to Equal Array Elements| +|[709](https://leetcode.com/problems/to-lower-case/)| To Lower Case| +|[1710](https://leetcode.com/problems/maximum-units-on-a-truck/)| Maximum Units on a Truck| +|[1047](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/)| Remove All Adjacent Duplicates In String| +|[108](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/)| Convert Sorted Array to Binary Search Tree| +|[415](https://leetcode.com/problems/add-strings/)| Add Strings| +|[653](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/)| Two Sum IV - Input is a BST| +|[1629](https://leetcode.com/problems/slowest-key/)| Slowest Key| +|[206](https://leetcode.com/problems/reverse-linked-list/)| Reverse Linked List| +|[1189](https://leetcode.com/problems/maximum-number-of-balloons/)| Maximum Number of Balloons| +|[350](https://leetcode.com/problems/intersection-of-two-arrays-ii/)| Intersection of Two Arrays II| +|[1275](https://leetcode.com/problems/find-winner-on-a-tic-tac-toe-game/)| Find Winner on a Tic Tac Toe Game| +|[485](https://leetcode.com/problems/max-consecutive-ones/)| Max Consecutive Ones| +|[929](https://leetcode.com/problems/unique-email-addresses/)| Unique Email Addresses| +|[922](https://leetcode.com/problems/sort-array-by-parity-ii/)| Sort Array By Parity II| +|[463](https://leetcode.com/problems/island-perimeter/)| Island Perimeter| +|[70](https://leetcode.com/problems/climbing-stairs/)| Climbing Stairs| +|[543](https://leetcode.com/problems/diameter-of-binary-tree/)| Diameter of Binary Tree| +|[374](https://leetcode.com/problems/guess-number-higher-or-lower/)| Guess Number Higher or Lower| +|[496](https://leetcode.com/problems/next-greater-element-i/)| Next Greater Element I| +|[155](https://leetcode.com/problems/min-stack/)| Min Stack| +|[226](https://leetcode.com/problems/invert-binary-tree/)| Invert Binary Tree| +|[441](https://leetcode.com/problems/arranging-coins/)| Arranging Coins| +|[1413](https://leetcode.com/problems/minimum-value-to-get-positive-step-by-step-sum/)| Minimum Value to Get Positive Step by Step Sum| +|[203](https://leetcode.com/problems/remove-linked-list-elements/)| Remove Linked List Elements| +|[448](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/)| Find All Numbers Disappeared in an Array| +|[461](https://leetcode.com/problems/hamming-distance/)| Hamming Distance| +|[53](https://leetcode.com/problems/maximum-subarray/)| Maximum Subarray| +|[35](https://leetcode.com/problems/search-insert-position/)| Search Insert Position| +|[1217](https://leetcode.com/problems/minimum-cost-to-move-chips-to-the-same-position/)| Minimum Cost to Move Chips to The Same Position| +|[563](https://leetcode.com/problems/binary-tree-tilt/)| Binary Tree Tilt| +|[1446](https://leetcode.com/problems/consecutive-characters/)| Consecutive Characters| +|[938](https://leetcode.com/problems/range-sum-of-bst/)| Range Sum of BST| +|[1200](https://leetcode.com/problems/minimum-absolute-difference/)| Minimum Absolute Difference| +|[231](https://leetcode.com/problems/power-of-two/)| Power of Two| +|[476](https://leetcode.com/problems/number-complement/)| Number Complement| +|[876](https://leetcode.com/problems/middle-of-the-linked-list/)| Middle of the Linked List| +|[997](https://leetcode.com/problems/find-the-town-judge/)| Find the Town Judge| +|[1009](https://leetcode.com/problems/complement-of-base-10-integer/)| Complement of Base 10 Integer| +|[67](https://leetcode.com/problems/add-binary/)| Add Binary| +|[290](https://leetcode.com/problems/word-pattern/)| Word Pattern| +|[605](https://leetcode.com/problems/can-place-flowers/)| Can Place Flowers| +|[520](https://leetcode.com/problems/detect-capital/)| Detect Capital| +|[941](https://leetcode.com/problems/valid-mountain-array/)| Valid Mountain Array| +|[389](https://leetcode.com/problems/find-the-difference/)| Find the Difference| +|[258](https://leetcode.com/problems/add-digits/)| Add Digits| +|[1108](https://leetcode.com/problems/defanging-an-ip-address/)| Defanging an IP Address| +|[1832](https://leetcode.com/problems/check-if-the-sentence-is-pangram/)| Check if the Sentence Is Pangram| +|[104](https://leetcode.com/problems/maximum-depth-of-binary-tree/)| Maximum Depth of Binary Tree| +|[136](https://leetcode.com/problems/single-number/)| Single Number| +|[171](https://leetcode.com/problems/excel-sheet-column-number/)| Excel Sheet Column Number| +|[228](https://leetcode.com/problems/summary-ranges/)| Summary Ranges| +|[338](https://leetcode.com/problems/counting-bits/)| Counting Bits| +|[392](https://leetcode.com/problems/is-subsequence/)| Is Subsequence| +|[21](https://leetcode.com/problems/merge-two-sorted-lists/)| Merge Two Sorted Lists| +|[141](https://leetcode.com/problems/linked-list-cycle/)| Linked List Cycle| +|[617](https://leetcode.com/problems/merge-two-binary-trees/)| Merge Two Binary Trees| +|[20](https://leetcode.com/problems/valid-parentheses/)| Valid Parentheses| +|[1351](https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/)| Count Negative Numbers in a Sorted Matrix| +|[905](https://leetcode.com/problems/sort-array-by-parity/)| Sort Array By Parity| +|[344](https://leetcode.com/problems/reverse-string/)| Reverse String| +|[1460](https://leetcode.com/problems/make-two-arrays-equal-by-reversing-sub-arrays/)| Make Two Arrays Equal by Reversing Sub-arrays| +|[977](https://leetcode.com/problems/squares-of-a-sorted-array/)| Squares of a Sorted Array| +|[349](https://leetcode.com/problems/intersection-of-two-arrays/)| Intersection of Two Arrays| +|[1002](https://leetcode.com/problems/find-common-characters/)| Find Common Characters| +|[766](https://leetcode.com/problems/toeplitz-matrix/)| Toeplitz Matrix| +|[704](https://leetcode.com/problems/binary-search/)| Binary Search| +|[1160](https://leetcode.com/problems/find-words-that-can-be-formed-by-characters/)| Find Words That Can Be Formed by Characters| +|[412](https://leetcode.com/problems/fizz-buzz/)| Fizz Buzz| +|[266](https://leetcode.com/problems/palindrome-permutation/)| Palindrome Permutation| +|[145](https://leetcode.com/problems/binary-tree-postorder-traversal/)| Binary Tree Postorder Traversal| +|[169](https://leetcode.com/problems/majority-element/)| Majority Element| +|[242](https://leetcode.com/problems/valid-anagram/)| Valid Anagram| +|[217](https://leetcode.com/problems/contains-duplicate/)| Contains Duplicate| +|[283](https://leetcode.com/problems/move-zeroes/)| Move Zeroes| +|[1260](https://leetcode.com/problems/shift-2d-grid/)| Shift 2D Grid| +|[700](https://leetcode.com/problems/search-in-a-binary-search-tree/)| Search in a Binary Search Tree| +|[844](https://leetcode.com/problems/backspace-string-compare/)| Backspace String Compare| +|[88](https://leetcode.com/problems/merge-sorted-array/)| Merge Sorted Array| +|[859](https://leetcode.com/problems/buddy-strings/)| Buddy Strings| +|[557](https://leetcode.com/problems/reverse-words-in-a-string-iii/)| Reverse Words in a String III| +|[976](https://leetcode.com/problems/largest-perimeter-triangle/)| Largest Perimeter Triangle| +|[219](https://leetcode.com/problems/contains-duplicate-ii/)| Contains Duplicate II| +|[1544](https://leetcode.com/problems/make-the-string-great/)| Make The String Great| +|[1323](https://leetcode.com/problems/maximum-69-number/)| Maximum 69 Number| +|[2325](https://leetcode.com/problems/decode-the-message/)| Decode the Message| +|[121](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)| Best Time to Buy and Sell Stock| +|[1971](https://leetcode.com/problems/find-if-path-exists-in-graph/)| Find if Path Exists in Graph| +|[2389](https://leetcode.com/problems/longest-subsequence-with-limited-sum/)| Longest Subsequence With Limited Sum| +|[2073](https://leetcode.com/problems/time-needed-to-buy-tickets/)| Time Needed to Buy Tickets| +|[697](https://leetcode.com/problems/degree-of-an-array/)| Degree of an Array| +|[1071](https://leetcode.com/problems/greatest-common-divisor-of-strings/)| Greatest Common Divisor of Strings| +|[1470](https://leetcode.com/problems/shuffle-the-array/)| Shuffle the Array| +|[1523](https://leetcode.com/problems/count-odd-numbers-in-an-interval-range/)| Count Odd Numbers in an Interval Range| +|[989](https://leetcode.com/problems/add-to-array-form-of-integer/)| Add to Array-Form of Integer| +|[783](https://leetcode.com/problems/minimum-distance-between-bst-nodes/)| Minimum Distance Between BST Nodes| +|[1137](https://leetcode.com/problems/n-th-tribonacci-number/)| N-th Tribonacci Number| +|[746](https://leetcode.com/problems/min-cost-climbing-stairs/)| Min Cost Climbing Stairs| +|[1539](https://leetcode.com/problems/kth-missing-positive-number/)| Kth Missing Positive Number| +|[101](https://leetcode.com/problems/symmetric-tree/)| Symmetric Tree| +|[1768](https://leetcode.com/problems/merge-strings-alternately/)| Merge Strings Alternately| +|[1491](https://leetcode.com/problems/average-salary-excluding-the-minimum-and-maximum-salary/)| Average Salary Excluding the Minimum and Maximum Salary| +|[1822](https://leetcode.com/problems/sign-of-the-product-of-an-array/)| Sign of the Product of an Array| +|[2215](https://leetcode.com/problems/find-the-difference-of-two-arrays/)| Find the Difference of Two Arrays| +|[1572](https://leetcode.com/problems/matrix-diagonal-sum/)| Matrix Diagonal Sum| +|[1456](https://leetcode.com/problems/maximum-number-of-vowels-in-a-substring-of-given-length/)| Maximum Number of Vowels in a Substring of Given Length| +|[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/617.go b/Easy/617.go new file mode 100644 index 0000000..bda188c --- /dev/null +++ b/Easy/617.go @@ -0,0 +1,32 @@ +package Easy + +func mergeTrees(root1 *TreeNode, root2 *TreeNode) *TreeNode { + return dfs(root1, root2) +} + +func dfs(t1, t2 *TreeNode) *TreeNode { + if t1 == nil && t2 == nil { + return nil + } + if t1 == nil { + return t2 + } + if t2 == nil { + return t1 + } + + var root *TreeNode + + if t1 != nil && t2 == nil { + root = &TreeNode{Val: t1.Val} + } else if t1 == nil && t2 != nil { + root = &TreeNode{Val: t2.Val} + } else { + root = &TreeNode{Val: t1.Val + t2.Val} + } + + root.Left = dfs(t1.Left, t2.Left) + root.Right = dfs(t1.Right, t2.Right) + + return root +} diff --git a/Easy/L1002.go b/Easy/L1002.go new file mode 100644 index 0000000..459406b --- /dev/null +++ b/Easy/L1002.go @@ -0,0 +1,28 @@ +package Easy + +func commonChars(words []string) []string { + var res []string + count := make([]int, 26) + for i := 0; i < 26; i++ { + count[i] = math.MaxInt32 + } + for _, w := range words { + cnt := make([]int, 26) + for i := range w { + cnt[w[i]-'a']++ + } + for i := 0; i < 26; i++ { + if cnt[i] < count[i] { + count[i] = cnt[i] + } + } + } + + for ch := 'a'; ch <= 'z'; ch++ { + for i := count[ch-'a']; i > 0; i-- { + res = append(res, string(ch)) + } + } + + return res +} diff --git a/Easy/L1009.go b/Easy/L1009.go new file mode 100644 index 0000000..48a5c56 --- /dev/null +++ b/Easy/L1009.go @@ -0,0 +1,21 @@ +package Easy + +func bitwiseComplement(n int) int { + if n == 0 { + return 1 + } + res, ind := 0, 0 + + for n > 0 { + digit := n % 2 + flippedDigit := 0 + if digit != 1 { + flippedDigit = 1 + } + res += flippedDigit << ind + n /= 2 + ind++ + } + + return res +} diff --git a/Easy/L101.go b/Easy/L101.go new file mode 100644 index 0000000..5c89435 --- /dev/null +++ b/Easy/L101.go @@ -0,0 +1,29 @@ +package Easy + +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func isSymmetric(root *TreeNode) bool { + if root == nil { + return true + } + + var solve func(left, right *TreeNode) bool + solve = func(left, right *TreeNode) bool { + if left == nil || right == nil { + return left == right + } + if left.Val != right.Val { + return false + } + + return solve(left.Left, right.Right) && solve(left.Right, right.Left) + } + + return solve(root.Left, root.Right) +} diff --git a/Easy/L104.go b/Easy/L104.go new file mode 100644 index 0000000..a3f6560 --- /dev/null +++ b/Easy/L104.go @@ -0,0 +1,21 @@ +package Easy + +func maxDepth(root *TreeNode) int { + maxLevel := 0 + dfs(root, 1, &maxLevel) + + return maxLevel +} + +func dfs(root *TreeNode, currLevel int, maxLevel *int) { + if root == nil { + return + } + + if currLevel > *maxLevel { + *maxLevel = currLevel + } + + dfs(root.Left, currLevel+1, maxLevel) + dfs(root.Right, currLevel+1, maxLevel) +} diff --git a/Easy/L1047.go b/Easy/L1047.go new file mode 100644 index 0000000..8b80657 --- /dev/null +++ b/Easy/L1047.go @@ -0,0 +1,60 @@ +package Easy + +func removeDuplicates(s string) string { + st := NewStack() + + for _, c := range s { + if !st.isEmpty() { + if st.peek() == byte(c) { + st.pop() + continue + } else { + st.push(byte(c)) + } + } else { + st.push(byte(c)) + } + } + + var sb strings.Builder + for !st.isEmpty() { + sb.WriteByte(st.pop()) + } + + return reverse(sb.String()) +} + +type Stack struct { + st []byte +} + +func NewStack() *Stack { + return &Stack{st: []byte{}} +} + +func (s *Stack) pop() byte { + ret := s.st[len(s.st)-1] + s.st = s.st[:len(s.st)-1] + + return ret +} + +func (s *Stack) peek() byte { + return s.st[len(s.st)-1] +} + +func (s *Stack) push(c byte) { + s.st = append(s.st, c) +} + +func (s *Stack) isEmpty() bool { + return len(s.st) == 0 +} + +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) +} diff --git a/Easy/L1071.go b/Easy/L1071.go new file mode 100644 index 0000000..511bf6a --- /dev/null +++ b/Easy/L1071.go @@ -0,0 +1,19 @@ +package Easy + +func gcdOfStrings(str1 string, str2 string) string { + s1, s2 := fmt.Sprintf("%s%s", str1, str2), fmt.Sprintf("%s%s", str2, str1) + if s1 != s2 { + return "" + } + + gcdVal := gcd(len(str1), len(str2)) + return str2[:gcdVal] +} + +func gcd(p, q int) int { + if q == 0 { + return p + } + + return gcd(q, p%q) +} diff --git a/Easy/L108.go b/Easy/L108.go new file mode 100644 index 0000000..e096fec --- /dev/null +++ b/Easy/L108.go @@ -0,0 +1,23 @@ +package Easy + +func sortedArrayToBST(nums []int) *TreeNode { + if len(nums) == 0 { + return nil + } + + head := solve(nums, 0, len(nums) - 1) + return head +} + +func solve(nums []int, lo, hi int) *TreeNode{ + if lo > hi { + return nil + } + + mid := lo + (hi - lo)/2 + node := new(TreeNode) + node.Val = nums[mid] + node.Left, node.Right = solve(nums, lo, mid -1), solve(nums, mid + 1, hi) + + return node +} diff --git a/Easy/L1108.go b/Easy/L1108.go new file mode 100644 index 0000000..9ff5ab1 --- /dev/null +++ b/Easy/L1108.go @@ -0,0 +1,15 @@ +package easy + +func defangIPaddr(address string) string { + var s strings.Builder + + for i := 0; i < len(address); i++ { + if address[i] == '.' { + s.WriteString("[.]") + } else { + s.WriteByte(address[i]) + } + } + + return s.String() +} diff --git a/Easy/L111.go b/Easy/L111.go new file mode 100644 index 0000000..6d3f859 --- /dev/null +++ b/Easy/L111.go @@ -0,0 +1,41 @@ +package Easy + +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func minDepth(root *TreeNode) int { + if root == nil { + return 0 + } + + var q []*TreeNode + lvl := 1 + q = append(q, root) + + for len(q) > 0 { + size := len(q) + for i := 0; i < size; i++ { + node := q[0] + q = q[1:] + + if node.Left == nil && node.Right == nil { + return lvl + } + + if node.Left != nil { + q = append(q, node.Left) + } + if node.Right != nil { + q = append(q, node.Right) + } + } + lvl++ + } + + return lvl +} diff --git a/Easy/L1137.go b/Easy/L1137.go new file mode 100644 index 0000000..62455c2 --- /dev/null +++ b/Easy/L1137.go @@ -0,0 +1,25 @@ +package Easy + +func tribonacci(n int) int { + mp := map[int]int{ + 0: 0, + 1: 1, + 2: 1, + } + + var solve func(int) int + solve = func(n int) int { + if n < 0 { + return 0 + } + + if v, ok := mp[n]; ok { + return v + } + + mp[n] = solve(n - 1) + solve(n - 2) + solve(n - 3) + return mp[n] + } + + return solve(n) +} diff --git a/Easy/L1160.go b/Easy/L1160.go new file mode 100644 index 0000000..bca44ba --- /dev/null +++ b/Easy/L1160.go @@ -0,0 +1,34 @@ +package Easy + +func countCharacters(words []string, chars string) int { + var isMatch func(s string) bool + res := 0 + + isMatch = func(s string) bool { + mp := make(map[byte]int) + + for _, c := range chars { + mp[byte(c)]++ + } + + for _, c := range s { + if _, ok := mp[byte(c)]; !ok { + return false + } + mp[byte(c)]-- + if mp[byte(c)] < 0 { + return false + } + } + + return true + } + + for _, w := range words { + if isMatch(w) { + res += len(w) + } + } + + return res +} diff --git a/Easy/L118.go b/Easy/L118.go new file mode 100644 index 0000000..38027de --- /dev/null +++ b/Easy/L118.go @@ -0,0 +1,14 @@ +package Easy + +func generate(numRows int) [][]int { + a := make([][]int, numRows) + for i := 0; i = 1; j-- { + res[j] += res[j-1] + } + } + + return res +} diff --git a/Easy/L1200.go b/Easy/L1200.go new file mode 100644 index 0000000..eb2f1dc --- /dev/null +++ b/Easy/L1200.go @@ -0,0 +1,24 @@ +package Easy + +func minimumAbsDifference(arr []int) [][]int { + var res [][]int + + if len(arr) == 0 { + return res + } + + sort.Ints(arr) + min := math.MaxInt64 + for i := 1; i < len(arr); i++ { + diff := arr[i] - arr[i-1] + if diff <= min { + if diff < min { + min = diff + res = nil + } + res = append(res, []int{arr[i-1], arr[i]}) + } + } + + return res +} diff --git a/Easy/L121.go b/Easy/L121.go new file mode 100644 index 0000000..5323746 --- /dev/null +++ b/Easy/L121.go @@ -0,0 +1,34 @@ +package Easy + +func maxProfit(prices []int) int { + mp := make(map[string]int) + + return solve(prices, 0, 1, true, mp) +} + +func solve(prices []int, i, k int, buy bool, mp map[string]int) int { + if i >= len(prices) || k <= 0 { + return 0 + } + + key := fmt.Sprintf("%d-%t", i, buy) + if v, ok := mp[key]; ok { + return v + } + + if buy { + mp[key] = max(-prices[i]+solve(prices, i+1, k, !buy, mp), solve(prices, i+1, k, buy, mp)) + return mp[key] + } + + mp[key] = max(prices[i]+solve(prices, i+1, k-1, !buy, mp), solve(prices, i+1, k, buy, mp)) + return mp[key] +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Easy/L1217.go b/Easy/L1217.go new file mode 100644 index 0000000..4ed5158 --- /dev/null +++ b/Easy/L1217.go @@ -0,0 +1,19 @@ +package Easy + +func minCostToMoveChips(position []int) int { + odd, even := 0, 0 + + for _, p := range position { + if p%2 == 0 { + even++ + } else { + odd++ + } + } + + if even < odd { + return even + } + + return odd +} diff --git a/Easy/L1260.go b/Easy/L1260.go new file mode 100644 index 0000000..2383d85 --- /dev/null +++ b/Easy/L1260.go @@ -0,0 +1,32 @@ +package Easy + +func shiftGrid(grid [][]int, k int) [][]int { + r, c := len(grid), len(grid[0]) + n := r * c + sh := k % n + + res := make([][]int, len(grid)) + for i := range grid { + res[i] = make([]int, len(grid[i])) + copy(res[i], grid[i]) + } + + reverse(&res, 0, n-sh) + reverse(&res, n-sh, n) + reverse(&res, 0, n) + + return res +} + +func reverse(grid *[][]int, lo, hi int) { + for lo < hi { + hi-- + swap(grid, lo, hi) + lo++ + } +} + +func swap(grid *[][]int, lo, hi int) { + n := len((*grid)[0]) + (*grid)[lo/n][lo%n], (*grid)[hi/n][hi%n] = (*grid)[hi/n][hi%n], (*grid)[lo/n][lo%n] +} 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/L1275.go b/Easy/L1275.go new file mode 100644 index 0000000..1162582 --- /dev/null +++ b/Easy/L1275.go @@ -0,0 +1,47 @@ +package Easy + +func tictactoe(moves [][]int) string { + n := 3 + rows, cols := make([]int, n), make([]int, n) + d1, d2, curr := 0, 0, 1 + + for _, currMove := range moves { + rows[currMove[0]] += curr + cols[currMove[1]] += curr + + if currMove[0] == currMove[1] { + d1 += curr + } + + if currMove[0]+currMove[1] == n-1 { + d2 += curr + } + + if abs(rows[currMove[0]]) == n || + abs(cols[currMove[1]]) == n || + abs(d1) == n || + abs(d2) == n { + if curr == 1 { + return "A" + } + return "B" + } + + // 1 is 'A', -1 is 'B' + curr *= -1 + } + + if len(moves) < 9 { + return "Pending" + } + + return "Draw" +} + +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/L1323.go b/Easy/L1323.go new file mode 100644 index 0000000..9ac2c5a --- /dev/null +++ b/Easy/L1323.go @@ -0,0 +1,16 @@ +package Easy + +func maximum69Number(num int) int { + str := fmt.Sprintf("%d", num) + arr := []byte(str) + + for i := range arr { + if arr[i] == '6' { + arr[i] = '9' + ret, _ := strconv.Atoi(string(arr)) + return ret + } + } + + return num +} diff --git a/Easy/L1351.go b/Easy/L1351.go new file mode 100644 index 0000000..0d94cc0 --- /dev/null +++ b/Easy/L1351.go @@ -0,0 +1,26 @@ +package Easy + +func countNegatives(grid [][]int) int { + res := 0 + + for _, r := range grid { + res += binarySearch(r) + } + + return res +} + +func binarySearch(row []int) int { + l, r := 0, len(row) + + for l < r { + m := l + (r-l)/2 + if row[m] < 0 { + r = m + } else { + l = m + 1 + } + } + + return len(row) - l +} diff --git a/Easy/L136.go b/Easy/L136.go new file mode 100644 index 0000000..b439413 --- /dev/null +++ b/Easy/L136.go @@ -0,0 +1,11 @@ +package Easy + +func singleNumber(nums []int) int { + val := 0 + + for _, n := range nums { + val ^= n + } + + return val +} diff --git a/Easy/L141.go b/Easy/L141.go new file mode 100644 index 0000000..90d9e3a --- /dev/null +++ b/Easy/L141.go @@ -0,0 +1,14 @@ +package Easy + +func hasCycle(head *ListNode) bool { + walker, runner := head, head + + for runner != nil && runner.Next != nil { + walker, runner = walker.Next, runner.Next.Next + if walker == runner { + return true + } + } + + return false +} diff --git a/Easy/L1413.go b/Easy/L1413.go new file mode 100644 index 0000000..114680a --- /dev/null +++ b/Easy/L1413.go @@ -0,0 +1,14 @@ +package Easy + +func minStartValue(nums []int) int { + sum, minSum := 0, 0 + + for _, n := range nums { + sum += n + if sum < minSum { + minSum = sum + } + } + + return 1 - minSum +} 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/L1446.go b/Easy/L1446.go new file mode 100644 index 0000000..0115682 --- /dev/null +++ b/Easy/L1446.go @@ -0,0 +1,21 @@ +package Easy + +func maxPower(s string) int { + if len(s) == 0 { + return 0 + } + + cnt, ans := 1, 1 + for i := 1; i < len(s); i++ { + if s[i] == s[i-1] { + cnt++ + if cnt > ans { + ans = cnt + } + } else { + cnt = 1 + } + } + + return ans +} diff --git a/Easy/L145.go b/Easy/L145.go new file mode 100644 index 0000000..12a14e6 --- /dev/null +++ b/Easy/L145.go @@ -0,0 +1,50 @@ +package Easy + +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ + +// Iterative Solution +func preorderTraversal(root *TreeNode) []int { + var ( + res []int + st []*TreeNode + ) + st = append(st, root) + + for len(st) > 0 { + node := st[len(st) - 1] + st = st[:len(st) - 1] + if node != nil { + res = append(res, node.Val) + st = append(st, node.Right) + st = append(st, node.Left) + } + } + + return res +} + + +// Recursive Solution +func preorderTraversal(root *TreeNode) []int { + var res []int + + solve(root, &res) + return res +} + +func solve(root *TreeNode, res *[]int) { + if root == nil { + return + } + + *res = append(*res, root.Val) + solve(root.Left, res) + solve(root.Right, res) +} diff --git a/Easy/L1456.go b/Easy/L1456.go new file mode 100644 index 0000000..bfe8430 --- /dev/null +++ b/Easy/L1456.go @@ -0,0 +1,32 @@ +package Easy + +var exists struct{} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} +func maxVowels(s string, k int) int { + vowels, ans, cnt := "aeiou", 0, 0 + st := make(map[byte]struct{}) + for i := range vowels { + st[vowels[i]] = exists + } + + for i := range s { + if _, ok := st[s[i]]; ok { + cnt++ + } + if i >= k { + if _, ok := st[s[i - k]]; ok { + cnt-- + } + } + ans = max(ans, cnt) + } + + return ans +} diff --git a/Easy/L1460.go b/Easy/L1460.go new file mode 100644 index 0000000..1c1efc9 --- /dev/null +++ b/Easy/L1460.go @@ -0,0 +1,22 @@ +package Easy + +func canBeEqual(target []int, arr []int) bool { + m, n := len(arr), len(target) + if m != n { + return false + } + + mp := make(map[int]int) + for i := 0; i < m; i++ { + mp[target[i]]++ + mp[arr[i]]-- + } + + for _, v := range mp { + if v != 0 { + return false + } + } + + return true +} diff --git a/Easy/L1470.go b/Easy/L1470.go new file mode 100644 index 0000000..77d42dd --- /dev/null +++ b/Easy/L1470.go @@ -0,0 +1,13 @@ +package Easy + +func shuffle(nums []int, n int) []int { + res := make([]int, 2*n) + for i, j, idx := 0, n, 0; idx < len(res); i, j = i+1, j+1 { + res[idx] = nums[i] + idx++ + res[idx] = nums[j] + idx++ + } + + return res +} diff --git a/Easy/L1491.go b/Easy/L1491.go new file mode 100644 index 0000000..8aa3f23 --- /dev/null +++ b/Easy/L1491.go @@ -0,0 +1,30 @@ +package Easy + +func average(salary []int) float64 { + var sum float64 + minimum, maximum := math.MaxInt32, math.MinInt32 + + for i := 0; i < len(salary); i++ { + sum += float64(salary[i]) + minimum, maximum = min(minimum, salary[i]), max(maximum, salary[i]) + } + + sum -= float64(minimum + maximum) + return sum / float64(len(salary)-2) +} + +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/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/L1523.go b/Easy/L1523.go new file mode 100644 index 0000000..c7ad8ca --- /dev/null +++ b/Easy/L1523.go @@ -0,0 +1,15 @@ +package Easy + +func countOdds(low int, high int) int { + cnt := (high - low) / 2 + + if isOdd(low) || isOdd(high) { + cnt++ + } + + return cnt +} + +func isOdd(n int) bool { + return n%2 != 0 +} diff --git a/Easy/L1539.go b/Easy/L1539.go new file mode 100644 index 0000000..db486c5 --- /dev/null +++ b/Easy/L1539.go @@ -0,0 +1,17 @@ +package Easy + +func findKthPositive(arr []int, k int) int { + left, right := 0, len(arr)-1 + + for left <= right { + mid := left + (right-left)/2 + + if arr[mid]-mid <= k { + left = mid + 1 + } else { + right = mid - 1 + } + } + + return left + k +} diff --git a/Easy/L1544.go b/Easy/L1544.go new file mode 100644 index 0000000..3cf241b --- /dev/null +++ b/Easy/L1544.go @@ -0,0 +1,32 @@ +package Easy + +func makeGood(s string) string { + var st []byte + + for i := range s { + if len(st) > 0 && areEqual(st[len(st)-1], s[i]) { + st = st[:len(st)-1] + continue + } + st = append(st, s[i]) + } + + return string(st) +} + +func areEqual(a, b byte) bool { + if (isUpperCase(a) && isLowerCase(b)) || + (isLowerCase(a) && isUpperCase(b)) { + return byte(unicode.ToLower(rune(a))) == byte(unicode.ToLower(rune(b))) + } + + return false +} + +func isUpperCase(ch byte) bool { + return ch >= 'A' && ch <= 'Z' +} + +func isLowerCase(ch byte) bool { + return ch >= 'a' && ch <= 'z' +} diff --git a/Easy/L155.go b/Easy/L155.go new file mode 100644 index 0000000..66af987 --- /dev/null +++ b/Easy/L155.go @@ -0,0 +1,47 @@ +package Easy + +type StackNode struct { + val int + min int + next *StackNode +} + +func NewStackNode(val, min int, next *StackNode) *StackNode { + return &StackNode{ + val: val, + min: min, + next: next, + } +} + +type MinStack struct { + head *StackNode +} + +func Constructor() MinStack { + return MinStack{head: nil} +} + +func (this *MinStack) Push(val int) { + if this.head == nil { + this.head = NewStackNode(val, val, nil) + } else { + min := val + if this.head.min < min { + min = this.head.min + } + this.head = NewStackNode(val, min, this.head) + } +} + +func (this *MinStack) Pop() { + this.head = this.head.next +} + +func (this *MinStack) Top() int { + return this.head.val +} + +func (this *MinStack) GetMin() int { + return this.head.min +} diff --git a/Easy/L1572.go b/Easy/L1572.go new file mode 100644 index 0000000..c5d4f63 --- /dev/null +++ b/Easy/L1572.go @@ -0,0 +1,15 @@ +package Easy + +func diagonalSum(mat [][]int) int { + sum, n := 0, len(mat[0]) + + for i := 0; i < n; i++ { + sum += mat[i][i] + + if i != n - 1 - i { + sum += mat[i][n - 1 - i] + } + } + + return sum +} 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/L1629.go b/Easy/L1629.go new file mode 100644 index 0000000..d3802d0 --- /dev/null +++ b/Easy/L1629.go @@ -0,0 +1,21 @@ +package Easy + +func slowestKey(releaseTimes []int, keysPressed string) byte { + max, key := releaseTimes[0], keysPressed[0] + + for i := 1; i < len(releaseTimes); i++ { + relTime := releaseTimes[i] - releaseTimes[i-1] + if relTime >= max { + if relTime == max { + if keysPressed[i] > key { + key = keysPressed[i] + } + } else { + max = relTime + key = keysPressed[i] + } + } + } + + return key +} diff --git a/Easy/L1662.go b/Easy/L1662.go new file mode 100644 index 0000000..0c46622 --- /dev/null +++ b/Easy/L1662.go @@ -0,0 +1,27 @@ +package Easy + +func arrayStringsAreEqual(word1 []string, word2 []string) bool { + idx1, idx2, arrIdx1, arrIdx2 := 0, 0, 0, 0 + + for arrIdx1 < len(word1) && arrIdx2 < len(word2) { + if word1[arrIdx1][idx1] != word2[arrIdx2][idx2] { + return false + } + + if idx1 == len(word1[arrIdx1])-1 { + idx1 = 0 + arrIdx1++ + } else { + idx1++ + } + + if idx2 == len(word2[arrIdx2])-1 { + idx2 = 0 + arrIdx2++ + } else { + idx2++ + } + } + + return arrIdx1 == len(word1) && arrIdx2 == len(word2) +} diff --git a/Easy/L169.go b/Easy/L169.go new file mode 100644 index 0000000..5098eb8 --- /dev/null +++ b/Easy/L169.go @@ -0,0 +1,19 @@ +package Easy + +func majorityElement(nums []int) int { + cnt, candidate := 0, -1 + + for _, n := range nums { + if cnt == 0 { + candidate = n + } + + if candidate == n { + cnt++ + } else { + cnt -= 1 + } + } + + return candidate +} 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/L171.go b/Easy/L171.go new file mode 100644 index 0000000..1cabf7e --- /dev/null +++ b/Easy/L171.go @@ -0,0 +1,10 @@ +package Easy + +func titleToNumber(columnTitle string) int { + res := 0 + for i := 0; i < len(columnTitle); i++ { + res = res*26 + int(columnTitle[i]) - 'A' + 1 + } + + return res +} diff --git a/Easy/L1710.go b/Easy/L1710.go new file mode 100644 index 0000000..da8a7d0 --- /dev/null +++ b/Easy/L1710.go @@ -0,0 +1,22 @@ +package Easy + +func maximumUnits(boxTypes [][]int, truckSize int) int { + sort.Slice(boxTypes, func(i, j int) bool { + return boxTypes[i][1] > boxTypes[j][1] + }) + + sum, trucks := 0, 0 + for _, b := range boxTypes { + if trucks < truckSize { + if trucks+b[0] > truckSize { + sum += (truckSize - trucks) * b[1] + break + } else { + sum += b[0] * b[1] + trucks += b[0] + } + } + } + + return sum +} 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/L1748.go b/Easy/L1748.go index 0f5b6ad..04374f5 100644 --- a/Easy/L1748.go +++ b/Easy/L1748.go @@ -1,22 +1,14 @@ package Easy func sumOfUnique(nums []int) int { - if len(nums) == 0 { - return 0 - } - - mp := make(map[int]bool) + mp, sum := make(map[int]int), 0 - sum := 0 - for _, v := range nums { - if _, ok := mp[v]; ok { - if mp[v] { - sum -= v - mp[v] = false - } - } else { - mp[v] = true - sum += v + for _, n := range nums { + mp[n]++ + if mp[n] == 1 { + sum += n + } else if mp[n] == 2 { + sum -= n } } 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/L1768.go b/Easy/L1768.go new file mode 100644 index 0000000..ce7213b --- /dev/null +++ b/Easy/L1768.go @@ -0,0 +1,22 @@ +package Easy + +func mergeAlternately(word1 string, word2 string) string { + i, j, n, m := 0, 0, len(word1), len(word2) + res := make([]byte, n + m) + + for k := 0; k < n + m; k++ { + if i < n && j < m { + res[k] = word1[i] + k, i = k + 1, i + 1 + } else if i < n { + res[k] = word1[i] + i++ + } + if j < m { + res[k] = word2[j] + j++ + } + } + + return string(res) +} diff --git a/Easy/L1822.go b/Easy/L1822.go new file mode 100644 index 0000000..170c4db --- /dev/null +++ b/Easy/L1822.go @@ -0,0 +1,14 @@ +package Easy + +func arraySign(nums []int) int { + sign := 1 + for _, n := range nums { + if n < 0 { + sign *= -1 + } else if n == 0 { + return 0 + } + } + + return sign +} diff --git a/Easy/L1832.go b/Easy/L1832.go new file mode 100644 index 0000000..1581e59 --- /dev/null +++ b/Easy/L1832.go @@ -0,0 +1,13 @@ +package Easy + +var exists struct{} + +func checkIfPangram(sentence string) bool { + mp := make(map[byte]struct{}) + + for i := 0; i < len(sentence); i++ { + mp[sentence[i]] = exists + } + + return len(mp) == 26 +} 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/L1971.go b/Easy/L1971.go new file mode 100644 index 0000000..fe543ad --- /dev/null +++ b/Easy/L1971.go @@ -0,0 +1,34 @@ +package Easy + +var exists struct{} + +func validPath(n int, edges [][]int, source int, destination int) bool { + graph, vis := make([][]int, n), make(map[int]struct{}) + for i := 0; i < n; i++ { + graph[i] = make([]int, 0) + } + + for _, e := range edges { + graph[e[0]] = append(graph[e[0]], e[1]) + graph[e[1]] = append(graph[e[1]], e[0]) + } + + return dfs(graph, vis, source, destination) +} + +func dfs(graph [][]int, vis map[int]struct{}, source, dest int) bool { + if source == dest { + return true + } + if _, ok := vis[source]; ok { + return false + } + vis[source] = exists + + found := false + for _, neigh := range graph[source] { + found = found || dfs(graph, vis, neigh, dest) + } + + return found +} diff --git a/Easy/L20.go b/Easy/L20.go new file mode 100644 index 0000000..a029bc1 --- /dev/null +++ b/Easy/L20.go @@ -0,0 +1,59 @@ +package Easy + +type Stack struct { + arr []byte +} + +func NewStack() *Stack { + return &Stack{arr: make([]byte, 0)} +} + +func (s *Stack) Push(b byte) { + s.arr = append(s.arr, b) +} + +func (s *Stack) Pop() byte { + if s.IsEmpty() { + return 0 + } + + ret := s.arr[len(s.arr)-1] + s.arr = s.arr[:len(s.arr)-1] + return ret +} + +func (s *Stack) Top() byte { + if s.IsEmpty() { + return 0 + } + + return s.arr[len(s.arr)-1] +} + +func (s *Stack) IsEmpty() bool { + return len(s.arr) == 0 +} + +func isValid(s string) bool { + if len(s) == 0 { + return false + } + st := NewStack() + + for i := 0; i < len(s); i++ { + switch s[i] { + case '(': + st.Push(')') + case '{': + st.Push('}') + case '[': + st.Push(']') + default: + if st.IsEmpty() || st.Pop() != s[i] { + return false + } + } + } + + return st.IsEmpty() +} 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/L203.go b/Easy/L203.go new file mode 100644 index 0000000..afa05ae --- /dev/null +++ b/Easy/L203.go @@ -0,0 +1,15 @@ +package Easy + +func removeElements(head *ListNode, val int) *ListNode { + if head == nil { + return nil + } + + head.Next = removeElements(head.Next, val) + + if head.Val == val { + return head.Next + } + + return head +} diff --git a/Easy/L206.go b/Easy/L206.go new file mode 100644 index 0000000..52c0a0e --- /dev/null +++ b/Easy/L206.go @@ -0,0 +1,13 @@ +package Easy + +func reverseList(head *ListNode) *ListNode { + var newHead *ListNode + for head != nil { + next := head.Next + head.Next = newHead + newHead = head + head = next + } + + return newHead +} diff --git a/Easy/L2073.go b/Easy/L2073.go new file mode 100644 index 0000000..96f7441 --- /dev/null +++ b/Easy/L2073.go @@ -0,0 +1,18 @@ +package Easy + +func timeRequiredToBuy(tickets []int, k int) int { + total := 0 + for i := 0; i < len(tickets); i++ { + if tickets[i] <= tickets[k] { + total += tickets[i] + } else { + total += tickets[k] + } + + if i > k && tickets[i] >= tickets[k] { + total-- + } + } + + return total +} diff --git a/Easy/L21.go b/Easy/L21.go new file mode 100644 index 0000000..fe79c1c --- /dev/null +++ b/Easy/L21.go @@ -0,0 +1,19 @@ +package Easy + +func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode { + if l1 == nil { + return l2 + } + + if l2 == nil { + return l1 + } + + if l1.Val < l2.Val { + l1.Next = mergeTwoLists(l1.Next, l2) + return l1 + } else { + l2.Next = mergeTwoLists(l1, l2.Next) + return l2 + } +} diff --git a/Easy/L217.go b/Easy/L217.go new file mode 100644 index 0000000..9bd0e9b --- /dev/null +++ b/Easy/L217.go @@ -0,0 +1,15 @@ +package Easy + +var exists struct{} +func containsDuplicate(nums []int) bool { + mp := make(map[int]struct{} + + for _, n := range nums { + if _, ok := mp[n]; ok { + return true + } + mp[n] = exists + } + + return len(mp) != len(nums) +} diff --git a/Easy/L219.go b/Easy/L219.go new file mode 100644 index 0000000..d6d04d6 --- /dev/null +++ b/Easy/L219.go @@ -0,0 +1,16 @@ +package Easy + +func containsNearbyDuplicate(nums []int, k int) bool { + mp := make(map[int]int) + + for i := range nums { + if v, ok := mp[nums[i]]; ok { + if i-v <= k { + return true + } + } + mp[nums[i]] = i + } + + return false +} diff --git a/Easy/L2215.go b/Easy/L2215.go new file mode 100644 index 0000000..3581603 --- /dev/null +++ b/Easy/L2215.go @@ -0,0 +1,35 @@ +package Easy + +var exists struct{} + +func findDifference(nums1 []int, nums2 []int) [][]int { + var res [][]int + st1, st2, i := make(map[int]struct{}), make(map[int]struct{}), 0 + + for i = 0; i < len(nums1); i++ { + st1[nums1[i]] = exists + if i < len(nums2) { + st2[nums2[i]] = exists + } + } + for ; i < len(nums2); i++ { + st2[nums2[i]] = exists + } + + var res1, res2 []int + for k, _ := range st1 { + if _, ok := st2[k]; ok { + continue + } + res1 = append(res1, k) + } + for k, _ := range st2 { + if _, ok := st1[k]; ok { + continue + } + res2 = append(res2, k) + } + + res = append(res, res1, res2) + return res +} diff --git a/Easy/L226.go b/Easy/L226.go new file mode 100644 index 0000000..ea9b3c3 --- /dev/null +++ b/Easy/L226.go @@ -0,0 +1,17 @@ +package Easy + +func invertTree(root *TreeNode) *TreeNode { + return dfs(root) +} + +func dfs(root *TreeNode) *TreeNode { + if root == nil { + return root + } + + left, right := root.Left, root.Right + root.Left = dfs(right) + root.Right = dfs(left) + + return root +} 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/L228.go b/Easy/L228.go new file mode 100644 index 0000000..4f7343d --- /dev/null +++ b/Easy/L228.go @@ -0,0 +1,21 @@ +package Easy + +func summaryRanges(nums []int) []string { + start, end := 0, 0 + var list []string + + for i := 0; i < len(nums); i++ { + for i < len(nums)-1 && nums[i]+1 == nums[i+1] { + end, i = end+1, i+1 + } + if start == end { + list = append(list, fmt.Sprintf("%d", nums[start])) + } else { + list = append(list, fmt.Sprintf("%d->%d", nums[start], nums[end])) + } + end++ + start = end + } + + return list +} diff --git a/Easy/L2325.go b/Easy/L2325.go new file mode 100644 index 0000000..85cb498 --- /dev/null +++ b/Easy/L2325.go @@ -0,0 +1,27 @@ +package Easy + +func decodeMessage(key string, message string) string { + var sb strings.Builder + hash, j := make(map[byte]byte), 0 + + for i := range key { + if key[i] == ' ' { + continue + } + if _, ok := hash[key[i]]; !ok { + hash[key[i]] = byte('a' + j) + j++ + } + } + + for i := range message { + if message[i] == ' ' { + sb.WriteByte(' ') + continue + } + by := hash[message[i]] + sb.WriteByte(by) + } + + return sb.String() +} 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/L235.go b/Easy/L235.go new file mode 100644 index 0000000..60ebcff --- /dev/null +++ b/Easy/L235.go @@ -0,0 +1,20 @@ +package Easy + +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ + +func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode { + if root.Val > p.Val && root.Val > q.Val { + return lowestCommonAncestor(root.Left, p, q) + } else if root.Val < p.Val && root.Val < q.Val { + return lowestCommonAncestor(root.Right, p, q) + } else { + return 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/L2389.go b/Easy/L2389.go new file mode 100644 index 0000000..2a52d03 --- /dev/null +++ b/Easy/L2389.go @@ -0,0 +1,26 @@ +package Easy + +func answerQueries(nums []int, queries []int) []int { + n, m, sum := len(nums), len(queries), 0 + + sort.Ints(nums) + var preSum []int + + for i := 0; i < n; i++ { + sum += nums[i] + preSum = append(preSum, sum) + } + + ans := make([]int, m) + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if preSum[j] <= queries[i] { + ans[i] = j + 1 + } else { + break + } + } + } + + return ans +} diff --git a/Easy/L242.go b/Easy/L242.go new file mode 100644 index 0000000..9434b75 --- /dev/null +++ b/Easy/L242.go @@ -0,0 +1,22 @@ +package Easy + +func isAnagram(s string, t string) bool { + alphabet := make([]int, 26) + for i := range s { + alphabet[s[i]-'a']++ + } + for i := range t { + alphabet[t[i]-'a']-- + if alphabet[t[i]-'a'] < 0 { + return false + } + } + + for _, a := range alphabet { + if a != 0 { + return false + } + } + + return true +} 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/L258.go b/Easy/L258.go new file mode 100644 index 0000000..251963b --- /dev/null +++ b/Easy/L258.go @@ -0,0 +1,13 @@ +package Easy + +func addDigits(num int) int { + if num == 0 { + return num + } + + if num%9 == 0 { + return 9 + } + + return num % 9 +} diff --git a/Easy/L266.go b/Easy/L266.go new file mode 100644 index 0000000..fca1027 --- /dev/null +++ b/Easy/L266.go @@ -0,0 +1,17 @@ +package Easy + +var exists struct{} + +func canPermutePalindrome(s string) bool { + mp := make(map[byte]struct{}) + + for i := range s { + if _, ok := mp[s[i]]; !ok { + mp[s[i]] = exists + } else { + delete(mp, s[i]) + } + } + + return len(mp) <= 1 +} 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/L283.go b/Easy/L283.go new file mode 100644 index 0000000..23384e2 --- /dev/null +++ b/Easy/L283.go @@ -0,0 +1,20 @@ +package Easy + +func moveZeroes(nums []int) { + if len(nums) == 0 { + return + } + + insertPos := 0 + for _, n := range nums { + if n != 0 { + nums[insertPos] = n + insertPos++ + } + } + + for insertPos < len(nums) { + nums[insertPos] = 0 + insertPos++ + } +} diff --git a/Easy/L290.go b/Easy/L290.go new file mode 100644 index 0000000..8e94b1b --- /dev/null +++ b/Easy/L290.go @@ -0,0 +1,28 @@ +package Easy + +var exists struct{} + +func wordPattern(pattern string, s string) bool { + mp, st := make(map[byte]string), make(map[string]struct{}) + strs := strings.Split(s, " ") + + if len(strs) != len(pattern) { + return false + } + + for i := range strs { + if v, ok := mp[pattern[i]]; ok { + if v != strs[i] { + return false + } + } else { + if _, ok := st[strs[i]]; ok { + return false + } + st[strs[i]] = exists + mp[pattern[i]] = strs[i] + } + } + + return true +} diff --git a/Easy/L338.go b/Easy/L338.go new file mode 100644 index 0000000..d232aee --- /dev/null +++ b/Easy/L338.go @@ -0,0 +1,24 @@ +package Easy + +func countBits(num int) []int { + arr := make([]int, num+1) + + for i := 1; i < num+1; i++ { + arr[i] = solve(i&(i-1), &arr) + 1 + } + + return arr +} + +func solve(n int, arr *[]int) int { + if n == 0 { + return n + } + + if (*arr)[n&(n-1)] != 0 { + return (*arr)[n&(n-1)] + 1 + } + (*arr)[n] = solve(n&(n-1), arr) + 1 + + return (*arr)[n] +} diff --git a/Easy/L344.go b/Easy/L344.go new file mode 100644 index 0000000..4281dd7 --- /dev/null +++ b/Easy/L344.go @@ -0,0 +1,13 @@ +package Easy + +func reverseString(s []byte) { + if len(s) == 0 { + return + } + + st, end := 0, len(s)-1 + for st <= end { + s[st], s[end] = s[end], s[st] + st, end = st+1, end-1 + } +} diff --git a/Easy/L349.go b/Easy/L349.go new file mode 100644 index 0000000..67730f4 --- /dev/null +++ b/Easy/L349.go @@ -0,0 +1,28 @@ +package Easy + +func intersection(nums1 []int, nums2 []int) []int { + var res []int + if len(nums1) == 0 || len(nums2) == 0 { + return res + } + + sort.Ints(nums1) + sort.Ints(nums2) + + for i, j := 0, 0; i < len(nums1) && j < len(nums2); { + if nums1[i] == nums2[j] { + size := len(res) + i, j = i+1, j+1 + if size != 0 && res[size-1] == nums1[i-1] { + continue + } + res = append(res, nums1[i-1]) + } else if nums1[i] < nums2[j] { + i++ + } else { + j++ + } + } + + return res +} diff --git a/Easy/L35.go b/Easy/L35.go new file mode 100644 index 0000000..7f0a5ed --- /dev/null +++ b/Easy/L35.go @@ -0,0 +1,22 @@ +package Easy + +func searchInsert(nums []int, target int) int { + if len(nums) == 0 { + return 0 + } + + l, r, mid := 0, len(nums)-1, 0 + + for l <= r { + mid = (r-l)/2 + l + if nums[mid] == target { + return mid + } else if nums[mid] < target { + l = mid + 1 + } else { + r = mid - 1 + } + } + + return l +} diff --git a/Easy/L350.go b/Easy/L350.go new file mode 100644 index 0000000..f2e8c27 --- /dev/null +++ b/Easy/L350.go @@ -0,0 +1,28 @@ +package Easy + +func intersect(nums1 []int, nums2 []int) []int { + var res []int + mp1, mp2 := make(map[int]int), make(map[int]int) + + for _, n := range nums1 { + mp1[n]++ + } + + for _, n := range nums2 { + mp2[n]++ + } + + for k, v := range mp2 { + if val, ok := mp1[k]; ok { + minVal := v + if val < minVal { + minVal = val + } + for i := 0; i < minVal; i++ { + res = append(res, k) + } + } + } + + return res +} diff --git a/Easy/L374.go b/Easy/L374.go new file mode 100644 index 0000000..95e293a --- /dev/null +++ b/Easy/L374.go @@ -0,0 +1,18 @@ +package Easy + +func guessNumber(n int) int { + i, j := 1, n + for i < j { + mid := i + (j-i)/2 + switch guess(mid) { + case 0: + return mid + case 1: + i = mid + 1 + case -1: + j = mid + } + } + + return i +} diff --git a/Easy/L389.go b/Easy/L389.go new file mode 100644 index 0000000..bed066d --- /dev/null +++ b/Easy/L389.go @@ -0,0 +1,15 @@ +package Easy + +func findTheDifference(s string, t string) byte { + sumS, sumT := 0, 0 + + for i := 0; i < len(s); i++ { + sumS += int(s[i]) + } + + for i := 0; i < len(t); i++ { + sumT += int(t[i]) + } + + return byte(sumT - sumS - 'a') +} diff --git a/Easy/L392.go b/Easy/L392.go new file mode 100644 index 0000000..f2549a5 --- /dev/null +++ b/Easy/L392.go @@ -0,0 +1,20 @@ +package Easy + +func isSubsequence(s string, t string) bool { + if len(s) == 0 { + return true + } + + indexS, indexT := 0, 0 + for indexT < len(t) { + if t[indexT] == s[indexS] { + indexS++ + if indexS == len(s) { + return true + } + } + indexT++ + } + + return false +} diff --git a/Easy/L412.go b/Easy/L412.go new file mode 100644 index 0000000..e17f06a --- /dev/null +++ b/Easy/L412.go @@ -0,0 +1,28 @@ +func fizzBuzz(n int) []string { + var res []string + if n == 0 { + return res + } + + for i := 1; i <= n; i++ { + if isDiv3(i) && isDiv5(i) { + res = append(res, "FizzBuzz") + } else if isDiv3(i) && !isDiv5(i) { + res = append(res, "Fizz") + } else if !isDiv3(i) && isDiv5(i) { + res = append(res, "Buzz") + } else { + res = append(res, fmt.Sprintf("%d", i)) + } + } + + return res +} + +func isDiv3(n int) bool { + return n%3 == 0 +} + +func isDiv5(n int) bool { + return n%5 == 0 +} diff --git a/Easy/L415.go b/Easy/L415.go new file mode 100644 index 0000000..6c49b3f --- /dev/null +++ b/Easy/L415.go @@ -0,0 +1,34 @@ +package Easy + +func addStrings(num1 string, num2 string) string { + carry, i, j := 0, len(num1)-1, len(num2)-1 + var sb strings.Builder + + for i >= 0 || j >= 0 { + n1, n2 := 0, 0 + if i >= 0 { + n1 = int(num1[i] - '0') + } + if j >= 0 { + n2 = int(num2[j] - '0') + } + sum := n1 + n2 + carry + carry = sum / 10 + sb.WriteByte(byte(sum%10 + '0')) + i-- + j-- + } + + if carry != 0 { + sb.WriteByte(byte(carry + '0')) + } + + return reverse(sb.String()) +} + +func reverse(s string) (result string) { + for _, v := range s { + result = string(v) + result + } + return +} diff --git a/Easy/L441.go b/Easy/L441.go new file mode 100644 index 0000000..68a4453 --- /dev/null +++ b/Easy/L441.go @@ -0,0 +1,15 @@ +package Easy + +func arrangeCoins(n int) int { + i := 0 + for n > 0 { + i += 1 + n -= i + } + + if n == 0 { + return i + } + + return i - 1 +} diff --git a/Easy/L448.go b/Easy/L448.go new file mode 100644 index 0000000..ae4e278 --- /dev/null +++ b/Easy/L448.go @@ -0,0 +1,18 @@ +package Easy + +func findDisappearedNumbers(nums []int) []int { + for i := range nums { + for nums[i] != i+1 && nums[i] != nums[nums[i]-1] { + nums[i], nums[nums[i]-1] = nums[nums[i]-1], nums[i] + } + } + + var res []int + for i := range nums { + if nums[i] != i+1 { + res = append(res, i+1) + } + } + + return res +} 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/L461.go b/Easy/L461.go new file mode 100644 index 0000000..3d99e05 --- /dev/null +++ b/Easy/L461.go @@ -0,0 +1,12 @@ +package Easy + +func hammingDistance(x int, y int) int { + xor, res := x^y, 0 + + for xor != 0 { + res += xor & 1 + xor >>= 1 + } + + return res +} diff --git a/Easy/L463.go b/Easy/L463.go new file mode 100644 index 0000000..a6594a8 --- /dev/null +++ b/Easy/L463.go @@ -0,0 +1,25 @@ +package Easy + +func islandPerimeter(grid [][]int) int { + m, n, cnt, dirs := len(grid), len(grid[0]), 0, [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if grid[i][j] == 1 { + for _, d := range dirs { + x, y := i+d[0], j+d[1] + if isValid(grid, x, y) { + cnt++ + } + } + } + } + } + + return cnt +} + +func isValid(grid [][]int, x, y int) bool { + m, n := len(grid), len(grid[0]) + + return x < 0 || y < 0 || x == m || y == n || grid[x][y] == 0 +} diff --git a/Easy/L476.go b/Easy/L476.go new file mode 100644 index 0000000..85ecfac --- /dev/null +++ b/Easy/L476.go @@ -0,0 +1,24 @@ +package Easy + +func findComplement(num int) int { + i, j := 0, 0 + + for i < num { + i += pow(j) + j++ + } + + return i - num +} + +func pow(n int) int { + if n == 0 { + return 1 + } + result := 2 + for i := 2; i <= n; i++ { + result *= 2 + } + + return result +} diff --git a/Easy/L485.go b/Easy/L485.go new file mode 100644 index 0000000..2dc6eee --- /dev/null +++ b/Easy/L485.go @@ -0,0 +1,21 @@ +package Easy + +func findMaxConsecutiveOnes(nums []int) int { + result, max := 0, 0 + + if len(nums) == 0 { + return result + } + + for i := range nums { + max += nums[i] + if nums[i] == 0 { + max = 0 + } else { + if max >= result { + result = max + } + } + } + return result +} diff --git a/Easy/L496.go b/Easy/L496.go new file mode 100644 index 0000000..7aa64f2 --- /dev/null +++ b/Easy/L496.go @@ -0,0 +1,24 @@ +package Easy + +func nextGreaterElement(nums1 []int, nums2 []int) []int { + mp, res := make(map[int]int), make([]int, len(nums1)) + var st []int + for _, n := range nums2 { + for len(st) > 0 && st[len(st)-1] < n { + mp[st[len(st)-1]] = n + st = st[:len(st)-1] + } + st = append(st, n) + } + + for i := range nums1 { + val, ok := mp[nums1[i]] + if !ok { + res[i] = -1 + } else { + res[i] = val + } + } + + return res +} 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/L509.go b/Easy/L509.go index dc20ce7..b4ab958 100644 --- a/Easy/L509.go +++ b/Easy/L509.go @@ -17,3 +17,25 @@ func fibo(mp map[int]int, n int) int { return mp[n] } + +// With anonymous function +func fib(n int) int { + mp := map[int]int{ + 0: 0, + 1: 1, + 2: 1, + } + + var solve func(n int) int + solve = func(n int) int { + if v, ok := mp[n]; ok { + return v + } + + mp[n] = solve(n-1) + solve(n-2) + + return mp[n] + } + + return solve(n) +} diff --git a/Easy/L520.go b/Easy/L520.go new file mode 100644 index 0000000..66c72f3 --- /dev/null +++ b/Easy/L520.go @@ -0,0 +1,23 @@ +package Easy + +func detectCapitalUse(word string) bool { + cnt := 0 + for i := 0; i < len(word); i++ { + if isUpper(word[i]) { + cnt++ + } + } + + if cnt == 0 || cnt == len(word) { + return true + } + + if cnt == 1 && isUpper(word[0]) { + return true + } + return false +} + +func isUpper(b byte) bool { + return b >= 'A' && b <= 'Z' +} diff --git a/Easy/L53.go b/Easy/L53.go new file mode 100644 index 0000000..20ea9fa --- /dev/null +++ b/Easy/L53.go @@ -0,0 +1,28 @@ +package Easy + +func maxSubArray(nums []int) int { + max := math.MinInt64 + solve(nums, 0, &max) + + return max +} + +func solve(nums []int, idx int, max *int) int { + maxSoFar := 0 + if idx == len(nums)-1 { + maxSoFar = nums[idx] + } else { + maxSoFar = maximum(nums[idx], nums[idx]+solve(nums, idx+1, max)) + } + *max = maximum(*max, maxSoFar) + + return maxSoFar +} + +func maximum(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Easy/L530.go b/Easy/L530.go new file mode 100644 index 0000000..ff78a39 --- /dev/null +++ b/Easy/L530.go @@ -0,0 +1,35 @@ +package Easy + +func min(a, b int) int { + if a < b { + return a + } + + return b +} + +func getMinimumDifference(root *TreeNode) int { + var ( + solve func(root *TreeNode) int + ) + minimum, prev := math.MaxInt32, -1 + + solve = func(root *TreeNode) int { + if root == nil { + return minimum + } + + solve(root.Left) + + if prev != -1 { + minimum = min(minimum, root.Val-prev) + } + prev = root.Val + + solve(root.Right) + + return minimum + } + + return solve(root) +} diff --git a/Easy/L543.go b/Easy/L543.go new file mode 100644 index 0000000..8414359 --- /dev/null +++ b/Easy/L543.go @@ -0,0 +1,25 @@ +package Easy + +func diameterOfBinaryTree(root *TreeNode) int { + max := 0 + maxDepth(root, &max) + return max +} + +func maxDepth(root *TreeNode, max *int) int { + if root == nil { + return 0 + } + + left, right := maxDepth(root.Left, max), maxDepth(root.Right, max) + + if left+right > *max { + *max = left + right + } + + if left > right { + return left + 1 + } else { + return right + 1 + } +} diff --git a/Easy/L557.go b/Easy/L557.go new file mode 100644 index 0000000..94582f1 --- /dev/null +++ b/Easy/L557.go @@ -0,0 +1,23 @@ +package Easy + +func reverseWords(s string) string { + var sb strings.Builder + + strs := strings.Split(s, " ") + for i := 0; i < len(strs); i++ { + sb.WriteString(reverse(strs[i])) + if i != len(strs)-1 { + sb.WriteString(" ") + } + } + + return sb.String() +} + +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) +} diff --git a/Easy/L563.go b/Easy/L563.go new file mode 100644 index 0000000..7171015 --- /dev/null +++ b/Easy/L563.go @@ -0,0 +1,28 @@ +package Easy + +func findTilt(root *TreeNode) int { + res := 0 + + postOrder(root, &res) + return res +} + +func postOrder(root *TreeNode, res *int) int { + if root == nil { + return 0 + } + + left, right := postOrder(root.Left, res), postOrder(root.Right, res) + + *res += abs(left - right) + + return left + right + root.Val +} + +func abs(a int) int { + if a < 0 { + return -a + } + + return a +} diff --git a/Easy/L605.go b/Easy/L605.go new file mode 100644 index 0000000..cf283e3 --- /dev/null +++ b/Easy/L605.go @@ -0,0 +1,25 @@ +package Easy + +func canPlaceFlowers(flowerbed []int, n int) bool { + cnt, res, size := 0, 0, len(flowerbed) + + for i := 0; i <= size; i++ { + if i < size && flowerbed[i] == 0 { + cnt++ + if i == 0 { + cnt++ + } + if i == size - 1 { + cnt++ + } + } else { + res += (cnt - 1) / 2 + if res >= n { + return true + } + cnt = 0 + } + } + + return false +} 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/L637.go b/Easy/L637.go index f38f7e3..ca3deb2 100644 --- a/Easy/L637.go +++ b/Easy/L637.go @@ -1,27 +1,30 @@ package Easy func averageOfLevels(root *TreeNode) []float64 { - if root == nil { - return make([]float64, 0) - } - avgs := make([]float64, 0, 10) - queue := make([]*TreeNode, 1, 10) - queue[0] = root - for len(queue) != 0 { - n := len(queue) - sum := 0 - for i := 0; i < n; i++ { - cur := queue[0] - sum += cur.Val - queue = queue[1:] - if cur.Left != nil { - queue = append(queue, cur.Left) - } - if cur.Right != nil { - queue = append(queue, cur.Right) - } - } - avgs = append(avgs, float64(sum)/float64(n)) - } - return avgs + var ( + res []float64 + q []*TreeNode + ) + if root == nil { + return res + } + + q = append(q, root) + for len(q) != 0 { + n := len(q) + sum := 0 + for i := 0; i < n; i++ { + cur := q[0] + sum += cur.Val + q = q[1:] + if cur.Left != nil { + q = append(q, cur.Left) + } + if cur.Right != nil { + q = append(q, cur.Right) + } + } + res = append(res, float64(sum)/float64(n)) + } + return res } diff --git a/Easy/L653.go b/Easy/L653.go new file mode 100644 index 0000000..66157af --- /dev/null +++ b/Easy/L653.go @@ -0,0 +1,21 @@ +package Easy + +func findTarget(root *TreeNode, k int) bool { + return dfs(root, root, k) +} + +func dfs(root, cur *TreeNode, k int) bool { + if cur == nil { + return false + } + + return search(root, cur, k-cur.Val) || dfs(root, cur.Left, k) || dfs(root, cur.Right, k) +} + +func search(root, curr *TreeNode, val int) bool { + if root == nil { + return false + } + + return (root.Val == val) && (root != curr) || (root.Val < val) && search(root.Right, curr, val) || (root.Val > val) && search(root.Left, curr, val) +} 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/L67.go b/Easy/L67.go new file mode 100644 index 0000000..424bf38 --- /dev/null +++ b/Easy/L67.go @@ -0,0 +1,36 @@ +package Easy + +func addBinary(a string, b string) string { + var sb strings.Builder + i, j, carry := len(a)-1, len(b)-1, 0 + + for i >= 0 || j >= 0 { + sum := carry + if j >= 0 { + sum += int(b[j] - '0') + j-- + } + + if i >= 0 { + sum += int(a[i] - '0') + i-- + } + sb.WriteString(fmt.Sprintf("%d", sum%2)) + carry = sum / 2 + } + + if carry != 0 { + sb.WriteString(fmt.Sprintf("%d", carry)) + } + + ret := sb.String() + return reverse(ret) +} + +func reverse(s string) string { + r := []rune(s) + for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 { + r[i], r[j] = r[j], r[i] + } + return string(r) +} 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/L697.go b/Easy/L697.go new file mode 100644 index 0000000..17ee9bc --- /dev/null +++ b/Easy/L697.go @@ -0,0 +1,36 @@ +package Easy + +func findShortestSubArray(nums []int) int { + if len(nums) == 0 { + return 0 + } + + mp := make(map[int][]int) + for i := range nums { + if _, ok := mp[nums[i]]; !ok { + mp[nums[i]] = append(mp[nums[i]], []int{1, i, i}...) + } else { + mp[nums[i]][0]++ + mp[nums[i]][2] = i + } + } + + deg, res := math.MinInt32, math.MaxInt32 + for _, v := range mp { + if v[0] > deg { + deg, res = v[0], v[2]-v[1]+1 + } else if v[0] == deg { + res = min(res, v[2]-v[1]+1) + } + } + + return res +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Easy/L70.go b/Easy/L70.go new file mode 100644 index 0000000..b3759d7 --- /dev/null +++ b/Easy/L70.go @@ -0,0 +1,43 @@ +package Easy + +func climbStairs(n int) int { + mp := make(map[int]int) + + mp[1], mp[2], mp[3] = 1,2,3 + return dp(mp, n) +} + +func dp(mp map[int]int, n int) int { + if _, ok := mp[n]; ok { + return mp[n] + } + + mp[n] = dp(mp, n-1) + dp(mp, n-2) + + return mp[n] +} + +// With anonymous function +func climbStairs(n int) int { + mp := map[int]int{ + 0: 0, + 1: 1, + 2: 2, + } + + var solve func(int) int + solve = func(n int) int { + if n < 0 { + return 0 + } + + if v, ok := mp[n]; ok { + return v + } + + mp[n] = solve(n-1) + solve(n-2) + return mp[n] + } + + return solve(n) +} diff --git a/Easy/L700.go b/Easy/L700.go new file mode 100644 index 0000000..fa16bea --- /dev/null +++ b/Easy/L700.go @@ -0,0 +1,13 @@ +package Easy + +func searchBST(root *TreeNode, val int) *TreeNode { + if root == nil || val == root.Val { + return root + } + + if val < root.Val { + return searchBST(root.Left, val) + } + + return searchBST(root.Right, val) +} diff --git a/Easy/L704.go b/Easy/L704.go new file mode 100644 index 0000000..41088e3 --- /dev/null +++ b/Easy/L704.go @@ -0,0 +1,18 @@ +package Easy + +func search(nums []int, target int) int { + low, high := 0, len(nums)-1 + + for low < high { + mid := low + (high-low)/2 + if target == nums[mid] { + return mid + } else if target > nums[mid] { + low = mid + 1 + } else { + high = mid - 1 + } + } + + return -1 +} diff --git a/Easy/L744.go b/Easy/L744.go new file mode 100644 index 0000000..cf207de --- /dev/null +++ b/Easy/L744.go @@ -0,0 +1,20 @@ +package Easy + +func nextGreatestLetter(letters []byte, target byte) byte { + low, high := 0, len(letters) - 1 + + if target >= letters[len(letters) - 1] { + return letters[0] + } + + for low < high { + mid := low + (high - low) / 2 + if letters[mid] > target { + high = mid + } else { + low = mid + 1 + } + } + + return letters[low % len(letters)] +} diff --git a/Easy/L746.go b/Easy/L746.go new file mode 100644 index 0000000..7ee5a88 --- /dev/null +++ b/Easy/L746.go @@ -0,0 +1,31 @@ +package Easy + +func minCostClimbingStairs(cost []int) int { + mp := make(map[int]int) + + var solve func(int) int + solve = func(n int) int { + if n >= len(cost) { + return 0 + } + if v, ok := mp[n]; ok { + return v + } + + oneStep := cost[n] + solve(n + 1) + twoStep := cost[n] + solve(n + 2) + + mp[n] = min(oneStep, twoStep) + return mp[n] + } + + return min(solve(0), solve(1)) +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Easy/L766.go b/Easy/L766.go new file mode 100644 index 0000000..1c263de --- /dev/null +++ b/Easy/L766.go @@ -0,0 +1,13 @@ +package Easy + +func isToeplitzMatrix(matrix [][]int) bool { + for i := 0; i < len(matrix)-1; i++ { + for j := 0; j < len(matrix[i])-1; j++ { + if matrix[i][j] != matrix[i+1][j+1] { + return false + } + } + } + + return true +} diff --git a/Easy/L783.go b/Easy/L783.go new file mode 100644 index 0000000..a48fe7a --- /dev/null +++ b/Easy/L783.go @@ -0,0 +1,31 @@ +package Easy + +func min(a, b int) int { + if a < b { + return a + } + + return b +} + +func minDiffInBST(root *TreeNode) int { + var prev *TreeNode + minimum := math.MaxInt32 + + solve := func(root *TreeNode, prev **TreeNode) {} + solve = func(root *TreeNode, prev **TreeNode) { + if root == nil { + return + } + + solve(root.Left, prev) + if prev != nil && *prev != nil { + minimum = min(minimum, root.Val-(*prev).Val) + } + *prev = root + solve(root.Right, prev) + } + + solve(root, &prev) + return minimum +} diff --git a/Easy/L844.go b/Easy/L844.go new file mode 100644 index 0000000..b35dc8d --- /dev/null +++ b/Easy/L844.go @@ -0,0 +1,24 @@ +package Easy + +func backspaceCompare(s string, t string) bool { + return eval(s) == eval(t) +} + +func eval(s string) string { + n, cnt := len(s), 0 + var res strings.Builder + + for i := n - 1; i >= 0; i-- { + if s[i] == '#' { + cnt++ + } else { + if cnt > 0 { + cnt-- + } else { + res.WriteByte(s[i]) + } + } + } + + return res.String() +} diff --git a/Easy/L859.go b/Easy/L859.go new file mode 100644 index 0000000..d88a61d --- /dev/null +++ b/Easy/L859.go @@ -0,0 +1,26 @@ +package Easy + +func buddyStrings(s string, goal string) bool { + if len(s) != len(goal) { + return false + } + + var exists struct{} + uniqueS := make(map[byte]struct{}) + for i := range s { + uniqueS[s[i]] = exists + } + if len(uniqueS) < len(s) && s == goal { + return true + } + + var diff []byte + for i := 0; i < len(s) && len(diff) <= 4; i++ { + if s[i] != goal[i] { + diff = append(diff, s[i]) + diff = append(diff, goal[i]) + } + } + + return len(diff) == 4 && diff[0] == diff[3] && diff[1] == diff[2] +} 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/L876.go b/Easy/L876.go new file mode 100644 index 0000000..b065e03 --- /dev/null +++ b/Easy/L876.go @@ -0,0 +1,11 @@ +package Easy + +func middleNode(head *ListNode) *ListNode { + slow, fast := head, head + + for fast != nil && fast.Next != nil { + slow, fast = slow.Next, fast.Next.Next + } + + return slow +} diff --git a/Easy/L88.go b/Easy/L88.go new file mode 100644 index 0000000..99d94d5 --- /dev/null +++ b/Easy/L88.go @@ -0,0 +1,19 @@ +package Easy + +func merge(nums1 []int, m int, nums2 []int, n int) { + i, j, k := m-1, n-1, m+n-1 + + for i >= 0 && j >= 0 { + if nums1[i] > nums2[j] { + nums1[k] = nums1[i] + k, i = k-1, i-1 + } else { + nums1[k] = nums2[j] + k, j = k-1, j-1 + } + } + for j >= 0 { + nums1[k] = nums2[j] + k, j = k-1, j-1 + } +} diff --git a/Easy/L905.go b/Easy/L905.go new file mode 100644 index 0000000..2f93232 --- /dev/null +++ b/Easy/L905.go @@ -0,0 +1,25 @@ +package Easy + +func sortArrayByParity(nums []int) []int { + ret := make([]int, len(nums)) + if len(nums) == 0 { + return ret + } + + i, j := 0, len(nums)-1 + for _, n := range nums { + if isOdd(n) { + ret[j] = n + j-- + } else { + ret[i] = n + i++ + } + } + + return ret +} + +func isOdd(n int) bool { + return n%2 > 0 +} diff --git a/Easy/L922.go b/Easy/L922.go new file mode 100644 index 0000000..10d014e --- /dev/null +++ b/Easy/L922.go @@ -0,0 +1,20 @@ +package Easy + +func sortArrayByParityII(nums []int) []int { + i, j, n := 0, 1, len(nums) + + for i < n && j < n { + for i < n && nums[i]%2 == 0 { + i += 2 + } + for j < n && nums[j]%2 == 1 { + j += 2 + } + if i < n && j < n { + // swap + nums[i], nums[j] = nums[j], nums[i] + } + } + + return nums +} diff --git a/Easy/L929.go b/Easy/L929.go new file mode 100644 index 0000000..15263ba --- /dev/null +++ b/Easy/L929.go @@ -0,0 +1,29 @@ +package Easy + +func numUniqueEmails(emails []string) int { + mp := make(map[string]bool) + + for _, s := range emails { + mp[cleanStrings(s)] = true + } + + return len(mp) +} + +func cleanStrings(s string) string { + arr := strings.Split(s, "@") + var sb strings.Builder + + for _, c := range arr[0] { + if c == '.' { + continue + } else if c == '+' { + break + } else { + sb.WriteByte(byte(c)) + } + } + sb.WriteString(fmt.Sprintf("@%s", arr[1])) + + return sb.String() +} diff --git a/Easy/L938.go b/Easy/L938.go new file mode 100644 index 0000000..ff3fc7e --- /dev/null +++ b/Easy/L938.go @@ -0,0 +1,20 @@ +package Easy + +func rangeSumBST(root *TreeNode, low int, high int) int { + if root == nil { + return 0 + } + + sum := 0 + if root.Val > low { + sum += rangeSumBST(root.Left, low, high) + } + if root.Val < high { + sum += rangeSumBST(root.Right, low, high) + } + if root.Val >= low && root.Val <= high { + sum += root.Val + } + + return sum +} 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/Easy/L941.go b/Easy/L941.go new file mode 100644 index 0000000..752d31b --- /dev/null +++ b/Easy/L941.go @@ -0,0 +1,20 @@ +package Easy + +func validMountainArray(arr []int) bool { + if len(arr) < 3 { + return false + } + + start, end := 0, len(arr)-1 + for start < end { + if arr[start+1] > arr[start] { + start++ + } else if arr[end-1] > arr[end] { + end-- + } else { + break + } + } + + return start != 0 && end != len(arr)-1 && start == end +} diff --git a/Easy/L976.go b/Easy/L976.go new file mode 100644 index 0000000..31ddd1d --- /dev/null +++ b/Easy/L976.go @@ -0,0 +1,15 @@ +package Easy + +func largestPerimeter(nums []int) int { + sort.Ints(nums) + + for i := len(nums) - 1; i >= 0; i-- { + perimeter := nums[i] + nums[i-1] + nums[i-2] + + if nums[i] < nums[i-1]+nums[i-2] { + return perimeter + } + } + + return 0 +} diff --git a/Easy/L977.go b/Easy/L977.go new file mode 100644 index 0000000..f7d4d0c --- /dev/null +++ b/Easy/L977.go @@ -0,0 +1,29 @@ +package Easy + +func sortedSquares(nums []int) []int { + ret := make([]int, len(nums)) + if len(nums) == 0 { + return ret + } + + i, j := 0, len(nums)-1 + for idx := len(nums) - 1; idx >= 0; idx-- { + if abs(nums[i]) > abs(nums[j]) { + ret[idx] = nums[i] * nums[i] + i++ + } else { + ret[idx] = nums[j] * nums[j] + j-- + } + } + + return ret +} + +func abs(n int) int { + if n < 0 { + return -n + } + + return n +} diff --git a/Easy/L989.go b/Easy/L989.go new file mode 100644 index 0000000..6cd9113 --- /dev/null +++ b/Easy/L989.go @@ -0,0 +1,17 @@ +package Easy + +func addToArrayForm(num []int, k int) []int { + var res []int + + for i := len(num) - 1; i >= 0; i-- { + res = append([]int{(num[i] + k) % 10}, res...) + k = (num[i] + k) / 10 + } + + for k > 0 { + res = append([]int{k % 10}, res...) + k /= 10 + } + + return res +} diff --git a/Easy/L993.go b/Easy/L993.go index e9f529f..6c175e4 100644 --- a/Easy/L993.go +++ b/Easy/L993.go @@ -5,8 +5,8 @@ func isCousins(root *TreeNode, x int, y int) bool { return false } - q := make([]*TreeNode, 1, 10) - q[0] = root + var q []*TreeNode + q = append(q, root) var xExist, yExist bool for len(q) > 0 { diff --git a/Easy/L997.go b/Easy/L997.go new file mode 100644 index 0000000..14cf9a2 --- /dev/null +++ b/Easy/L997.go @@ -0,0 +1,26 @@ +package Easy + +var exists struct{} + +func findJudge(n int, trust [][]int) int { + mp, inDegree := make(map[int]struct{}), make([]int, n+1) + + for i := 1; i <= n; i++ { + mp[i] = exists + } + + for _, t := range trust { + delete(mp, t[0]) + inDegree[t[1]]++ + } + + if len(mp) == 1 { + for k, _ := range mp { + if inDegree[k] == n-1 { + return k + } + } + } + + return -1 +} diff --git a/Hard.md b/Hard.md new file mode 100644 index 0000000..8d0115c --- /dev/null +++ b/Hard.md @@ -0,0 +1,85 @@ +## Hard +|LC #|Description| +|:-:|:-| +|[354](https://leetcode.com/problems/russian-doll-envelopes/)| Russian Doll Envelopes| +|[936](https://leetcode.com/problems/stamping-the-sequence/)| Stamping The Sequence| +|[32](https://leetcode.com/problems/longest-valid-parentheses/)| Longest Valid Parentheses| +|[1559](https://leetcode.com/problems/detect-cycles-in-2d-grid/)| Detect Cycles in 2D Grid| +|[329](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/)| Longest Increasing Path in a Matrix| +|[1192](https://leetcode.com/problems/critical-connections-in-a-network/)| Critical Connections in a Network| +|[980](https://leetcode.com/problems/unique-paths-iii/)| Unique Paths III| +|[745](https://leetcode.com/problems/prefix-and-suffix-search/)| Prefix and Suffix Search| +|[630](https://leetcode.com/problems/course-schedule-iii/)| Course Schedule III| +|[65](https://leetcode.com/problems/valid-number/)| Valid Number| +|[968](https://leetcode.com/problems/binary-tree-cameras/)| Binary Tree Cameras| +|[1473](https://leetcode.com/problems/paint-house-iii/)| Paint House III| +|[51](https://leetcode.com/problems/n-queens/)| N-Queens| +|[52](https://leetcode.com/problems/n-queens-ii/)| N-Queens II| +|[778](https://leetcode.com/problems/swim-in-rising-water/)| Swim in Rising Water| +|[315](https://leetcode.com/problems/count-of-smaller-numbers-after-self/)| Count of Smaller Numbers After Self| +|[135](https://leetcode.com/problems/candy/)| Candy| +|[927](https://leetcode.com/problems/three-equal-parts/)| Three Equal Parts| +|[25](https://leetcode.com/problems/reverse-nodes-in-k-group/)| Reverse Nodes in k-Group| +|[233](https://leetcode.com/problems/number-of-digit-one/)| Number of Digit One| +|[42](https://leetcode.com/problems/trapping-rain-water/)| Trapping Rain Water| +|[132](https://leetcode.com/problems/palindrome-partitioning-ii/)| Palindrome Partitioning II| +|[546](https://leetcode.com/problems/remove-boxes/)| Remove Boxes| +|[37](https://leetcode.com/problems/sudoku-solver/)| Sudoku Solver| +|[850](https://leetcode.com/problems/rectangle-area-ii/)| Rectangle Area II| +|[330](https://leetcode.com/problems/patching-array//)| Patching Array| +|[899](https://leetcode.com/problems/orderly-queue/)| Orderly Queue| +|[224](https://leetcode.com/problems/basic-calculator/)| Basic Calculator| +|[782](https://leetcode.com/problems/transform-to-chessboard/)| Transform to Chessboard| +|[174](https://leetcode.com/problems/dungeon-game/)| Dungeon Game| +|[123](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/)| Best Time to Buy and Sell Stock III| +|[154](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/)| Find Minimum in Rotated Sorted Array II| +|[668](https://leetcode.com/problems/kth-smallest-number-in-multiplication-table/)| Kth Smallest Number in Multiplication Table| +|[952](https://leetcode.com/problems/largest-component-size-by-common-factor/)| Largest Component Size by Common Factor| +|[85](https://leetcode.com/problems/maximal-rectangle/)| Maximal Rectangle| +|[1032](https://leetcode.com/problems/stream-of-characters/)| Stream of Characters| +|[878](https://leetcode.com/problems/nth-magical-number/)| Nth Magical Number| +|[902](https://leetcode.com/problems/numbers-at-most-n-given-digit-set/)| Numbers At Most N Given Digit Set| +|[1463](https://leetcode.com/problems/cherry-pickup-ii/)| Cherry Pickup II| +|[1345](https://leetcode.com/problems/jump-game-iv/)| Jump Game IV| +|[1510](https://leetcode.com/problems/stone-game-iv/)| Stone Game IV| +|[127](https://leetcode.com/problems/word-ladder/)| Word Ladder| +|[410](https://leetcode.com/problems/split-array-largest-sum/)| Split Array Largest Sum| +|[629](https://leetcode.com/problems/k-inverse-pairs-array/)| K Inverse Pairs Array| +|[1074](https://leetcode.com/problems/number-of-submatrices-that-sum-to-target/)| Number of Submatrices That Sum to Target| +|[1531](https://leetcode.com/problems/string-compression-ii/)| String Compression II| +|[1335](https://leetcode.com/problems/minimum-difficulty-of-a-job-schedule/)| Minimum Difficulty of a Job Schedule| +|[76](https://leetcode.com/problems/minimum-window-substring/)| Minimum Window Substring| +|[2136](https://leetcode.com/problems/earliest-possible-day-of-full-bloom/)| Earliest Possible Day of Full Bloom| +|[2193](https://leetcode.com/problems/minimum-number-of-moves-to-make-palindrome/)| Minimum Number of Moves to Make Palindrome| +|[1235](https://leetcode.com/problems/maximum-profit-in-job-scheduling/)| Maximum Profit in Job Scheduling| +|[446](https://leetcode.com/problems/arithmetic-slices-ii-subsequence/)| Arithmetic Slices II - Subsequence| +|[124](https://leetcode.com/problems/binary-tree-maximum-path-sum/)| Binary Tree Maximum Path Sum| +|[600](https://leetcode.com/problems/non-negative-integers-without-consecutive-ones/)| Non-negative Integers without Consecutive Ones| +|[72](https://leetcode.com/problems/edit-distance/)| Edit Distance| +|[1340](https://leetcode.com/problems/jump-game-v/)| Jump Game V| +|[403](https://leetcode.com/problems/frog-jump/)| Frog Jump| +|[188](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/)| Best Time to Buy and Sell Stock IV| +|[149](https://leetcode.com/problems/max-points-on-a-line/)| Max Points on a Line| +|[140](https://leetcode.com/problems/word-break-ii/)| Word Break II| +|[1289](https://leetcode.com/problems/minimum-falling-path-sum-ii/)| Minimum Falling Path Sum II| +|[2246](https://leetcode.com/problems/longest-path-with-different-adjacent-characters/)| Longest Path With Different Adjacent Characters| +|[2421](https://leetcode.com/problems/number-of-good-paths/)| Number of Good Paths| +|[472](https://leetcode.com/problems/concatenated-words/)| Concatenated Words| +|[2444](https://leetcode.com/problems/count-subarrays-with-fixed-bounds/)| Count Subarrays With Fixed Bounds| +|[23](https://leetcode.com/problems/merge-k-sorted-lists/)| Merge k Sorted Lists| +|[2360](https://leetcode.com/problems/longest-cycle-in-a-graph/)| Longest Cycle in a Graph| +|[1402](https://leetcode.com/problems/reducing-dishes/)| Reducing Dishes| +|[87](https://leetcode.com/problems/scramble-string/)| Scramble String| +|[1857](https://leetcode.com/problems/largest-color-value-in-a-directed-graph/)| Largest Color Value in a Directed Graph| +|[879](https://leetcode.com/problems/profitable-schemes/)| Profitable Schemes| +|[839](https://leetcode.com/problems/similar-string-groups/)| Similar String Groups| +|[2551](https://leetcode.com/problems/put-marbles-in-bags/)| Put Marbles in Bags| +|[2141](https://leetcode.com/problems/maximum-running-time-of-n-computers/)| Maximum Running Time of N Computers| +|[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/L1032.go b/Hard/L1032.go new file mode 100644 index 0000000..1c1dbe2 --- /dev/null +++ b/Hard/L1032.go @@ -0,0 +1,66 @@ +package Hard + +type TrieNode struct { + children map[byte]*TrieNode + word bool +} + +func NewTrieNode() *TrieNode { + return &TrieNode{ + children: make(map[byte]*TrieNode), + word: false, + } +} + +type StreamChecker struct { + trie *TrieNode + stream []byte +} + +func Constructor(words []string) StreamChecker { + sc := StreamChecker{ + trie: NewTrieNode(), + stream: make([]byte, 0), + } + + for _, w := range words { + node := sc.trie + reversedWord := reverse(w) + for _, c := range reversedWord { + if _, ok := node.children[c]; !ok { + node.children[c] = NewTrieNode() + } + node = node.children[c] + } + node.word = true + } + + return sc +} + +func (this *StreamChecker) Query(letter byte) bool { + this.stream = append([]byte{letter}, this.stream...) + + node := this.trie + for _, c := range this.stream { + if node.word { + return true + } + if _, ok := node.children[c]; !ok { + return false + } + node = node.children[c] + } + + return node.word +} + +func reverse(s string) []byte { + ret := []byte(s) + + for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 { + ret[i], ret[j] = ret[j], ret[i] + } + + return ret +} diff --git a/Hard/L1074.go b/Hard/L1074.go new file mode 100644 index 0000000..b9f9ddf --- /dev/null +++ b/Hard/L1074.go @@ -0,0 +1,32 @@ +package Hard + +func numSubmatrixSumTarget(matrix [][]int, target int) int { + res, m, n := 0, len(matrix), len(matrix[0]) + + for i := 0; i < m; i++ { + for j := 1; j < n; j++ { + matrix[i][j] += matrix[i][j-1] + } + } + + for i := 0; i < n; i++ { + for j := i; j < n; j++ { + mp := make(map[int]int) + mp[0] = 1 + cur := 0 + for k := 0; k < m; k++ { + if i > 0 { + cur += matrix[k][j] - matrix[k][i - 1] + } else { + cur += matrix[k][j] + } + if v, ok := mp[cur - target]; ok { + res += v + } + mp[cur]++ + } + } + } + + return res +} diff --git a/Hard/L123.go b/Hard/L123.go new file mode 100644 index 0000000..a193852 --- /dev/null +++ b/Hard/L123.go @@ -0,0 +1,36 @@ +package Hard + +func maxProfit(prices []int) int { + return solve(prices, 0, 2, 0, make(map[string]int)) +} + +func solve(prices []int, i, k, buyOrSell int, dp map[string]int) int { + if i >= len(prices) || k == 0 { + return 0 + } + key := fmt.Sprintf("%d#%d#%d", i, buyOrSell, k) + if val, ok := dp[key]; ok { + return val + } + res := 0 + if buyOrSell == 0 { + buy := solve(prices, i+1, k, 1, dp) - prices[i] + noBuy := solve(prices, i+1, k, 0, dp) + res += max(buy, noBuy) + } else { + sell := solve(prices, i+1, k-1, 0, dp) + prices[i] + noSell := solve(prices, i+1, k, 1, dp) + res += max(sell, noSell) + } + + dp[key] = res + return res +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Hard/L1235.go b/Hard/L1235.go new file mode 100644 index 0000000..e4f271e --- /dev/null +++ b/Hard/L1235.go @@ -0,0 +1,57 @@ +package Hard + +func jobScheduling(startTime []int, endTime []int, profit []int) int { + memo := make(map[int]int) + jobs := make([][]int, len(startTime)) + for i := 0; i < len(startTime); i++ { + jobs[i] = []int{startTime[i], endTime[i], profit[i]} + } + sort.Slice(jobs, func(i, j int) bool { + return jobs[i][0] < jobs[j][0] + }) + + return dfs(0, jobs, memo) +} + +func dfs(cur int, jobs [][]int, mp map[int]int) int { + if cur == len(jobs) { + return 0 + } + + if v, ok := mp[cur]; ok { + return v + } + + next := findNext(cur, jobs) + inclProf := jobs[cur][2] + if next != -1 { + inclProf += dfs(next, jobs, mp) + } + exclProf := dfs(cur+1, jobs, mp) + + max := inclProf + if exclProf > inclProf { + max = exclProf + } + + mp[cur] = max + return max +} + +func findNext(cur int, jobs [][]int) int { + lo, hi := cur+1, len(jobs)-1 + for lo <= hi { + mid := lo + (hi-lo)/2 + if jobs[mid][0] >= jobs[cur][1] { + if jobs[mid-1][0] >= jobs[cur][1] { + hi = mid - 1 + } else { + return mid + } + } else { + lo = mid + 1 + } + } + + return -1 +} diff --git a/Hard/L124.go b/Hard/L124.go new file mode 100644 index 0000000..43c5ee5 --- /dev/null +++ b/Hard/L124.go @@ -0,0 +1,29 @@ +package Hard + +func maxPathSum(root *TreeNode) int { + maxi := math.MinInt32 + + solve(root, &maxi) + + return maxi +} + +func solve(root *TreeNode, maximum *int) int { + if root == nil { + return 0 + } + + left, right := max(solve(root.Left, maximum), 0), max(solve(root.Right, maximum), 0) + + *maximum = max(*maximum, root.Val+right+left) + + return root.Val + max(left, right) +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Hard/L127.go b/Hard/L127.go new file mode 100644 index 0000000..2938821 --- /dev/null +++ b/Hard/L127.go @@ -0,0 +1,52 @@ +package Hard + +var exists struct{} + +func ladderLength(beginWord string, endWord string, wordList []string) int { + beginSet, endSet, visited, dict := make(map[string]struct{}), make(map[string]struct{}), make(map[string]struct{}), make(map[string]struct{}) + + for _, w := range wordList { + dict[w] = exists + } + + if _, ok := dict[endWord]; !ok { + return 0 + } + + beginSet[beginWord], endSet[endWord] = exists, exists + length := 1 + + for len(beginSet) > 0 && len(endSet) > 0 { + if len(beginSet) > len(endSet) { + beginSet, endSet = endSet, beginSet + } + + tmp := make(map[string]struct{}) + for s, _ := range beginSet { + word := []byte(s) + for i := 0; i < len(word); i++ { + orig := word[i] + for ch := 'a'; ch <= 'z'; ch++ { + if byte(ch) == orig { + continue + } + word[i] = byte(ch) + target := string(word) + if _, ok := endSet[target]; ok { + return length + 1 + } + if _, ok := visited[target]; !ok { + if _, contains := dict[target]; contains { + visited[target] = exists + tmp[target] = exists + } + } + word[i] = orig + } + } + } + length, beginSet = length+1, tmp + } + + return 0 +} diff --git a/Hard/L1289.go b/Hard/L1289.go new file mode 100644 index 0000000..c446aa1 --- /dev/null +++ b/Hard/L1289.go @@ -0,0 +1,50 @@ +package Hard + +func minFallingPathSum(grid [][]int) int { + n, mp, res := len(grid), make([][]int, len(grid)), math.MaxInt32 + if n == 1 { + return grid[0][0] + } + + for i := 0; i < n; i++ { + mp[i] = make([]int, n) + for j := 0; j < n; j++ { + mp[i][j] = -1 + } + } + + for i := 0; i < n; i++ { + res = min(res, solve(0, i, grid, &mp)) + } + + return res +} + +func solve(r, c int, grid [][]int, mp *[][]int) int { + if r == len(grid) { + return 0 + } + + if (*mp)[r][c] != -1 { + return (*mp)[r][c] + } + + res := math.MaxInt32 + for k := 0; k < len(grid[0]); k++ { + if c == k { + continue + } + res = min(res, grid[r][c]+solve(r+1, k, grid, mp)) + } + + (*mp)[r][c] = res + return (*mp)[r][c] +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Hard/L132.go b/Hard/L132.go new file mode 100644 index 0000000..e808ada --- /dev/null +++ b/Hard/L132.go @@ -0,0 +1,28 @@ +package Hard + +func minCut(s string) int { + cut, n := make([]int, len(s)), len(s) + pal := make([][]bool, n*n) + for i := 0; i < n; i++ { + pal[i] = make([]bool, n) + } + + for i := 0; i < n; i++ { + min := i + for j := 0; j <= i; j++ { + if s[j] == s[i] && (j+1 > i-1 || pal[j+1][i-1]) { + pal[j][i] = true + if j == 0 { + min = 0 + } else { + if cut[j-1]+1 < min { + min = cut[j-1] + 1 + } + } + } + } + cut[i] = min + } + + return cut[n-1] +} diff --git a/Hard/L1335.go b/Hard/L1335.go new file mode 100644 index 0000000..43bf7d2 --- /dev/null +++ b/Hard/L1335.go @@ -0,0 +1,50 @@ +package Hard + +func minDifficulty(jobDifficulty []int, d int) int { + if d > len(jobDifficulty) { + return -1 + } + + m, n := d-1, len(jobDifficulty) + dp := make([][]int, m) + for i := 0; i < m; i++ { + dp[i] = make([]int, n) + for j := 0; j < n; j++ { + dp[i][j] = -1 + } + } + + return solve(jobDifficulty, d-1, 0, &dp) +} + +func solve(jobDifficulty []int, d, pos int, dp *[][]int) int { + if d == 0 { + max := jobDifficulty[pos] + for i := pos; i < len(jobDifficulty); i++ { + if jobDifficulty[i] > max { + max = jobDifficulty[i] + } + } + + return max + } + + day := len(*dp) - d + if (*dp)[day][pos] != -1 { + return (*dp)[day][pos] + } + + max, min := math.MinInt32, math.MaxInt32 + for i := pos; i < len(jobDifficulty)-d; i++ { + if jobDifficulty[i] > max { + max = jobDifficulty[i] + } + compute := solve(jobDifficulty, d-1, i+1, dp) + if max+compute < min { + min = max + compute + } + } + + (*dp)[day][pos] = min + return min +} diff --git a/Hard/L1340.go b/Hard/L1340.go new file mode 100644 index 0000000..042cb21 --- /dev/null +++ b/Hard/L1340.go @@ -0,0 +1,44 @@ +package Hard + +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 +} + +func maxJumps(arr []int, d int) int { + n, mp, res := len(arr), make(map[int]int), 1 + + for i := 0; i < n; i++ { + res = max(res, solve(arr, mp, n, d, i)) + } + + return res +} + +func solve(arr []int, mp map[int]int, n, d, idx int) int { + if v, ok := mp[idx]; ok { + return v + } + + res := 1 + for j := idx + 1; j <= min(idx + d, n - 1) && arr[j] < arr[idx]; j++ { + res = max(res, 1 + solve(arr, mp, n, d, j)) + } + for j := idx - 1; j >= max(idx - d, 0) && arr[j] < arr[idx]; j-- { + res = max(res, 1 + solve(arr, mp, n, d, j)) + } + + mp[idx] = res + return mp[idx] +} diff --git a/Hard/L1345.go b/Hard/L1345.go new file mode 100644 index 0000000..d5d6347 --- /dev/null +++ b/Hard/L1345.go @@ -0,0 +1,57 @@ +package Hard + +var exists struct{} + +func minJumps(arr []int) int { + if len(arr) <= 1 { + return 0 + } + + mp := make(map[int][]int) + for i := range arr { + if _, ok := mp[arr[i]]; !ok { + mp[arr[i]] = make([]int, 0) + } + mp[arr[i]] = append(mp[arr[i]], i) + } + visited := make(map[int]struct{}) + var q []int + q = append(q, 0) + visited[0] = exists + cnt := 0 + + for len(q) > 0 { + size := len(q) + for i := 0; i < size; i++ { + n := q[0] + q = q[1:] + if n == len(arr)-1 { + return cnt + } + if n > 0 { + if _, ok := visited[n-1]; !ok { + visited[n-1] = exists + q = append(q, n-1) + } + } + if n < len(arr)-1 { + if _, ok := visited[n+1]; !ok { + visited[n+1] = exists + q = append(q, n+1) + } + } + if _, ok := mp[arr[n]]; ok { + for _, v := range mp[arr[n]] { + if _, present := visited[v]; !present { + visited[v] = exists + q = append(q, v) + } + } + delete(mp, arr[n]) + } + } + cnt++ + } + + return -1 +} diff --git a/Hard/L135.go b/Hard/L135.go new file mode 100644 index 0000000..e0b6ed1 --- /dev/null +++ b/Hard/L135.go @@ -0,0 +1,33 @@ +package Hard + +func candy(ratings []int) int { + candies := make([]int, len(ratings)) + for i := range candies { + candies[i] = 1 + } + + for i := range candies { + if i == 0 { + continue + } + + if ratings[i] > ratings[i-1] { + candies[i] = candies[i-1] + 1 + } + } + + for i := len(candies) - 2; i >= 0; i-- { + if ratings[i] > ratings[i+1] { + if candies[i+1]+1 > candies[i] { + candies[i] = candies[i+1] + 1 + } + } + } + + sum := 0 + for _, c := range candies { + sum += c + } + + return sum +} diff --git a/Hard/L1359.go b/Hard/L1359.go new file mode 100644 index 0000000..d14337a --- /dev/null +++ b/Hard/L1359.go @@ -0,0 +1,50 @@ +package Hard + +func countOrders(n int) int { + dp := make([][]int64, 501) + for i := 0; i < 501; i++ { + dp[i] = make([]int64, 501) + for j := 0; j < 501; j++ { + dp[i][j] = -1 + } + } + + return int(solve(n, n, &dp)) +} + +func solve(pick, del int, dp *[][]int64) int64 { + if del < 0 || pick < 0 { + //base case as it can't be negative + return 0 + } + + if del < pick { + // condition to insure we are first picking then delivering + return 0 + } + + if pick == 0 && del == 0 { + //everything finishes return 1 + return 1 + } + + if (*dp)[pick][del] != -1 { + //memoization + return (*dp)[pick][del] + } + + var ans int64 + mod := 1000000007 + + // if there are pick number of orders we have [pick]C1 = pick number of choices for selecting and we have picked one so we do pick-1 + ans += int64(pick) * solve(pick-1, del, dp) + ans %= int64(mod) + + // delivering : the number of items we have picked but not delivered is (del-pick) so we can select one item from these to deliver [del-pick]C1 =del-pick and we have delivered so del-1 + ans += int64(del-pick) * solve(pick, del-1, dp) + ans %= int64(mod) + + (*dp)[pick][del] = ans + + return (*dp)[pick][del] +} diff --git a/Hard/L140.go b/Hard/L140.go new file mode 100644 index 0000000..b36776e --- /dev/null +++ b/Hard/L140.go @@ -0,0 +1,42 @@ +package Hard + +var exists struct{} + +func wordBreak(s string, wordDict []string) []string { + mp, st := make(map[int][]string), make(map[string]struct{}) + + for _, w := range wordDict { + st[w] = exists + } + + return solve(s, 0, st, mp) +} + +func solve(s string, start int, st map[string]struct{}, mp map[int][]string) []string { + if v, ok := mp[start]; ok { + return v + } + + var res []string + if start == len(s) { + res = append(res, "") + return res + } + + curr := s[start:] + for w, _ := range st { + if strings.HasPrefix(curr, w) { + subLst := solve(s, start+len(w), st, mp) + for _, sub := range subLst { + if len(sub) == 0 { + res = append(res, w+"") + } else { + res = append(res, w+" "+sub) + } + } + } + } + + mp[start] = res + return mp[start] +} diff --git a/Hard/L1402.go b/Hard/L1402.go new file mode 100644 index 0000000..65fd78d --- /dev/null +++ b/Hard/L1402.go @@ -0,0 +1,34 @@ +package Hard + +func maxSatisfaction(satisfaction []int) int { + sort.Ints(satisfaction) + mp := make(map[string]int) + var solve func(idx, time int) int + + solve = func(idx, time int) int { + if idx == len(satisfaction) { + return 0 + } + + key := fmt.Sprintf("%d-%d", idx, time) + if v, ok := mp[key]; ok { + return v + } + + includeDish := (satisfaction[idx] * (time + 1)) + solve(idx+1, time+1) + excludeDish := solve(idx+1, time) + + mp[key] = max(includeDish, excludeDish) + return mp[key] + } + + return solve(0, 0) +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} 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/L1463.go b/Hard/L1463.go new file mode 100644 index 0000000..a16a5e2 --- /dev/null +++ b/Hard/L1463.go @@ -0,0 +1,51 @@ +package Hard + +func cherryPickup(grid [][]int) int { + m, n := len(grid), len(grid[0]) + dp := make([][][]int, m) + + for i := 0; i < m; i++ { + dp[i] = make([][]int, n) + for j := 0; j < n; j++ { + dp[i][j] = make([]int, n) + for k := 0; k < n; k++ { + dp[i][j][k] = -1 + } + } + } + + return dfs(grid, m, n, 0, 0, n-1, &dp) +} + +func dfs(grid [][]int, m, n, r, c1, c2 int, dp *[][][]int) int { + if r == m { + return 0 + } + + if (*dp)[r][c1][c2] != -1 { + return (*dp)[r][c1][c2] + } + + ans := 0 + for i := -1; i <= 1; i++ { + for j := -1; j <= 1; j++ { + nc1, nc2 := c1+i, c2+j + if nc1 >= 0 && nc1 < n && nc2 >= 0 && nc2 < n { + val := dfs(grid, m, n, r+1, nc1, nc2, dp) + if val > ans { + ans = val + } + } + } + } + + cherries := 0 + if c1 == c2 { + cherries = grid[r][c1] + } else { + cherries = grid[r][c1] + grid[r][c2] + } + + (*dp)[r][c1][c2] = ans + cherries + return (*dp)[r][c1][c2] +} diff --git a/Hard/L149.go b/Hard/L149.go new file mode 100644 index 0000000..89d257b --- /dev/null +++ b/Hard/L149.go @@ -0,0 +1,47 @@ +package Hard + +func maxPoints(points [][]int) int { + if len(points) == 0 { + return 0 + } + + res := 0 + for i := 0; i < len(points); i++ { + mp, dup, maxi := make(map[string]int), 0, 0 + for j := i + 1; j < len(points); j++ { + deltaX := points[j][0] - points[i][0] + deltaY := points[j][1] - points[i][1] + + if deltaX == 0 && deltaY == 0 { + dup++ + continue + } + + gcd := greatestCommonDiv(deltaX, deltaY) + dX, dY := deltaX / gcd, deltaY / gcd + + key := fmt.Sprintf("%d-%d", dX, dY) + mp[key]++ + maxi = max(maxi, mp[key]) + } + res = max(res, maxi + dup + 1) + } + + return res +} + +func greatestCommonDiv(a, b int) int { + if b == 0 { + return a + } + + return greatestCommonDiv(b, a % b) +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Hard/L1510.go b/Hard/L1510.go new file mode 100644 index 0000000..72ca39f --- /dev/null +++ b/Hard/L1510.go @@ -0,0 +1,25 @@ +package Hard + +func winnerSquareGame(n int) bool { + return solve(n, make(map[int]bool)) +} + +func solve(n int, mp map[int]bool) bool { + if n == 0 { + return false + } + + if v, ok := mp[n]; ok { + return v + } + + res := false + for i := 1; i*i <= n; i++ { + if !solve(n-i*i, mp) { + res = true + break + } + } + mp[n] = res + return res +} diff --git a/Hard/L1531.go b/Hard/L1531.go new file mode 100644 index 0000000..d0b27d0 --- /dev/null +++ b/Hard/L1531.go @@ -0,0 +1,66 @@ +package Hard + +func getLengthOfOptimalCompression(s string, k int) int { + m, n := len(s), k+1 + dp := make([][]int, m) + for i := 0; i < m; i++ { + dp[i] = make([]int, n) + for j := 0; j < n; j++ { + dp[i][j] = -1 + } + } + + return solve(s, 0, k, &dp) +} + +func solve(s string, currIdx, rest int, dp *[][]int) int { + if currIdx == len(s) || len(s)-currIdx <= rest { + return 0 + } + + if (*dp)[currIdx][rest] != -1 { + return (*dp)[currIdx][rest] + } + + free := make([]int, 26) + most, res := 0, math.MaxInt32 + + for i := currIdx; i < len(s); i++ { + idx := s[i] - 'a' + free[idx]++ + + if most < free[idx] { + most = free[idx] + } + if rest >= i-currIdx+1-most { + res = min(res, getLen(most)+1+solve(s, i+1, rest-(i-currIdx+1-most), dp)) + } + } + + (*dp)[currIdx][rest] = res + return res +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} + +func getLen(most int) int { + if most == 1 { + return 0 + } + + if most < 10 { + return 1 + } + + if most < 99 { + return 2 + } + + return 3 +} diff --git a/Hard/L154.go b/Hard/L154.go new file mode 100644 index 0000000..d00947e --- /dev/null +++ b/Hard/L154.go @@ -0,0 +1,19 @@ +package Hard + +func findMin(nums []int) int { + lo, hi, mid := 0, len(nums)-1, 0 + + for lo < hi { + mid = lo + (hi-lo)/2 + + if nums[mid] > nums[hi] { + lo = mid + 1 + } else if nums[mid] < nums[hi] { + hi = mid + } else { + hi-- + } + } + + return nums[lo] +} 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/L174.go b/Hard/L174.go new file mode 100644 index 0000000..ac38c07 --- /dev/null +++ b/Hard/L174.go @@ -0,0 +1,51 @@ +package Hard + +func calculateMinimumHP(dungeon [][]int) int { + m, n := len(dungeon), len(dungeon[0]) + dp := make([][]int, m) + for i := 0; i < m; i++ { + dp[i] = make([]int, n) + for j := 0; j < n; j++ { + dp[i][j] = math.MaxInt64 + } + } + + return solve(dungeon, 0, 0, &dp) +} + +func solve(mat [][]int, i, j int, dp *[][]int) int { + m, n := len(mat), len(mat[0]) + + if i == m || j == n { + return math.MaxInt64 + } + if i == m-1 && j == n-1 { + if mat[i][j] < 0 { + return -mat[i][j] + 1 + } else { + return 1 + } + } + + if (*dp)[i][j] != math.MaxInt64 { + return (*dp)[i][j] + } + + right, down := solve(mat, i, j+1, dp), solve(mat, i+1, j, dp) + minHpReq := min(right, down) - mat[i][j] + + (*dp)[i][j] = 1 + if minHpReq > 0 { + (*dp)[i][j] = minHpReq + } + + return (*dp)[i][j] +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} 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/L1857.go b/Hard/L1857.go new file mode 100644 index 0000000..cdbdf73 --- /dev/null +++ b/Hard/L1857.go @@ -0,0 +1,76 @@ +package Hard + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func largestPathValue(colors string, edges [][]int) int { + var graph [][]int + n, inDegree := len(colors), make([]int, len(colors)) + + for i := 0; i < n; i++ { + graph = append(graph, make([]int, 0)) + } + for _, e := range edges { + u, v := e[0], e[1] + inDegree[v]++ + graph[u] = append(graph[u], v) + } + + mp := make([][]int, n) + for i := 0; i < n; i++ { + mp[i] = make([]int, 26) + } + + var q []int + for i := 0; i < n; i++ { + if inDegree[i] == 0 { + q = append(q, i) + mp[i][colors[i]-'a'] = 1 + } + } + + getMax := func(nums []int) int { + maxi := math.MinInt32 + + for _, n := range nums { + maxi = max(maxi, n) + } + + return maxi + } + + var res, seen int + for len(q) > 0 { + node := q[0] + q = q[1:] + seen++ + + res = max(res, getMax(mp[node])) + + for _, nei := range graph[node] { + for i := 0; i < 26; i++ { + val := mp[node][i] + if int(colors[nei]-'a') == i { + val++ + } + mp[nei][i] = max(mp[nei][i], val) + } + inDegree[nei]-- + + if inDegree[nei] == 0 { + q = append(q, nei) + } + } + } + + if seen == n { + return res + } + + return -1 +} diff --git a/Hard/L188.go b/Hard/L188.go new file mode 100644 index 0000000..19d78a4 --- /dev/null +++ b/Hard/L188.go @@ -0,0 +1,34 @@ +package Hard + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func maxProfit(k int, prices []int) int { + mp := make(map[string]int) + + return solve(prices, mp, 0, k, true) +} + +func solve(prices []int, mp map[string]int, idx, k int, buy bool) int { + if idx >= len(prices) || k <= 0 { + return 0 + } + + key := fmt.Sprintf("%d-%d-%d", idx, buy, k) + if v, ok := mp[key]; ok { + return v + } + + if buy { + mp[key] = max(-prices[idx]+solve(prices, mp, idx+1, k, !buy), solve(prices, mp, idx+1, k, buy)) + } else { + mp[key] = max(prices[idx]+solve(prices, mp, idx+1, k-1, !buy), solve(prices, mp, idx+1, k, buy)) + } + + return mp[key] +} diff --git a/Hard/L2136.go b/Hard/L2136.go new file mode 100644 index 0000000..d3b6e85 --- /dev/null +++ b/Hard/L2136.go @@ -0,0 +1,24 @@ +package Hard + +func earliestFullBloom(plantTime []int, growTime []int) int { + n := len(plantTime) + pairs := make([][]int, n) + for i := 0; i < n; i++ { + pairs[i] = make([]int, 2) + pairs[i][0], pairs[i][1] = plantTime[i], growTime[i] + } + + sort.Slice(pairs, func(i, j int) bool { + return pairs[j][1] > pairs[i][1] + }) + + plantingDays, totalDays := 0, 0 + for _, p := range pairs { + if plantingDays+p[0]+p[1] > totalDays { + totalDays = plantingDays + p[0] + p[1] + } + plantingDays += p[0] + } + + return totalDays +} diff --git a/Hard/L2141.go b/Hard/L2141.go new file mode 100644 index 0000000..ea4f548 --- /dev/null +++ b/Hard/L2141.go @@ -0,0 +1,47 @@ +package Hard + +func maxRunTime(n int, batteries []int) int64 { + var ( + canFit func(k int64) bool + lower, upper, res, batSum int64 + ) + + for _, b := range batteries { + batSum += int64(b) + } + lower, upper, res = 0, batSum/int64(n), -1 + + canFit = func(k int64) bool { + var ( + currBatSum, target int64 + ) + + target = int64(n) * k + for _, b := range batteries { + if int64(b) < k { + currBatSum += int64(b) + } else { + currBatSum += k + } + + if currBatSum >= target { + return true + } + } + + return currBatSum >= target + } + + for lower <= upper { + var mid int64 + mid = lower + (upper - lower) / 2 + + if canFit(mid) { + res, lower = mid, mid + 1 + } else { + upper = mid - 1 + } + } + + return res +} diff --git a/Hard/L2193.go b/Hard/L2193.go new file mode 100644 index 0000000..4190668 --- /dev/null +++ b/Hard/L2193.go @@ -0,0 +1,42 @@ +package Hard + +func minMovesToMakePalindrome(s string) int { + l, r, k, cnt := 0, len(s)-1, len(s)-1, 0 + arr := []byte(s) + + for l < r { + if arr[l] == arr[r] { + l, r = l+1, r-1 + } else { + k = findKthIndexMatchingwithLthIndex(arr, l, r) + + if k == l { + if l+1 < len(s) { + arr[l], arr[l+1] = arr[l+1], arr[l] + } + cnt++ + } else { + for k < r { + if k+1 < len(s) { + arr[k], arr[k+1] = arr[k+1], arr[k] + } + cnt++ + k++ + } + l, r = l+1, r-1 + } + } + } + + return cnt +} + +func findKthIndexMatchingwithLthIndex(arr []byte, l, k int) int { + for k > l { + if arr[k] == arr[l] { + return k + } + k-- + } + return k +} diff --git a/Hard/L224.go b/Hard/L224.go new file mode 100644 index 0000000..5353dbd --- /dev/null +++ b/Hard/L224.go @@ -0,0 +1,32 @@ +package Hard + +func calculate(s string) int { + if len(s) == 0 { + return 0 + } + + result, sign, num := 0, 1, 0 + + var st []int + st = append(st, sign) + + for i := range s { + if s[i] >= '0' && s[i] <= '9' { + num = num*10 + int(s[i]-'0') + } else if s[i] == '+' || s[i] == '-' { + result += sign * num + sign = st[len(st)-1] + if s[i] != '+' { + sign *= -1 + } + num = 0 + } else if s[i] == '(' { + st = append(st, sign) + } else if s[i] == ')' { + st = st[:len(st)-1] + } + } + + result += sign * num + return result +} diff --git a/Hard/L2246.go b/Hard/L2246.go new file mode 100644 index 0000000..09fa6c2 --- /dev/null +++ b/Hard/L2246.go @@ -0,0 +1,47 @@ +package Hard + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func longestPath(parent []int, s string) int { + longstPathVal, mp := math.MinInt32, make(map[int][]int) + + for i := range parent { + mp[parent[i]] = append(mp[parent[i]], i) + } + + solve(0, parent, mp, s, &longstPathVal) + if longstPathVal == math.MinInt32 { + return 1 + } + + return longstPathVal +} + +func solve(node int, parent []int, mp map[int][]int, s string, longstPathVal *int) int { + if _, ok := mp[node]; !ok { + return 1 + } + maxi, secondMaxi := 0, 0 + + for _, nei := range mp[node] { + longestPathFromNei := solve(nei, parent, mp, s, longstPathVal) + if s[node] == s[nei] { + continue + } + if longestPathFromNei > maxi { + secondMaxi = maxi + maxi = longestPathFromNei + } else if longestPathFromNei > secondMaxi { + secondMaxi = longestPathFromNei + } + } + + *longstPathVal = max(*longstPathVal, maxi+secondMaxi+1) + return maxi + 1 +} diff --git a/Hard/L23.go b/Hard/L23.go new file mode 100644 index 0000000..d3a69b6 --- /dev/null +++ b/Hard/L23.go @@ -0,0 +1,50 @@ +package Hard + +/** + * Definition for singly-linked list. + * type ListNode struct { + * Val int + * Next *ListNode + * } + */ +func mergeKLists(lists []*ListNode) *ListNode { + var ( + merge func(l1, l2 *ListNode) *ListNode + partition func(start, end int) *ListNode + ) + + merge = func(l1, l2 *ListNode) *ListNode { + if l1 == nil { + return l2 + } + + if l2 == nil { + return l1 + } + + if l1.Val < l2.Val { + l1.Next = merge(l1.Next, l2) + return l1 + } + + l2.Next = merge(l1, l2.Next) + return l2 + } + + partition = func(start, end int) *ListNode { + if start == end { + return lists[start] + } + + if start >= end { + return nil + } + + q := (start + end) / 2 + l1, l2 := partition(start, q), partition(q + 1, end) + + return merge(l1, l2) + } + + return partition(0, len(lists) - 1) +} diff --git a/Hard/L233.go b/Hard/L233.go new file mode 100644 index 0000000..35e01f6 --- /dev/null +++ b/Hard/L233.go @@ -0,0 +1,49 @@ +package Hard + +func countDigitOne(n int) int { + str := fmt.Sprintf("%d", n) + dp := make([][][]int, 10) + + for i := 0; i < 10; i++ { + dp[i] = make([][]int, 2) + for j := 0; j < 2; j++ { + dp[i][j] = make([]int, 10) + for k := 0; k < 10; k++ { + dp[i][j][k] = -1 + } + } + } + + return solve(str, 0, 1, 0, &dp) +} + +func solve(s string, idx, tight, count int, dp *[][][]int) int { + if idx == len(s) { + return count + } + + if (*dp)[idx][tight][count] != -1 { + return (*dp)[idx][tight][count] + } + + ans, bound := 0, 9 + if tight == 1 { + bound = int(s[idx] - '0') + } + + for i := 0; i <= bound; i++ { + add := 0 + if i == 1 { + add = 1 + } + + if i == bound && tight == 1 { + ans += solve(s, idx+1, tight, count+add, dp) + } else { + ans += solve(s, idx+1, 0, count+add, dp) + } + } + + (*dp)[idx][tight][count] = ans + return ans +} diff --git a/Hard/L2360.go b/Hard/L2360.go new file mode 100644 index 0000000..13b279b --- /dev/null +++ b/Hard/L2360.go @@ -0,0 +1,42 @@ +package Hard + +func longestCycle(edges []int) int { + var exists struct{} + res, st := -1, make(map[int]struct{}) + + for _, e := range edges { + if e != -1 { + if _, contains := st[e]; !contains { + mp, pos := make(map[int]int), 0 + mp[e], st[e] = pos, exists + + for edges[e] != -1 { + e = edges[e] + + if _, contains = mp[e]; contains { + res = max(res, pos-mp[e]+1) + break + } + + if _, contains = st[e]; contains { + break + } + + pos++ + mp[e] = pos + st[e] = exists + } + } + } + } + + return res +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Hard/L239.go b/Hard/L239.go new file mode 100644 index 0000000..2770efa --- /dev/null +++ b/Hard/L239.go @@ -0,0 +1,28 @@ +package Hard + +func maxSlidingWindow(nums []int, k int) []int { + if len(nums) == 0 || k <= 0 { + return []int{0} + } + + var ( + res, q []int + ) + n := len(nums) + + for i := 0; i < n; i++ { + for len(q) > 0 && q[0] < (i-k+1) { + q = q[1:] + } + for len(q) > 0 && nums[q[len(q)-1]] < nums[i] { + q = q[:len(q)-1] + } + q = append(q, i) + + if i >= k-1 { + res = append(res, nums[q[0]]) + } + } + + return res +} diff --git a/Hard/L2421.go b/Hard/L2421.go new file mode 100644 index 0000000..0541db6 --- /dev/null +++ b/Hard/L2421.go @@ -0,0 +1,87 @@ +package Hard + +type UnionFind struct { + parent []int +} + +func newUnionFind(n int) *UnionFind { + par := make([]int, n) + for i := 0; i < n; i++ { + par[i] = -1 + } + return &UnionFind{ + parent: par, + } +} + +func (u *UnionFind) find(x int) int { + if u.parent[x] >= 0 { + u.parent[x] = u.find(u.parent[x]) + return u.parent[x] + } + + return x +} + +func (u *UnionFind) union(x, y int) bool { + parentX, parentY := u.find(x), u.find(y) + + if parentY == parentX { + return false + } + + if u.parent[parentX] <= u.parent[parentY] { + u.parent[parentX] += u.parent[parentY] + u.parent[parentY] = parentX + } else { + u.parent[parentY] += u.parent[parentX] + u.parent[parentX] = parentY + } + + return true +} + +func numberOfGoodPaths(vals []int, edges [][]int) int { + adjList, mp, n := make(map[int][]int), make(map[int][]int), len(vals) + + for i := range vals { + mp[vals[i]] = append(mp[vals[i]], i) + } + + for _, e := range edges { + u, v := e[0], e[1] + + adjList[u] = append(adjList[u], v) + adjList[v] = append(adjList[v], u) + } + + var keys []int + for k, _ := range mp { + keys = append(keys, k) + } + sort.Ints(keys) + uf, res := newUnionFind(n), n + + for _, k := range keys { + for _, curr := range mp[k] { + for _, adj := range adjList[curr] { + if vals[adj] <= vals[curr] { + uf.union(curr, adj) + } + } + } + + group := make(map[int]int) + for _, curr := range mp[k] { + group[uf.find(curr)]++ + } + + for _, v := range group { + if v >= 2 { + res += v * (v - 1) / 2 + } + } + } + + return res +} diff --git a/Hard/L2444.go b/Hard/L2444.go new file mode 100644 index 0000000..d5ca6b3 --- /dev/null +++ b/Hard/L2444.go @@ -0,0 +1,35 @@ +package Hard + +func countSubarrays(nums []int, minK int, maxK int) int64 { + var ( + res, start int64 + minStart, maxStart int64 + ) + minFound, maxFound := false, false + + for i := range nums { + n := nums[i] + if n < minK || n > maxK { + minFound, maxFound, start = false, false, int64(i+1) + } + if n == minK { + minFound, minStart = true, int64(i) + } + if n == maxK { + maxFound, maxStart = true, int64(i) + } + if minFound && maxFound { + res += min(minStart, maxStart) - start + 1 + } + } + + return res +} + +func min(a, b int64) int64 { + if a < b { + return a + } + + return b +} diff --git a/Hard/L25.go b/Hard/L25.go new file mode 100644 index 0000000..ad849fa --- /dev/null +++ b/Hard/L25.go @@ -0,0 +1,23 @@ +package Hard + +func reverseKGroup(head *ListNode, k int) *ListNode { + node, cnt := head, 0 + for cnt < k { + if node == nil { + return head + } + node = node.Next + cnt++ + } + + prev := reverseKGroup(node, k) + for cnt > 0 { + next := head.Next + head.Next = prev + prev = head + head = next + cnt-- + } + + return prev +} diff --git a/Hard/L2551.go b/Hard/L2551.go new file mode 100644 index 0000000..ca91af2 --- /dev/null +++ b/Hard/L2551.go @@ -0,0 +1,17 @@ +package Hard + +func putMarbles(weights []int, k int) int64 { + n, pairs := len(weights), make([]int, len(weights)-1) + + for i := 1; i < n; i++ { + pairs[i-1] = weights[i] + weights[i-1] + } + sort.Ints(pairs) + minScore, maxScore := 0, 0 + for i := 0; i < k-1; i++ { + minScore += pairs[i] + maxScore += pairs[n-i-2] + } + + return int64(maxScore - minScore) +} diff --git a/Hard/L315.go b/Hard/L315.go new file mode 100644 index 0000000..d9518d2 --- /dev/null +++ b/Hard/L315.go @@ -0,0 +1,52 @@ +package Hard + +func countSmaller(nums []int) []int { + res, index := make([]int, len(nums)), make([]int, len(nums)) + for i := 0; i < len(res); i++ { + index[i] = i + } + + mergeSort(&res, &index, 0, len(nums)-1, nums) + return res +} + +func mergeSort(res, index *[]int, l, r int, nums []int) { + if l >= r { + return + } + + mid := (l + r) / 2 + mergeSort(res, index, l, mid, nums) + mergeSort(res, index, mid+1, r, nums) + merge(res, index, l, mid, mid+1, r, nums) +} + +func merge(res, index *[]int, l1, r1, l2, r2 int, nums []int) { + tmp := make([]int, r2-l1+1) + start, count, p := l1, 0, 0 + for l1 <= r1 || l2 <= r2 { + if l1 > r1 { + tmp[p] = (*index)[l2] + p += 1 + l2 += 1 + } else if l2 > r2 { + (*res)[(*index)[l1]] += count + tmp[p] = (*index)[l1] + p += 1 + l1 += 1 + } else if nums[(*index)[l1]] > nums[(*index)[l2]] { + tmp[p] = (*index)[l2] + p += 1 + l2 += 1 + count++ + } else { + (*res)[(*index)[l1]] += count + tmp[p] = (*index)[l1] + p += 1 + l1 += 1 + } + } + for i := 0; i < len(tmp); i++ { + (*index)[start+i] = tmp[i] + } +} diff --git a/Hard/L330.go b/Hard/L330.go new file mode 100644 index 0000000..99ca577 --- /dev/null +++ b/Hard/L330.go @@ -0,0 +1,17 @@ +package Hard + +func minPatches(nums []int, n int) int { + miss, added, i := 1, 0, 0 + + for miss <= n { + if i < len(nums) && nums[i] <= miss { + miss += nums[i] + i++ + } else { + miss += miss + added++ + } + } + + return added +} diff --git a/Hard/L37.go b/Hard/L37.go new file mode 100644 index 0000000..7634962 --- /dev/null +++ b/Hard/L37.go @@ -0,0 +1,39 @@ +package Hard + +func solveSudoku(board [][]byte) { + solve(board, 0, 0) +} + +func solve(board [][]byte, row, col int) bool { + for i := row; i < 9; i, col = i+1, 0 { + for j := col; j < 9; j++ { + if board[i][j] != '.' { + continue + } + for num := '1'; num <= '9'; num++ { + if isValid(board, i, j, byte(num)) { + board[i][j] = byte(num) + if solve(board, i, j+1) { + return true + } + board[i][j] = '.' + } + } + return false + } + } + + return true +} + +func isValid(board [][]byte, row, col int, num byte) bool { + blkrow, blkcol := (row/3)*3, (col/3)*3 + for i := 0; i < 9; i++ { + if board[i][col] == num || board[row][i] == num || + board[blkrow+i/3][blkcol+i%3] == num { + return false + } + } + + return true +} diff --git a/Hard/L403.go b/Hard/L403.go new file mode 100644 index 0000000..7ca864d --- /dev/null +++ b/Hard/L403.go @@ -0,0 +1,45 @@ +package Hard + +var exists struct{} + +func canCross(stones []int) bool { + st, mp, n := make(map[int]struct{}), make(map[string]bool), len(stones) + + for _, s := range stones { + st[s] = exists + } + + return solve(st, mp, stones, n, 0, 1) +} + +func solve(st map[int]struct{}, mp map[string]bool, stones []int, n, pos, prevStep int) bool { + if _, ok := st[pos]; !ok { + return false + } + if pos > stones[n-1] { + return false + } + if pos == stones[n-1] { + return true + } + + key := fmt.Sprintf("%d-%d", pos, prevStep) + if v, ok := mp[key]; ok { + return v + } + + if pos == 0 { + mp[key] = solve(st, mp, stones, n, pos+1, 1) + } else { + if prevStep-1 > 0 { + mp[key] = solve(st, mp, stones, n, pos+(prevStep-1), prevStep-1) + if mp[key] { + return mp[key] + } + } + mp[key] = solve(st, mp, stones, n, pos+prevStep, prevStep) || + solve(st, mp, stones, n, pos+(prevStep+1), prevStep+1) + } + + return mp[key] +} diff --git a/Hard/L410.go b/Hard/L410.go new file mode 100644 index 0000000..c3bf716 --- /dev/null +++ b/Hard/L410.go @@ -0,0 +1,42 @@ +package Hard + +func splitArray(nums []int, m int) int { + if len(nums) == 0 || m == 0 { + return 0 + } + + max, sum := math.MinInt32, 0 + for _, n := range nums { + if n > max { + max = n + } + sum += n + } + + l, r, mid := max, sum, 0 + + for l < r { + mid = l + (r-l)/2 + if isValid(nums, mid, m) { + r = mid + } else { + l = mid + 1 + } + } + + return l +} + +func isValid(nums []int, cap, m int) bool { + days, sum := 1, 0 + + for _, n := range nums { + sum += n + if sum > cap { + sum = n + days++ + } + } + + return days <= m +} diff --git a/Hard/L42.go b/Hard/L42.go new file mode 100644 index 0000000..431b20f --- /dev/null +++ b/Hard/L42.go @@ -0,0 +1,48 @@ +package Hard + +func trap(height []int) int { + if height == nil || len(height) == 0 { + return 0 + } + + left, right, sum := leftbound(height), rightbound(height), 0 + + for i := range height { + min := left[i] + if right[i] < left[i] { + min = right[i] + } + + sum += min - height[i] + } + + return sum +} + +func leftbound(arr []int) []int { + ret := make([]int, len(arr)) + + ret[0] = arr[0] + for i := 1; i < len(arr); i++ { + ret[i] = ret[i-1] + if arr[i] > ret[i-1] { + ret[i] = arr[i] + } + } + + return ret +} + +func rightbound(arr []int) []int { + ret := make([]int, len(arr)) + + ret[len(arr)-1] = arr[len(arr)-1] + for i := len(arr) - 2; i >= 0; i-- { + ret[i] = ret[i+1] + if arr[i] > ret[i+1] { + ret[i] = arr[i] + } + } + + return ret +} diff --git a/Hard/L446.go b/Hard/L446.go new file mode 100644 index 0000000..1f11f0c --- /dev/null +++ b/Hard/L446.go @@ -0,0 +1,33 @@ +package Hard + +func numberOfArithmeticSlices(nums []int) int { + n, res := len(nums), 0 + + for i := 0; i < n; i++ { + for j := i + 1; j < n; j++ { + mp := make(map[string]int) + res += solve(nums, j + 1, int64(nums[j]) - int64(nums[i]), 2, mp) + } + } + + return res +} + +func solve(nums []int, idx int, diff int64, cnt int, mp map[string]int) int { + res, key := 0, fmt.Sprintf("%d-%d", idx, diff) + if v, ok := mp[key]; ok { + return v + } + + if cnt >= 3 { + res++ + } + + for i := idx; i < len(nums); i++ { + if int64(nums[i]) - int64(nums[idx - 1]) == diff { + res += solve(nums, i + 1, diff, cnt + 1, mp) + } + } + mp[key] = res + return res +} diff --git a/Hard/L472.go b/Hard/L472.go new file mode 100644 index 0000000..17c1330 --- /dev/null +++ b/Hard/L472.go @@ -0,0 +1,46 @@ +package Hard + +var exists struct{} + +func findAllConcatenatedWordsInADict(words []string) []string { + var res []string + preWords := make(map[string]struct{}) + + sort.Slice(words, func(i, j int) bool { + return len(words[i]) < len(words[j]) + }) + + for i := 0; i < len(words); i++ { + if canConcat(0, words[i], preWords, make(map[int]bool)) { + res = append(res, words[i]) + } + preWords[words[i]] = exists + } + + return res +} + +func canConcat(idx int, s string, st map[string]struct{}, mp map[int]bool) bool { + if idx == len(s) { + return true + } + if len(st) == 0 { + return false + } + + if v, ok := mp[idx]; ok { + return v + } + + for i := idx + 1; i <= len(s); i++ { + if _, ok := st[s[idx:i]]; ok { + if canConcat(i, s, st, mp) { + mp[idx] = true + return mp[idx] + } + } + } + + mp[idx] = false + return mp[idx] +} 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/L546.go b/Hard/L546.go new file mode 100644 index 0000000..0659827 --- /dev/null +++ b/Hard/L546.go @@ -0,0 +1,45 @@ +package Hard + +func removeBoxes(boxes []int) int { + n := len(boxes) + dp := make([][][]int, n) + for i := 0; i < n; i++ { + dp[i] = make([][]int, n) + for j := 0; j < n; j++ { + dp[i][j] = make([]int, n) + for k := 0; k < n; k++ { + dp[i][j][k] = -1 + } + } + } + + return solve(boxes, &dp, 0, n-1, 0) +} + +func solve(boxes []int, dp *[][][]int, i, j, k int) int { + if i > j { + return 0 + } + + if (*dp)[i][j][k] > 0 { + return (*dp)[i][j][k] + } + + i0, k0 := i, k + for ; i+1 <= j && boxes[i+1] == boxes[i]; i, k = i+1, k+1 { + + } + + res := (k+1)*(k+1) + solve(boxes, dp, i+1, j, 0) + for m := i + 1; m <= j; m++ { + if boxes[i] == boxes[m] { + val := solve(boxes, dp, i+1, m-1, 0) + solve(boxes, dp, m, j, k+1) + if val > res { + res = val + } + } + } + + (*dp)[i0][j][k0] = res + return res +} diff --git a/Hard/L600.go b/Hard/L600.go new file mode 100644 index 0000000..c9b6a1c --- /dev/null +++ b/Hard/L600.go @@ -0,0 +1,26 @@ +package Hard + +func findIntegers(n int) int { + f := make([]int, 32) + f[0], f[1] = 1, 2 + + for i := 2; i < 32; i++ { + f[i] = f[i-1] + f[i-2] + } + + ans, k, preBit := 0, 30, 0 + for k >= 0 { + if (n & (1 << k)) > 0 { + ans += f[k] + if preBit > 0 { + return ans + } + preBit = 1 + } else { + preBit = 0 + } + k-- + } + + return ans + 1 +} diff --git a/Hard/L629.go b/Hard/L629.go new file mode 100644 index 0000000..7bbfa18 --- /dev/null +++ b/Hard/L629.go @@ -0,0 +1,40 @@ +package Hard + +func kInversePairs(n int, k int) int { + memo := make([][]int, n+1) + for i := 0; i < n+1; i++ { + memo[i] = make([]int, k+1) + for j := 0; j < k+1; j++ { + memo[i][j] = -1 + } + } + + return solve(&memo, 1, n, k) +} + +func solve(memo *[][]int, num, n, k int) int { + mod := 1000000007 + if num == n+1 { + if k == 0 { + return 1 + } + + return 0 + } + + if (*memo)[num][k] != -1 { + return (*memo)[num][k] + } + + cnt, i := 0, 0 + if k-num+1 > 0 { + i = k - num + 1 + } + for ; i <= k; i++ { + val := solve(memo, num+1, n, i) + cnt = (cnt + val) % mod + } + + (*memo)[num][k] = cnt + return (*memo)[num][k] +} diff --git a/Hard/L664.go b/Hard/L664.go new file mode 100644 index 0000000..a94af1f --- /dev/null +++ b/Hard/L664.go @@ -0,0 +1,39 @@ +package Hard + +func strangePrinter(s string) int { + var ( + solve func(left, right int) int + ) + mp := make(map[string]int) + + solve = func(left, right int) int { + if left == right { + return 1 + } + key := fmt.Sprintf("%d-%d", left, right) + if v, ok := mp[key]; ok { + return v + } + + res := math.MaxInt32 + for k := left; k < right; k++ { + res = min(res, solve(left, k)+solve(k+1, right)) + } + + if s[left] == s[right] { + res-- + } + mp[key] = res + return mp[key] + } + + return solve(0, len(s)-1) +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Hard/L668.go b/Hard/L668.go new file mode 100644 index 0000000..d71253e --- /dev/null +++ b/Hard/L668.go @@ -0,0 +1,34 @@ +package Hard + +func findKthNumber(m int, n int, k int) int { + lo, hi, mid := 0, m*n, 0 + + for lo < hi { + mid = lo + (hi-lo)/2 + + if kSmaller(n, m, mid, k) { + hi = mid + } else { + lo = mid + 1 + } + } + + return lo +} + +func kSmaller(n, m, num, k int) bool { + c := 0 + for i := 0; i <= m; i++ { + c += min(n, num/i) + } + + return c >= k +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Hard/L68.go b/Hard/L68.go new file mode 100644 index 0000000..8b362ff --- /dev/null +++ b/Hard/L68.go @@ -0,0 +1,89 @@ +package Hard + +func fullJustify(words []string, maxWidth int) []string { + var res []string + left := 0 + + for left < len(words) { + right := findRight(words, left, maxWidth) + res = append(res, justify(words, left, right, maxWidth)) + left = right + 1 + } + + return res +} + +func findRight(words []string, left, maxWidth int) int { + right := left + sum := len(words[right]) + right++ + + for right < len(words) && (sum + 1 + len(words[right])) <= maxWidth { + sum += 1 + len(words[right]) + right++ + } + + return right - 1 +} + +func justify(words []string, left, right, maxWidth int) string { + if right - left == 0 { + return padResult(words[left], maxWidth) + } + + lastLine := isLastLine(words, right) + numSpaces := right - left + totalSpace := maxWidth - wordsLength(words, left, right) + + space, remainder := " ", 0 + if !lastLine { + space = blank(totalSpace / numSpaces) + remainder = totalSpace % numSpaces + } + + var sb strings.Builder + for i := left; i <= right; i++ { + sb.WriteString(words[i]) + sb.WriteString(space) + + if remainder > 0 { + sb.WriteString(" ") + } + remainder-- + } + + return padResult(strings.Trim(sb.String(), " "), maxWidth) +} + +func isLastLine(words []string, right int) bool { + return right == len(words) - 1 +} + +func wordsLength(words []string, left, right int) int { + wordsLen := 0 + + for i := left; i <= right; i++ { + wordsLen += len(words[i]) + } + + return wordsLen +} + +func padResult(result string, maxWidth int) string { + var sb strings.Builder + + sb.WriteString(result) + sb.WriteString(blank(maxWidth - len(result))) + + return sb.String() +} + +func blank(length int) string { + var sb strings.Builder + + for i := 0; i < length; i++ { + sb.WriteString(" ") + } + + return sb.String() +} diff --git a/Hard/L72.go b/Hard/L72.go new file mode 100644 index 0000000..95e25e0 --- /dev/null +++ b/Hard/L72.go @@ -0,0 +1,42 @@ +package Hard + +func minDistance(word1 string, word2 string) int { + m, n, mp := len(word1), len(word2), make(map[string]int) + return solve(word1, word2, m, n, mp) +} + +func solve(w1, w2 string, m, n int, mp map[string]int) int { + key := fmt.Sprintf("%d-%d", m, n) + if m == 0 { + mp[key] = n + return mp[key] + } + + if n == 0 { + mp[key] = m + return mp[key] + } + + if _, ok := mp[key]; ok { + return mp[key] + } + + if w1[m-1] == w2[n-1] { + return solve(w1, w2, m-1, n-1, mp) + } + + insertChar := solve(w1, w2, m-1, n, mp) + deleteChar := solve(w1, w2, m, n-1, mp) + replaceChar := solve(w1, w2, m - 1, n - 1, mp) + + mp[key] = 1 + min(insertChar, min(replaceChar, deleteChar)) + return mp[key] +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Hard/L76.go b/Hard/L76.go new file mode 100644 index 0000000..969c9b2 --- /dev/null +++ b/Hard/L76.go @@ -0,0 +1,45 @@ +package Hard + +func minWindow(s string, t string) string { + if len(t) > len(s) { + return "" + } + + mp := make(map[byte]int) + for i := range t { + mp[t[i]]++ + } + + begin, end, counter, length, head := 0, 0, len(mp), math.MaxInt32, 0 + + for end < len(s) { + if v, ok := mp[s[end]]; ok { + mp[s[end]] = v - 1 + if mp[s[end]] == 0 { + counter-- + } + } + end++ + + for counter == 0 { + if v, ok := mp[s[begin]]; ok { + mp[s[begin]] = v + 1 + if mp[s[begin]] > 0 { + counter++ + } + } + + if end-begin < length { + length = end - begin + head = begin + } + begin++ + } + } + + if length == math.MaxInt32 { + return "" + } + + return s[head : head+length] +} diff --git a/Hard/L778.go b/Hard/L778.go new file mode 100644 index 0000000..3ed0cae --- /dev/null +++ b/Hard/L778.go @@ -0,0 +1,40 @@ +package Hard + +var dirs = [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + +func swimInWater(grid [][]int) int { + time, m := 0, len(grid) + + for { + vis := make(map[int]bool) + dfs(grid, vis, 0, 0, time) + time++ + if _, ok := vis[m*m-1]; ok { + break + } + } + + return time - 1 +} + +func isValid(grid [][]int, x, y, time int) bool { + m, n := len(grid), len(grid[0]) + + return x >= 0 && x < m && y >= 0 && y < n && grid[x][y] <= time +} + +func dfs(grid [][]int, vis map[int]bool, i, j, time int) { + if !isValid(grid, i, j, time) { + return + } + + if _, ok := vis[i*len(grid)+j]; ok { + return + } + + vis[i*len(grid)+j] = true + + for _, d := range dirs { + dfs(grid, vis, i+d[0], j+d[1], time) + } +} diff --git a/Hard/L782.go b/Hard/L782.go new file mode 100644 index 0000000..307e4cb --- /dev/null +++ b/Hard/L782.go @@ -0,0 +1,53 @@ +package Hard + +func movesToChessboard(board [][]int) int { + n := len(board) + for i := 0; i < n; i++ { + for j := 0; j < n; j++ { + if (board[0][0] ^ board[i][0] ^ board[0][j] ^ board[i][j]) == 1 { + return -1 + } + } + } + + rowSum, colSum, rowMisplaced, colMisplaced := 0, 0, 0, 0 + for i := 0; i < n; i++ { + rowSum += board[0][i] + colSum += board[i][0] + if board[i][0] == i%2 { + rowMisplaced++ + } + if board[0][i] == i%2 { + colMisplaced++ + } + } + + if rowSum != n/2 && rowSum != (n+1)/2 { + return -1 + } + if colSum != n/2 && colSum != (n+1)/2 { + return -1 + } + + if n%2 == 1 { + if colMisplaced%2 == 1 { + colMisplaced = n - colMisplaced + } + if rowMisplaced%2 == 1 { + rowMisplaced = n - rowMisplaced + } + } else { + colMisplaced = min(n-colMisplaced, colMisplaced) + rowMisplaced = min(n-rowMisplaced, rowMisplaced) + } + + return (colMisplaced + rowMisplaced) / 2 +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} 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/Hard/L839.go b/Hard/L839.go new file mode 100644 index 0000000..de0db9e --- /dev/null +++ b/Hard/L839.go @@ -0,0 +1,51 @@ +package Hard + +func numSimilarGroups(strs []string) int { + n := len(strs) + parent := make([]int, n) + var ( + isSimilar func(s1, s2 string) bool + find func(x int) int + ) + + isSimilar = func(s1, s2 string) bool { + diff := 0 + for i := 0; i < len(s1); i++ { + if s1[i] != s2[i] { + diff++ + } + } + + return diff == 2 || diff == 0 + } + + find = func(x int) int { + if parent[x] != x { + parent[x] = find(parent[x]) + } + return parent[x] + } + + for i := 0; i < n; i++ { + parent[i] = i + } + for i := 0; i < n; i++ { + for j := i + 1; j < n; j++ { + if isSimilar(strs[i], strs[j]) { + p1, p2 := find(i), find(j) + if p1 != p2 { + parent[p2] = p1 + } + } + } + } + + res := 0 + for i := 0; i < n; i++ { + if parent[i] == i { + res++ + } + } + + return res +} diff --git a/Hard/L85.go b/Hard/L85.go new file mode 100644 index 0000000..20e24f2 --- /dev/null +++ b/Hard/L85.go @@ -0,0 +1,38 @@ +package Hard + +func maximalRectangle(matrix [][]byte) int { + if len(matrix) == 0 { + return 0 + } + + ans, m, n, height := 0, len(matrix), len(matrix[0]), make([]int, len(matrix[0])) + + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if matrix[i][j] == '0' { + height[j] = 0 + continue + } + height[j]++ + for cur, pre := j-1, height[j]; cur >= 0; cur-- { + if height[cur] == 0 { + break + } + + if height[cur] < pre { + pre = height[cur] + } + + if pre*(j-cur+1) > ans { + ans = pre * (j - cur + 1) + } + } + + if height[j] > ans { + ans = height[j] + } + } + } + + return ans +} diff --git a/Hard/L850.go b/Hard/L850.go new file mode 100644 index 0000000..bba5159 --- /dev/null +++ b/Hard/L850.go @@ -0,0 +1,73 @@ +package Hard + +package main + +func main() { + + n := []int{4, -2, 2, -4} + println(canReorderDoubled(n)) +} + +func rectangleArea(rectangles [][]int) int { + mod, res := 1000000007, 0 + var recList [][]int + for _, r := range rectangles { + addRectangle(&recList, &r, 0) + } + + for _, r := range recList { + res = res + ((r[2]-r[0])*(r[3]-r[1]))%mod + } + + return res % mod +} + +func addRectangle(recList *[][]int, curRec *[]int, start int) { + if start >= len(*recList) { + *recList = append(*recList, *curRec) + return + } + + r := (*recList)[start] + + if (*curRec)[2] <= r[0] || (*curRec)[3] <= r[1] || (*curRec)[0] >= r[2] || (*curRec)[1] >= r[3] { + addRectangle(recList, curRec, start+1) + return + } + + if (*curRec)[0] < r[0] { + tmp := []int{(*curRec)[0], (*curRec)[1], r[0], (*curRec)[3]} + addRectangle(recList, &tmp, start+1) + } + + if (*curRec)[2] > r[2] { + tmp := []int{r[2], (*curRec)[1], (*curRec)[2], (*curRec)[3]} + addRectangle(recList, &tmp, start+1) + } + + if (*curRec)[1] < r[1] { + tmp := []int{max(r[0], (*curRec)[0]), (*curRec)[1], min(r[2], (*curRec)[2]), r[1]} + addRectangle(recList, &tmp, start+1) + } + + if (*curRec)[3] > r[3] { + tmp := []int{max(r[0], (*curRec)[0]), r[3], min(r[2], (*curRec)[2]), (*curRec)[3]} + addRectangle(recList, &tmp, start+1) + } +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Hard/L87.go b/Hard/L87.go new file mode 100644 index 0000000..301a4eb --- /dev/null +++ b/Hard/L87.go @@ -0,0 +1,45 @@ +package Hard + +func isScramble(s1 string, s2 string) bool { + var solve func(a, b string) bool + mp := make(map[string]bool) + + if s1 == s2 { + return true + } + if len(s1) != len(s2) { + return false + } + if len(s1) == 0 { + return true + } + + solve = func(a, b string) bool { + if a == b { + return true + } + if len(a) <= 1 { + return false + } + + key := fmt.Sprintf("%s-%s", a, b) + if v, ok := mp[key]; ok { + return v + } + + n, check := len(a), false + for i := 1; i < n; i++ { + swap := solve(a[:i], b[n-i:]) && solve(a[i:], b[0:n-i]) + unSwap := solve(a[0:i], b[0:i]) && solve(a[i:], b[i:]) + + if swap || unSwap { + check = true + break + } + } + mp[key] = check + return mp[key] + } + + return solve(s1, s2) +} diff --git a/Hard/L878.go b/Hard/L878.go new file mode 100644 index 0000000..4030d3e --- /dev/null +++ b/Hard/L878.go @@ -0,0 +1,31 @@ +package Hard + +func nthMagicalNumber(n int, a int, b int) int { + A, B, mod := a, b, 1000000007 + l, r := min(a, b), n*min(a, b) + + for B > 0 { + B, A = A%B, B + } + + lcm := (a * b) / A + for l < r { + mid := l + (r-l)/2 + + if (mid/a)+(mid/b)-(mid/lcm) < n { + l = mid + 1 + } else { + r = mid + } + } + + return l % mod +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Hard/L879.go b/Hard/L879.go new file mode 100644 index 0000000..d403e9e --- /dev/null +++ b/Hard/L879.go @@ -0,0 +1,51 @@ +package Hard + +func profitableSchemes(n int, minProfit int, group []int, profit []int) int { + mod := int64(1000000007) + mp := make(map[string]int64) + var solve func(n, i, minimumProfit int) int64 + + solve = func(n, i, minimumProfit int) int64 { + var ( + ways int64 + zeroProfitKey = fmt.Sprintf("%d-%d-0", n, i) + key = fmt.Sprintf("%d-%d-%d", n, i, minimumProfit) + ) + + if i == len(group) { + if minimumProfit <= 0 { + return 1 + } + + return 0 + } + + if minimumProfit <= 0 { + if v, ok := mp[zeroProfitKey]; ok { + return v + } + } else if minimumProfit > 0 { + if v, ok := mp[key]; ok { + return v + } + } + + ways += solve(n, i+1, minimumProfit) + ways %= mod + + if n >= group[i] { + ways += solve(n-group[i], i+1, minimumProfit-profit[i]) + ways %= mod + } + + if minimumProfit <= 0 { + mp[zeroProfitKey] = ways % mod + } else { + mp[key] = ways % mod + } + + return ways % mod + } + + return int(solve(n, 0, minProfit)) +} diff --git a/Hard/L899.go b/Hard/L899.go new file mode 100644 index 0000000..8b35d29 --- /dev/null +++ b/Hard/L899.go @@ -0,0 +1,50 @@ +package Hard + +func orderlyQueue(s string, k int) string { + if len(s) == 0 { + return s + } + + n, s := len(s), s+s + + if k >= 2 { + cnt := make([]int, 26) + for i := 0; i < n; i++ { + cnt[s[i]-'a']++ + } + var sb strings.Builder + for i := 0; i < 26; i++ { + for j := 0; j < cnt[i]; j++ { + sb.WriteByte(byte(i + 'a')) + } + } + + return sb.String() + } + + res, arr, x := make([]byte, n*2), make([]int, n*2), 0 + res[0], arr[0] = s[0], -1 + + for i := 1; i < n*2; i++ { + for x >= 0 && res[arr[x]+1] > s[i] { + x = arr[x] + } + res[x+1] = s[i] + + if x >= 0 { + idx := arr[x] + for idx >= 0 && res[idx+1] != s[i] { + idx = arr[idx] + } + + if res[idx+1] == s[i] { + idx++ + } + arr[x+1] = idx + } + + x++ + } + + return string(res[:n]) +} diff --git a/Hard/L902.go b/Hard/L902.go new file mode 100644 index 0000000..6bb79bb --- /dev/null +++ b/Hard/L902.go @@ -0,0 +1,41 @@ +package Hard + +func atMostNGivenDigitSet(digits []string, n int) int { + if len(digits) == 0 || n == 0 { + return 0 + } + + nStr := fmt.Sprintf("%d", n) + numDigitsN, total, numDigits := len(nStr), 0, len(digits) + + for i := 1; i < numDigitsN; i++ { + total += IntPow(numDigits, i) + } + + for i := 0; i < numDigitsN; i++ { + hasSameNum := false + for _, d := range digits { + if d[0] < nStr[i] { + total += IntPow(numDigits, numDigitsN-i-1) + } else if d[0] == nStr[i] { + hasSameNum = true + } + } + if !hasSameNum { + return total + } + } + + return total + 1 +} + +func IntPow(n, m int) int { + if m == 0 { + return 1 + } + result := n + for i := 2; i <= m; i++ { + result *= n + } + return result +} diff --git a/Hard/L927.go b/Hard/L927.go new file mode 100644 index 0000000..4dbb86b --- /dev/null +++ b/Hard/L927.go @@ -0,0 +1,54 @@ +func threeEqualParts(arr []int) []int { + numOne := 0 + for _, i := range arr { + if i == 1 { + numOne++ + } + } + + noRes := []int{-1, -1} + if numOne == 0 { + return []int{0, 2} + } + if numOne%3 != 0 { + return noRes + } + + idxThird, temp := 0, 0 + for i := len(arr) - 1; i >= 0; i-- { + if arr[i] == 1 { + temp++ + if temp == numOne/3 { + idxThird = i + break + } + } + } + + res1 := findEndIdx(arr, 0, idxThird) + if res1 < 0 { + return noRes + } + + res2 := findEndIdx(arr, res1+1, idxThird) + if res2 < 0 { + return noRes + } + + return []int{res1, res2 + 1} +} + +func findEndIdx(A []int, left, right int) int { + for A[left] == 0 { + left++ + } + for right < len(A) { + if A[left] != A[right] { + return -1 + } + left++ + right++ + } + + return left - 1 +} diff --git a/Hard/L952.go b/Hard/L952.go new file mode 100644 index 0000000..de42a92 --- /dev/null +++ b/Hard/L952.go @@ -0,0 +1,70 @@ +package Hard + +type UnionFind struct { + Parent []int + Size []int + Max int +} + +func NewUnionFind(n int) *UnionFind { + parent, size, max := make([]int, n), make([]int, n), 1 + for i := 0; i < n; i++ { + parent[i], size[i] = i, 1 + } + + return &UnionFind{ + Parent: parent, + Size: size, + Max: max, + } +} + +func (u *UnionFind) find(x int) int { + if x == u.Parent[x] { + return x + } + u.Parent[x] = u.find(u.Parent[x]) + return u.Parent[x] +} + +func (u *UnionFind) union(x, y int) { + rootX, rootY := u.find(x), u.find(y) + + if rootY != rootX { + u.Parent[rootX] = rootY + u.Size[rootY] += u.Size[rootX] + if u.Size[rootY] > u.Max { + u.Max = u.Size[rootY] + } + } +} + +func largestComponentSize(nums []int) int { + mp, uf := make(map[int]int), NewUnionFind(len(nums)) + + for i := range nums { + a := nums[i] + for j := 2; j*j <= a; j++ { + if a%j == 0 { + if _, ok := mp[j]; !ok { + mp[j] = i + } else { + uf.union(i, mp[j]) + } + + if _, ok := mp[a/j]; !ok { + mp[a/j] = i + } else { + uf.union(i, mp[a/j]) + } + } + } + if _, ok := mp[a]; !ok { + mp[a] = i + } else { + uf.union(i, mp[a]) + } + } + + return uf.Max +} diff --git a/Medium.md b/Medium.md new file mode 100644 index 0000000..b14a62e --- /dev/null +++ b/Medium.md @@ -0,0 +1,350 @@ +## Medium +|LC #|Description| +|:-:|:-| +|[931](https://leetcode.com/problems/minimum-falling-path-sum/)| Minimum Falling Path Sum| +|[946](https://leetcode.com/problems/validate-stack-sequences/)| Validate Stack Sequences| +|[29](https://leetcode.com/problems/divide-two-integers/)| Divide Two Integers| +|[820](https://leetcode.com/problems/short-encoding-of-words/)| Short Encoding of Words| +|[1381](https://leetcode.com/problems/design-a-stack-with-increment-operation/)| Design a Stack With Increment Operation| +|[623](https://leetcode.com/problems/add-one-row-to-tree/)| Add One Row to Tree| +|[12](https://leetcode.com/problems/integer-to-roman/)| Integer to Roman| +|[1315](https://leetcode.com/problems/sum-of-nodes-with-even-valued-grandparent/)| Sum of Nodes with Even-Valued Grandparent| +|[1302](https://leetcode.com/problems/deepest-leaves-sum/)| Deepest Leaves Sum| +|[322](https://leetcode.com/problems/coin-change/)| Coin Change| +|[1305](https://leetcode.com/problems/all-elements-in-two-binary-search-trees/)| All Elements in Two Binary Search Trees| +|[1461](https://leetcode.com/problems/check-if-a-string-contains-all-binary-codes-of-size-k/)| Check If a String Contains All Binary Codes of Size K| +|[1721](https://leetcode.com/problems/swapping-nodes-in-a-linked-list/)| Swapping Nodes in a Linked List| +|[714](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/)| Best Time to Buy and Sell Stock with Transaction Fee| +|[478](https://leetcode.com/problems/generate-random-point-in-a-circle/)| Generate Random Point in a Circle| +|[208](https://leetcode.com/problems/implement-trie-prefix-tree/)| Implement Trie (Prefix Tree)| +|[376](https://leetcode.com/problems/wiggle-subsequence/)| Wiggle Subsequence| +|[38](https://leetcode.com/problems/count-and-say/)| Count and Say| +|[146](https://leetcode.com/problems/lru-cache/)| LRU Cache| +|[1583](https://leetcode.com/problems/count-unhappy-friends/)| Count Unhappy Friends| +|[729](https://leetcode.com/problems/my-calendar-i/)| My Calendar I| +|[841](https://leetcode.com/problems/keys-and-rooms/)| Keys And Rooms| +|[113](https://leetcode.com/problems/path-sum-ii/)| Path Sum II| +|[1398](https://leetcode.com/problems/design-underground-system/)| Design Underground System| +|[1797](https://leetcode.com/problems/design-authentication-manager/)| Design Authentication Manager| +|[1798](https://leetcode.com/problems/maximum-number-of-consecutive-values-you-can-make/)| Maximum Number of Consecutive Values You Can Make| +|[966](https://leetcode.com/problems/vowel-spellchecker/)| Vowel Spellchecker| +|[1689](https://leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers/)| Partitioning Into Minimum Number Of Deci-Binary Numbers| +|[1764](https://leetcode.com/problems/form-array-by-concatenating-subarrays-of-another-array/)| Form Array by Concatenating Subarrays of Another Array| +|[923](https://leetcode.com/problems/3sum-with-multiplicity/)| 3Sum With Multiplicity| +|[417](https://leetcode.com/problems/pacific-atlantic-water-flow/)| Pacific Atlantic Water Flow| +|[916](https://leetcode.com/problems/word-subsets/)| Word Subsets| +|[5](https://leetcode.com/problems/longest-palindromic-substring/)| Longest Palindromic Substring| +|[647](https://leetcode.com/problems/palindromic-substrings/)| Palindromic Substrings| +|[971](https://leetcode.com/problems/flip-binary-tree-to-match-preorder-traversal/)| Flip Binary Tree To Match Preorder Traversal| +|[1726](https://leetcode.com/problems/tuple-with-same-product/)| Tuple with Same Product| +|[474](https://leetcode.com/problems/ones-and-zeroes/)| Ones and Zeroes| +|[1488](https://leetcode.com/problems/avoid-flood-in-the-city/)| Avoid Flood in The City| +|[947](https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/)| Most Stones Removed with Same Row or Column| +|[622](https://leetcode.com/problems/design-circular-queue/)| Design Circular Queue| +|[1670](https://leetcode.com/problems/design-front-middle-back-queue/)| Design Front Middle Back Queue| +|[494](https://leetcode.com/problems/target-sum/)| Target Sum| +|[17](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)| Letter Combinations of a Phone Number| +|[638](https://leetcode.com/problems/shopping-offers/)| Shopping Offers| +|[667](https://leetcode.com/problems/beautiful-arrangement-ii/)| Beautiful Arrangement II| +|[650](https://leetcode.com/problems/2-keys-keyboard/)| 2 Keys Keyboard| +|[801](https://leetcode.com/problems/minimum-swaps-to-make-sequences-increasing/)| Minimum Swaps To Make Sequences Increasing| +|[341](https://leetcode.com/problems/flatten-nested-list-iterator/)| Flatten Nested List Iterator| +|[86](https://leetcode.com/problems/partition-list/)| Partition List| +|[91](https://leetcode.com/problems/decode-ways/)| Decode Ways| +|[62](https://leetcode.com/problems/unique-paths/)| Unique Paths| +|[1209](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string-ii/)| Remove All Adjacent Duplicates in String II| +|[279](https://leetcode.com/problems/perfect-squares/)| Perfect Squares| +|[377](https://leetcode.com/problems/combination-sum-iv/)| Combination Sum IV| +|[120](https://leetcode.com/problems/triangle/)| Triangle| +|[554](https://leetcode.com/problems/brick-wall/)| Brick Wall| +|[48](https://leetcode.com/problems/rotate-image/)| Rotate Image| +|[935](https://leetcode.com/problems/knight-dialer/)| Knight Dialer| +|[740](https://leetcode.com/problems/delete-and-earn/)| Delete and Earn| +|[63](https://leetcode.com/problems/unique-paths-ii/)| Unique Paths II| +|[34](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/)| Find First and Last Position of Element in Sorted Array| +|[970](https://leetcode.com/problems/powerful-integers/)| Powerful Integers| +|[665](https://leetcode.com/problems/non-decreasing-array/)| Non-decreasing Array| +|[1472](https://leetcode.com/problems/design-browser-history/)| Design Browser History| +|[109](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/)| Convert Sorted List to Binary Search Tree| +|[583](https://leetcode.com/problems/delete-operation-for-two-strings/)| Delete Operation for Two Strings| +|[1423](https://leetcode.com/problems/maximum-points-you-can-obtain-from-cards/)| Maximum Points You Can Obtain from Cards| +|[304](https://leetcode.com/problems/range-sum-query-2d-immutable/)| Range Sum Query 2D - Immutable| +|[816](https://leetcode.com/problems/ambiguous-coordinates/)| Ambiguous Coordinates| +|[114](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/)| Flatten Binary Tree to Linked List| +|[1048](https://leetcode.com/problems/longest-string-chain/)| Longest String Chain| +|[213](https://leetcode.com/problems/house-robber-ii/)| House Robber II| +|[462](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/)| Minimum Moves to Equal Array Elements II| +|[890](https://leetcode.com/problems/find-and-replace-pattern/)| Find and Replace Pattern| +|[337](https://leetcode.com/problems/house-robber-iii/)| House Robber III| +|[921](https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/)| Minimum Add to Make Parentheses Valid| +|[1871](https://leetcode.com/problems/jump-game-vii/)| Jump Game VII| +|[150](https://leetcode.com/problems/evaluate-reverse-polish-notation/)| Evaluate Reverse Polish Notation| +|[318](https://leetcode.com/problems/maximum-product-of-word-lengths/)| Maximum Product of Word Lengths| +|[1695](https://leetcode.com/problems/maximum-erasure-value/)| Maximum Erasure Value| +|[1268](https://leetcode.com/problems/search-suggestions-system/)| Search Suggestions System| +|[695](https://leetcode.com/problems/max-area-of-island/)| Max Area of Island| +|[97](https://leetcode.com/problems/interleaving-string/)| Interleaving String| +|[1465](https://leetcode.com/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/)| Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts| +|[128](https://leetcode.com/problems/longest-consecutive-sequence/)| Longest Consecutive Sequence| +|[105](https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)| Construct Binary Tree from Preorder and Inorder Traversal| +|[1696](https://leetcode.com/problems/jump-game-vi/)| Jump Game VI| +|[698](https://leetcode.com/problems/partition-to-k-equal-sum-subsets/)| Partition to K Equal Sum Subsets| +|[22](https://leetcode.com/problems/generate-parentheses/)| Generate Parentheses| +|[795](https://leetcode.com/problems/number-of-subarrays-with-bounded-maximum/)| Number of Subarrays with Bounded Maximum| +|[118](https://leetcode.com/problems/pascals-triangle/)| Pascal's Triangle| +|[576](https://leetcode.com/problems/out-of-boundary-paths/)| Out of Boundary Paths| +|[684](https://leetcode.com/problems/redundant-connection/)| Redundant Connection| +|[1004](https://leetcode.com/problems/max-consecutive-ones-iii/)| Max Consecutive Ones III| +|[236](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/)| Lowest Common Ancestor of a Binary Tree| +|[89](https://leetcode.com/problems/gray-code/)| Gray Code| +|[378](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/)| Kth Smallest Element in a Sorted Matrix| +|[718](https://leetcode.com/problems/maximum-length-of-repeated-subarray/)| Maximum Length of Repeated Subarray| +|[300](https://leetcode.com/problems/longest-increasing-subsequence/)| Longest Increasing Subsequence| +|[162](https://leetcode.com/problems/find-peak-element/)| Find Peak Element| +|[791](https://leetcode.com/problems/custom-sort-string/)| Custom Sort String| +|[611](https://leetcode.com/problems/valid-triangle-number/)| Valid Triangle Number| +|[235](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)| Lowest Common Ancestor of a Binary Search Tree| +|[838](https://leetcode.com/problems/push-dominoes/)| Push Dominoes| +|[915](https://leetcode.com/problems/partition-array-into-disjoint-intervals/)| Partition Array into Disjoint Intervals| +|[814](https://leetcode.com/problems/binary-tree-pruning/)| Binary Tree Pruning| +|[90](https://leetcode.com/problems/subsets-ii/)| Subsets II| +|[877](https://leetcode.com/problems/stone-game/)| Stone Game| +|[429](https://leetcode.com/problems/n-ary-tree-level-order-traversal/)| N-ary Tree Level Order Traversal| +|[926](https://leetcode.com/problems/flip-string-to-monotone-increasing/)| Flip String to Monotone Increasing| +|[954](https://leetcode.com/problems/array-of-doubled-pairs/)| Array of Doubled Pairs| +|[49](https://leetcode.com/problems/group-anagrams/)| Group Anagrams| +|[73](https://leetcode.com/problems/set-matrix-zeroes/)| Set Matrix Zeroes| +|[1448](https://leetcode.com/problems/count-good-nodes-in-binary-tree/)| Count Good Nodes in Binary Tree| +|[36](https://leetcode.com/problems/valid-sudoku/)| Valid Sudoku| +|[153](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/)| Find Minimum in Rotated Sorted Array| +|[565](https://leetcode.com/problems/array-nesting/)| Array Nesting| +|[848](https://leetcode.com/problems/shifting-letters/)| Shifting Letters| +|[978](https://leetcode.com/problems/longest-turbulent-subarray/)| Longest Turbulent Subarray| +|[54](https://leetcode.com/problems/spiral-matrix/)| Spiral Matrix| +|[1239](https://leetcode.com/problems/maximum-length-of-a-concatenated-string-with-unique-characters/)| Maximum Length of a Concatenated String with Unique Characters| +|[725](https://leetcode.com/problems/split-linked-list-in-parts/)| Split Linked List in Parts| +|[473](https://leetcode.com/problems/matchsticks-to-square/)| Matchsticks to Square| +|[1143](https://leetcode.com/problems/longest-common-subsequence/)| Longest Common Subsequence| +|[55](https://leetcode.com/problems/jump-game/)| Jump Game| +|[442](https://leetcode.com/problems/find-all-duplicates-in-an-array/)| Find All Duplicates in an Array| +|[79](https://leetcode.com/problems/word-search/)| Word Search| +|[201](https://leetcode.com/problems/bitwise-and-of-numbers-range/)| Bitwise AND of Numbers Range| +|[1008](https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal/)| Construct Binary Search Tree from Preorder Traversal| +|[309](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/)| Best Time to Buy and Sell Stock with Cooldown| +|[437](https://leetcode.com/problems/path-sum-iii/)| Path Sum III| +|[4511](https://leetcode.com/problems/sort-characters-by-frequency/)| Sort Characters By Frequency| +|[222](https://leetcode.com/problems/count-complete-tree-nodes/)| Count Complete Tree Nodes| +|[75](https://leetcode.com/problems/sort-colors/)| Sort Colors| +|[15](https://leetcode.com/problems/3sum/)| 3Sum| +|[994](https://leetcode.com/problems/rotting-oranges/)| Rotting Oranges| +|[430](https://leetcode.com/problems/flatten-a-multilevel-doubly-linked-list/)| Flatten a Multilevel Doubly Linked List| +|[130](https://leetcode.com/problems/surrounded-regions/)| Surrounded Regions| +|[129](https://leetcode.com/problems/sum-root-to-leaf-numbers/)| Sum Root to Leaf Numbers| +|[260](https://leetcode.com/problems/single-number-iii/)| Single Number III| +|[43](https://leetcode.com/problems/multiply-strings/)| Multiply Strings| +|[96](https://leetcode.com/problems/unique-binary-search-trees/)| Unique Binary Search Trees| +|[122](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/)| Best Time to Buy and Sell Stock II| +|[739](https://leetcode.com/problems/daily-temperatures/)| Daily Temperatures| +|[368](https://leetcode.com/problems/largest-divisible-subset/)| Largest Divisible Subset| +|[540](https://leetcode.com/problems/single-element-in-a-sorted-array/)| Single Element in a Sorted Array| +|[106](https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/)| Construct Binary Tree from Inorder and Postorder Traversal| +|[450](https://leetcode.com/problems/delete-node-in-a-bst/)| Delete Node in a BST| +|[986](https://leetcode.com/problems/interval-list-intersections/)| Interval List Intersections| +|[238](https://leetcode.com/problems/product-of-array-except-self/)| Product of Array Except Self| +|[797](https://leetcode.com/problems/all-paths-from-source-to-target/)| All Paths From Source to Target| +|[721](https://leetcode.com/problems/accounts-merge/)| Accounts Merge| +|[198](https://leetcode.com/problems/house-robber/)| House Robber| +|[328](https://leetcode.com/problems/odd-even-linked-list/)| Odd Even Linked List| +|[152](https://leetcode.com/problems/maximum-product-subarray/)| Maximum Product Subarray| +|[1306](https://leetcode.com/problems/jump-game-iii/)| Jump Game III| +|[790](https://leetcode.com/problems/domino-and-tromino-tiling/)| Domino and Tromino Tiling| +|[416](https://leetcode.com/problems/partition-equal-subset-sum/)| Partition Equal Subset Sum| +|[310](https://leetcode.com/problems/minimum-height-trees/)| Minimum Height Trees| +|[221](https://leetcode.com/problems/maximal-square/)| Maximal Square| +|[394](https://leetcode.com/problems/decode-string/)| Decode String| +|[143](https://leetcode.com/problems/reorder-list/)| Reorder List| +|[210](https://leetcode.com/problems/course-schedule-ii/)| Course Schedule II| +|[56](https://leetcode.com/problems/merge-intervals/)| Merge Intervals| +|[227](https://leetcode.com/problems/basic-calculator-ii/)| Basic Calculator II| +|[973](https://leetcode.com/problems/k-closest-points-to-origin/)| K Closest Points to Origin| +|[116](https://leetcode.com/problems/populating-next-right-pointers-in-each-node/)| Populating Next Right Pointers in Each Node| +|[1015](https://leetcode.com/problems/smallest-integer-divisible-by-k/)| Smallest Integer Divisible by K| +|[1026](https://leetcode.com/problems/maximum-difference-between-node-and-ancestor/)| Maximum Difference Between Node and Ancestor| +|[1010](https://leetcode.com/problems/pairs-of-songs-with-total-durations-divisible-by-60/)| Pairs of Songs With Total Durations Divisible by 60| +|[131](https://leetcode.com/problems/palindrome-partitioning/)| Palindrome Partitioning| +|[382](https://leetcode.com/problems/linked-list-random-node/)| Linked List Random Node| +|[1041](https://leetcode.com/problems/robot-bounded-in-circle/)| Robot Bounded In Circle| +|[701](https://leetcode.com/problems/insert-into-a-binary-search-tree/)| Insert into a Binary Search Tree| +|[452](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/)| Minimum Number of Arrows to Burst Balloons| +|[8](https://leetcode.com/problems/string-to-integer-atoi/)| String to Integer (atoi)| +|[849](https://leetcode.com/problems/maximize-distance-to-closest-person/)| Maximize Distance to Closest Person| +|[142](https://leetcode.com/problems/linked-list-cycle-ii/)| Linked List Cycle II| +|[875](https://leetcode.com/problems/koko-eating-bananas/)| Koko Eating Bananas| +|[134](https://leetcode.com/problems/gas-station/)| Gas Station| +|[1291](https://leetcode.com/problems/sequential-digits/)| Sequential Digits| +|[421](https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array/)| Maximum XOR of Two Numbers in an Array| +|[211](https://leetcode.com/problems/design-add-and-search-words-data-structure/)| Design Add and Search Words Data Structure| +|[438](https://leetcode.com/problems/find-all-anagrams-in-a-string/)| Find All Anagrams in a String| +|[454](https://leetcode.com/problems/4sum-ii/)| 4Sum II| +|[525](https://leetcode.com/problems/contiguous-array/)| Contiguous Array| +|[80](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/)| Remove Duplicates from Sorted Array II| +|[532](https://leetcode.com/problems/k-diff-pairs-in-an-array/)| K-diff Pairs in an Array| +|[560](https://leetcode.com/problems/subarray-sum-equals-k/)| Subarray Sum Equals K| +|[567](https://leetcode.com/problems/permutation-in-string/)| Permutation in String| +|[78](https://leetcode.com/problems/subsets/)| Subsets| +|[39](https://leetcode.com/problems/combination-sum/)| Combination Sum| +|[402](https://leetcode.com/problems/remove-k-digits/)| Remove K Digits| +|[133](https://leetcode.com/problems/clone-graph/)| Clone Graph| +|[148](https://leetcode.com/problems/sort-list/)| Sort List| +|[662](https://leetcode.com/problems/maximum-width-of-binary-tree/)| Maximum Width of Binary Tree| +|[413](https://leetcode.com/problems/arithmetic-slices/)| Arithmetic Slices| +|[799](https://leetcode.com/problems/champagne-tower/)| Champagne Tower| +|[82](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/)| Remove Duplicates from Sorted List II| +|[61](https://leetcode.com/problems/rotate-list/)| Rotate List| +|[138](https://leetcode.com/problems/copy-list-with-random-pointer/)| Copy List with Random Pointer| +|[71](https://leetcode.com/problems/simplify-path/)| Simplify Path| +|[1249](https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/)| Minimum Remove to Make Valid Parentheses| +|[856](https://leetcode.com/problems/score-of-parentheses/)| Score of Parentheses| +|[316](https://leetcode.com/problems/remove-duplicate-letters/)| Remove Duplicate Letters| +|[763](https://leetcode.com/problems/partition-labels/)| Partition Labels| +|[1663](https://leetcode.com/problems/smallest-string-with-a-given-numeric-value/)| Smallest String With A Given Numeric Value| +|[991](https://leetcode.com/problems/broken-calculator/)| Broken Calculator| +|[881](https://leetcode.com/problems/boats-to-save-people/)| Boats to Save People| +|[1024](https://leetcode.com/problems/two-city-scheduling/)| Two City Scheduling| +|[81](https://leetcode.com/problems/search-in-rotated-sorted-array-ii/)| Search in Rotated Sorted Array II| +|[287](https://leetcode.com/problems/find-the-duplicate-number/)| Find the Duplicate Number| +|[74](https://leetcode.com/problems/search-a-2d-matrix/)| Search a 2D Matrix| +|[11](https://leetcode.com/problems/container-with-most-water/)| Container With Most Water| +|[538](https://leetcode.com/problems/convert-bst-to-greater-tree/)| Convert BST to Greater Tree| +|[230](https://leetcode.com/problems/kth-smallest-element-in-a-bst/)| Kth Smallest Element in a BST| +|[284](https://leetcode.com/problems/peeking-iterator/)| Peeking Iterator| +|[216](https://leetcode.com/problems/combination-sum-iii/)| Combination Sum III| +|[47](https://leetcode.com/problems/permutations-ii/)| Permutations II| +|[117](https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/)| Populating Next Right Pointers in Each Node II| +|[743](https://leetcode.com/problems/network-delay-time/)| Network Delay Time| +|[474](https://leetcode.com/problems/ones-and-zeroes/)| Ones and Zeroes| +|[167](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/)| Two Sum II - Input Array Is Sorted| +|[3](https://leetcode.com/problems/longest-substring-without-repeating-characters/)| Longest Substring Without Repeating Characters| +|[1658](https://leetcode.com/problems/minimum-operations-to-reduce-x-to-zero/)| Minimum Operations to Reduce X to Zero| +|[215](https://leetcode.com/problems/kth-largest-element-in-an-array/)| Kth Largest Element in an Array| +|[1570](https://leetcode.com/problems/dot-product-of-two-sparse-vectors/)| Dot Product of Two Sparse Vectors| +|[199](https://leetcode.com/problems/binary-tree-right-side-view/)| Binary Tree Right Side View| +|[92](https://leetcode.com/problems/reverse-linked-list-ii/)| Reverse Linked List II| +|[307](https://leetcode.com/problems/range-sum-query-mutable/)| Range Sum Query - Mutable| +|[240](https://leetcode.com/problems/search-a-2d-matrix-ii/)| Search a 2D Matrix II| +|[1457](https://leetcode.com/problems/pseudo-palindromic-paths-in-a-binary-tree/)| Pseudo-Palindromic Paths in a Binary Tree| +|[1770](https://leetcode.com/problems/maximum-score-from-performing-multiplication-operations/)| Maximum Score from Performing Multiplication Operations| +|[985](https://leetcode.com/problems/sum-of-even-numbers-after-queries/)| Sum of Even Numbers After Queries| +|[1680](https://leetcode.com/problems/concatenation-of-consecutive-binary-numbers/)| Concatenation of Consecutive Binary Numbers| +|[990](https://leetcode.com/problems/satisfiability-of-equality-equations/)| Satisfiability of Equality Equations| +|[658](https://leetcode.com/problems/find-k-closest-elements/description/)| Find K Closest Elements| +|[1578](https://leetcode.com/problems/minimum-time-to-make-rope-colorful/description/)| Minimum Time to Make Rope Colorful| +|[16](https://leetcode.com/problems/3sum-closest/description/)| 3Sum Closest| +|[334](https://leetcode.com/problems/increasing-triplet-subsequence/)| Increasing Triplet Subsequence| +|[2095](https://leetcode.com/problems/delete-the-middle-node-of-a-linked-list/)| Delete the Middle Node of a Linked List| +|[1662](https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/)| Check If Two String Arrays are Equivalent| +|[523](https://leetcode.com/problems/continuous-subarray-sum/)| Continuous Subarray Sum| +|[835](https://leetcode.com/problems/image-overlap/)| Image Overlap| +|[433](https://leetcode.com/problems/minimum-genetic-mutation/)| Minimum Genetic Mutation| +|[1926](https://leetcode.com/problems/nearest-exit-from-entrance-in-maze/)| Nearest Exit from Entrance in Maze| +|[2225](https://leetcode.com/problems/find-players-with-zero-or-one-losses/)| Find Players With Zero or One Losses| +|[380](https://leetcode.com/problems/insert-delete-getrandom-o1/)| Insert Delete GetRandom O(1)| +|[1207](https://leetcode.com/problems/unique-number-of-occurrences/)| Unique Number of Occurrences| +|[45](https://leetcode.com/problems/jump-game-ii/)| Jump Game II| +|[1014](https://leetcode.com/problems/best-sightseeing-pair/)| Best Sightseeing Pair| +|[886](https://leetcode.com/problems/possible-bipartition/)| Possible Bipartition| +|[2279](https://leetcode.com/problems/maximum-bags-with-full-capacity-of-rocks/)| Maximum Bags With Full Capacity of Rocks| +|[343](https://leetcode.com/problems/integer-break/)| Integer Break| +|[256](https://leetcode.com/problems/paint-house/)| Paint House| +|[487](https://leetcode.com/problems/max-consecutive-ones-ii/)| Max Consecutive Ones II| +|[1746](https://leetcode.com/problems/maximum-subarray-sum-after-one-operation/)| Maximum Subarray Sum After One Operation| +|[1230](https://leetcode.com/problems/toss-strange-coins/)| Toss Strange Coins| +|[2498](https://leetcode.com/problems/frog-jump-ii/)| Frog Jump II| +|[2244](https://leetcode.com/problems/minimum-rounds-to-complete-all-tasks/)| Minimum Rounds to Complete All Tasks| +|[1749](https://leetcode.com/problems/maximum-absolute-sum-of-any-subarray/)| Maximum Absolute Sum of Any Subarray| +|[2186](https://leetcode.com/problems/minimum-number-of-steps-to-make-two-strings-anagram-ii/)| Minimum Number of Steps to Make Two Strings Anagram II| +|[2414](https://leetcode.com/problems/length-of-the-longest-alphabetical-continuous-substring/)| Length of the Longest Alphabetical Continuous Substring| +|[1519](https://leetcode.com/problems/number-of-nodes-in-the-sub-tree-with-the-same-label/)| Number of Nodes in the Sub-Tree With the Same Label| +|[1061](https://leetcode.com/problems/lexicographically-smallest-equivalent-string/)| Lexicographically Smallest Equivalent String| +|[1314](https://leetcode.com/problems/matrix-block-sum/)| Matrix Block Sum| +|[57](https://leetcode.com/problems/insert-interval/)| Insert Interval| +|[974](https://leetcode.com/problems/subarray-sums-divisible-by-k/)| Subarray Sums Divisible by K| +|[491](https://leetcode.com/problems/non-decreasing-subsequences/)| Non-decreasing Subsequences| +|[2359](https://leetcode.com/problems/find-closest-node-to-given-two-nodes/)| Find Closest Node to Given Two Nodes| +|[909](https://leetcode.com/problems/snakes-and-ladders/)| Snakes and Ladders| +|[787](https://leetcode.com/problems/cheapest-flights-within-k-stops/)| Cheapest Flights Within K Stops| +|[6](https://leetcode.com/problems/zigzag-conversion/)| Zigzag Conversion| +|[904](https://leetcode.com/problems/fruit-into-baskets/)| Fruit Into Baskets| +|[1162](https://leetcode.com/problems/as-far-from-land-as-possible/)| As Far from Land as Possible| +|[2477](https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/)| Minimum Fuel Cost to Report to the Capital| +|[1129](https://leetcode.com/problems/shortest-path-with-alternating-colors/)| Shortest Path with Alternating Colors| +|[103](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/)| Binary Tree Zigzag Level Order Traversal| +|[1011](https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/)| Capacity To Ship Packages Within D Days| +|[427](https://leetcode.com/problems/construct-quad-tree/)| Construct Quad Tree| +|[652](https://leetcode.com/problems/find-duplicate-subtrees/)| Find Duplicate Subtrees| +|[443](https://leetcode.com/problems/string-compression/)| String Compression| +|[2187](https://leetcode.com/problems/minimum-time-to-complete-trips/)| Minimum Time to Complete Trips| +|[958](https://leetcode.com/problems/check-completeness-of-a-binary-tree/)| Check Completeness of a Binary Tree| +|[2492](https://leetcode.com/problems/minimum-score-of-a-path-between-two-cities/)| Minimum Score of a Path Between Two Cities| +|[1466](https://leetcode.com/problems/reorder-routes-to-make-all-paths-lead-to-the-city-zero/)| Reorder Routes to Make All Paths Lead to the City Zero| +|[2316](https://leetcode.com/problems/count-unreachable-pairs-of-nodes-in-an-undirected-graph/)| Count Unreachable Pairs of Nodes in an Undirected Graph| +|[2405](https://leetcode.com/problems/optimal-partition-of-string/)| Optimal Partition of String| +|[2300](https://leetcode.com/problems/successful-pairs-of-spells-and-potions/)| Successful Pairs of Spells and Potions| +|[2439](https://leetcode.com/problems/minimize-maximum-of-array/)| Minimize Maximum of Array| +|[516](https://leetcode.com/problems/longest-palindromic-subsequence/)| Longest Palindromic Subsequence| +|[319](https://leetcode.com/problems/bulb-switcher/)| Bulb Switcher| +|[649](https://leetcode.com/problems/dota2-senate/)| Dota2 Senate| +|[934](https://leetcode.com/problems/shortest-bridge/)| Shortest Bridge| +|[1318](https://leetcode.com/problems/minimum-flips-to-make-a-or-b-equal-to-c/)| Minimum Flips to Make a OR b Equal to c| +|[2352](https://leetcode.com/problems/equal-row-and-column-pairs/)| Equal Row and Column Pairs| +|[863](https://leetcode.com/problems/all-nodes-distance-k-in-binary-tree/)| All Nodes Distance K in Binary Tree| +|[207](https://leetcode.com/problems/course-schedule/)| Course Schedule| +|[1218](https://leetcode.com/problems/longest-arithmetic-subsequence-of-given-difference/)| Longest Arithmetic Subsequence of Given Difference| +|[735](https://leetcode.com/problems/asteroid-collision/)| Asteroid Collision| +|[673](https://leetcode.com/problems/number-of-longest-increasing-subsequence/)| Number of Longest Increasing Subsequence| +|[688](https://leetcode.com/problems/knight-probability-in-chessboard/)| Knight Probability in Chessboard| +|[852](https://leetcode.com/problems/peak-index-in-a-mountain-array/)| Peak Index in a Mountain Array| +|[852](https://leetcode.com/problems/minimum-speed-to-arrive-on-time/)| Minimum Speed to Arrive on Time| +|[486](https://leetcode.com/problems/predict-the-winner/)| Predict the Winner| +|[808](https://leetcode.com/problems/soup-servings/)| Soup Servings| +|[712](https://leetcode.com/problems/minimum-ascii-delete-sum-for-two-strings/)| Minimum ASCII Delete Sum for Two Strings| +|[77](https://leetcode.com/problems/combinations/)| Combinations| +|[46](https://leetcode.com/problems/permutations/)| Permutations| +|[33](https://leetcode.com/problems/search-in-rotated-sorted-array/)| Search in Rotated Sorted Array| +|[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/L1004.go b/Medium/L1004.go new file mode 100644 index 0000000..92326e2 --- /dev/null +++ b/Medium/L1004.go @@ -0,0 +1,22 @@ +package Medium + +func longestOnes(nums []int, k int) int { + max, zeroCnt, i, j := 0, 0, 0, 0 + for ; j < len(nums); j++ { + if nums[j] == 0 { + zeroCnt++ + } + + for zeroCnt > k { + if nums[i] == 0 { + zeroCnt-- + } + i++ + } + if (j - i + 1) > max { + max = j - i + 1 + } + } + + return max +} diff --git a/Medium/L1008.go b/Medium/L1008.go new file mode 100644 index 0000000..7cbbc0f --- /dev/null +++ b/Medium/L1008.go @@ -0,0 +1,23 @@ +package Medium + +func bstFromPreorder(preorder []int) *TreeNode { + idx := 0 + return dfs(preorder, math.MinInt64, math.MaxInt64, &idx) +} + +func dfs(preorder []int, low, high int, idx *int) *TreeNode { + if *idx >= len(preorder) { + return nil + } + if preorder[*idx] < low || preorder[*idx] > high { + return nil + } + + root := &TreeNode{ + Val: preorder[*idx], + } + *idx += 1 + root.Left, root.Right = dfs(preorder, low, root.Val, idx), dfs(preorder, root.Val, high, idx) + + return root +} diff --git a/Medium/L1010.go b/Medium/L1010.go new file mode 100644 index 0000000..95fe644 --- /dev/null +++ b/Medium/L1010.go @@ -0,0 +1,18 @@ +package Medium + +func numPairsDivisibleBy60(time []int) int { + ans, mp := 0, make(map[int]int) + + for _, t := range time { + other, reducedTime := 0, t%60 + if reducedTime != 0 { + other = 60 - reducedTime + } + if val, ok := mp[other]; ok { + ans += val + } + mp[reducedTime]++ + } + + return ans +} diff --git a/Medium/L1011.go b/Medium/L1011.go new file mode 100644 index 0000000..054e35d --- /dev/null +++ b/Medium/L1011.go @@ -0,0 +1,54 @@ +package Medium + +func shipWithinDays(weights []int, days int) int { + if len(weights) == 0 { + return 0 + } + + maxi, sum := math.MinInt32, 0 + for _, w := range weights { + maxi = max(maxi, w) + sum += w + } + + if days == 1 { + return sum + } + + isFeasible := func(maxWeight int) bool { + cnt, maximum, day := 0, maxWeight, 0 + for _, w := range weights { + if w <= maximum { + cnt++ + } else { + cnt = 0 + maximum = maxWeight + day++ + } + maximum -= w + } + + return day+1 <= days + } + + low, high := maxi, sum + for low < high { + mid := low + (high-low)/2 + + if isFeasible(mid) { + high = mid + } else { + low = mid + 1 + } + } + + return low +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L1014.go b/Medium/L1014.go new file mode 100644 index 0000000..5791d4d --- /dev/null +++ b/Medium/L1014.go @@ -0,0 +1,41 @@ +package Medium + +func maxScoreSightseeingPair(values []int) int { + mp := make(map[string]int) + + return solve(0, 0, values, mp) +} + +func solve(i, taken int, values []int, mp map[string]int) int { + if taken >= 2 { + return 0 + } + + if i >= len(values) { + return math.MinInt32 + } + + key := fmt.Sprintf("%d-%d", i, taken) + if v, ok := mp[key]; ok { + return v + } + + pick, notPick := values[i]+solve(i+1, taken+1, values, mp), solve(i+1, taken, values, mp) + + if taken == 1 { + pick -= i + } else { + pick += i + } + + mp[key] = max(pick, notPick) + return mp[key] +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L1015.go b/Medium/L1015.go new file mode 100644 index 0000000..0b12dbb --- /dev/null +++ b/Medium/L1015.go @@ -0,0 +1,34 @@ +package Medium + +// Time Complexity:O(k) +// Space Complexity:O(k) +var exists struct{} + +func smallestRepunitDivByK(k int) int { + n, ans, mp := 0, 0, make(map[int]struct{}) + + for { + ans, n = ans+1, (n*10+1)%k + if n == 0 { + return ans + } + if _, ok := mp[n]; ok { + return -1 + } + mp[n] = exists + } +} + +// Time Complexity:O(k) +// Space Complexity:O(1) +func smallestRepunitDivByK(k int) int { + n := 0 + for i := 0; i < k; i++ { + n = (n*10 + 1) % k + if n == 0 { + return i + 1 + } + } + + return -1 +} diff --git a/Medium/L1026.go b/Medium/L1026.go new file mode 100644 index 0000000..c508696 --- /dev/null +++ b/Medium/L1026.go @@ -0,0 +1,46 @@ +package Medium + +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func maxAncestorDiff(root *TreeNode) int { + res := 0 + if root == nil { + return res + } + dfs(root, root.Val, root.Val, &res) + + return res +} + +func dfs(root *TreeNode, minimum, maximum int, res *int) { + if root == nil { + return + } + minimum, maximum = min(root.Val, minimum), max(root.Val, maximum) + *res = max(*res, maximum - minimum) + + dfs(root.Left, minimum, maximum, res) + dfs(root.Right, minimum, maximum, res) +} + +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/L1029.go b/Medium/L1029.go new file mode 100644 index 0000000..9f03ac2 --- /dev/null +++ b/Medium/L1029.go @@ -0,0 +1,18 @@ +package Medium + +func twoCitySchedCost(costs [][]int) int { + sort.Slice(costs, func(i, j int) bool { + return (costs[i][1]-costs[i][0])-(costs[j][1]-costs[j][0]) > 0 + }) + + res := 0 + for i := 0; i < len(costs); i++ { + if i < len(costs)/2 { + res += costs[i][0] + } else { + res += costs[i][1] + } + } + + return res +} diff --git a/Medium/L103.go b/Medium/L103.go new file mode 100644 index 0000000..5df5925 --- /dev/null +++ b/Medium/L103.go @@ -0,0 +1,46 @@ +package Medium + +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func zigzagLevelOrder(root *TreeNode) [][]int { + var res [][]int + if root == nil { + return res + } + + var q []*TreeNode + q = append(q, root) + normalOrder := false + + for len(q) > 0 { + size := len(q) + var lvlVals []int + normalOrder = !normalOrder + for i := 0; i < size; i++ { + cur := q[0] + q = q[1:] + + if normalOrder { + lvlVals = append(lvlVals, cur.Val) + } else { + lvlVals = append([]int{cur.Val}, lvlVals...) + } + + if cur.Left != nil { + q = append(q, cur.Left) + } + if cur.Right != nil { + q = append(q, cur.Right) + } + } + res = append(res, lvlVals) + } + + return res +} diff --git a/Medium/L1041.go b/Medium/L1041.go new file mode 100644 index 0000000..da6ffd6 --- /dev/null +++ b/Medium/L1041.go @@ -0,0 +1,37 @@ +package Medium + +type Direction int + +const ( + DirectionUp Direction = 0 + DirectionRight Direction = 1 + DirectionDown Direction = 2 + DirectionLeft Direction = 3 + DirectionInvalid Direction = 4 +) + +func isRobotBounded(instructions string) bool { + cur, dirs := []int{0, 0}, [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + dir := DirectionUp + + for _, c := range instructions { + if c == 'G' { + cur[0] += dirs[dir][0] + cur[1] += dirs[dir][1] + } else if c == 'L' { + dir = (dir + 3) % 4 + } else { + dir = (dir + 1) % 4 + } + } + + if cur[0] == 0 && cur[1] == 0 { + return true + } + + if dir == 0 && !(cur[0] == 0 && cur[1] == 0) { + return false + } + + return true +} diff --git a/Medium/L105.go b/Medium/L105.go new file mode 100644 index 0000000..e46dfbd --- /dev/null +++ b/Medium/L105.go @@ -0,0 +1,33 @@ +package Medium + +func buildTree(preorder []int, inorder []int) *TreeNode { + if len(preorder) == 0 || len(inorder) == 0 { + return nil + } + + mp := make(map[int]int) + for i := range inorder { + mp[inorder[i]] = i + } + + return solve(preorder, inorder, mp, 0, len(preorder)-1, 0, len(inorder)-1) +} + +func solve(preorder, inorder []int, mp map[int]int, preStart, preEnd, inStart, inEnd int) *TreeNode { + if preStart > preEnd || inStart > inEnd { + return nil + } + + root := &TreeNode{ + Val: preorder[preStart], + Left: nil, + Right: nil, + } + inRoot := mp[root.Val] + numLeft := inRoot - inStart + + root.Left = solve(preorder, inorder, mp, preStart+1, preStart+numLeft, inStart, inRoot-1) + root.Right = solve(preorder, inorder, mp, preStart+numLeft+1, preEnd, inRoot+1, inEnd) + + return root +} diff --git a/Medium/L106.go b/Medium/L106.go new file mode 100644 index 0000000..9d21799 --- /dev/null +++ b/Medium/L106.go @@ -0,0 +1,31 @@ +package Medium + +func buildTree(inorder []int, postorder []int) *TreeNode { + if len(inorder) == 0 || len(postorder) == 0 { + return nil + } + + mp := make(map[int]int) + for i := range inorder { + mp[inorder[i]] = i + } + + return helper(postorder, 0, len(postorder)-1, inorder, 0, len(inorder)-1, mp) +} + +func helper(postOrder []int, postStart, postEnd int, inOrder []int, inStart, inEnd int, mp map[int]int) *TreeNode { + if postStart > postEnd || inStart > inEnd { + return nil + } + + root := &TreeNode{ + Val: postOrder[postEnd], + } + inRoot := mp[root.Val] + numsLeft := inRoot - inStart + + root.Left = helper(postOrder, postStart, postStart+numsLeft-1, inOrder, inStart, inRoot-1, mp) + root.Right = helper(postOrder, postStart+numsLeft, postEnd-1, inOrder, inRoot+1, inEnd, mp) + + return root +} diff --git a/Medium/L1061.go b/Medium/L1061.go new file mode 100644 index 0000000..0d6a5e6 --- /dev/null +++ b/Medium/L1061.go @@ -0,0 +1,51 @@ +package Medium + +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 +} + +func smallestEquivalentString(s1 string, s2 string, baseStr string) string { + var sb strings.Builder + parent := make([]int, 26) + for i := 0; i < 26; i++ { + parent[i] = -1 + } + + for i := 0; i < len(s1); i++ { + union(int(s1[i]-'a'), int(s2[i]-'a'), &parent) + } + for i := 0; i < len(baseStr); i++ { + sb.WriteByte(byte(find(int(baseStr[i]-'a'), &parent) + 'a')) + } + + return sb.String() +} + +func union(x, y int, parent *[]int) { + x, y = find(x, parent), find(y, parent) + + if x != y { + (*parent)[max(x, y)] = min(x, y) + } +} + +func find(x int, parent *[]int) int { + if (*parent)[x] == -1 { + return x + } + + (*parent)[x] = find((*parent)[x], parent) + return (*parent)[x] +} diff --git a/Medium/L11.go b/Medium/L11.go new file mode 100644 index 0000000..6a7f332 --- /dev/null +++ b/Medium/L11.go @@ -0,0 +1,33 @@ +package Medium + +func maxArea(height []int) int { + l, r, mini, maxi := 0, len(height)-1, math.MaxInt32, math.MinInt32 + + for l <= r { + mini = min(height[l], height[r]) + maxi = max(maxi, mini*(r-l)) + if l <= r && height[l] < height[r] { + l++ + } else { + r-- + } + } + + return maxi +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Medium/L1129.go b/Medium/L1129.go new file mode 100644 index 0000000..6d0d837 --- /dev/null +++ b/Medium/L1129.go @@ -0,0 +1,57 @@ +package Medium + +var exists struct{} + +//1=red, 2=blue, 0=root-edge (special case) +func shortestAlternatingPaths(n int, redEdges [][]int, blueEdges [][]int) []int { + reds, blues := make([][]int, n), make([][]int, n) + + for _, e := range redEdges { + reds[e[0]] = append(reds[e[0]], e[1]) + } + + for _, e := range blueEdges { + blues[e[0]] = append(blues[e[0]], e[1]) + } + + var q [][]int + res, moves, seen := make([]int, n), 0, make(map[string]struct{}) + for i := 0; i < n; i++ { + res[i] = -1 + } + q = append(q, []int{0, 0}) + + for len(q) > 0 { + size := len(q) + for i := 0; i < size; i++ { + curr := q[0] + q = q[1:] + key := fmt.Sprintf("%d-%d", curr[0], curr[1]) + if _, ok := seen[key]; ok { + continue + } + seen[key] = exists + + if res[curr[0]] == -1 { + res[curr[0]] = moves + } + if curr[1] == 2 || curr[1] == 0 { + if len(reds[curr[0]]) > 0 { + for _, neigh := range reds[curr[0]] { + q = append(q, []int{neigh, 1}) + } + } + } + if curr[1] == 1 || curr[1] == 0 { + if len(blues[curr[0]]) > 0 { + for _, neigh := range blues[curr[0]] { + q = append(q, []int{neigh, 2}) + } + } + } + } + moves++ + } + + return res +} diff --git a/Medium/L1143.go b/Medium/L1143.go new file mode 100644 index 0000000..58589cd --- /dev/null +++ b/Medium/L1143.go @@ -0,0 +1,30 @@ +package Medium + +func longestCommonSubsequence(text1 string, text2 string) int { + var ( + solve func(m, n int) int + ) + m, n := len(text1), len(text2) + mp := make(map[string]int) + + solve = func(m, n int) int { + if m == 0 || n == 0 { + return 0 + } + + key := fmt.Sprintf("%d#%d", m, n) + if v, ok := mp[key]; ok { + return v + } + + 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)) + } + + return mp[key] + } + + return solve(m, n) +} diff --git a/Medium/L116.go b/Medium/L116.go new file mode 100644 index 0000000..49b4f18 --- /dev/null +++ b/Medium/L116.go @@ -0,0 +1,52 @@ +// DFS solution +func connect(root *Node) *Node { + dfs(root, nil) + return root +} + +func dfs(curr, next *Node) { + if curr == nil { + return + } + + curr.Next = next + dfs(curr.Left, curr.Right) + + if curr.Next != nil { + dfs(curr.Right, curr.Next.Left) + } else { + dfs(curr.Right, nil) + } +} + +// BFS solution +func connect(root *Node) *Node { + if root == nil { + return root + } + + var q []*Node + q = append(q, root) + + for len(q) != 0 { + size := len(q) + for i := 0; i < size; i++ { + curr := q[0] + q = q[1:] + + if i != size-1 { + curr.Next = q[0] + } + + if curr.Left != nil { + q = append(q, curr.Left) + } + + if curr.Right != nil { + q = append(q, curr.Right) + } + } + } + + return root +} diff --git a/Medium/L1161.go b/Medium/L1161.go new file mode 100644 index 0000000..d8f524c --- /dev/null +++ b/Medium/L1161.go @@ -0,0 +1,32 @@ +package Medium + +func maxLevelSum(root *TreeNode) int { + var q []*TreeNode + maximum, maxLevel, lvl := math.MinInt32, -1, 1 + + q = append(q, root) + for len(q) > 0 { + size := len(q) + sum := 0 + for i := 0; i < size; i++ { + node := q[0] + q = q[1:] + + sum += node.Val + + if node.Left != nil { + q = append(q, node.Left) + } + if node.Right != nil { + q = append(q, node.Right) + } + } + if sum > maximum { + maximum = sum + maxLevel = lvl + } + lvl++ + } + + return maxLevel +} diff --git a/Medium/L1162.go b/Medium/L1162.go new file mode 100644 index 0000000..20688c5 --- /dev/null +++ b/Medium/L1162.go @@ -0,0 +1,61 @@ +package Medium + +var dirs = [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + +func maxDistance(grid [][]int) int { + if len(grid) == 0 { + return 0 + } + + m, n := len(grid), len(grid[0]) + vis := make([][]bool, m) + for i := 0; i < m; i++ { + vis[i] = make([]bool, n) + } + var q [][]int + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if grid[i][j] == 1 { + q = append(q, []int{i, j}) + vis[i][j] = true + } + } + } + + if len(q) == 0 || len(q) == m*n { + return -1 + } + + lvl := -1 + for len(q) > 0 { + size := len(q) + for i := 0; i < size; i++ { + c := q[0] + q = q[1:] + + for _, d := range dirs { + newX, newY := c[0]+d[0], c[1]+d[1] + + if isValid(grid, newX, newY) { + if !vis[newX][newY] { + q = append(q, []int{newX, newY}) + vis[newX][newY] = true + } + } + } + } + lvl++ + } + + if lvl <= 0 { + return -1 + } + + return lvl +} + +func isValid(grid [][]int, x, y int) bool { + m, n := len(grid), len(grid[0]) + + return x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 0 +} diff --git a/Medium/L117.go b/Medium/L117.go new file mode 100644 index 0000000..96a44fa --- /dev/null +++ b/Medium/L117.go @@ -0,0 +1,34 @@ +package Medium + +func connect(root *Node) *Node { + if root == nil { + return root + } + + var q []*Node + q = append(q, root) + + for len(q) > 0 { + size := len(q) + tmp := make([]*Node, len(q)) + copy(tmp, q) + for i := 0; i < size; i++ { + node := q[0] + q = q[1:] + + if i != size-1 { + node.Next = tmp[i+1] + } + + if node.Left != nil { + q = append(q, node.Left) + } + + if node.Right != nil { + q = append(q, node.Right) + } + } + } + + return root +} diff --git a/Medium/L1207.go b/Medium/L1207.go new file mode 100644 index 0000000..c551ff0 --- /dev/null +++ b/Medium/L1207.go @@ -0,0 +1,18 @@ +package Medium + +func uniqueOccurrences(arr []int) bool { + var exists struct{} + mp, seen := make(map[int]int), make(map[int]struct{}) + + for _, n := range arr { + mp[n]++ + } + for _, v := range mp { + if _, ok := seen[v]; ok { + return false + } + seen[v] = exists + } + + return true +} diff --git a/Medium/L1218.go b/Medium/L1218.go new file mode 100644 index 0000000..5dcd61e --- /dev/null +++ b/Medium/L1218.go @@ -0,0 +1,25 @@ +package Medium + +func longestSubsequence(arr []int, difference int) int { + mp, ans := make(map[int]int), 0 + + for i := range arr { + if v, ok := mp[arr[i]-difference]; ok { + ans = max(ans, v+1) + mp[arr[i]] = v + 1 + } else { + ans = max(ans, 1) + mp[arr[i]] = 1 + } + } + + return ans +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} 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/L122.go b/Medium/L122.go new file mode 100644 index 0000000..73e2675 --- /dev/null +++ b/Medium/L122.go @@ -0,0 +1,45 @@ +package Medium + +func maxProfit(prices []int) int { + n := len(prices) + + if n < 2 { + return 0 + } + + memo := make([][]int, n+1) + for i := 0; i < n+1; i++ { + memo[i] = make([]int, 2) + for j := 0; j < 2; j++ { + memo[i][j] = -1 + } + } + + return solve(0, 1, prices, &memo) +} + +func solve(index, buy int, prices []int, memo *[][]int) int { + if index >= len(prices) { + return 0 + } + + if (*memo)[index][buy] != -1 { + return (*memo)[index][buy] + } + + if buy == 1 { + (*memo)[index][buy] = max(-prices[index]+solve(index+1, 0, prices, memo), solve(index+1, 1, prices, memo)) + } else { + (*memo)[index][buy] = max(prices[index]+solve(index+1, 1, prices, memo), solve(index+1, 0, prices, memo)) + } + + return (*memo)[index][buy] +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L1230.go b/Medium/L1230.go new file mode 100644 index 0000000..9827c44 --- /dev/null +++ b/Medium/L1230.go @@ -0,0 +1,31 @@ +package Medium + +func probabilityOfHeads(prob []float64, target int) float64 { + mp := make(map[string]float64) + + return solve(len(prob), target, prob, mp) +} + +func solve(idx, tgt int, prob []float64, mp map[string]float64) float64 { + if idx == 0 && tgt == 0 { + return 1 + } + if idx == 0 { + return 0 + } + if idx < tgt { + return 0 + } + + key := fmt.Sprintf("%d-%d", idx, tgt) + if v, ok := mp[key]; ok { + return v + } + + if tgt == 1 { + mp[key] += solve(idx-1, tgt-1, prob, mp) * prob[idx-1] + } + mp[key] += solve(idx-1, tgt, prob, mp) * (1 - prob[idx-1]) + + return mp[key] +} diff --git a/Medium/L1239.go b/Medium/L1239.go new file mode 100644 index 0000000..476bbbe --- /dev/null +++ b/Medium/L1239.go @@ -0,0 +1,44 @@ +package Medium + +func maxLength(arr []string) int { + result := 0 + + if len(arr) == 0 { + return result + } + + dfs(arr, "", 0, &result) + + return result +} + +func dfs(arr []string, path string, idx int, result *int) { + unique := isUnique(path) + + if unique { + if len(path) > *result { + *result = len(path) + } + } + + if idx == len(arr) || !unique { + return + } + + for i := idx; i < len(arr); i++ { + dfs(arr, path+arr[i], i+1, result) + } +} + +func isUnique(s string) bool { + mp := make(map[byte]bool) + + for _, c := range s { + if _, ok := mp[byte(c)]; ok { + return false + } + mp[byte(c)] = true + } + + return true +} diff --git a/Medium/L1249.go b/Medium/L1249.go new file mode 100644 index 0000000..7a00eac --- /dev/null +++ b/Medium/L1249.go @@ -0,0 +1,68 @@ +package Medium + +type Stack struct { + arr []int +} + +func NewStack() *Stack { + return &Stack{arr: make([]int, 0)} +} + +func (s *Stack) Push(c int) { + s.arr = append(s.arr, c) +} + +func (s *Stack) IsEmpty() bool { + return len(s.arr) == 0 +} + +func (s *Stack) Pop() int { + if s.IsEmpty() { + return 0 + } + + ret := s.arr[len(s.arr)-1] + s.arr = s.arr[:len(s.arr)-1] + return ret +} + +func (s *Stack) Top() int { + if s.IsEmpty() { + return 0 + } + + return s.arr[len(s.arr)-1] +} + +func minRemoveToMakeValid(s string) string { + var sb strings.Builder + st := NewStack() + match := make([]bool, len(s)) + + for i := 0; i < len(s); i++ { + if s[i] == '(' { + st.Push(i) + } else if s[i] == ')' { + if !st.IsEmpty() { + // match these pairs, all unmatched are false anyway + match[i] = true + match[st.Pop()] = true + } + } else { + // any character other than ( and ) are true anyway + match[i] = true + } + } + + for i := 0; i < len(s); i++ { + if match[i] { + sb.WriteByte(s[i]) + } + } + + if sb.Len() == 0 { + return "" + } + + return sb.String() +} diff --git a/Medium/L128.go b/Medium/L128.go new file mode 100644 index 0000000..8b2f67a --- /dev/null +++ b/Medium/L128.go @@ -0,0 +1,32 @@ +package Medium + +func longestConsecutive(nums []int) int { + numMap := map[int]bool{} + consecutiveNumCnt := 0 + + for _, num := range nums{ + numMap[num] = true + } + + for num := range numMap{ + if numMap[num - 1]{ + continue + } + + cur := num + for numMap[cur+1]{ + cur++ + } + + consecutiveNumCnt = max(consecutiveNumCnt, cur - num+1) + } + + return consecutiveNumCnt +} + +func max(a, b int)int{ + if a > b{ + return a + } + return b +} diff --git a/Medium/L129.go b/Medium/L129.go new file mode 100644 index 0000000..189da3e --- /dev/null +++ b/Medium/L129.go @@ -0,0 +1,20 @@ +package Medium + +func sumNumbers(root *TreeNode) int { + return dfs(root, 0) +} + +func dfs(root *TreeNode, currSum int) int { + if root == nil { + return 0 + } + + currSum = currSum*10 + root.Val + if root.Left == nil && root.Right == nil { + return currSum + } + + leftSum, rightSum := dfs(root.Left, currSum), dfs(root.Right, currSum) + + return leftSum + rightSum +} diff --git a/Medium/L1291.go b/Medium/L1291.go new file mode 100644 index 0000000..ebba04f --- /dev/null +++ b/Medium/L1291.go @@ -0,0 +1,27 @@ +package Medium + +func sequentialDigits(low int, high int) []int { + var q []int + for i := 1; i <= 9; i++ { + q = append(q, i) + } + + var ret []int + for len(q) > 0 { + n := q[0] + q = q[1:] + if n <= high && n >= low { + ret = append(ret, n) + } + + if n > high { + break + } + num := n % 10 + if num < 9 { + q = append(q, n*10+(num+1)) + } + } + + return ret +} diff --git a/Medium/L130.go b/Medium/L130.go new file mode 100644 index 0000000..8dc9aaa --- /dev/null +++ b/Medium/L130.go @@ -0,0 +1,66 @@ +package Medium + +var dirs = [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + +func isValid(board *[][]byte, x, y int) bool { + m, n := len(*board), len((*board)[0]) + + return x >= 0 && x < m && y >= 0 && y < n && (*board)[x][y] == 'O' +} + +func bfs(board *[][]byte, i, j int) { + var q [][]int + q = append(q, []int{i, j}) + + for len(q) > 0 { + tmp := q[0] + q = q[1:] + + x, y := tmp[0], tmp[1] + (*board)[x][y] = '1' + + for _, d := range dirs { + newX, newY := x+d[0], y+d[1] + if isValid(board, newX, newY) { + (*board)[newX][newY] = '1' + q = append(q, []int{newX, newY}) + } + } + } +} + +func solve(board [][]byte) { + for i := 0; i < len(board[0]); i++ { + if board[0][i] == 'O' { + bfs(&board, 0, i) + } + } + + for i := 0; i < len(board[0]); i++ { + if board[len(board)-1][i] == 'O' { + bfs(&board, len(board)-1, i) + } + } + + for i := 0; i < len(board); i++ { + if board[i][0] == 'O' { + bfs(&board, i, 0) + } + } + + for i := 0; i < len(board); i++ { + if board[i][len(board[0])-1] == 'O' { + bfs(&board, i, len(board[0])-1) + } + } + + for i := 0; i < len(board); i++ { + for j := 0; j < len(board[0]); j++ { + if board[i][j] == 'O' { + board[i][j] = 'X' + } else if board[i][j] == '1' { + board[i][j] = 'O' + } + } + } +} diff --git a/Medium/L1302.go b/Medium/L1302.go index b0e7e99..6090328 100644 --- a/Medium/L1302.go +++ b/Medium/L1302.go @@ -9,34 +9,33 @@ package Medium * } */ func deepestLeavesSum(root *TreeNode) int { - if root == nil { + if root == nil { return 0 } - - sum := 0 + var q []*TreeNode q = append(q, root) - + sum := 0 + for len(q) > 0 { size := len(q) sum = 0 for ; size > 0; size-- { - n := q[0] + node := q[0] q = q[1:] - - if n.Left == nil && n.Right == nil { - sum += n.Val - } - - if n.Left != nil { - q = append(q, n.Left) - } - - if n.Right != nil { - q = append(q, n.Right) + + if node.Left == nil && node.Right == nil { + sum += node.Val + } else { + if node.Left != nil { + q = append(q, node.Left) + } + if node.Right != nil { + q = append(q, node.Right) + } } } } - + return sum } diff --git a/Medium/L1305.go b/Medium/L1305.go index 7da5c01..03ccbfc 100644 --- a/Medium/L1305.go +++ b/Medium/L1305.go @@ -9,41 +9,38 @@ package Medium * } */ func getAllElements(root1 *TreeNode, root2 *TreeNode) []int { - var res []int - if root1 == nil && root2 == nil { - return res - } + var q1, q2, ans []int - var st1, st2 []*TreeNode - pushLeft(&st1, root1) - pushLeft(&st2, root2) + inorder(root1, &q1) + inorder(root2, &q2) - for len(st1) != 0 || len(st2) != 0 { - var st *[]*TreeNode - if len(st1) == 0 { - st = &st2 - } else if len(st2) == 0 { - st = &st1 + for len(q1) > 0 || len(q2) > 0 { + if len(q2) == 0 { + ans = append(ans, q1[0]) + q1 = q1[1:] + } else if len(q1) == 0 { + ans = append(ans, q2[0]) + q2 = q2[1:] } else { - if st1[len(st1)-1].Val < st2[len(st2)-1].Val { - st = &st1 + if q1[0] < q2[0] { + ans = append(ans, q1[0]) + q1 = q1[1:] } else { - st = &st2 + ans = append(ans, q2[0]) + q2 = q2[1:] } } - - curr := (*st)[len(*st)-1] - *st = (*st)[:len(*st)-1] - res = append(res, curr.Val) - pushLeft(st, curr.Right) } - return res + return ans } -func pushLeft(st *[]*TreeNode, node *TreeNode) { - for node != nil { - *st = append(*st, node) - node = node.Left +func inorder(root *TreeNode, q *[]int) { + if root == nil { + return } + + inorder(root.Left, q) + *q = append(*q, root.Val) + inorder(root.Right, q) } diff --git a/Medium/L1306.go b/Medium/L1306.go new file mode 100644 index 0000000..ed53b2a --- /dev/null +++ b/Medium/L1306.go @@ -0,0 +1,22 @@ +package Medium + +func canReach(arr []int, start int) bool { + return solve(arr, start, make(map[int]bool)) +} + +func solve(arr []int, pos int, seen map[int]bool) bool { + if pos < 0 || pos >= len(arr) { + return false + } + + if _, ok := seen[pos]; ok { + return false + } + + if arr[pos] == 0 { + return true + } + + seen[pos] = true + return solve(arr, pos+arr[pos], seen) || solve(arr, pos-arr[pos], seen) +} diff --git a/Medium/L131.go b/Medium/L131.go new file mode 100644 index 0000000..ee69bc5 --- /dev/null +++ b/Medium/L131.go @@ -0,0 +1,33 @@ +func partition(s string) [][]string { + var res [][]string + dfs(s, 0, make([]string, 0), &res) + + return res +} + +func dfs(s string, pos int, list []string, res *[][]string) { + if pos == len(s) { + tmp := make([]string, len(list)) + copy(tmp, list) + *res = append(*res, tmp) + } else { + for i := pos; i < len(s); i++ { + if isPalindrome(s, pos, i) { + list = append(list, s[pos:i+1]) + dfs(s, i+1, list, res) + list = list[:len(list)-1] + } + } + } +} + +func isPalindrome(s string, low, high int) bool { + for low < high { + if s[low] != s[high] { + return false + } + low, high = low+1, high-1 + } + + return true +} diff --git a/Medium/L1314.go b/Medium/L1314.go new file mode 100644 index 0000000..3089f40 --- /dev/null +++ b/Medium/L1314.go @@ -0,0 +1,48 @@ +package Medium + +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 +} + +func matrixBlockSum(mat [][]int, k int) [][]int { + m, n, total := len(mat), len(mat[0]), make([][]int, len(mat)+1) + for i := 0; i <= m; i++ { + total[i] = make([]int, n+1) + } + + for r := 1; r <= m; r++ { + for c := 1; c <= n; c++ { + total[r][c] = mat[r-1][c-1] + total[r-1][c] + total[r][c-1] - total[r-1][c-1] + } + } + + res := make([][]int, m) + for i := 0; i < m; i++ { + res[i] = make([]int, n) + } + + for r := 0; r < m; r++ { + for c := 0; c < n; c++ { + r1, c1 := max(0, r-k), max(0, c-k) + r2, c2 := min(m-1, r+k), min(n-1, c+k) + + r1, c1 = r1+1, c1+1 + r2, c2 = r2+1, c2+1 + res[r][c] = total[r2][c2] - total[r2][c1-1] - total[r1-1][c2] + total[r1-1][c1-1] + } + } + + return res +} diff --git a/Medium/L1318.go b/Medium/L1318.go new file mode 100644 index 0000000..316bb49 --- /dev/null +++ b/Medium/L1318.go @@ -0,0 +1,18 @@ +package Medium + +func minFlips(a int, b int, c int) int { + flips := 0 + for a > 0 || b > 0 || c > 0 { + bitA, bitB, bitC := a&1, b&1, c&1 + + if bitC == 0 { + flips += bitA + bitB + } else if bitA == 0 && bitB == 0 { + flips++ + } + + a, b, c = a>>1, b>>1, c>>1 + } + + return flips +} 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/L133.go b/Medium/L133.go new file mode 100644 index 0000000..e2e8de6 --- /dev/null +++ b/Medium/L133.go @@ -0,0 +1,26 @@ +package Medium + +func cloneGraph(node *Node) *Node { + return dfs(node, make(map[int]*Node)) +} + +func dfs(node *Node, mp map[int]*Node) *Node { + if node == nil { + return nil + } + + if val, ok := mp[node.Val]; ok { + return val + } + + newNode := &Node{ + Val: node.Val, + Neighbors: make([]*Node, 0), + } + mp[newNode.Val] = newNode + for _, n := range node.Neighbors { + newNode.Neighbors = append(newNode.Neighbors, dfs(n, mp)) + } + + return newNode +} diff --git a/Medium/L134.go b/Medium/L134.go new file mode 100644 index 0000000..ca16a1c --- /dev/null +++ b/Medium/L134.go @@ -0,0 +1,19 @@ +package Medium + +func canCompleteCircuit(gas []int, cost []int) int { + sumGas, sumCost, start, tank := 0, 0, 0, 0 + for i := range gas { + sumGas += gas[i] + sumCost += cost[i] + tank += gas[i] - cost[i] + if tank < 0 { + start, tank = i+1, 0 + } + } + + if sumGas < sumCost { + return -1 + } + + return start +} 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/L138.go b/Medium/L138.go new file mode 100644 index 0000000..2edf4d3 --- /dev/null +++ b/Medium/L138.go @@ -0,0 +1,33 @@ +package Medium + +/** + * Definition for a Node. + * type Node struct { + * Val int + * Next *Node + * Random *Node + * } + */ + +func copyRandomList(head *Node) *Node { + if head == nil { + return nil + } + + mp, node := make(map[*Node]*Node), head + // loop 1. copy all the nodes + for node != nil { + mp[node] = &Node{Val: node.Val} + node = node.Next + } + + node = head + // loop 2. assign next and random pointers + for node != nil { + mp[node].Next = mp[node.Next] + mp[node].Random = mp[node.Random] + node = node.Next + } + + return mp[head] +} 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/L142.go b/Medium/L142.go new file mode 100644 index 0000000..0c045e5 --- /dev/null +++ b/Medium/L142.go @@ -0,0 +1,18 @@ +package Medium + +func detectCycle(head *ListNode) *ListNode { + slow, fast := head, head + + for fast != nil && fast.Next != nil { + slow, fast = slow.Next, fast.Next.Next + if slow == fast { + slow = head + for slow != fast { + slow, fast = slow.Next, fast.Next + } + return slow + } + } + + return nil +} 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/L143.go b/Medium/L143.go new file mode 100644 index 0000000..c027972 --- /dev/null +++ b/Medium/L143.go @@ -0,0 +1,29 @@ +package Medium + +func reorderList(head *ListNode) { + if head == nil || head.Next == nil { + return + } + + p1, p2 := head, head + for p2.Next != nil && p2.Next.Next != nil { + p1, p2 = p1.Next, p2.Next.Next + } + + preMiddle, preCurrent := p1, p1.Next + for preCurrent.Next != nil { + current := preCurrent.Next + preCurrent.Next = current.Next + current.Next = preMiddle.Next + preMiddle.Next = current + } + + p1, p2 = head, preMiddle.Next + for p1 != preMiddle { + preMiddle.Next = p2.Next + p2.Next = p1.Next + p1.Next = p2 + p1 = p2.Next + p2 = preMiddle.Next + } +} diff --git a/Medium/L1448.go b/Medium/L1448.go new file mode 100644 index 0000000..6ac2667 --- /dev/null +++ b/Medium/L1448.go @@ -0,0 +1,28 @@ +package Medium + +func goodNodes(root *TreeNode) int { + cnt := 0 + if root == nil { + return cnt + } + dfs(root, root.Val, &cnt) + return cnt +} + +func dfs(root *TreeNode, val int, cnt *int) { + if root == nil { + return + } + + if root.Val >= val { + *cnt = (*cnt) + 1 + } + + max := val + if val < root.Val { + max = root.Val + } + + dfs(root.Left, max, cnt) + dfs(root.Right, max, cnt) +} diff --git a/Medium/L1457.go b/Medium/L1457.go new file mode 100644 index 0000000..b6d59ea --- /dev/null +++ b/Medium/L1457.go @@ -0,0 +1,39 @@ +func pseudoPalindromicPaths(root *TreeNode) int { + res, mp := 0, make([]int, 10) + findPesudoPalindromUtil(&res, &mp, root) + + return res +} + +func findPesudoPalindromUtil(res *int, mp *[]int, root *TreeNode) { + if root == nil { + return + } + + (*mp)[root.Val] = (*mp)[root.Val] + 1 + if root.Left == nil && root.Right == nil { + if isPalindrome(mp) { + *res++ + } + } + + findPesudoPalindromUtil(res, mp, root.Left) + findPesudoPalindromUtil(res, mp, root.Right) + + (*mp)[root.Val] = (*mp)[root.Val] - 1 +} + +func isPalindrome(mp *[]int) bool { + miss := 0 + + for i := 0; i <= 9; i++ { + if (*mp)[i]%2 != 0 { + miss++ + } + if miss > 1 { + return false + } + } + + return true +} diff --git a/Medium/L1465.go b/Medium/L1465.go new file mode 100644 index 0000000..1b2d517 --- /dev/null +++ b/Medium/L1465.go @@ -0,0 +1,28 @@ +package Medium + +func maxArea(h int, w int, horizontalCuts []int, verticalCuts []int) int { + sort.Ints(horizontalCuts) + sort.Ints(verticalCuts) + + maxX := max(h - horizontalCuts[len(horizontalCuts) - 1], + horizontalCuts[0]) + + maxY := max(w - verticalCuts[len(verticalCuts) - 1], + verticalCuts[0]) + + for i := 0; i < len(horizontalCuts) - 1; i++ { + maxX = max(maxX, horizontalCuts[i + 1]-horizontalCuts[i]) + } + for i := 0; i < len(verticalCuts) - 1; i++ { + maxY = max(maxY, verticalCuts[i + 1]-verticalCuts[i]) + } + + return (maxX * maxY) % 1000000007 +} + +func max(a, b int) int { + if a > b { + return a + } + return b +} diff --git a/Medium/L1466.go b/Medium/L1466.go new file mode 100644 index 0000000..207b564 --- /dev/null +++ b/Medium/L1466.go @@ -0,0 +1,41 @@ +package Medium + +type pair struct { + neighbor, edgeWeight int +} + +func newPair(x, y int) pair { + return pair{ + neighbor: x, + edgeWeight: y, + } +} + +func minReorder(n int, connections [][]int) int { + mp, ans := make(map[int][]pair), 0 + var solve func(node, parent int) + + for _, c := range connections { + if _, ok := mp[c[0]]; !ok { + mp[c[0]] = make([]pair, 0) + } + mp[c[0]] = append(mp[c[0]], newPair(c[1], 1)) + + if _, ok := mp[c[1]]; !ok { + mp[c[1]] = make([]pair, 0) + } + mp[c[1]] = append(mp[c[1]], newPair(c[0], 0)) + } + + solve = func(node, parent int) { + for _, nei := range mp[node] { + if nei.neighbor != parent { + ans += nei.edgeWeight + solve(nei.neighbor, node) + } + } + } + + solve(0, -1) + return ans +} diff --git a/Medium/L148.go b/Medium/L148.go new file mode 100644 index 0000000..54f4f6b --- /dev/null +++ b/Medium/L148.go @@ -0,0 +1,46 @@ +package Medium + +func sortList(head *ListNode) *ListNode { + if head == nil || head.Next == nil { + return head + } + + // step 1. cut the list to two halves + var prev *ListNode + slow, fast := head, head + + for fast != nil && fast.Next != nil { + prev, slow, fast = slow, slow.Next, fast.Next.Next + } + + prev.Next = nil + + // step 2. sort each half + l1, l2 := sortList(head), sortList(slow) + + // step 3. merge l1 and l2 + return merge(l1, l2) +} + +func merge(l1, l2 *ListNode) *ListNode { + l := &ListNode{} + p := l + + for l1 != nil && l2 != nil { + if l1.Val < l2.Val { + p.Next, l1 = l1, l1.Next + } else { + p.Next, l2 = l2, l2.Next + } + p = p.Next + } + + if l1 != nil { + p.Next = l1 + } + if l2 != nil { + p.Next = l2 + } + + return l.Next +} 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/L15.go b/Medium/L15.go new file mode 100644 index 0000000..075232d --- /dev/null +++ b/Medium/L15.go @@ -0,0 +1,31 @@ +package Medium + +func threeSum(nums []int) [][]int { + var res [][]int + sort.Ints(nums) + for i := 0; i+2 < len(nums); i++ { + if i > 0 && nums[i] == nums[i-1] { + continue + } + + j, k, tgt := i+1, len(nums)-1, -nums[i] + for j < k { + if nums[j]+nums[k] == tgt { + res = append(res, []int{nums[i], nums[j], nums[k]}) + j++ + k-- + for j < k && nums[j] == nums[j-1] { + j++ + } + for j < k && nums[k] == nums[k+1] { + k-- + } + } else if nums[j]+nums[k] > tgt { + k-- + } else { + j++ + } + } + } + return res +} diff --git a/Medium/L1519.go b/Medium/L1519.go new file mode 100644 index 0000000..6550eb2 --- /dev/null +++ b/Medium/L1519.go @@ -0,0 +1,30 @@ +package Medium + +func countSubTrees(n int, edges [][]int, labels string) []int { + res, mp := make([]int, n), make(map[int][]int) + + for _, e := range edges { + mp[e[0]] = append(mp[e[0]], e[1]) + mp[e[1]] = append(mp[e[1]], e[0]) + } + + solve(mp, labels, 0, -1, &res) + return res +} + +func solve(graph map[int][]int, labels string, node, parent int, res *[]int) []int { + nodeCnt := make([]int, 26) + nodeCnt[labels[node]-'a']++ + + for _, nei := range graph[node] { + if nei != parent { + childCnt := solve(graph, labels, nei, node, res) + for i := 0; i < 26; i++ { + nodeCnt[i] += childCnt[i] + } + } + } + + (*res)[node] = nodeCnt[labels[node]-'a'] + return nodeCnt +} diff --git a/Medium/L152.go b/Medium/L152.go new file mode 100644 index 0000000..28903ef --- /dev/null +++ b/Medium/L152.go @@ -0,0 +1,34 @@ +package Medium + +func maxProduct(nums []int) int { + if len(nums) == 0 { + return 0 + } + + maxi, mini, res := nums[0], nums[0], nums[0] + for i := 1; i < len(nums); i++ { + tmp := maxi + maxi = max(max(maxi*nums[i], mini*nums[i]), nums[i]) + mini = min(min(tmp*nums[i], mini*nums[i]), nums[i]) + + res = max(maxi, res) + } + + return res +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Medium/L153.go b/Medium/L153.go new file mode 100644 index 0000000..633ad6b --- /dev/null +++ b/Medium/L153.go @@ -0,0 +1,16 @@ +package Medium + +func findMin(nums []int) int { + l, h, mid, n := 0, len(nums)-1, 0, len(nums) + + for l < h { + mid = l + (h-l)/2 + if nums[mid] < nums[h] { + h = mid + } else { + l = (mid + 1) % n + } + } + + return nums[l] +} 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/L1570.go b/Medium/L1570.go new file mode 100644 index 0000000..a131db4 --- /dev/null +++ b/Medium/L1570.go @@ -0,0 +1,33 @@ +package Medium + +type SparseVector struct { + mp map[int]int +} + +func Constructor(nums []int) SparseVector { + mp := make(map[int]int) + + for i := range nums { + if nums[i] != 0 { + mp[i] = nums[i] + } + } + + return SparseVector{mp: mp} +} + +// Return the dotProduct of two sparse vectors +func (this *SparseVector) dotProduct(vec SparseVector) int { + if len(vec.mp) < len(this.mp) { + return vec.dotProduct(*this) + } + + sum := 0 + for k, _ := range this.mp { + if _, ok := vec.mp[k]; ok { + sum += this.mp[k] * vec.mp[k] + } + } + + return sum +} diff --git a/Medium/L1578.go b/Medium/L1578.go new file mode 100644 index 0000000..2889466 --- /dev/null +++ b/Medium/L1578.go @@ -0,0 +1,32 @@ +package Medium + +func minCost(colors string, neededTime []int) int { + n, res, prev := len(colors), 0, neededTime[0] + + for i := 1; i < n; i++ { + if colors[i] == colors[i-1] { + res += min(neededTime[i], prev) + prev = max(neededTime[i], prev) + } else { + prev = neededTime[i] + } + } + + return res +} + +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/L16.go b/Medium/L16.go new file mode 100644 index 0000000..4468f12 --- /dev/null +++ b/Medium/L16.go @@ -0,0 +1,36 @@ +package Medium + +func threeSumClosest(nums []int, target int) int { + if len(nums) < 3 { + return 0 + } + sort.Ints(nums) + res := nums[0] + nums[1] + nums[2] + for i := 0; i < len(nums)-2; i++ { + l, r := i+1, len(nums)-1 + for l < r { + sum := nums[i] + nums[l] + nums[r] + if sum == target { + return sum + } + if abs(sum-target) < abs(res-target) { + res = sum + } + if sum < target { + l += 1 + } else if sum > target { + r -= 1 + } + } + } + + return res +} + +func abs(a int) int { + if a < 0 { + return -a + } + + return a +} diff --git a/Medium/L1615.go b/Medium/L1615.go new file mode 100644 index 0000000..ae96757 --- /dev/null +++ b/Medium/L1615.go @@ -0,0 +1,35 @@ +package Medium + +func maximalNetworkRank(n int, roads [][]int) int { + connected, cnt := make([][]bool, n), make([]int, n) + for i := 0; i < n; i++ { + connected[i] = make([]bool, n) + } + + for _, r := range roads { + cnt[r[0]]++ + cnt[r[1]]++ + connected[r[0]][r[1]], connected[r[1]][r[0]] = true, true + } + + res := 0 + for i := 0; i < n; i++ { + for j := i + 1; j < n; j++ { + if connected[i][j] { + res = max(res, cnt[i]+cnt[j]-1) + } else { + res = max(res, cnt[i]+cnt[j]) + } + } + } + + return res +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L162.go b/Medium/L162.go new file mode 100644 index 0000000..24dccac --- /dev/null +++ b/Medium/L162.go @@ -0,0 +1,17 @@ +package Medium + +func findPeakElement(nums []int) int { + l, h, mid := 0, len(nums)-1, 0 + + for l < h { + mid = l + (h-l)/2 + + if nums[mid] < nums[mid+1] { + l = mid + 1 + } else { + h = mid + } + } + + return l +} 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/L1658.go b/Medium/L1658.go new file mode 100644 index 0000000..67b04c7 --- /dev/null +++ b/Medium/L1658.go @@ -0,0 +1,37 @@ +package Medium + +func minOperations(nums []int, x int) int { + tgt := -x + for _, n := range nums { + tgt += n + } + + if tgt == 0 { + return len(nums) + } + + mp, sum, res := make(map[int]int), 0, math.MinInt32 + mp[0] = -1 + for i := 0; i < len(nums); i++ { + sum += nums[i] + if _, ok := mp[sum-tgt]; ok { + res = maximum(res, i-mp[sum-tgt]) + } + + mp[sum] = i + } + + if res == math.MinInt32 { + return -1 + } + + return len(nums) - res +} + +func maximum(i, j int) int { + if i > j { + return i + } + + return j +} diff --git a/Medium/L1663.go b/Medium/L1663.go new file mode 100644 index 0000000..67842a2 --- /dev/null +++ b/Medium/L1663.go @@ -0,0 +1,20 @@ +package Medium + +func getSmallestString(n int, k int) string { + chars := make([]byte, n) + for i := 0; i < n; i++ { + chars[i] = 'a' + } + k -= n + + for k > 0 { + if chars[n-1] < 'z' { + chars[n-1]++ + k-- + } else { + n-- + } + } + + return string(chars) +} diff --git a/Medium/L167.go b/Medium/L167.go new file mode 100644 index 0000000..bd35d6d --- /dev/null +++ b/Medium/L167.go @@ -0,0 +1,37 @@ +package Medium + +func twoSum(numbers []int, target int) []int { + ret := make([]int, 2) + + if len(numbers) == 0 { + return ret + } + + for i := range numbers { + idx := binSearch(numbers, i+1, len(numbers)-1, target-numbers[i]) + if idx != -1 { + ret[0], ret[1] = i+1, idx+1 + break + } + } + + return ret +} + +func binSearch(arr []int, st, end, tgt int) int { + for st <= end { + mid := st + (end-st)/2 + + if arr[mid] == tgt { + return mid + } + + if arr[mid] > tgt { + end = mid - 1 + } else { + st = mid + 1 + } + } + + return -1 +} diff --git a/Medium/L1680.go b/Medium/L1680.go new file mode 100644 index 0000000..4ac8e77 --- /dev/null +++ b/Medium/L1680.go @@ -0,0 +1,15 @@ +package Medium + +func concatenatedBinary(n int) int { + mod, res := 1000000007, 0 + + for i := 1; i <= n; i++ { + tmp := i + for tmp > 0 { + tmp, res = tmp/2, res*2 + } + res = (res + i) % mod + } + + return res +} 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/L1696.go b/Medium/L1696.go new file mode 100644 index 0000000..ac11742 --- /dev/null +++ b/Medium/L1696.go @@ -0,0 +1,18 @@ +package Medium + +func maxResult(nums []int, k int) int { + var dq []int + dq = append(dq, 0) + for i := 1; i < len(nums); i++ { + if dq[0]+k < i { + dq = dq[1:] + } + nums[i] += nums[dq[0]] + for len(dq) > 0 && nums[dq[len(dq)-1]] <= nums[i] { + dq = dq[:len(dq)-1] + } + dq = append(dq, i) + } + + return nums[len(nums)-1] +} 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/L1746.go b/Medium/L1746.go new file mode 100644 index 0000000..9c2a079 --- /dev/null +++ b/Medium/L1746.go @@ -0,0 +1,39 @@ +package Medium + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func maxSumAfterOperation(nums []int) int { + mp, finalRes := make(map[string]int), nums[0] + + solve(0, &finalRes, true, nums, mp) + return finalRes +} + +func solve(idx int, finalRes *int, useSquare bool, nums []int, mp map[string]int) int { + if idx >= len(nums) { + return 0 + } + + key := fmt.Sprintf("%d-%v", idx, useSquare) + if v, ok := mp[key]; ok { + return v + } + + ans := 0 + if useSquare { + ans = max(nums[idx]*nums[idx], (nums[idx]*nums[idx])+solve(idx+1, finalRes, false, nums, mp)) + } + + ans = max(ans, max(nums[idx]+solve(idx+1, finalRes, useSquare, nums, mp), nums[idx])) + + mp[key] = ans + *finalRes = max(*finalRes, ans) + + return mp[key] +} diff --git a/Medium/L1749.go b/Medium/L1749.go new file mode 100644 index 0000000..ddb734d --- /dev/null +++ b/Medium/L1749.go @@ -0,0 +1,39 @@ +package Medium + +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 +} + +func maxAbsoluteSum(nums []int) int { + posAns, curPosSum, negAns, curNegSum := 0, 0, 0, 0 + + for i := range nums { + if curPosSum+nums[i] > 0 { + curPosSum += nums[i] + } else { + curPosSum = 0 + } + posAns = max(posAns, curPosSum) + + if curNegSum+nums[i] < 0 { + curNegSum += nums[i] + } else { + curNegSum = 0 + } + negAns = min(negAns, curNegSum) + } + + return max(posAns, -negAns) +} diff --git a/Medium/L1770.go b/Medium/L1770.go new file mode 100644 index 0000000..f24e7bd --- /dev/null +++ b/Medium/L1770.go @@ -0,0 +1,37 @@ +package Medium + +func maximumScore(nums []int, multipliers []int) int { + m := len(multipliers) + memo := make([][]int, m) + for i := 0; i < m; i++ { + memo[i] = make([]int, m) + } + + solveMaxScore(nums, multipliers, 0, 0, &memo) + + return memo[0][0] +} + +func solveMaxScore(nums, multipliers []int, l, i int, memo *[][]int) int { + if i == len(multipliers) { + return 0 + } + + if (*memo)[l][i] != 0 { + return (*memo)[l][i] + } + + pickLeft := solveMaxScore(nums, multipliers, l+1, i+1, memo) + (nums[l] * multipliers[i]) + pickRight := solveMaxScore(nums, multipliers, l, i+1, memo) + (nums[len(nums)-(i-l)-1] * multipliers[i]) + + (*memo)[l][i] = max(pickLeft, pickRight) + return (*memo)[l][i] +} + +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/L1870.go b/Medium/L1870.go new file mode 100644 index 0000000..d081ba2 --- /dev/null +++ b/Medium/L1870.go @@ -0,0 +1,34 @@ +package Medium + +func minSpeedOnTime(dist []int, hour float64) int { + var timeTaken func(speed int) float64 + left, right, res := 1, 10000007, -1 + + timeTaken = func(speed int) float64 { + var ans float64 + + for i := 0; i < len(dist); i++ { + if i == len(dist)-1 { + ans += float64(dist[i]) / float64(speed) + } else { + ans += math.Ceil(float64(dist[i]) / float64(speed)) + } + } + + return ans + } + + for left <= right { + mid := right - (right-left)/2 + dur := timeTaken(mid) + + if dur <= hour { + res = mid + right = mid - 1 + } else { + left = mid + 1 + } + } + + return res +} 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/L1926.go b/Medium/L1926.go new file mode 100644 index 0000000..6ac739c --- /dev/null +++ b/Medium/L1926.go @@ -0,0 +1,60 @@ +package Medium + +var ( + exists struct{} + dirs = [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} +) + +func nearestExit(maze [][]byte, entrance []int) int { + vis := make(map[string]struct{}) + + var q [][]int + q = append(q, entrance) + vis[key(entrance[0], entrance[1])] = exists + + cnt := 0 + for len(q) > 0 { + cnt++ + size := len(q) + for i := 0; i < size; i++ { + curr := q[0] + q = q[1:] + + for _, d := range dirs { + x, y := curr[0]+d[0], curr[1]+d[1] + + if !isValid(maze, x, y) { + continue + } + if _, ok := vis[key(x, y)]; ok { + continue + } + + if isExit(maze, x, y) { + return cnt + } + + vis[key(x, y)] = exists + q = append(q, []int{x, y}) + } + } + } + + return -1 +} + +func isValid(maze [][]byte, x, y int) bool { + m, n := len(maze), len(maze[0]) + + return x >= 0 && x < m && y >= 0 && y < n && maze[x][y] == '.' +} + +func isExit(maze [][]byte, x, y int) bool { + m, n := len(maze), len(maze[0]) + + return x == 0 || y == 0 || x == m-1 || y == n-1 +} + +func key(x, y int) string { + return fmt.Sprintf("%dx%d", x, y) +} diff --git a/Medium/L198.go b/Medium/L198.go new file mode 100644 index 0000000..63b7b4e --- /dev/null +++ b/Medium/L198.go @@ -0,0 +1,29 @@ +package Medium + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func rob(nums []int) int { + mp := make(map[int]int) + n := len(nums) + return max(count(mp, nums, n-1), count(mp, nums, n-2)) +} + +func count(mp map[int]int, nums []int, n int) int { + if _, ok := mp[n]; ok { + return mp[n] + } + + if n < 0 { + return 0 + } + + mp[n] = nums[n] + max(count(mp, nums, n-2), count(mp, nums, n-3)) + + return mp[n] +} diff --git a/Medium/L199.go b/Medium/L199.go new file mode 100644 index 0000000..31db945 --- /dev/null +++ b/Medium/L199.go @@ -0,0 +1,35 @@ +package Medium + +func rightSideView(root *TreeNode) []int { + var res []int + + if root == nil { + return res + } + + var q []*TreeNode + q = append(q, root) + + for len(q) > 0 { + size := len(q) + + for size > 0 { + size-- + cur := q[0] + q = q[1:] + + if size == 0 { + res = append(res, cur.Val) + } + + if cur.Left != nil { + q = append(q, cur.Left) + } + if cur.Right != nil { + q = append(q, cur.Right) + } + } + } + + 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/L201.go b/Medium/L201.go new file mode 100644 index 0000000..76576df --- /dev/null +++ b/Medium/L201.go @@ -0,0 +1,9 @@ +package Medium + +func rangeBitwiseAnd(left int, right int) int { + for left < right { + right = right & (right - 1) + } + + return left & right +} 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/L207.go b/Medium/L207.go new file mode 100644 index 0000000..9bf8c34 --- /dev/null +++ b/Medium/L207.go @@ -0,0 +1,46 @@ +package Medium + +func canFinish(numCourses int, prerequisites [][]int) bool { + var exists struct{} + if numCourses == 0 { + return false + } + + inDegree, mp := make([]int, numCourses), make(map[int][]int) + for i := 0; i < numCourses; i++ { + mp[i] = make([]int, 0) + } + + for _, p := range prerequisites { + mp[p[1]] = append(mp[p[1]], p[0]) + inDegree[p[0]]++ + } + + var q []int + for i := 0; i < len(inDegree); i++ { + if inDegree[i] == 0 { + q = append(q, i) + } + } + st := make(map[int]struct{}) + for len(q) > 0 { + size := len(q) + for i := 0; i < size; i++ { + c := q[0] + q = q[1:] + + if _, ok := st[c]; ok { + continue + } + st[c] = exists + for _, n := range mp[c] { + inDegree[n]-- + if inDegree[n] == 0 { + q = append(q, n) + } + } + } + } + + return len(st) == numCourses +} diff --git a/Medium/L2095.go b/Medium/L2095.go new file mode 100644 index 0000000..79578be --- /dev/null +++ b/Medium/L2095.go @@ -0,0 +1,15 @@ +package Medium + +func deleteMiddle(head *ListNode) *ListNode { + if head == nil || head.Next == nil { + return nil + } + + slow, fast := head, head.Next.Next + for fast != nil && fast.Next != nil { + fast, slow = fast.Next.Next, slow.Next + } + + slow.Next = slow.Next.Next + return head +} diff --git a/Medium/L210.go b/Medium/L210.go new file mode 100644 index 0000000..b7b1ebd --- /dev/null +++ b/Medium/L210.go @@ -0,0 +1,55 @@ +package Medium + +func findOrder(numCourses int, prerequisites [][]int) []int { + if numCourses == 0 { + return []int{} + } + + ret, lst, indDegree, vis, cnt, idx := make([]int, numCourses), make([][]int, numCourses), make([]int, numCourses), make([]bool, numCourses), 0, 0 + if len(prerequisites) == 0 { + for i := 0; i < numCourses; i++ { + ret[i] = i + } + return ret + } + + for i := 0; i < numCourses; i++ { + lst[i] = make([]int, 0) + } + for _, p := range prerequisites { + lst[p[1]] = append(lst[p[1]], p[0]) + indDegree[p[0]]++ + } + + for i := 0; i < numCourses; i++ { + if indDegree[i] == 0 && !vis[i] { + dfs(lst, ret, indDegree, vis, i, &idx, &cnt) + } + } + + if numCourses == cnt { + return ret + } + + return []int{} +} + +func dfs(lst [][]int, ret, inDegree []int, vis []bool, c int, idx, cnt *int) { + if vis[c] { + return + } + + vis[c] = true + if inDegree[c] == 0 { + ret[(*idx)] = c + *idx++ + *cnt++ + } + + for _, nei := range lst[c] { + inDegree[nei]-- + if inDegree[nei] == 0 { + dfs(lst, ret, inDegree, vis, nei, idx, cnt) + } + } +} diff --git a/Medium/L211.go b/Medium/L211.go new file mode 100644 index 0000000..9053f3c --- /dev/null +++ b/Medium/L211.go @@ -0,0 +1,55 @@ +package Medium + +type Trie struct { + isWord bool + child []*Trie +} + +func NewTrie() *Trie { + return &Trie{ + child: make([]*Trie, 26), + } +} + +type WordDictionary struct { + root *Trie +} + +func Constructor() WordDictionary { + return WordDictionary{ + root: NewTrie(), + } +} + +func (this *WordDictionary) AddWord(word string) { + currNode := this.root + for i := 0; i < len(word); i++ { + if currNode.child[word[i]-'a'] == nil { + currNode.child[word[i]-'a'] = NewTrie() + } + currNode = currNode.child[word[i]-'a'] + } + currNode.isWord = true +} + +func (this *WordDictionary) Search(word string) bool { + return match(word, 0, this.root) +} + +func match(word string, idx int, root *Trie) bool { + if idx >= len(word) { + return root.isWord + } + + if word[idx] != '.' { + return root.child[word[idx]-'a'] != nil && match(word, idx+1, root.child[word[idx]-'a']) + } + + for ch := 'a'; ch <= 'z'; ch++ { + if root.child[ch-'a'] != nil && match(word, idx+1, root.child[ch-'a']) { + return true + } + } + + return false +} 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/L215.go b/Medium/L215.go new file mode 100644 index 0000000..6fb4d5b --- /dev/null +++ b/Medium/L215.go @@ -0,0 +1,28 @@ +package Medium + +func findKthLargest(nums []int, k int) int { + return quickSelect(nums, 0, len(nums)-1, k) +} + +func quickSelect(nums []int, low, high, k int) int { + pivot := low + + j := low + for ; j < high; j++ { + if nums[j] <= nums[high] { + nums[pivot], nums[j] = nums[j], nums[pivot] + pivot++ + } + } + + nums[pivot], nums[j] = nums[j], nums[pivot] + cnt := high - pivot + 1 + + if cnt == k { + return nums[pivot] + } else if cnt > k { + return quickSelect(nums, pivot+1, high, k) + } + + return quickSelect(nums, low, pivot-1, k-cnt) +} diff --git a/Medium/L216.go b/Medium/L216.go new file mode 100644 index 0000000..723f4d3 --- /dev/null +++ b/Medium/L216.go @@ -0,0 +1,33 @@ +package Medium + +func combinationSum3(k int, n int) [][]int { + var ans [][]int + var tmp []int + + if k == 0 || n == 0 { + return ans + } + + arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9} + backtrack(&ans, &tmp, arr, k, n, 0) + + return ans +} + +func backtrack(ans *[][]int, tmp *[]int, arr []int, k, target, start int) { + if len(*tmp) == k && target == 0 { + tmpCopy := make([]int, len(*tmp)) + copy(tmpCopy, *tmp) + *ans = append(*ans, tmpCopy) + } + + if target < 0 { + return + } + + for i := start; i < len(arr); i++ { + *tmp = append(*tmp, arr[i]) + backtrack(ans, tmp, arr, k, target-arr[i], i+1) + *tmp = (*tmp)[:len(*tmp)-1] + } +} diff --git a/Medium/L2187.go b/Medium/L2187.go new file mode 100644 index 0000000..9b18c29 --- /dev/null +++ b/Medium/L2187.go @@ -0,0 +1,47 @@ +package Medium + +func minimumTime(time []int, totalTrips int) int64 { + var ( + lowTime int64 + highTime int64 + ) + minTripTime := func() int64 { + mini := math.MaxInt32 + + for _, t := range time { + mini = min(mini, t) + } + + return int64(mini) + } + + numTripsForGivenTime := func(givenTime int64) int64 { + var totTrips int64 + for _, t := range time { + totTrips += givenTime / int64(t) + } + + return totTrips + } + lowTime, highTime = 1, minTripTime()*int64(totalTrips) + + for lowTime < highTime { + mid := lowTime + (highTime-lowTime)/2 + + if numTripsForGivenTime(mid) >= int64(totalTrips) { + highTime = mid + } else { + lowTime = mid + 1 + } + } + + return lowTime +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Medium/L2189.go b/Medium/L2189.go new file mode 100644 index 0000000..68ae8af --- /dev/null +++ b/Medium/L2189.go @@ -0,0 +1,26 @@ +package Medium + +func abs(a int) int { + if a < 0 { + return -a + } + + return a +} + +func minSteps(s string, t string) int { + cnt, arr := 0, make([]int, 26) + + for _, c := range s { + arr[c-'a']++ + } + for _, c := range t { + arr[c-'a']-- + } + + for _, v := range arr { + cnt += abs(v) + } + + return cnt +} diff --git a/Medium/L22.go b/Medium/L22.go new file mode 100644 index 0000000..c3d90de --- /dev/null +++ b/Medium/L22.go @@ -0,0 +1,32 @@ +package Medium + +func generateParenthesis(n int) []string { + var ans []string + var tmp string + if n == 0 { + return ans + } + + dfs(&ans, &tmp, n, 0, 0) + + return ans +} + +func dfs(ans *[]string, str *string, n, open, close int) { + if len(*str) == 2*n { + *ans = append(*ans, *str) + return + } + + if open < n { + *str += "(" + dfs(ans, str, n, open+1, close) + *str = (*str)[:len(*str)-1] + } + + if close < open { + *str += ")" + dfs(ans, str, n, open, close+1) + *str = (*str)[:len(*str)-1] + } +} diff --git a/Medium/L221.go b/Medium/L221.go new file mode 100644 index 0000000..8a6c74f --- /dev/null +++ b/Medium/L221.go @@ -0,0 +1,59 @@ +package Medium + +func maximalSquare(matrix [][]byte) int { + if len(matrix) == 0 { + return 0 + } + + m, n, ans := len(matrix), len(matrix[0]), math.MinInt64 + dp := make([][]int, m) + for i := 0; i < m; i++ { + dp[i] = make([]int, n) + } + + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if matrix[i][j] == '1' { + ans = max(ans, dfs(matrix, i, j, dp)) + } + } + } + + return ans * ans +} + +func isValid(matrix [][]byte, x, y int) bool { + m, n := len(matrix), len(matrix[0]) + + return x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] == '1' +} + +func dfs(matrix [][]byte, i, j int, dp [][]int) int { + if !isValid(matrix, i, j) { + return 0 + } + + if dp[i][j] != 0 { + return dp[i][j] + } + + down, right, diag := dfs(matrix, i+1, j, dp), dfs(matrix, i, j+1, dp), dfs(matrix, i+1, j+1, dp) + dp[i][j] = 1 + min(min(down, right), diag) + return dp[i][j] +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Medium/L222.go b/Medium/L222.go new file mode 100644 index 0000000..821d37d --- /dev/null +++ b/Medium/L222.go @@ -0,0 +1,31 @@ +package Medium + +func countNodes(root *TreeNode) int { + cnt := 0 + if root == nil { + return cnt + } + + var q []*TreeNode + q = append(q, root) + + for len(q) > 0 { + size := len(q) + + for idx := 0; idx < size; idx++ { + node := q[0] + q = q[1:] + cnt++ + + if node.Left != nil { + q = append(q, node.Left) + } + + if node.Right != nil { + q = append(q, node.Right) + } + } + } + + return cnt +} diff --git a/Medium/L2225.go b/Medium/L2225.go new file mode 100644 index 0000000..fb375d2 --- /dev/null +++ b/Medium/L2225.go @@ -0,0 +1,26 @@ +package Medium + +func findWinners(matches [][]int) [][]int { + var winners, losers []int + table := make(map[int]int) + + for _, m := range matches { + if _, ok := table[m[0]]; !ok { + table[m[0]] = 0 + } + table[m[1]]++ + } + + for k, v := range table { + if v == 0 { + winners = append(winners, k) + } + if v == 1 { + losers = append(losers, k) + } + } + + sort.Ints(winners) + sort.Ints(losers) + return [][]int{winners, losers} +} diff --git a/Medium/L2244.go b/Medium/L2244.go new file mode 100644 index 0000000..a78e7a7 --- /dev/null +++ b/Medium/L2244.go @@ -0,0 +1,23 @@ +package Medium + +func minimumRounds(tasks []int) int { + cnt, mp := 0, make(map[int]int) + + for _, t := range tasks { + mp[t]++ + } + + for _, v := range mp { + if v < 2 { + return -1 + } + + if v%3 == 0 { + cnt += v / 3 + } else { + cnt += (v / 3) + 1 + } + } + + return cnt +} diff --git a/Medium/L227.go b/Medium/L227.go new file mode 100644 index 0000000..827be0d --- /dev/null +++ b/Medium/L227.go @@ -0,0 +1,112 @@ +package Medium + +type Deque struct { + operands []int + operators []byte +} + +func NewDeque() *Deque { + return &Deque{ + operands: make([]int, 0), + operators: make([]byte, 0), + } +} + +func (d *Deque) PushOperand(val int) { + d.operands = append(d.operands, val) +} + +func (d *Deque) PopOperand() int { + val := d.operands[len(d.operands)-1] + d.operands = d.operands[:len(d.operands)-1] + + return val +} + +func (d *Deque) PushOperator(ch byte) { + d.operators = append(d.operators, ch) +} + +func (d *Deque) PopOperator() byte { + val := d.operators[len(d.operators)-1] + d.operators = d.operators[:len(d.operators)-1] + + return val +} + +func (d *Deque) PeekOperator() byte { + return d.operators[len(d.operators)-1] +} + +func (d *Deque) isOperatorEmpty() bool { + return len(d.operators) == 0 +} + +func (d *Deque) operate() int { + a, b, c := d.PopOperand(), d.PopOperand(), d.PopOperator() + + switch c { + case '+': + return a + b + case '-': + return b - a + case '*': + return a * b + case '/': + return b / a + default: + return 0 + } +} + +var precedenceMap = map[byte]int{ + '(': -1, + '+': 0, + '-': 0, + '*': 1, + '/': 1, +} + +func calculate(s string) int { + q, n := NewDeque(), len(s) + + for i := 0; i < n; i++ { + c := s[i] + if isDigit(c) { + val := int(c - '0') + for i+1 < n && isDigit(s[i+1]) { + val = val*10 + int(s[i+1]-'0') + i++ + } + q.PushOperand(val) + } else if c == ' ' { + continue + } else if c == '(' { + q.PushOperator(c) + } else if c == ')' { + for q.PeekOperator() != '(' { + q.PushOperand(q.operate()) + } + q.PopOperator() + } else { + for !q.isOperatorEmpty() && comparePrecedence(c, q.PeekOperator()) <= 0 { + q.PushOperand(q.operate()) + } + q.PushOperator(c) + } + } + + for !q.isOperatorEmpty() { + q.PushOperand(q.operate()) + } + + return q.PopOperand() +} + +func comparePrecedence(a, b byte) int { + return precedenceMap[a] - precedenceMap[b] +} + +func isDigit(c byte) bool { + return c >= '0' && c <= '9' +} diff --git a/Medium/L2279.go b/Medium/L2279.go new file mode 100644 index 0000000..27929f2 --- /dev/null +++ b/Medium/L2279.go @@ -0,0 +1,20 @@ +package Medium + +func maximumBags(capacity []int, rocks []int, additionalRocks int) int { + var diff []int + for i := 0; i < len(rocks); i++ { + diff = append(diff, capacity[i]-rocks[i]) + } + + sort.Ints(diff) + ans, cnt := 0, 0 + for _, entry := range diff { + cnt += entry + if cnt > additionalRocks { + break + } + ans++ + } + + return ans +} diff --git a/Medium/L230.go b/Medium/L230.go new file mode 100644 index 0000000..37b6e09 --- /dev/null +++ b/Medium/L230.go @@ -0,0 +1,32 @@ +package Medium + +func kthSmallest(root *TreeNode, k int) int { + if root == nil { + return 0 + } + + var st []*TreeNode + st = append(st, root) + + for len(st) > 0 { + node := st[len(st)-1] + st = st[:len(st)-1] + for node != nil { + st = append(st, node) + node = node.Left + } + + if len(st) > 0 { + node = st[len(st)-1] + st = st[:len(st)-1] + + k-- + if k == 0 { + return node.Val + } + st = append(st, node.Right) + } + } + + return 0 +} diff --git a/Medium/L2300.go b/Medium/L2300.go new file mode 100644 index 0000000..c23e2e8 --- /dev/null +++ b/Medium/L2300.go @@ -0,0 +1,22 @@ +package Medium + +func successfulPairs(spells []int, potions []int, success int64) []int { + res := make([]int, len(spells)) + sort.Ints(potions) + + for i := 0; i < len(spells); i++ { + low, high := 0, len(potions) - 1 + for low <= high { + mid := low + (high - low) / 2 + + if int64(spells[i] * potions[mid]) >= success { + high = mid - 1 + } else { + low = mid + 1 + } + } + res[i] = len(potions) - 1 - high + } + + return res +} diff --git a/Medium/L231.go b/Medium/L231.go new file mode 100644 index 0000000..b09f855 --- /dev/null +++ b/Medium/L231.go @@ -0,0 +1,5 @@ +package Easy + +func isPowerOfTwo(n int) bool { + return n > 0 && (n&(n-1) == 0) +} diff --git a/Medium/L2316.go b/Medium/L2316.go new file mode 100644 index 0000000..f1b3816 --- /dev/null +++ b/Medium/L2316.go @@ -0,0 +1,39 @@ +package Medium + +class Solution { +public: + void dfs(vectoradj[],int src,vector&vis,int &counter){ + if(vis[src]) return; + vis[src]=true; + counter++; + for(auto ele:adj[src]){ + if(!vis[ele]){ + dfs(adj,ele,vis,counter); + } + } + + } + long long countPairs(int n, vector>& edges) { + vectoradj[n]; + for(auto ele:edges){ + adj[ele[0]].push_back(ele[1]); + adj[ele[1]].push_back(ele[0]); + } + long long res = 0; + vectorvis(n,false); + vectortemp; + for(int i = 0;i b { + return a + } + + return b +} + +func closestMeetingNode(edges []int, node1 int, node2 int) int { + n, ans, minDist := len(edges), -1, math.MaxInt32 + dist1, dist2 := make([]int, n), make([]int, n) + vis1, vis2 := make(map[int]struct{}), make(map[int]struct{}) + + solve(edges, node1, &dist1, vis1) + solve(edges, node2, &dist2, vis2) + + for i := 0; i < n; i++ { + if hasVisited(i, vis1) && hasVisited(i, vis2) { + if minDist > max(dist1[i], dist2[i]) { + minDist = max(dist1[i], dist2[i]) + ans = i + } + } + } + + return ans +} + +func hasVisited(node int, vis map[int]struct{}) bool { + if _, ok := vis[node]; ok { + return true + } + + return false +} + +func solve(edges []int, node int, dist *[]int, vis map[int]struct{}) { + vis[node] = exists + neigh := edges[node] + if neigh != -1 { + if !hasVisited(neigh, vis) { + (*dist)[neigh] = (*dist)[node] + 1 + solve(edges, neigh, dist, vis) + } + } +} diff --git a/Medium/L236.go b/Medium/L236.go new file mode 100644 index 0000000..3ed89de --- /dev/null +++ b/Medium/L236.go @@ -0,0 +1,25 @@ +package Medium + +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode { + if root == p || root == q || root == nil { + return root + } + + left, right := lowestCommonAncestor(root.Left, p, q), lowestCommonAncestor(root.Right, p, q) + + if left == nil { + return right + } else if right == nil { + return left + } else { + return root + } +} diff --git a/Medium/L238.go b/Medium/L238.go new file mode 100644 index 0000000..975affe --- /dev/null +++ b/Medium/L238.go @@ -0,0 +1,21 @@ +package Medium + +func productExceptSelf(nums []int) []int { + if len(nums) == 0 { + return []int{} + } + + ret := make([]int, len(nums)) + ret[0] = 1 + for i := 1; i < len(nums); i++ { + ret[i] = ret[i-1] * nums[i-1] + } + + right := 1 + for i := len(nums) - 2; i >= 0; i-- { + right *= nums[i+1] + ret[i] = ret[i] * right + } + + return ret +} 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/L240.go b/Medium/L240.go new file mode 100644 index 0000000..24a95c8 --- /dev/null +++ b/Medium/L240.go @@ -0,0 +1,36 @@ +package Medium + +func searchMatrix(matrix [][]int, target int) bool { + if len(matrix) == 0 || len(matrix[0]) == 0 { + return false + } + + found := false + for _, m := range matrix { + if target >= m[0] && target <= m[len(m)-1] { + found = binSearch(m, 0, len(m)-1, target) + if found { + return found + } + } + } + + return found +} + +func binSearch(arr []int, low, high, tgt int) bool { + for low <= high { + mid := low + (high-low)/2 + if arr[mid] == tgt { + return true + } + + if tgt < arr[mid] { + high = mid - 1 + } else { + low = mid + 1 + } + } + + return false +} diff --git a/Medium/L2405.go b/Medium/L2405.go new file mode 100644 index 0000000..55d64d9 --- /dev/null +++ b/Medium/L2405.go @@ -0,0 +1,18 @@ +package Medium + +func partitionString(s string) int { + var exists struct{} + idx, cnt := 0, 0 + mp := make(map[byte]struct{}) + + for i := range s { + if _, ok := mp[s[i]]; ok { + cnt++ + mp = make(map[byte]struct{}) + } + mp[s[i]] = exists + idx++ + } + + return cnt + 1 +} diff --git a/Medium/L2414.go b/Medium/L2414.go new file mode 100644 index 0000000..b73b949 --- /dev/null +++ b/Medium/L2414.go @@ -0,0 +1,25 @@ +package Medium + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func longestContinuousSubstring(s string) int { + res, cnt := 0, 1 + + for i := 1; i < len(s); i++ { + if s[i-1] + 1 == s[i] { + cnt++ + } else { + res = max(res, cnt) + cnt = 1 + } + } + + res = max(res, cnt) + return res +} diff --git a/Medium/L2439.go b/Medium/L2439.go new file mode 100644 index 0000000..c9963a4 --- /dev/null +++ b/Medium/L2439.go @@ -0,0 +1,33 @@ +package Medium + +func minimizeArrayValue(nums []int) int { + low, high, res := 0, math.MaxInt32, 0 + + isPossible := func(maximum int) bool { + excess := 0 + for _, n := range nums { + if n > maximum { + candidate := n - maximum + if candidate > excess { + return false + } + excess -= candidate + } else { + excess += maximum - n + } + } + + return true + } + + for low <= high { + mid := low + (high-low)/2 + if isPossible(mid) { + high, res = mid-1, mid + } else { + low = mid + 1 + } + } + + return res +} diff --git a/Medium/L2477.go b/Medium/L2477.go new file mode 100644 index 0000000..3fdcc63 --- /dev/null +++ b/Medium/L2477.go @@ -0,0 +1,34 @@ +package Medium + +func minimumFuelCost(roads [][]int, seats int) int64 { + res, mp := int64(0), make(map[int][]int) + + for _, r := range roads { + mp[r[0]] = append(mp[r[0]], r[1]) + mp[r[1]] = append(mp[r[1]], r[0]) + } + + solve(0, -1, int64(seats), mp, &res) + return res +} + +func solve(node, parent int, seats int64, mp map[int][]int, res *int64) int64 { + rep := int64(1) + + if _, ok := mp[node]; !ok { + return rep + } + + for _, n := range mp[node] { + if n != parent { + rep += solve(n, node, seats, mp, res) + } + } + + if node != 0 { + // math.ceil for int64 + *res += (rep + seats - 1) / seats + } + + return rep +} 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/L2492.go b/Medium/L2492.go new file mode 100644 index 0000000..7a2cce9 --- /dev/null +++ b/Medium/L2492.go @@ -0,0 +1,47 @@ +package Medium + +type pair struct { + x, y int +} + +func newPair(x, y int) pair { + return pair{ + x: x, + y: y, + } +} + +func minScore(n int, roads [][]int) int { + adj, vis := make([][]pair, n+1), make([]bool, n+1) + for i := 0; i < n+1; i++ { + adj[i] = make([]pair, 0) + } + + for i := range roads { + adj[roads[i][0]] = append(adj[roads[i][0]], newPair(roads[i][1], roads[i][2])) + adj[roads[i][1]] = append(adj[roads[i][1]], newPair(roads[i][0], roads[i][2])) + } + + var q []int + q = append(q, 1) + vis[1] = true + for len(q) > 0 { + node := q[0] + q = q[1:] + for _, p := range adj[node] { + if !vis[p.x] { + q = append(q, p.x) + vis[p.x] = true + } + } + } + + minPath := math.MaxInt32 + for i := range roads { + if vis[roads[i][0]] && vis[roads[i][1]] && roads[i][2] < minPath { + minPath = roads[i][2] + } + } + + return minPath +} diff --git a/Medium/L2498.go b/Medium/L2498.go new file mode 100644 index 0000000..7b7e624 --- /dev/null +++ b/Medium/L2498.go @@ -0,0 +1,18 @@ +package Medium + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func maxJump(stones []int) int { + res := stones[1] - stones[0] + for i := 2; i < len(stones); i++ { + res = max(res, stones[i] - stones[i - 2]) + } + + return res +} diff --git a/Medium/L256.go b/Medium/L256.go new file mode 100644 index 0000000..363e0cf --- /dev/null +++ b/Medium/L256.go @@ -0,0 +1,46 @@ +package Medium + +func minCost(costs [][]int) int { + mp := make(map[string]int) + + mini := math.MaxInt32 + for i := 0; i < len(costs[0]); i++ { + mini = min(mini, solve(costs, mp, 0, i)) + } + + return mini +} + +func solve(costs [][]int, mp map[string]int, house, color int) int { + if house >= len(costs) { + return 0 + } + + if color >= len(costs[0]) { + return 0 + } + + key := fmt.Sprintf("%d-%d", house, color) + if v, ok := mp[key]; ok { + return v + } + + mini := math.MaxInt32 + for i := 0; i < len(costs[0]); i++ { + if i == color { + continue + } + mini = min(mini, costs[house][color]+solve(costs, mp, house+1, i)) + } + + mp[key] = mini + return mp[key] +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Medium/L260.go b/Medium/L260.go new file mode 100644 index 0000000..5c1a1c5 --- /dev/null +++ b/Medium/L260.go @@ -0,0 +1,20 @@ +package Medium + +func singleNumber(nums []int) []int { + diff := 0 + for _, n := range nums { + diff ^= n + } + + diff = diff & -diff + rets := []int{0, 0} + for _, n := range nums { + if n&diff == 0 { + rets[0] ^= n + } else { + rets[1] ^= n + } + } + + return rets +} 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/L284.go b/Medium/L284.go new file mode 100644 index 0000000..516bf13 --- /dev/null +++ b/Medium/L284.go @@ -0,0 +1,54 @@ +package Medium + +/* Below is the interface for Iterator, which is already defined for you. + * + * type Iterator struct { + * + * } + * + * func (this *Iterator) hasNext() bool { + * // Returns true if the iteration has more elements. + * } + * + * func (this *Iterator) next() int { + * // Returns the next element in the iteration. + * } + */ + +type PeekingIterator struct { + nextInt int + iter *Iterator +} + +func Constructor(iter *Iterator) *PeekingIterator { + pk := &PeekingIterator{ + nextInt: -1, + iter: iter, + } + + if iter.hasNext() { + pk.nextInt = iter.next() + } + + return pk +} + +func (this *PeekingIterator) hasNext() bool { + return this.nextInt != -1 +} + +func (this *PeekingIterator) next() int { + res := this.nextInt + + if this.iter.hasNext() { + this.nextInt = this.iter.next() + } else { + this.nextInt = -1 + } + + return res +} + +func (this *PeekingIterator) peek() int { + return this.nextInt +} 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/L287.go b/Medium/L287.go new file mode 100644 index 0000000..4ad154c --- /dev/null +++ b/Medium/L287.go @@ -0,0 +1,16 @@ +package Medium + +func findDuplicate(nums []int) int { + slow, fast := nums[0], nums[nums[0]] + + for slow != fast { + slow, fast = nums[slow], nums[nums[fast]] + } + + fast = 0 + for fast != slow { + fast, slow = nums[fast], nums[slow] + } + + return slow +} 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/L3.go b/Medium/L3.go new file mode 100644 index 0000000..6ccbbe4 --- /dev/null +++ b/Medium/L3.go @@ -0,0 +1,27 @@ +package Medium + +func lengthOfLongestSubstring(s string) int { + if len(s) == 0 { + return 0 + } + + mp, max := make(map[byte]int), 0 + + for i, j := 0, 0; i < len(s); i++ { + if _, ok := mp[s[i]]; ok { + j = maximum(j, mp[s[i]]+1) + } + mp[s[i]] = i + max = maximum(max, i-j+1) + } + + return max +} + +func maximum(i, j int) int { + if i > j { + return i + } + + return j +} diff --git a/Medium/L300.go b/Medium/L300.go new file mode 100644 index 0000000..4afdd90 --- /dev/null +++ b/Medium/L300.go @@ -0,0 +1,38 @@ +package Medium + +func lengthOfLIS(nums []int) int { + if len(nums) == 1 { + return 1 + } + + dp := make([]int, len(nums)) + for i := range dp { + dp[i] = math.MinInt64 + } + + return solve(nums, 0, math.MinInt64, &dp) +} + +func solve(nums []int, idx, prev int, dp *[]int) int { + if idx >= len(nums) { + return 0 + } + + curr := nums[idx] + left, right := 0, 0 + + if curr > prev { + if (*dp)[idx] == math.MinInt64 { + (*dp)[idx] = 1 + solve(nums, idx+1, curr, dp) + } + left = (*dp)[idx] + } + + right = solve(nums, idx+1, prev, dp) + + if left > right { + return left + } + + return right +} diff --git a/Medium/L307.go b/Medium/L307.go new file mode 100644 index 0000000..7e8b1e5 --- /dev/null +++ b/Medium/L307.go @@ -0,0 +1,75 @@ +package Medium + +type NumArray struct { + root *SegmentTree +} + +type SegmentTree struct { + start, end, sum int + left, right *SegmentTree +} + +func newSegmentTree(start, end int) *SegmentTree { + return &SegmentTree{ + start: start, + end: end, + } +} + +func Constructor(nums []int) NumArray { + return NumArray{root: buildTree(nums, 0, len(nums)-1)} +} + +func buildTree(nums []int, start, end int) *SegmentTree { + if start > end { + return nil + } + + ret := newSegmentTree(start, end) + if start == end { + ret.sum = nums[start] + } else { + mid := start + (end-start)/2 + ret.left = buildTree(nums, start, mid) + ret.right = buildTree(nums, mid+1, end) + ret.sum = ret.left.sum + ret.right.sum + } + + return ret +} + +func (this *NumArray) Update(index int, val int) { + update(this.root, index, val) +} + +func update(root *SegmentTree, pos, val int) { + if root.start == root.end { + root.sum = val + } else { + mid := root.start + (root.end-root.start)/2 + if pos <= mid { + update(root.left, pos, val) + } else { + update(root.right, pos, val) + } + root.sum = root.left.sum + root.right.sum + } +} + +func (this *NumArray) SumRange(left int, right int) int { + return sumRange(this.root, left, right) +} + +func sumRange(root *SegmentTree, start, end int) int { + if root.end == end && root.start == start { + return root.sum + } + + mid := root.start + (root.end-root.start)/2 + if end <= mid { + return sumRange(root.left, start, end) + } else if start >= mid+1 { + return sumRange(root.right, start, end) + } + return sumRange(root.right, mid+1, end) + sumRange(root.left, start, mid) +} diff --git a/Medium/L309.go b/Medium/L309.go new file mode 100644 index 0000000..caab14d --- /dev/null +++ b/Medium/L309.go @@ -0,0 +1,30 @@ +package Medium + +func maxProfit(prices []int) int { + return solve(prices, 0, make(map[int]int)) +} + +func solve(prices []int, current int, mp map[int]int) int { + if current > len(prices) { + return 0 + } + + if val, ok := mp[current]; ok { + return val + } + + max := 0 + for i := current + 1; i < len(prices); i++ { + sell := prices[i] - prices[current] + solve(prices, i+2, mp) + if sell > max { + max = sell + } + } + + profit := solve(prices, current+1, mp) + if profit > max { + max = profit + } + mp[current] = max + return max +} diff --git a/Medium/L310.go b/Medium/L310.go new file mode 100644 index 0000000..376c5ce --- /dev/null +++ b/Medium/L310.go @@ -0,0 +1,40 @@ +package Medium + +func findMinHeightTrees(n int, edges [][]int) []int { + if n == 1 { + return []int{0} + } + + adj := make([]map[int]bool, n) + for i := 0; i < n; i++ { + adj[i] = make(map[int]bool) + } + for _, e := range edges { + adj[e[0]][e[1]] = true + adj[e[1]][e[0]] = true + } + + var leaves []int + for i := 0; i < n; i++ { + if len(adj[i]) == 1 { + leaves = append(leaves, i) + } + } + + for n > 2 { + n -= len(leaves) + var newLeaves []int + for _, i := range leaves { + for v, _ := range adj[i] { + delete(adj[v], i) + if len(adj[v]) == 1 { + newLeaves = append(newLeaves, v) + } + break + } + } + leaves = newLeaves + } + + return leaves +} diff --git a/Medium/L316.go b/Medium/L316.go new file mode 100644 index 0000000..b59ddf7 --- /dev/null +++ b/Medium/L316.go @@ -0,0 +1,44 @@ +package Medium + +func removeDuplicateLetters(s string) string { + lastIndex := make([]int, 26) + for i := 0; i < len(s); i++ { + // track the lastIndex of character presence + lastIndex[s[i]-'a'] = i + } + + var st []int + seen := make([]bool, 26) + + for i := 0; i < len(s); i++ { + curr := s[i] - 'a' + if seen[curr] { + // if seen continue as we need to pick one char only + continue + } + for len(st) > 0 && st[len(st)-1] > int(curr) && i < lastIndex[st[len(st)-1]] { + // mark unseen + seen[st[len(st)-1]] = false + // pop out + st = st[:len(st)-1] + } + st = append(st, int(curr)) + seen[curr] = true + } + + var sb strings.Builder + for len(st) > 0 { + sb.WriteByte(byte(st[len(st)-1] + 'a')) + st = st[:len(st)-1] + } + + return reverse(sb.String()) +} + +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) +} diff --git a/Medium/L319.go b/Medium/L319.go new file mode 100644 index 0000000..1dcc42e --- /dev/null +++ b/Medium/L319.go @@ -0,0 +1,19 @@ +package Medium + +func bulbSwitch(n int) int { + low, high := 0, n + + for low <= high { + mid := low + (high - low) / 2 + candidate := mid * mid + if candidate == n { + return mid + } else if candidate < n { + low = mid + 1 + } else { + high = mid - 1 + } + } + + return low - 1 +} diff --git a/Medium/L328.go b/Medium/L328.go new file mode 100644 index 0000000..90dd494 --- /dev/null +++ b/Medium/L328.go @@ -0,0 +1,19 @@ +package Medium + +func oddEvenList(head *ListNode) *ListNode { + if head == nil { + return head + } + + odd, even, evenHead := head, head.Next, head.Next + + for even != nil && even.Next != nil { + odd.Next = odd.Next.Next + even.Next = even.Next.Next + odd = odd.Next + even = even.Next + } + odd.Next = evenHead + + return head +} diff --git a/Medium/L33.go b/Medium/L33.go new file mode 100644 index 0000000..7625c15 --- /dev/null +++ b/Medium/L33.go @@ -0,0 +1,45 @@ +package Medium + +func search(nums []int, target int) int { + if len(nums) == 0 { + return -1 + } + + var rotationCnt func() int + + rotationCnt = func() int { + l, r := 0, len(nums)-1 + + for l < r { + mid := l + (r-l)/2 + if mid < r && nums[mid] > nums[mid+1] { + return mid + 1 + } + if mid > l && nums[mid] < nums[mid-1] { + return mid + } + if nums[mid] < nums[r] { + r = mid - 1 + } else { + l = mid + 1 + } + } + + return l + } + rotCnt := rotationCnt() + low, high := 0, len(nums)-1 + for low <= high { + mid := low + (high-low)/2 + realMid := (mid + rotCnt) % len(nums) + if nums[realMid] == target { + return realMid + } else if nums[realMid] < target { + low = mid + 1 + } else { + high = mid - 1 + } + } + + return -1 +} diff --git a/Medium/L334.go b/Medium/L334.go new file mode 100644 index 0000000..0ca1216 --- /dev/null +++ b/Medium/L334.go @@ -0,0 +1,19 @@ +package Medium + +func increasingTriplet(nums []int) bool { + left, mid := math.MaxInt32, math.MaxInt32 + + for _, n := range nums { + if n > mid { + return true + } + + if n < mid && n > left { + mid = n + } else if n < left { + left = n + } + } + + return false +} diff --git a/Medium/L343.go b/Medium/L343.go new file mode 100644 index 0000000..ff1c07e --- /dev/null +++ b/Medium/L343.go @@ -0,0 +1,34 @@ +package Medium + +func integerBreak(n int) int { + mp := make(map[string]int) + + return solve(n, n - 1, mp) +} + +func solve(n, idx int, mp map[string]int) int { + if n == 0 || idx == 0 { + return 1 + } + + key := fmt.Sprintf("%d-%d", n, idx) + if v, ok := mp[key]; ok { + return v + } + + if idx > n { + mp[key] = solve(n, idx - 1, mp) + } else { + mp[key] = max(idx * solve(n - idx, idx, mp), solve(n, idx - 1, mp)) + } + + return mp[key] +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L36.go b/Medium/L36.go new file mode 100644 index 0000000..4abe9f1 --- /dev/null +++ b/Medium/L36.go @@ -0,0 +1,46 @@ +package Medium + +func isValidSudoku(board [][]byte) bool { + if len(board) == 0 { + return false + } + + index := 0 + for row := 0; row < len(board); row++ { + rowCheck, colCheck, boxCheck := make([]bool, 9), make([]bool, 9), make([]bool, 9) + for col := 0; col < len(board[row]); col++ { + if board[row][col] != '.' { + index = int((board[row][col] - '0') - 1) + + if rowCheck[index] { + return false + } + + rowCheck[index] = true + } + + if board[col][row] != '.' { + index = int((board[col][row] - '0') - 1) + + if colCheck[index] { + return false + } + + colCheck[index] = true + } + + boxRow, boxCol := (row/3)*3+col/3, (row%3)*3+col%3 + if board[boxRow][boxCol] != '.' { + index = int((board[boxRow][boxCol] - '0') - 1) + + if boxCheck[index] { + return false + } + + boxCheck[index] = true + } + } + } + + return true +} diff --git a/Medium/L368.go b/Medium/L368.go new file mode 100644 index 0000000..c4027cb --- /dev/null +++ b/Medium/L368.go @@ -0,0 +1,40 @@ +package Medium + +type Solution struct { + ans []int + dp []int + tmp []int +} + +func largestDivisibleSubset(nums []int) []int { + s := &Solution{ + dp: make([]int, 0), + tmp: make([]int, 0), + } + + sort.Ints(nums) + for i := 0; i < len(nums); i++ { + s.dp = append(s.dp, -1) + } + s.solve(0, 1, nums) + + return s.ans +} + +func (s *Solution) solve(i, prev int, nums []int) { + if i >= len(nums) { + if len(s.tmp) > len(s.ans) { + s.ans = make([]int, len(s.tmp)) + copy(s.ans, s.tmp) + } + return + } + + if len(s.tmp) > s.dp[i] && nums[i]%prev == 0 { + s.dp[i] = len(s.tmp) + s.tmp = append(s.tmp, nums[i]) + s.solve(i+1, nums[i], nums) + s.tmp = s.tmp[:len(s.tmp)-1] + } + s.solve(i+1, prev, nums) +} diff --git a/Medium/L378.go b/Medium/L378.go new file mode 100644 index 0000000..b5f0d47 --- /dev/null +++ b/Medium/L378.go @@ -0,0 +1,31 @@ +package Medium + +func kthSmallest(matrix [][]int, k int) int { + lo, hi := matrix[0][0], matrix[len(matrix)-1][len(matrix)-1] + for lo <= hi { + mid := lo + (hi-lo)/2 + cnt := getLessEqual(matrix, mid) + if cnt < k { + lo = mid + 1 + } else { + hi = mid - 1 + } + } + + return lo +} + +func getLessEqual(matrix [][]int, val int) int { + res, n, i, j := 0, len(matrix), len(matrix)-1, 0 + + for i >= 0 && j < n { + if matrix[i][j] > val { + i-- + } else { + res += i + 1 + j++ + } + } + + return res +} diff --git a/Medium/L380.go b/Medium/L380.go new file mode 100644 index 0000000..75dda73 --- /dev/null +++ b/Medium/L380.go @@ -0,0 +1,46 @@ +package Medium + +type RandomizedSet struct { + nums []int + locs map[int]int +} + +/** Initialize your data structure here. */ +func Constructor() RandomizedSet { + rand.Seed(time.Now().Unix()) + return RandomizedSet{ + nums: make([]int, 0), + locs: make(map[int]int), + } +} + +/** Inserts a value to the set. Returns true if the set did not already contain the specified element. */ +func (this *RandomizedSet) Insert(val int) bool { + if _, ok := this.locs[val]; ok { + return false + } + this.locs[val] = len(this.nums) + this.nums = append(this.nums, val) + return true +} + +/** Removes a value from the set. Returns true if the set contained the specified element. */ +func (this *RandomizedSet) Remove(val int) bool { + if _, ok := this.locs[val]; !ok { + return false + } + location := this.locs[val] + if location < len(this.nums)-1 { + lastOne := this.nums[len(this.nums)-1] + this.nums[location] = lastOne + this.locs[lastOne] = location + } + delete(this.locs, val) + this.nums = this.nums[:len(this.nums)-1] + return true +} + +/** Get a random element from the set. */ +func (this *RandomizedSet) GetRandom() int { + return this.nums[rand.Intn(len(this.nums))] +} diff --git a/Medium/L382.go b/Medium/L382.go new file mode 100644 index 0000000..4a085b0 --- /dev/null +++ b/Medium/L382.go @@ -0,0 +1,23 @@ +package Medium + +type Solution struct { + head *ListNode +} + +func Constructor(head *ListNode) Solution { + return Solution{head: head} +} + +func (this *Solution) GetRandom() int { + cnt, node, candidate := 0, this.head, this.head + + for node != nil { + cnt++ + if rand.Intn(cnt) == 0 { + candidate = node + } + node = node.Next + } + + return candidate.Val +} diff --git a/Medium/L39.go b/Medium/L39.go new file mode 100644 index 0000000..b863c98 --- /dev/null +++ b/Medium/L39.go @@ -0,0 +1,31 @@ +package Medium + +func combinationSum(candidates []int, target int) [][]int { + var ans [][]int + + if len(candidates) == 0 { + return ans + } + + bt(&ans, make([]int, 0), candidates, 0, target) + + return ans +} + +func bt(ans *[][]int, tmp, nums []int, idx, tgt int) { + if tgt < 0 || idx > len(nums) { + return + } + + if tgt == 0 { + cpyTmp := make([]int, len(tmp)) + copy(cpyTmp, tmp) + *ans = append(*ans, cpyTmp) + } + + for i := idx; i < len(nums); i++ { + tmp = append(tmp, nums[i]) + bt(ans, tmp, nums, i, tgt-nums[i]) + tmp = tmp[:len(tmp)-1] + } +} diff --git a/Medium/L394.go b/Medium/L394.go new file mode 100644 index 0000000..097e592 --- /dev/null +++ b/Medium/L394.go @@ -0,0 +1,41 @@ +package Medium + +func decodeString(s string) string { + index := 0 + return solve(s, &index) +} + +func solve(s string, index *int) string { + var sb strings.Builder + var num string + + for i := *index; i < len(s); i++ { + if s[i] != '[' && s[i] != ']' && !isDigit(s[i]) { + sb.WriteByte(s[i]) + } else if isDigit(s[i]) { + num += string(rune(s[i])) + } else if s[i] == '[' { + *index = i + 1 + next := solve(s, index) + for n := intVal(num); n > 0; n-- { + sb.WriteString(next) + } + num, i = "", *index + } else if s[i] == ']' { + *index = i + return sb.String() + } + } + + return sb.String() +} + +func isDigit(c byte) bool { + return c >= '0' && c <= '9' +} + +func intVal(num string) int { + i, _ := strconv.Atoi(num) + + return i +} diff --git a/Medium/L402.go b/Medium/L402.go new file mode 100644 index 0000000..4bb91b4 --- /dev/null +++ b/Medium/L402.go @@ -0,0 +1,83 @@ +package Medium + +type Stack struct { + arr []byte +} + +func NewStack() *Stack { + return &Stack{ + arr: make([]byte, 0), + } +} + +func (s *Stack) Push(c byte) { + s.arr = append(s.arr, c) +} + +func (s *Stack) Pop() byte { + if s.IsEmpty() { + return 0 + } + + ret := s.arr[len(s.arr)-1] + s.arr = s.arr[:len(s.arr)-1] + + return ret +} + +func (s *Stack) IsEmpty() bool { + return len(s.arr) <= 0 +} + +func (s *Stack) Peek() byte { + if s.IsEmpty() { + return 0 + } + + return s.arr[len(s.arr)-1] +} + +func removeKdigits(num string, k int) string { + if k == 0 { + return num + } + if len(num) == k { + return "0" + } + + st := NewStack() + index := 0 + + for index < len(num) { + for k > 0 && !st.IsEmpty() && st.Peek() > num[index] { + st.Pop() + k-- + } + st.Push(num[index]) + index = index + 1 + } + + for k > 0 { + k-- + st.Pop() + } + + var sb strings.Builder + for !st.IsEmpty() { + sb.WriteByte(st.Pop()) + } + smallest := reverse(sb.String()) + for len(smallest) > 1 && smallest[0] == '0' { + smallest = smallest[1:] + } + + return smallest +} + +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) +} diff --git a/Medium/L413.go b/Medium/L413.go new file mode 100644 index 0000000..fe620d6 --- /dev/null +++ b/Medium/L413.go @@ -0,0 +1,22 @@ +package Medium + +func numberOfArithmeticSlices(nums []int) int { + if len(nums) < 3 { + return 0 + } + + cnt := 0 + for i := 0; i < len(nums)-2; i++ { + d := nums[i+1] - nums[i] + cnt += helper(nums, i+2, nums[i+1], d, len(nums)) + } + return cnt +} + +func helper(nums []int, idx, prev, d, n int) int { + if idx == n || nums[idx] - prev != d { + return 0 + } + + return 1 + helper(nums, idx+1, nums[idx], d, n) +} diff --git a/Medium/L416.go b/Medium/L416.go new file mode 100644 index 0000000..1c0031b --- /dev/null +++ b/Medium/L416.go @@ -0,0 +1,39 @@ +package Medium + +func canPartition(nums []int) bool { + sum, n := 0, len(nums) + + for _, itm := range nums { + sum += itm + } + + if sum%2 != 0 { + return false + } + + sum /= 2 + dp, visited := make([][]bool, sum+1), make([][]bool, sum+1) + for i := 0; i < sum+1; i++ { + dp[i] = make([]bool, n) + } + for i := 0; i < sum+1; i++ { + visited[i] = make([]bool, n) + } + return solve(nums, dp, visited, sum, n-1) +} + +func solve(nums []int, dp, visited [][]bool, sum, index int) bool { + if index < 0 || sum < 0 { + return false + } + if sum == 0 { + dp[sum][index] = true + return dp[sum][index] + } + if visited[sum][index] { + return dp[sum][index] + } + visited[sum][index] = true + dp[sum][index] = solve(nums, dp, visited, sum, index-1) || solve(nums, dp, visited, sum-nums[index], index-1) + return dp[sum][index] +} diff --git a/Medium/L421.go b/Medium/L421.go new file mode 100644 index 0000000..8b6f4a1 --- /dev/null +++ b/Medium/L421.go @@ -0,0 +1,61 @@ +package Medium + +type Trie struct { + children []*Trie +} + +func NewTrie() *Trie { + return &Trie{ + children: make([]*Trie, 2), + } +} + +func findMaximumXOR(nums []int) int { + if len(nums) == 0 { + return 0 + } + + root := NewTrie() + for _, n := range nums { + curNode := root + for i := 30; i >= 0; i-- { + curBit := getIthBit(n, i) + if curNode.children[curBit^1] == nil { + curNode.children[curBit^1] = NewTrie() + } + + curNode = curNode.children[curBit^1] + } + } + + ans := math.MinInt32 + for _, n := range nums { + curNode, rst := root, 0 + for i := 30; i >= 0; i-- { + bit := getIthBit(n, i) + + if curNode.children[bit] != nil { + curNode = curNode.children[bit] + rst += 1 << i + } else { + curNode = curNode.children[bit^1] + } + } + if rst > ans { + ans = rst + } + if ans == math.MaxInt32 { + break + } + } + + return ans +} + +func getIthBit(num, i int) int { + if (num & (1 << i)) == 0 { + return 0 + } + + return 1 +} diff --git a/Medium/L427.go b/Medium/L427.go new file mode 100644 index 0000000..1baa4bc --- /dev/null +++ b/Medium/L427.go @@ -0,0 +1,40 @@ +package Medium + +func construct(grid [][]int) *Node { + var solve func(x1, x2, y1, y2 int) *Node + solve = func(x1, x2, y1, y2 int) *Node { + if x1 == x2 { + val := false + if grid[x1][y1] == 1 { + val = true + } + return &Node{ + Val: val, + IsLeaf: true, + } + } + + rowMid, colMid := (x1+x2)/2, (y1+y2)/2 + topLeft := solve(x1, rowMid, y1, colMid) + topRight := solve(x1, rowMid, colMid+1, y2) + bottomLeft := solve(rowMid+1, x2, y1, colMid) + bottomRight := solve(rowMid+1, x2, colMid+1, y2) + + if topLeft.IsLeaf && topRight.IsLeaf && bottomLeft.IsLeaf && bottomRight.IsLeaf && + topRight.Val == topLeft.Val && topRight.Val == bottomLeft.Val && topRight.Val == bottomRight.Val { + return &Node{ + Val: topLeft.Val, + IsLeaf: true, + } + } else { + return &Node{ + TopLeft: topLeft, + TopRight: topRight, + BottomLeft: bottomLeft, + BottomRight: bottomRight, + } + } + } + + return solve(0, len(grid)-1, 0, len(grid[0])-1) +} diff --git a/Medium/L429.go b/Medium/L429.go new file mode 100644 index 0000000..76dc963 --- /dev/null +++ b/Medium/L429.go @@ -0,0 +1,28 @@ +package Medium + +func levelOrder(root *Node) [][]int { + var res [][]int + if root == nil { + return res + } + + var q []*Node + q = append(q, root) + + for len(q) > 0 { + size := len(q) + var tmp []int + for i := 0; i < size; i++ { + n := q[0] + q = q[1:] + tmp = append(tmp, n.Val) + + for _, v := range n.Children { + q = append(q, v) + } + } + res = append(res, tmp) + } + + return res +} diff --git a/Medium/L43.go b/Medium/L43.go new file mode 100644 index 0000000..325b5d6 --- /dev/null +++ b/Medium/L43.go @@ -0,0 +1,29 @@ +package Medium + +func multiply(num1 string, num2 string) string { + n1, n2 := len(num1), len(num2) + products := make([]byte, n1+n2) + for i := n1 - 1; i >= 0; i-- { + for j := n2 - 1; j >= 0; j-- { + d1, d2 := num1[i]-'0', num2[j]-'0' + products[i+j+1] += d1 * d2 + } + } + + carry := 0 + for i := len(products) - 1; i >= 0; i-- { + tmp := (int(products[i]) + carry) % 10 + carry = (int(products[i]) + carry) / 10 + products[i] = byte(tmp) + } + + for len(products) != 0 && products[0] == '0' { + products = products[1:] + } + + if len(products) == 0 { + return "0" + } + + return string(products) +} diff --git a/Medium/L430.go b/Medium/L430.go new file mode 100644 index 0000000..3528627 --- /dev/null +++ b/Medium/L430.go @@ -0,0 +1,28 @@ +package Medium + +func flatten(root *Node) *Node { + if root == nil { + return root + } + + p := root + for p != nil { + if p.Child == nil { + p = p.Next + continue + } + tmp := p.Child + for tmp.Next != nil { + tmp = tmp.Next + } + tmp.Next = p.Next + if p.Next != nil { + p.Next.Prev = tmp + } + p.Next = p.Child + p.Child.Prev = p + p.Child = nil + } + + return root +} diff --git a/Medium/L433.go b/Medium/L433.go new file mode 100644 index 0000000..cc1db99 --- /dev/null +++ b/Medium/L433.go @@ -0,0 +1,45 @@ +package Medium + +var exists struct{} + +func minMutation(start string, end string, bank []string) int { + return dfs(start, end, bank, make(map[string]struct{})) +} + +func dfs(start, end string, bank []string, visited map[string]struct{}) int { + if start == end { + return 0 + } + + min := math.MaxInt32 + for _, s := range bank { + diff := 0 + for i := 0; i < len(start); i++ { + if start[i] != s[i] { + diff++ + } + if diff > 1 { + break + } + } + + if _, ok := visited[s]; !ok { + if diff == 1 { + visited[s] = exists + h := dfs(s, end, bank, visited) + if h >= 0 { + if 1+h < min { + min = 1 + h + } + } + delete(visited, s) + } + } + } + + if min == math.MaxInt32 { + return -1 + } + + return min +} diff --git a/Medium/L437.go b/Medium/L437.go new file mode 100644 index 0000000..f89fda8 --- /dev/null +++ b/Medium/L437.go @@ -0,0 +1,32 @@ +package Medium + +func pathSum(root *TreeNode, targetSum int) int { + mp := make(map[int]int) + mp[0] = 1 + + return solve(root, 0, targetSum, mp) +} + +func solve(root *TreeNode, currSum, target int, mp map[int]int) int { + if root == nil { + return 0 + } + + currSum += root.Val + res := 0 + if val, ok := mp[currSum-target]; ok { + res = val + } + if val, ok := mp[currSum]; ok { + mp[currSum] = val + 1 + } else { + mp[currSum] = 1 + } + + res += solve(root.Left, currSum, target, mp) + solve(root.Right, currSum, target, mp) + if val, ok := mp[currSum]; ok { + mp[currSum] = val - 1 + } + + return res +} diff --git a/Medium/L438.go b/Medium/L438.go new file mode 100644 index 0000000..c299090 --- /dev/null +++ b/Medium/L438.go @@ -0,0 +1,41 @@ +package Medium + +func findAnagrams(s string, p string) []int { + var ans []int + if len(p) > len(s) { + return ans + } + + mp := make(map[byte]int) + for i := 0; i < len(p); i++ { + mp[p[i]]++ + } + + begin, end, counter := 0, 0, len(mp) + + for end < len(s) { + if _, ok := mp[s[end]]; ok { + mp[s[end]]-- + if mp[s[end]] == 0 { + counter-- + } + } + end++ + + for counter == 0 { + if _, ok := mp[s[begin]]; ok { + mp[s[begin]]++ + if mp[s[begin]] > 0 { + counter++ + } + } + + if end-begin == len(p) { + ans = append(ans, begin) + } + begin++ + } + } + + return ans +} diff --git a/Medium/L442.go b/Medium/L442.go new file mode 100644 index 0000000..61a103a --- /dev/null +++ b/Medium/L442.go @@ -0,0 +1,24 @@ +func findDuplicates(nums []int) []int { + var ret []int + if len(nums) == 0 { + return ret + } + + for _, n := range nums { + index := abs(n) - 1 + if nums[index] < 0 { + ret = append(ret, abs(n)) + } + nums[index] = -nums[index] + } + + return ret +} + +func abs(n int) int { + if n < 0 { + return -n + } + + return n +} diff --git a/Medium/L443.go b/Medium/L443.go new file mode 100644 index 0000000..7be4e6a --- /dev/null +++ b/Medium/L443.go @@ -0,0 +1,32 @@ +package Medium + +func compress(chars []byte) int { + index := 0 + + updateChars := func(freq int) { + arr := []byte(fmt.Sprintf("%d", freq)) + for i := range arr { + chars[index] = arr[i] + index++ + } + } + + for i := 0; i < len(chars); { + j := i + for j < len(chars) && chars[i] == chars[j] { + j++ + } + freq := j - i + chars[index] = chars[i] + index++ + if freq > 1 && freq < 10 { + chars[index] = byte(freq + '0') + index++ + } else if freq >= 10 { + updateChars(freq) + } + i = j + } + + return index +} diff --git a/Medium/L45.go b/Medium/L45.go new file mode 100644 index 0000000..df12cf5 --- /dev/null +++ b/Medium/L45.go @@ -0,0 +1,36 @@ +package Medium + +func jump(nums []int) int { + dp := make([]int, len(nums)) + for i := range dp { + dp[i] = -1 + } + + return solve(nums, &dp, 0) +} + +func solve(nums []int, dp *[]int, idx int) int { + if idx >= len(nums)-1 { + return 0 + } + + if (*dp)[idx] != -1 { + return (*dp)[idx] + } + + minJump := len(nums) + for i := idx + 1; i <= idx+nums[idx]; i++ { + minJump = min(minJump, 1+solve(nums, dp, i)) + } + + (*dp)[idx] = minJump + return minJump +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Medium/L450.go b/Medium/L450.go new file mode 100644 index 0000000..680e451 --- /dev/null +++ b/Medium/L450.go @@ -0,0 +1,33 @@ +package Medium + +func deleteNode(root *TreeNode, key int) *TreeNode { + if root == nil { + return root + } + + if key < root.Val { + root.Left = deleteNode(root.Left, key) + } else if key > root.Val { + root.Right = deleteNode(root.Right, key) + } else { + if root.Left == nil { + return root.Right + } else if root.Right == nil { + return root.Left + } + + minNode := findMin(root.Right) + root.Val = minNode.Val + root.Right = deleteNode(root.Right, root.Val) + } + + return root +} + +func findMin(root *TreeNode) *TreeNode { + for root.Left != nil { + root = root.Left + } + + return root +} diff --git a/Medium/L451.go b/Medium/L451.go new file mode 100644 index 0000000..543b569 --- /dev/null +++ b/Medium/L451.go @@ -0,0 +1,29 @@ +package Medium + +func frequencySort(s string) string { + mp := make(map[byte]int) + for i := range s { + mp[s[i]]++ + } + + bucket := make([][]byte, len(s)+1) + for i := 0; i < len(mp)+1; i++ { + bucket[i] = make([]byte, 0) + } + for k, freq := range mp { + bucket[freq] = append(bucket[freq], k) + } + + var sb strings.Builder + for i := len(bucket) - 1; i >= 0; i-- { + if len(bucket[i]) != 0 { + for idx := 0; idx < len(bucket[i]); idx++ { + for pos := 0; pos < i; pos++ { + sb.WriteByte(bucket[i][idx]) + } + } + } + } + + return sb.String() +} diff --git a/Medium/L452.go b/Medium/L452.go new file mode 100644 index 0000000..569c56f --- /dev/null +++ b/Medium/L452.go @@ -0,0 +1,25 @@ +package Medium + +func findMinArrowShots(points [][]int) int { + if len(points) == 0 { + return 0 + } + + sort.Slice(points, func(i, j int) bool { + if points[i][1] < points[j][1] { + return true + } + + return false + }) + + end, res := points[0][1], 1 + for _, p := range points { + if p[0] <= end { + continue + } + res++ + end = p[1] + } + return res +} diff --git a/Medium/L454.go b/Medium/L454.go new file mode 100644 index 0000000..40f0feb --- /dev/null +++ b/Medium/L454.go @@ -0,0 +1,24 @@ +package Medium + +func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int { + mp, n, res := make(map[int]int), len(nums1), 0 + + for i := 0; i < n; i++ { + for j := 0; j < n; j++ { + sum := nums3[i] + nums4[j] + mp[sum]++ + } + } + + for i := 0; i < n; i++ { + for j := 0; j < n; j++ { + sum := nums1[i] + nums2[j] + + if val, ok := mp[-sum]; ok { + res += val + } + } + } + + return res +} diff --git a/Medium/L46.go b/Medium/L46.go new file mode 100644 index 0000000..072aaeb --- /dev/null +++ b/Medium/L46.go @@ -0,0 +1,37 @@ +package Medium + +func permute(nums []int) [][]int { + var ( + ans [][]int + tmp []int + solve func(tmp []int) + ) + if len(nums) == 0 { + return ans + } + + mp := make(map[int]bool) + solve = func(tmp []int) { + if len(tmp) == len(nums) { + tmpCopy := make([]int, len(tmp)) + copy(tmpCopy, tmp) + ans = append(ans, tmpCopy) + return + } + + for i := 0; i < len(nums); i++ { + if mp[nums[i]] { + continue + } + tmp = append(tmp, nums[i]) + mp[nums[i]] = true + solve(tmp) + delElem := tmp[len(tmp) - 1] + tmp = tmp[:len(tmp) - 1] + delete(mp, delElem) + } + } + + solve(tmp) + return ans +} diff --git a/Medium/L47.go b/Medium/L47.go new file mode 100644 index 0000000..17909b0 --- /dev/null +++ b/Medium/L47.go @@ -0,0 +1,38 @@ +package Medium + +func permuteUnique(nums []int) [][]int { + var ( + ans [][]int + tmp []int + ) + if len(nums) == 0 { + return ans + } + + sort.Ints(nums) + used := make([]bool, len(nums)) + backTrack(&ans, &tmp, nums, &used) + + return ans +} + +func backTrack(ans *[][]int, tmp *[]int, nums []int, used *[]bool) { + if len(*tmp) == len(nums) { + tmpCopy := make([]int, len(*tmp)) + copy(tmpCopy, *tmp) + *ans = append(*ans, tmpCopy) + return + } + + for i := range nums { + if (*used)[i] || (i > 0 && nums[i] == nums[i-1] && !(*used)[i-1]) { + continue + } + + (*used)[i] = true + *tmp = append(*tmp, nums[i]) + backTrack(ans, tmp, nums, used) + (*used)[i] = false + *tmp = (*tmp)[:len(*tmp)-1] + } +} diff --git a/Medium/L473.go b/Medium/L473.go new file mode 100644 index 0000000..7cd1e4c --- /dev/null +++ b/Medium/L473.go @@ -0,0 +1,39 @@ +package Medium + +func makesquare(matchsticks []int) bool { + sum, max, k, vis := 0, 0, 4, make([]bool, len(matchsticks)) + for _, n := range matchsticks { + sum += n + if n > max { + max = n + } + } + + if sum%k != 0 || max > sum/k { + return false + } + + return solve(matchsticks, &vis, k, sum/k, 0, 0) +} + +func solve(nums []int, vis *[]bool, k, targetSubsetSum, curSubsetSum, nextIndexToCheck int) bool { + if k == 0 { + return true + } + + if curSubsetSum == targetSubsetSum { + return solve(nums, vis, k-1, targetSubsetSum, 0, 0) + } + + for i := nextIndexToCheck; i < len(nums); i++ { + if !(*vis)[i] && curSubsetSum+nums[i] <= targetSubsetSum { + (*vis)[i] = true + if solve(nums, vis, k, targetSubsetSum, curSubsetSum+nums[i], i+1) { + return true + } + (*vis)[i] = false + } + } + + return false +} diff --git a/Medium/L474.go b/Medium/L474.go index a44653d..08302d5 100644 --- a/Medium/L474.go +++ b/Medium/L474.go @@ -34,3 +34,58 @@ func max(a, b int) int { return b } + + +// Recursion + Memoization +func findMaxForm(strs []string, m int, n int) int { + if len(strs) == 0 { + return 0 + } + + return solve(strs, make(map[string]int), m, n, 0) +} + +func solve(strs []string, mp map[string]int, m, n, index int) int { + // If we are done with the our remaining zeros and ones return 0 as we cant get any furtherr strings. + if m == 0 && n == 0 { + return 0 + } + + if index >= len(strs) { + return 0 + } + + key := fmt.Sprintf("%d:%d:%d", m, n, index) + if _, ok := mp[key]; ok { + return mp[key] + } + + // For the current index count the required number of zeros and ones . + totalCnt, curr := 0, strs[index] + ones, zeroes := 0, 0 + + for i := range curr { + if curr[i] == '0' { + zeroes++ + } else { + ones++ + } + } + + takenStrCnt := 0 + // if we have the required number of zeros and ones we take the current string and update the + // remaining zeros and ones and go to the next index + if ones <= n && zeroes <= m { + takenStrCnt += 1 + solve(strs, mp, m-zeroes, n-ones, index+1) + } + + skippedStrNum := solve(strs, mp, m, n, index+1) + totalCnt = skippedStrNum + // For every position we also the option to skip the current string + if takenStrCnt > skippedStrNum { + totalCnt = takenStrCnt + } + + mp[key] = totalCnt + return totalCnt +} diff --git a/Medium/L486.go b/Medium/L486.go new file mode 100644 index 0000000..b6e8406 --- /dev/null +++ b/Medium/L486.go @@ -0,0 +1,45 @@ +package Medium + +func PredictTheWinner(nums []int) bool { + var solve func(i, j, c int) int + mp := make(map[string]int) + + solve = func(i, j, c int) int { + if j < i { + return 0 + } + + key := fmt.Sprintf("%d-%d-%d", i, j, c) + if v, ok := mp[key]; ok { + return v + } + + res := 0 + if c == 0 { + res = max(solve(i+1, j, 1-c)+nums[i], solve(i, j-1, 1-c)+nums[j]) + } else { + res = min(solve(i+1, j, 1-c)-nums[i], solve(i, j-1, 1-c)-nums[j]) + } + + return res + } + + ans := solve(0, len(nums)-1, 0) + return ans >= 0 +} + +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/L487.go b/Medium/L487.go new file mode 100644 index 0000000..63cb40a --- /dev/null +++ b/Medium/L487.go @@ -0,0 +1,38 @@ +package Medium + +func findMaxConsecutiveOnes(nums []int) int { + mp := make(map[string]int) + + return solve(0, 1, 0, nums, mp) +} + +func solve(idx, k, cnt int, nums []int, mp map[string]int) int { + if idx >= len(nums) { + return cnt + } + + if nums[idx] == 0 && k == 0 { + return cnt + } + + key := fmt.Sprintf("%d-%d", idx, k) + if v, ok := mp[key]; ok { + return v + } + + if nums[idx] == 0 { + mp[key] = max(solve(idx+1, k-1, cnt+1, nums, mp), solve(idx+1, k, 0, nums, mp)) + } else { + mp[key] = solve(idx + 1, k, cnt + 1, nums, mp) + } + + return mp[key] +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L49.go b/Medium/L49.go new file mode 100644 index 0000000..143ef2d --- /dev/null +++ b/Medium/L49.go @@ -0,0 +1,36 @@ +package Medium + +func groupAnagrams(strs []string) [][]string { + var ans [][]string + if len(strs) == 0 { + return ans + } + + mp := make(map[string][]string) + + for _, s := range strs { + k := getKey(s) + mp[k] = append(mp[k], s) + } + + for _, v := range mp { + ans = append(ans, v) + } + + return ans +} + +func getKey(s string) string { + arr := make([]byte, 26) + + for i := 0; i < len(s); i++ { + arr[s[i]-'a']++ + } + + var sb strings.Builder + for _, v := range arr { + sb.WriteByte(v) + } + + return sb.String() +} diff --git a/Medium/L491.go b/Medium/L491.go new file mode 100644 index 0000000..ac03c35 --- /dev/null +++ b/Medium/L491.go @@ -0,0 +1,32 @@ +package Medium + +func findSubsequences(nums []int) [][]int { + var ( + tmp []int + res [][]int + ) + solve(0, nums, &tmp, &res) + return res +} + +func solve(idx int, nums []int, tmp *[]int, res *[][]int) { + if idx > len(nums)-1 { + if len(*tmp) > 1 { + tmpCopy := make([]int, len(*tmp)) + copy(tmpCopy, *tmp) + *res = append(*res, tmpCopy) + } + return + } + + if len(*tmp) == 0 || nums[idx] >= (*tmp)[len(*tmp)-1] { + *tmp = append(*tmp, nums[idx]) + solve(idx+1, nums, tmp, res) + *tmp = (*tmp)[:len(*tmp)-1] + } + + if idx > 0 && len(*tmp) > 0 && nums[idx] == (*tmp)[len(*tmp)-1] { + return + } + solve(idx+1, nums, tmp, res) +} diff --git a/Medium/L516.go b/Medium/L516.go new file mode 100644 index 0000000..4a9e163 --- /dev/null +++ b/Medium/L516.go @@ -0,0 +1,37 @@ +func longestPalindromeSubseq(s string) int { + mp := make(map[string]int) + var solve func(left, right int) int + + solve = func(left, right int) int { + if left == right { + return 1 + } + + if left > right { + return 0 + } + + key := fmt.Sprintf("%d-%d", left, right) + if v, ok := mp[key]; ok { + return v + } + + if s[left] == s[right] { + mp[key] = 2 + solve(left+1, right-1) + } else { + mp[key] = max(solve(left+1, right), solve(left, right-1)) + } + + return mp[key] + } + + return solve(0, len(s) - 1) +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L523.go b/Medium/L523.go new file mode 100644 index 0000000..c0b42f3 --- /dev/null +++ b/Medium/L523.go @@ -0,0 +1,21 @@ +package Medium + +func checkSubarraySum(nums []int, k int) bool { + mp := make(map[int]int) + mp[0] = -1 + runningSum := 0 + for i := 0; i < len(nums); i++ { + runningSum += nums[i] + if k != 0 { + runningSum %= k + } + if v, ok := mp[runningSum]; ok { + if i-v > 1 { + return true + } + } else { + mp[runningSum] = i + } + } + return false +} diff --git a/Medium/L525.go b/Medium/L525.go new file mode 100644 index 0000000..9d67ef6 --- /dev/null +++ b/Medium/L525.go @@ -0,0 +1,24 @@ +package Medium + +func findMaxLength(nums []int) int { + mp, sum, max := make(map[int]int), 0, 0 + mp[0] = -1 + + for i := range nums { + if nums[i] == 0 { + sum++ + } else { + sum-- + } + + if val, ok := mp[sum]; ok { + if (i - val) > max { + max = i - val + } + } else { + mp[sum] = i + } + } + + return max +} diff --git a/Medium/L532.go b/Medium/L532.go new file mode 100644 index 0000000..e2aea8f --- /dev/null +++ b/Medium/L532.go @@ -0,0 +1,26 @@ +package Medium + +func findPairs(nums []int, k int) int { + if len(nums) == 0 || k < 0 { + return 0 + } + + mp, cnt := make(map[int]int), 0 + for _, n := range nums { + mp[n]++ + } + + for key, val := range mp { + if k == 0 { + if val >= 2 { + cnt++ + } + } else { + if _, ok := mp[key+k]; ok { + cnt++ + } + } + } + + return cnt +} diff --git a/Medium/L538.go b/Medium/L538.go new file mode 100644 index 0000000..609f36d --- /dev/null +++ b/Medium/L538.go @@ -0,0 +1,18 @@ +package Medium + +func convertBST(root *TreeNode) *TreeNode { + sum := 0 + convert(root, &sum) + return root +} + +func convert(cur *TreeNode, sum *int) { + if cur == nil { + return + } + + convert(cur.Right, sum) + cur.Val += *sum + *sum = cur.Val + convert(cur.Left, sum) +} diff --git a/Medium/L54.go b/Medium/L54.go new file mode 100644 index 0000000..c150ea8 --- /dev/null +++ b/Medium/L54.go @@ -0,0 +1,36 @@ +package Medium + +func spiralOrder(matrix [][]int) []int { + var res []int + if len(matrix) == 0 { + return res + } + + n, m := len(matrix), len(matrix[0]) + up, down, left, right := 0, n-1, 0, m-1 + + for len(res) < n*m { + for j := left; j <= right && len(res) < n*m; j++ { + res = append(res, matrix[up][j]) + } + + for i := up + 1; i <= down-1 && len(res) < n*m; i++ { + res = append(res, matrix[i][right]) + } + + for j := right; j >= left && len(res) < n*m; j-- { + res = append(res, matrix[down][j]) + } + + for i:= down-1; i >= up + 1 && len(res) < n*m; i-- { + res = append(res, matrix[i][left]) + } + + left++ + right-- + up++ + down-- + } + + return res +} diff --git a/Medium/L540.go b/Medium/L540.go new file mode 100644 index 0000000..1a47f46 --- /dev/null +++ b/Medium/L540.go @@ -0,0 +1,25 @@ +package Medium + +func singleNonDuplicate(nums []int) int { + lo, hi, mid := 0, len(nums)-1, -1 + + for lo < hi { + mid = lo + (hi-lo)/2 + + if mid%2 == 0 { + if nums[mid] == nums[mid+1] { + lo = mid + 2 + } else { + hi = mid + } + } else { + if nums[mid] == nums[mid-1] { + lo = mid + 1 + } else { + hi = mid + } + } + } + + return nums[lo] +} diff --git a/Medium/L542.go b/Medium/L542.go new file mode 100644 index 0000000..d6e45c8 --- /dev/null +++ b/Medium/L542.go @@ -0,0 +1,61 @@ +package Medium + +func updateMatrix(mat [][]int) [][]int { + var ( + res, q [][]int + isValid func(x, y int) bool + ) + if len(mat) == 0 { + return res + } + + dirs := [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + m, n := len(mat), len(mat[0]) + vis := make([][]bool, m) + for i := 0; i < m; i++ { + vis[i] = make([]bool, n) + } + + isValid = func(x, y int) bool { + return x >= 0 && y >= 0 && x < m && y < n && mat[x][y] == math.MaxInt32 + } + + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if mat[i][j] == 0 { + q = append(q, []int{i, j}) + } else { + mat[i][j] = math.MaxInt32 + } + } + } + + for len(q) > 0 { + c := q[0] + q = q[1:] + + if vis[c[0]][c[1]] { + continue + } + vis[c[0]][c[1]] = true + + for _, d := range dirs { + newX, newY := c[0]+d[0], c[1]+d[1] + if isValid(newX, newY) { + mat[newX][newY] = min(mat[newX][newY], mat[c[0]][c[1]]+1) + q = append(q, []int{newX, newY}) + } + } + } + + return mat +} + + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Medium/L55.go b/Medium/L55.go new file mode 100644 index 0000000..ed3ce39 --- /dev/null +++ b/Medium/L55.go @@ -0,0 +1,35 @@ +package Medium + +func canJump(nums []int) bool { + n, dp := len(nums), make([]int, len(nums)) + for i := 0; i < n; i++ { + dp[i] = -1 + } + return solve(nums, 0, &dp) +} + +func solve(nums []int, idx int, dp *[]int) bool { + if idx >= len(nums)-1 { + return true + } + + if nums[idx] == 0 { + (*dp)[idx] = 0 + return false + } + + if (*dp)[idx] != -1 { + return (*dp)[idx] == 1 + } + + jumps := nums[idx] + for i := 1; i <= jumps; i++ { + if solve(nums, idx+i, dp) { + (*dp)[idx] = 1 + return true + } + } + + (*dp)[idx] = 0 + return false +} diff --git a/Medium/L56.go b/Medium/L56.go new file mode 100644 index 0000000..51f0a7b --- /dev/null +++ b/Medium/L56.go @@ -0,0 +1,33 @@ +package Medium + +func merge(intervals [][]int) [][]int { + if len(intervals) == 0 { + return [][]int{} + } + + var ans [][]int + sort.Slice(intervals, func(i, j int) bool { + return intervals[i][0] < intervals[j][0] + }) + + start, end := intervals[0][0], intervals[0][1] + for _, i := range intervals { + if i[0] <= end { + end = max(end, i[1]) + } else { + ans = append(ans, []int{start, end}) + start, end = i[0], i[1] + } + } + ans = append(ans, []int{start, end}) + + return ans +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L560.go b/Medium/L560.go new file mode 100644 index 0000000..d42fc16 --- /dev/null +++ b/Medium/L560.go @@ -0,0 +1,16 @@ +package Medium + +func subarraySum(nums []int, k int) int { + sum, res, mp := 0, 0, make(map[int]int) + mp[0] = 1 + + for i := range nums { + sum += nums[i] + if val, ok := mp[sum-k]; ok { + res += val + } + mp[sum]++ + } + + return res +} diff --git a/Medium/L565.go b/Medium/L565.go new file mode 100644 index 0000000..b448213 --- /dev/null +++ b/Medium/L565.go @@ -0,0 +1,18 @@ +package Medium + +func arrayNesting(nums []int) int { + maxLen, visited := 0, make([]bool, len(nums)) + for _, n := range nums { + currLen := 0 + for !visited[n] { + currLen++ + visited[n] = true + n = nums[n] + } + if currLen > maxLen { + maxLen = currLen + } + } + + return maxLen +} diff --git a/Medium/L567.go b/Medium/L567.go new file mode 100644 index 0000000..fdc2cff --- /dev/null +++ b/Medium/L567.go @@ -0,0 +1,41 @@ +package Medium + +func checkInclusion(s1 string, s2 string) bool { + if len(s1) > len(s2) { + return false + } + + mp := make(map[byte]int) + for i := 0; i < len(s1); i++ { + mp[s1[i]]++ + } + + counter, begin, end := len(mp), 0, 0 + for end < len(s2) { + ch := s2[end] + + if _, ok := mp[ch]; ok { + mp[ch]-- + if mp[ch] == 0 { + counter-- + } + } + end++ + + for counter == 0 { + tmp := s2[begin] + if _, ok := mp[tmp]; ok { + mp[tmp]++ + if mp[tmp] > 0 { + counter++ + } + } + if end-begin == len(s1) { + return true + } + begin++ + } + } + + return false +} diff --git a/Medium/L57.go b/Medium/L57.go new file mode 100644 index 0000000..0ec39e7 --- /dev/null +++ b/Medium/L57.go @@ -0,0 +1,38 @@ +package Medium + +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 +} + +func insert(intervals [][]int, newInterval []int) [][]int { + var res [][]int + start, end := newInterval[0], newInterval[1] + + for _, itvl := range intervals { + currStart, currEnd := itvl[0], itvl[1] + if currEnd < start { + res = append(res, []int{currStart, currEnd}) + } else if currStart > end { + res = append(res, []int{start, end}) + start, end = currStart, currEnd + } else { + start = min(start, currStart) + end = max(end, currEnd) + } + } + res = append(res, []int{start, end}) + + return res +} diff --git a/Medium/L576.go b/Medium/L576.go new file mode 100644 index 0000000..8bd6ea0 --- /dev/null +++ b/Medium/L576.go @@ -0,0 +1,47 @@ +package Medium + +const MOD = 1000000007 + +var dirs = [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + +func findPaths(m int, n int, maxMove int, startRow int, startColumn int) int { + dp := make([][][]int, m) + for i := 0; i < m; i++ { + dp[i] = make([][]int, n) + for j := 0; j < n; j++ { + dp[i][j] = make([]int, maxMove+1) + for k := 0; k < maxMove+1; k++ { + dp[i][j][k] = -1 + } + } + } + + return dfs(&dp, m, n, startRow, startColumn, maxMove) +} + +func isValid(m, n, x, y int) bool { + return x >= 0 && x < m && y >= 0 && y < n +} + +func dfs(dp *[][][]int, m, n, i, j, maxMove int) int { + if maxMove < 0 { + return 0 + } + + if !isValid(m, n, i, j) { + return 1 + } + + if (*dp)[i][j][maxMove] != -1 { + return (*dp)[i][j][maxMove] + } + + sum := 0 + for _, d := range dirs { + sum += dfs(dp, m, n, i+d[0], j+d[1], maxMove-1) % MOD + } + + (*dp)[i][j][maxMove] = sum % MOD + + return (*dp)[i][j][maxMove] % MOD +} diff --git a/Medium/L6.go b/Medium/L6.go new file mode 100644 index 0000000..865c478 --- /dev/null +++ b/Medium/L6.go @@ -0,0 +1,24 @@ +package Medium + +func convert(s string, numRows int) string { + if numRows <= 1 { + return s + } + + res, idx, dir := make([]string, numRows), 0, -1 + + for i := 0; i < len(s); i++ { + res[idx] += fmt.Sprintf("%c", s[i]) + if idx == 0 || idx == numRows-1 { + dir = -dir + } + idx += dir + } + + var sb strings.Builder + for i := 0; i < len(res); i++ { + sb.WriteString(res[i]) + } + + return sb.String() +} diff --git a/Medium/L61.go b/Medium/L61.go new file mode 100644 index 0000000..6d33b62 --- /dev/null +++ b/Medium/L61.go @@ -0,0 +1,25 @@ +package Medium + +func rotateRight(head *ListNode, k int) *ListNode { + if head == nil { + return head + } + + listNum, tail := 1, head + + for tail.Next != nil { + listNum++ + tail = tail.Next + } + tail.Next = head + newHeadIndex := listNum - k%listNum + + for i := 0; i < newHeadIndex; i++ { + tail = tail.Next + } + + head = tail.Next + tail.Next = nil + + return head +} diff --git a/Medium/L611.go b/Medium/L611.go new file mode 100644 index 0000000..6681276 --- /dev/null +++ b/Medium/L611.go @@ -0,0 +1,23 @@ +package Medium + +func triangleNumber(nums []int) int { + res := 0 + if len(nums) < 3 { + return res + } + + sort.Ints(nums) + for i := 2; i < len(nums); i++ { + left, right := 0, i-1 + for left < right { + if nums[left]+nums[right] > nums[i] { + res += right - left + right-- + } else { + left++ + } + } + } + + return res +} diff --git a/Medium/L622.go b/Medium/L622.go index a147500..36973ef 100644 --- a/Medium/L622.go +++ b/Medium/L622.go @@ -1,14 +1,16 @@ package Medium type MyCircularQueue struct { - Q []int - Capacity int + maxSize, head, tail int + data []int } func Constructor(k int) MyCircularQueue { return MyCircularQueue{ - Q: make([]int, 0, k), - Capacity: k, + maxSize: k, + head: 0, + tail: -1, + data: make([]int, k), } } @@ -17,7 +19,9 @@ func (this *MyCircularQueue) EnQueue(value int) bool { return false } - this.Q = append(this.Q, value) + this.tail = (this.tail + 1) % this.maxSize + this.data[this.tail] = value + return true } @@ -26,7 +30,12 @@ func (this *MyCircularQueue) DeQueue() bool { return false } - this.Q = this.Q[1:] + if this.head == this.tail { + this.head, this.tail = 0, -1 + } else { + this.head = (this.head + 1) % this.maxSize + } + return true } @@ -35,7 +44,7 @@ func (this *MyCircularQueue) Front() int { return -1 } - return this.Q[0] + return this.data[this.head] } func (this *MyCircularQueue) Rear() int { @@ -43,15 +52,15 @@ func (this *MyCircularQueue) Rear() int { return -1 } - return this.Q[len(this.Q)-1] + return this.data[this.tail] } func (this *MyCircularQueue) IsEmpty() bool { - return len(this.Q) == 0 + return this.tail == -1 } func (this *MyCircularQueue) IsFull() bool { - return len(this.Q) == this.Capacity + return !this.IsEmpty() && (this.tail+1)%this.maxSize == this.head } /** diff --git a/Medium/L649.go b/Medium/L649.go new file mode 100644 index 0000000..9831a70 --- /dev/null +++ b/Medium/L649.go @@ -0,0 +1,29 @@ +package Medium + +func predictPartyVictory(senate string) string { + var q1, q2 []int + n := len(senate) + for i := 0; i < n; i++ { + if senate[i] == 'R' { + q1 = append(q1, i) + } else { + q2 = append(q2, i) + } + } + + for len(q1) > 0 && len(q2) > 0 { + rIndex, dIndex := q1[0], q2[0] + q1, q2 = q1[1:], q2[1:] + + if rIndex < dIndex { + q1 = append(q1, rIndex + n) + } else { + q2 = append(q2, dIndex + n) + } + } + if len(q1) > len(q2) { + return "Radiant" + } + + return "Dire" +} diff --git a/Medium/L652.go b/Medium/L652.go new file mode 100644 index 0000000..0bb4735 --- /dev/null +++ b/Medium/L652.go @@ -0,0 +1,35 @@ +package Medium + +func findDuplicateSubtrees(root *TreeNode) []*TreeNode { + curID := 1 + serialToID, idToCount := make(map[string]int), make(map[int]int) + var ( + res []*TreeNode + solve func(root *TreeNode) int + ) + solve = func(root *TreeNode) int { + if root == nil { + return 0 + } + + leftID, rightID := solve(root.Left), solve(root.Right) + curSerial := fmt.Sprintf("%d-%d-%d", leftID, root.Val, rightID) + serialID := curID + if v, ok := serialToID[curSerial]; ok { + serialID = v + } + if serialID == curID { + curID++ + } + serialToID[curSerial] = serialID + idToCount[serialID]++ + + if idToCount[serialID] == 2 { + res = append(res, root) + } + return serialID + } + + solve(root) + return res +} diff --git a/Medium/L658.go b/Medium/L658.go new file mode 100644 index 0000000..3211c0e --- /dev/null +++ b/Medium/L658.go @@ -0,0 +1,26 @@ +package Medium + +func findClosestElements(arr []int, k int, x int) []int { + lo, hi := 0, len(arr)-1 + for hi-lo >= k { + if abs(arr[lo]-x) > abs(arr[hi]-x) { + lo++ + } else { + hi-- + } + } + var res []int + for i := lo; i <= hi; i++ { + res = append(res, arr[i]) + } + + return res +} + +func abs(a int) int { + if a < 0 { + return -a + } + + return a +} diff --git a/Medium/L662.go b/Medium/L662.go new file mode 100644 index 0000000..5ab5ae8 --- /dev/null +++ b/Medium/L662.go @@ -0,0 +1,28 @@ +package Medium + +func widthOfBinaryTree(root *TreeNode) int { + maxWidth := 0 + var lst []int + dfs(root, 1, 0, &lst, &maxWidth) + + return maxWidth +} + +func dfs(root *TreeNode, id, depth int, lst *[]int, maxWidth *int) { + if root == nil { + return + } + if depth >= len(*lst) { + *lst = append(*lst, id) + } + if (id + 1 - (*lst)[depth]) > *maxWidth { + *maxWidth = id + 1 - (*lst)[depth] + } + + if root.Left != nil { + dfs(root.Left, id*2, depth+1, lst, maxWidth) + } + if root.Right != nil { + dfs(root.Right, id*2+1, depth+1, lst, maxWidth) + } +} diff --git a/Medium/L673.go b/Medium/L673.go new file mode 100644 index 0000000..e019848 --- /dev/null +++ b/Medium/L673.go @@ -0,0 +1,62 @@ +package Medium + +type Pair struct { + l, c int +} + +func newPair(a, b int) *Pair { + return &Pair{ + l: a, + c: b, + } +} + +func findNumberOfLIS(nums []int) int { + var ( + solve func(idx int) *Pair + maxL, maxC int + ) + dp := make(map[int]*Pair) + + solve = func(idx int) *Pair { + if idx == len(nums) { + return newPair(0, 0) + } + if v, ok := dp[idx]; ok { + return v + } + + ml, mc := 0, 0 + for i := idx + 1; i < len(nums); i++ { + if nums[i] > nums[idx] { + tmp := solve(i) + if tmp.l > ml { + ml = tmp.l + mc = tmp.c + } else if tmp.l == ml { + mc += tmp.c + } + } + } + + if ml == 0 && mc == 0 { + dp[idx] = newPair(1, 1) + return dp[idx] + } + + dp[idx] = newPair(1+ml, mc) + return dp[idx] + } + + for i := range nums { + tmpPair := solve(i) + if tmpPair.l > maxL { + maxL = tmpPair.l + maxC = tmpPair.c + } else if tmpPair.l == maxL { + maxC += tmpPair.c + } + } + + return maxC +} diff --git a/Medium/L684.go b/Medium/L684.go new file mode 100644 index 0000000..0c8b10f --- /dev/null +++ b/Medium/L684.go @@ -0,0 +1,38 @@ +package Medium + +func findRedundantConnection(edges [][]int) []int { + if len(edges) == 0 { + return []int{} + } + parent := make([]int, 5000) + for i := 0; i < len(parent); i++ { + parent[i] = i + } + + for _, e := range edges { + if find(parent, e[0]) == find(parent, e[1]) { + return e + } + union(e[0], e[1], &parent) + } + + return []int{} +} + +func find(parent []int, x int) int { + if parent[x] == x { + return x + } + + return find(parent, parent[x]) +} + +func union(p, q int, parent *[]int) { + x, y := find(*parent, p), find(*parent, q) + + if x == y { + return + } + + (*parent)[y] = x +} diff --git a/Medium/L688.go b/Medium/L688.go new file mode 100644 index 0000000..9ee9ed2 --- /dev/null +++ b/Medium/L688.go @@ -0,0 +1,31 @@ +package Medium + +func knightProbability(n int, k int, row int, column int) float64 { + var ( + solve func(K, r, c int) float64 + dir = [][]int{{-2, -1}, {-1, -2}, {1, -2}, {2, -1}, {2, 1}, {1, 2}, {-1, 2}, {-2, 1}} + mp = make(map[string]float64) + ) + + solve = func(K, r, c int) float64 { + if r < 0 || r > n-1 || c < 0 || c > n-1 { + return 0 + } + if K == 0 { + return 1 + } + key := fmt.Sprintf("%d-%d-%d", r, c, K) + if v, ok := mp[key]; ok { + return v + } + var rate float64 + for _, d := range dir { + rate += 0.125 * solve(K - 1, r + d[0], c + d[1]) + } + + mp[key] = rate + return mp[key] + } + + return solve(k, row, column) +} diff --git a/Medium/L698.go b/Medium/L698.go new file mode 100644 index 0000000..9c1c196 --- /dev/null +++ b/Medium/L698.go @@ -0,0 +1,35 @@ +package Medium + +func canPartitionKSubsets(nums []int, k int) bool { + sum := 0 + for _, n := range nums { + sum += n + } + if k <= 0 || sum%k != 0 { + return false + } + visited := make([]bool, len(nums)) + return solve(nums, &visited, 0, k, 0, 0, sum/k) +} + +func solve(nums []int, visited *[]bool, startIdx, k, curSum, curNum, target int) bool { + if k == 1 { + return true + } + + if curSum == target && curNum > 0 { + return solve(nums, visited, 0, k-1, 0, 0, target) + } + + for i := startIdx; i < len(nums); i++ { + if !(*visited)[i] { + (*visited)[i] = true + if solve(nums, visited, i+1, k, curSum+nums[i], curNum+1, target) { + return true + } + (*visited)[i] = false + } + } + + return false +} diff --git a/Medium/L701.go b/Medium/L701.go new file mode 100644 index 0000000..c3e0e44 --- /dev/null +++ b/Medium/L701.go @@ -0,0 +1,38 @@ +package Medium + +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func NewTreeNode(val int) *TreeNode { + return &TreeNode{ + Val: val, + Left: nil, + Right: nil, + } +} + +func insertIntoBST(root *TreeNode, val int) *TreeNode { + if root == nil { + return NewTreeNode(val) + } + + helper(root, val) + return root +} + +func helper(root *TreeNode, val int) { + if root.Val < val && root.Right == nil { + root.Right = NewTreeNode(val) + } else if root.Val > val && root.Left == nil { + root.Left = NewTreeNode(val) + } else if root.Val > val { + helper(root.Left, val) + } else { + helper(root.Right, val) + } +} diff --git a/Medium/L71.go b/Medium/L71.go new file mode 100644 index 0000000..d21d5e5 --- /dev/null +++ b/Medium/L71.go @@ -0,0 +1,65 @@ +package Medium + +type Stack struct { + arr []string +} + +func NewStack() *Stack { + return &Stack{arr: make([]string, 0)} +} + +func (s *Stack) Push(str string) { + s.arr = append(s.arr, str) +} + +func (s *Stack) Pop() string { + if s.IsEmpty() { + return "" + } + + ret := s.arr[len(s.arr)-1] + s.arr = s.arr[:len(s.arr)-1] + return ret +} + +func (s *Stack) Size() int { + return len(s.arr) +} + +func (s *Stack) Top() string { + if s.IsEmpty() { + return "" + } + + return s.arr[len(s.arr)-1] +} + +func (s *Stack) IsEmpty() bool { + return len(s.arr) == 0 +} + +func simplifyPath(path string) string { + var sb strings.Builder + st := NewStack() + + for _, s := range strings.Split(path, "/") { + if s == ".." { + if !st.IsEmpty() { + st.Pop() + } + } else if s != "" && s != "." { + st.Push(s) + } + } + + if st.Size() == 0 { + return "/" + } + + for i := 0; i < st.Size(); i++ { + sb.WriteString("/") + sb.WriteString(st.arr[i]) + } + + return sb.String() +} diff --git a/Medium/L712.go b/Medium/L712.go new file mode 100644 index 0000000..c85636d --- /dev/null +++ b/Medium/L712.go @@ -0,0 +1,54 @@ +package Medium + +func minimumDeleteSum(s1 string, s2 string) int { + var ( + solve func(i, j int) int + deadEndSum func(str string, i int) int + ) + mp, m, n := make(map[string]int), len(s1), len(s2) + + deadEndSum = func(str string, i int) int { + sum := 0 + for ; i < len(str); i++ { + sum += int(str[i]) + } + + return sum + } + + solve = func(i, j int) int { + sum := 0 + if i == m && j == n { + return 0 + } + if i == m { + return deadEndSum(s2, j) + } else if j == n { + return deadEndSum(s1, i) + } + + key := fmt.Sprintf("%d-%d", i, j) + if v, ok := mp[key]; ok { + return v + } + + if s1[i] == s2[j] { + sum = solve(i+1, j+1) + } else { + sum = min(solve(i+1, j)+int(s1[i]), solve(i, j+1)+int(s2[j])) + } + + mp[key] = sum + return mp[key] + } + + return solve(0, 0) +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Medium/L718.go b/Medium/L718.go new file mode 100644 index 0000000..445966f --- /dev/null +++ b/Medium/L718.go @@ -0,0 +1,40 @@ +package Medium + +func findLength(nums1 []int, nums2 []int) int { + res, m, n := 0, len(nums1), len(nums2) + + memo := make([][]int, m+1) + for i := range memo { + memo[i] = make([]int, n+1) + for j := range memo[i] { + memo[i][j] = -1 + } + } + + solve(nums1, nums2, m, n, &memo, &res) + return res +} + +func solve(n1, n2 []int, m, n int, memo *[][]int, res *int) int { + if m == 0 || n == 0 { + return 0 + } + + if (*memo)[m][n] != -1 { + return (*memo)[m][n] + } + + solve(n1, n2, m, n-1, memo, res) + solve(n1, n2, m-1, n, memo, res) + + if n1[m-1] == n2[n-1] { + (*memo)[m][n] = 1 + solve(n1, n2, m-1, n-1, memo, res) + if (*memo)[m][n] > *res { + *res = (*memo)[m][n] + } + return (*memo)[m][n] + } + (*memo)[m][n] = 0 + + return (*memo)[m][n] +} diff --git a/Medium/L721.go b/Medium/L721.go new file mode 100644 index 0000000..d31f3c5 --- /dev/null +++ b/Medium/L721.go @@ -0,0 +1,52 @@ +package Medium + +func accountsMerge(accounts [][]string) [][]string { + var ans [][]string + if len(accounts) == 0 { + return ans + } + + owner, graph := make(map[string]string), make(map[string]map[string]bool) + + for _, a := range accounts { + own := a[0] + for i := 1; i < len(a); i++ { + owner[a[i]] = own + if _, ok := graph[a[i]]; !ok { + graph[a[i]] = make(map[string]bool) + } + + if i == 1 { + continue + } + graph[a[i]][a[i-1]] = true + graph[a[i-1]][a[i]] = true + } + } + + vis := make(map[string]bool) + for k, _ := range graph { + if _, ok := vis[k]; !ok { + var tmp []string + dfs(graph, k, &tmp, vis) + sort.Strings(tmp) + tmp = append([]string{owner[k]}, tmp...) + ans = append(ans, tmp) + } + } + + return ans +} + +func dfs(graph map[string]map[string]bool, s string, tmp *[]string, vis map[string]bool) { + if _, ok := vis[s]; ok { + return + } + + vis[s] = true + *tmp = append(*tmp, s) + neighbors := graph[s] + for nei, _ := range neighbors { + dfs(graph, nei, tmp, vis) + } +} diff --git a/Medium/L725.go b/Medium/L725.go new file mode 100644 index 0000000..253b471 --- /dev/null +++ b/Medium/L725.go @@ -0,0 +1,32 @@ +package Medium + +func splitListToParts(head *ListNode, k int) []*ListNode { + n, curr := 0, head + for curr != nil { + n += 1 + curr = curr.Next + } + m, r, j := n/k, n%k, 0 + if m == 0 { + r -= k + } + + res := make([]*ListNode, k) + curr = head + for curr != nil { + res[j] = curr + j++ + for i := 1; i < m; i++ { + curr = curr.Next + } + if r > 0 { + curr = curr.Next + r -= 1 + } + tmp := curr.Next + curr.Next = nil + curr = tmp + } + + return res +} diff --git a/Medium/L73.go b/Medium/L73.go new file mode 100644 index 0000000..33a1677 --- /dev/null +++ b/Medium/L73.go @@ -0,0 +1,39 @@ +package Medium + +func setZeroes(matrix [][]int) { + fr, fc, m, n := false, false, len(matrix), len(matrix[0]) + + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if matrix[i][j] == 0 { + if i == 0 { + fr = true + } + if j == 0 { + fc = true + } + matrix[0][j] = 0 + matrix[i][0] = 0 + } + } + } + for i := 1; i < m; i++ { + for j := 1; j < n; j++ { + if matrix[i][0] == 0 || matrix[0][j] == 0 { + matrix[i][j] = 0 + } + } + } + + if fr { + for j := 0; j < n; j++ { + matrix[0][j] = 0 + } + } + + if fc { + for i := 0; i < m; i++ { + matrix[i][0] = 0 + } + } +} diff --git a/Medium/L735.go b/Medium/L735.go new file mode 100644 index 0000000..96ff228 --- /dev/null +++ b/Medium/L735.go @@ -0,0 +1,27 @@ +package Medium + +func asteroidCollision(asteroids []int) []int { + var res []int + if len(asteroids) == 0 { + return res + } + + for _, a := range asteroids { + if a > 0 { + res = append(res, a) + } else { + for len(res) > 0 && + res[len(res) - 1] > 0 && + -a > res[len(res) - 1] { + res = res[:len(res) - 1] + } + if len(res) == 0 || res[len(res) - 1] < 0 { + res = append(res, a) + } else if res[len(res) - 1] == -a { + res = res[:len(res) - 1] + } + } + } + + return res +} diff --git a/Medium/L739.go b/Medium/L739.go new file mode 100644 index 0000000..26c42d6 --- /dev/null +++ b/Medium/L739.go @@ -0,0 +1,19 @@ +package Medium + +func dailyTemperatures(T []int) []int { + ret, n := make([]int, len(T)), len(T) + var st []int + + for i := n - 1; i >= 0; i-- { + cur := T[i] + for len(st) > 0 && cur >= T[st[len(st)-1]] { + st = st[:len(st)-1] + } + if len(st) > 0 { + ret[i] = st[len(st)-1] - i + } + st = append(st, i) + } + + return ret +} diff --git a/Medium/L74.go b/Medium/L74.go new file mode 100644 index 0000000..21c467d --- /dev/null +++ b/Medium/L74.go @@ -0,0 +1,39 @@ +package Medium + +func searchMatrix(matrix [][]int, target int) bool { + if len(matrix) == 0 { + return false + } + + m, n := len(matrix), len(matrix[0]) + for i := 0; i < m; i++ { + if matrix[i][n-1] == target { + return true + } + + if matrix[i][n-1] > target { + return binSearch(matrix[i], target) + } + } + + return false +} + +func binSearch(n []int, tgt int) bool { + st, end := 0, len(n)-1 + + for st <= end { + mid := st + (end-st)/2 + if n[mid] == tgt { + return true + } + + if n[mid] < tgt { + st = mid + 1 + } else { + end = mid - 1 + } + } + + return false +} diff --git a/Medium/L743.go b/Medium/L743.go new file mode 100644 index 0000000..153b272 --- /dev/null +++ b/Medium/L743.go @@ -0,0 +1,30 @@ +package Medium + +func networkDelayTime(times [][]int, n int, k int) int { + dist := make([]int, n+1) + for i := 1; i < len(dist); i++ { + dist[i] = math.MaxInt32 + } + dist[k] = 0 + + for i := 1; i < n; i++ { + for _, t := range times { + source, dest, weight := t[0], t[1], t[2] + if dist[source] != math.MaxInt32 && dist[source]+weight < dist[dest] { + dist[dest] = dist[source] + weight + } + } + } + + max := math.MinInt32 + for i := range dist { + if dist[i] == math.MaxInt32 { + return -1 + } + if dist[i] > max { + max = dist[i] + } + } + + return max +} diff --git a/Medium/L75.go b/Medium/L75.go new file mode 100644 index 0000000..5942297 --- /dev/null +++ b/Medium/L75.go @@ -0,0 +1,21 @@ +package Medium + +func sortColors(nums []int) { + if len(nums) < 2 { + return + } + + low, high := 0, len(nums)-1 + for i := low; i <= high; { + if nums[i] == 0 { + nums[i], nums[low] = nums[low], nums[i] + i++ + low++ + } else if nums[i] == 2 { + nums[i], nums[high] = nums[high], nums[i] + high-- + } else { + i++ + } + } +} 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/L763.go b/Medium/L763.go new file mode 100644 index 0000000..b584c4f --- /dev/null +++ b/Medium/L763.go @@ -0,0 +1,29 @@ +package Medium + +func partitionLabels(s string) []int { + var res []int + if len(s) == 0 { + return res + } + + mp := make(map[byte]int) + right, size := 0, 0 + + for i := 0; i < len(s); i++ { + mp[s[i]] = i + } + + for left := 0; left < len(s); left++ { + size++ + if mp[s[left]] > right { + right = mp[s[left]] + } + + if left == right { + res = append(res, size) + size = 0 + } + } + + return res +} diff --git a/Medium/L767.go b/Medium/L767.go new file mode 100644 index 0000000..bbb2787 --- /dev/null +++ b/Medium/L767.go @@ -0,0 +1,51 @@ +package Medium + +type Pair struct { + Key byte + Value int +} + +type PairList []Pair + +func (p PairList) Len() int { return len(p) } +func (p PairList) Swap(i, j int) { p[i], p[j] = p[j], p[i] } +func (p PairList) Less(i, j int) bool { return p[i].Value > p[j].Value } + +func reorganizeString(s string) string { + freqMap, res := make(map[byte]int), make([]byte, len(s)) + for _, ch := range s { + freqMap[byte(ch)]++ + } + + getSortedChars := func() PairList { + p := make(PairList, len(freqMap)) + i := 0 + for k, v := range freqMap { + p[i] = Pair{ + Key: k, + Value: v, + } + i++ + } + sort.Sort(p) + + return p + } + + sortedChars := getSortedChars() + if freqMap[sortedChars[0].Key] > ((len(s) + 1) / 2) { + return "" + } + + idx := 0 + for _, pair := range sortedChars { + for j := 0; j < freqMap[pair.Key]; j++ { + if idx >= len(s) { + idx = 1 + } + res[idx] = pair.Key + idx += 2 + } + } + return string(res) +} diff --git a/Medium/L77.go b/Medium/L77.go new file mode 100644 index 0000000..5ae99a4 --- /dev/null +++ b/Medium/L77.go @@ -0,0 +1,27 @@ +package Medium + +func combine(n int, k int) [][]int { + var ( + solve func(tmp *[]int, start, k int) + res [][]int + tmp []int + ) + + solve = func(tmp *[]int, start, k int) { + if k == 0 { + tmpCopy := make([]int, len(*tmp)) + copy(tmpCopy, *tmp) + res = append(res, tmpCopy) + return + } + + for i := start; i <= n; i++ { + *tmp = append(*tmp, i) + solve(tmp, i+1, k-1) + *tmp = (*tmp)[:len(*tmp)-1] + } + } + + solve(&tmp, 1, k) + return res +} diff --git a/Medium/L78.go b/Medium/L78.go new file mode 100644 index 0000000..9ef3b75 --- /dev/null +++ b/Medium/L78.go @@ -0,0 +1,24 @@ +package Medium + +func subsets(nums []int) [][]int { + ans := make([][]int, 0) + if len(nums) == 0 { + return ans + } + + bt(&ans, make([]int, 0), nums, 0) + + return ans +} + +func bt(ans *[][]int, tmp, nums []int, start int) { + copyTmp := make([]int, len(tmp)) + copy(copyTmp, tmp) + *ans = append(*ans, copyTmp) + + for i := start; i < len(nums); i++ { + tmp = append(tmp, nums[i]) + bt(ans, tmp, nums, i+1) + tmp = tmp[:len(tmp)-1] + } +} diff --git a/Medium/L787.go b/Medium/L787.go new file mode 100644 index 0000000..6329b5c --- /dev/null +++ b/Medium/L787.go @@ -0,0 +1,36 @@ +package Medium + +func min(a, b int) int { + if a < b { + return a + } + + return b +} + +func findCheapestPrice(n int, flights [][]int, src int, dst int, k int) int { + cost := make([]int, n) + for i := 0; i < n; i++ { + cost[i] = math.MaxInt32 + } + cost[src] = 0 + + for i := 0; i <= k; i++ { + tmp := make([]int, len(cost)) + copy(tmp, cost) + for _, f := range flights { + curr, nxt, price := f[0], f[1], f[2] + if cost[curr] == math.MaxInt32 { + continue + } + tmp[nxt] = min(tmp[nxt], cost[curr]+price) + } + cost = tmp + } + + if cost[dst] == math.MaxInt32 { + return -1 + } + + return cost[dst] +} diff --git a/Medium/L79.go b/Medium/L79.go new file mode 100644 index 0000000..18e063a --- /dev/null +++ b/Medium/L79.go @@ -0,0 +1,55 @@ +package Medium + +var dirs = [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + +func exist(board [][]byte, word string) bool { + if len(board) == 0 || len(word) == 0 { + return false + } + m, n := len(board), len(board[0]) + vis := make([][]bool, m) + for i := 0; i < m; i++ { + vis[i] = make([]bool, n) + } + found := false + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + found = false + if board[i][j] == word[0] { + found = bt(board, &vis, i, j, 0, word) + if found { + return found + } + } + } + } + return found +} + +func isValid(board [][]byte, x, y int, ch byte) bool { + m, n := len(board), len(board[0]) + + return x >= 0 && x < m && y >= 0 && y < n && board[x][y] == ch +} + +func bt(board [][]byte, vis *[][]bool, i, j, index int, word string) bool { + if index == len(word) { + return true + } + + if !isValid(board, i, j, word[index]) { + return false + } + + if (*vis)[i][j] { + return false + } + (*vis)[i][j] = true + found := false + for _, d := range dirs { + found = found || bt(board, vis, i+d[0], j+d[1], index+1, word) + } + (*vis)[i][j] = false + + return found +} diff --git a/Medium/L790.go b/Medium/L790.go new file mode 100644 index 0000000..1c7e23b --- /dev/null +++ b/Medium/L790.go @@ -0,0 +1,43 @@ +package Medium + +func numTilings(n int) int { + return solve(n, 2, make(map[string]int)) +} + +func solve(n, colState int, memo map[string]int) int { + mod, ways := 1000000007, 0 + if n < 0 { + return 0 + } + + if n == 0 { + if colState == 2 { + return 1 + } else { + return 0 + } + } + + key := fmt.Sprintf("%d|%d", n, colState) + if val, ok := memo[key]; ok { + return val + } + + switch colState { + case 0: + ways += solve(n-2, 2, memo) + ways += solve(n-1, 1, memo) + case 1: + ways += solve(n-2, 2, memo) + ways += solve(n-1, 0, memo) + case 2: + ways += solve(n-1, 0, memo) + ways += solve(n-1, 1, memo) + ways += solve(n-1, 2, memo) + ways += solve(n-2, 2, memo) + } + + ways %= mod + memo[key] = ways + return ways +} diff --git a/Medium/L791.go b/Medium/L791.go new file mode 100644 index 0000000..a8dd6a4 --- /dev/null +++ b/Medium/L791.go @@ -0,0 +1,25 @@ +package Medium + +func customSortString(order string, str string) string { + arr := make([]int, 26) + for i := 0; i < len(str); i++ { + arr[str[i]-'a']++ + } + + var sb strings.Builder + for i := 0; i < len(order); i++ { + for arr[order[i]-'a'] > 0 { + sb.WriteByte(order[i]) + arr[order[i]-'a']-- + } + } + + for i := 0; i < len(arr); i++ { + for arr[i] > 0 { + sb.WriteByte(byte(i) + 'a') + arr[i]-- + } + } + + return sb.String() +} diff --git a/Medium/L795.go b/Medium/L795.go new file mode 100644 index 0000000..310ba75 --- /dev/null +++ b/Medium/L795.go @@ -0,0 +1,19 @@ +package Medium + +func numSubarrayBoundedMax(nums []int, left int, right int) int { + start, last, res := -1, -1, 0 + for i := range nums { + if nums[i] > right { + start, last = i, i + continue + } + + if nums[i] >= left { + last = i + } + + res += last - start + } + + return res +} diff --git a/Medium/L797.go b/Medium/L797.go new file mode 100644 index 0000000..7914aaa --- /dev/null +++ b/Medium/L797.go @@ -0,0 +1,35 @@ +package Medium + +func allPathsSourceTarget(graph [][]int) [][]int { + var ret, lst [][]int + if len(graph) == 0 { + return ret + } + + for i := range graph { + lst = append(lst, make([]int, 0)) + for _, g := range graph[i] { + lst[i] = append(lst[i], g) + } + } + + bt(&ret, lst, make([]int, 0), 0, len(graph)-1) + return ret +} + +func bt(ret *[][]int, lst [][]int, tmp []int, index, n int) { + if index == n { + tmp = append(tmp, index) + temp := make([]int, len(tmp)) + copy(temp, tmp) + *ret = append(*ret, temp) + tmp = tmp[:len(tmp)-1] + return + } + + tmp = append(tmp, index) + for _, nei := range lst[index] { + bt(ret, lst, tmp, nei, n) + } + tmp = tmp[:len(tmp)-1] +} diff --git a/Medium/L799.go b/Medium/L799.go new file mode 100644 index 0000000..ae98018 --- /dev/null +++ b/Medium/L799.go @@ -0,0 +1,44 @@ +package Medium + +func champagneTower(poured int, query_row int, query_glass int) float64 { + dp := make([][]float64, query_row+1) + for i := 0; i < query_row+1; i++ { + dp[i] = make([]float64, query_glass+1) + for j := 0; j < query_glass+1; j++ { + dp[i][j] = -1 + } + } + + ans := solve(query_row, query_glass, poured, &dp) + + if ans > 1 { + return 1 + } + + return ans +} + +func solve(row, col, poured int, dp *[][]float64) float64 { + if col < 0 || col > row { + return 0 + } + if row == 0 && col == 0 { + return float64(poured) + } + + if (*dp)[row][col] != -1 { + return (*dp)[row][col] + } + + (*dp)[row][col] = max(solve(row-1, col-1, poured, dp)-1, 0)/2 + max(solve(row-1, col, poured, dp)-1, 0)/2 + + return (*dp)[row][col] +} + +func max(a, b float64) float64 { + if a > b { + return a + } + + return b +} diff --git a/Medium/L8.go b/Medium/L8.go new file mode 100644 index 0000000..8c46d01 --- /dev/null +++ b/Medium/L8.go @@ -0,0 +1,46 @@ +package Medium + +func myAtoi(s string) int { + index, total, sign := 0, 0, 1 + + if len(s) == 0 { + return 0 + } + + for index < len(s) && s[index] == ' ' { + index++ + } + + if index == len(s) { + return 0 + } + + if s[index] == '+' || s[index] == '-' { + if s[index] == '+' { + sign = 1 + } else { + sign = -1 + } + index++ + } + + for index < len(s) { + digit := int(s[index] - '0') + if digit < 0 || digit > 9 { + break + } + + if math.MaxInt32/10 < total || (math.MaxInt32/10 == total && math.MaxInt32%10 < digit) { + if sign == 1 { + return math.MaxInt32 + } + + return math.MinInt32 + } + + total = total*10 + digit + index++ + } + + return total * sign +} diff --git a/Medium/L80.go b/Medium/L80.go new file mode 100644 index 0000000..70b990c --- /dev/null +++ b/Medium/L80.go @@ -0,0 +1,13 @@ +package Medium + +func removeDuplicates(nums []int) int { + i := 0 + for _, n := range nums { + if i < 2 || n > nums[i-2] { + nums[i] = n + i++ + } + } + + return i +} diff --git a/Medium/L808.go b/Medium/L808.go new file mode 100644 index 0000000..99c5811 --- /dev/null +++ b/Medium/L808.go @@ -0,0 +1,34 @@ +package Medium + +func soupServings(n int) float64 { + if n >= 5000 { + return 1.0 + } + + var solve func(a, b int) float64 + mp := make(map[string]float64) + + solve = func(a, b int) float64 { + if a <= 0 && b > 0 { + return 1.0 + } + + if a <= 0 && b <= 0 { + return 0.5 + } + + if a > 0 && b <= 0 { + return 0.0 + } + + key := fmt.Sprintf("%d-%d", a, b) + if v, ok := mp[key]; ok { + return v + } + + mp[key] = 0.25 * (solve(a-100, b) + solve(a-75, b-25) + solve(a-50, b-50) + solve(a-25, b-75)) + return mp[key] + } + + return solve(n, n) +} diff --git a/Medium/L81.go b/Medium/L81.go new file mode 100644 index 0000000..7027999 --- /dev/null +++ b/Medium/L81.go @@ -0,0 +1,29 @@ +package Medium + +func search(nums []int, target int) bool { + left, right := 0, len(nums)-1 + for left <= right { + mid := left + (right-left)/2 + if nums[mid] == target { + return true + } + + if nums[left] < nums[mid] { + if nums[left] <= target && target < nums[mid] { + right = mid - 1 + } else { + left = mid + 1 + } + } else if nums[left] > nums[mid] { + if nums[mid] < target && target <= nums[right] { + left = mid + 1 + } else { + right = mid - 1 + } + } else { + left++ + } + } + + return false +} diff --git a/Medium/L814.go b/Medium/L814.go new file mode 100644 index 0000000..b029417 --- /dev/null +++ b/Medium/L814.go @@ -0,0 +1,20 @@ +package Medium + +func pruneTree(root *TreeNode) *TreeNode { + return dfs(root) +} + +func dfs(root *TreeNode) *TreeNode { + if root == nil { + return root + } + + root.Left = dfs(root.Left) + root.Right = dfs(root.Right) + + if root.Left == nil && root.Right == nil && root.Val == 0 { + return nil + } + + return root +} diff --git a/Medium/L82.go b/Medium/L82.go new file mode 100644 index 0000000..64abd1a --- /dev/null +++ b/Medium/L82.go @@ -0,0 +1,31 @@ +package Medium + +/** + * Definition for singly-linked list. + * type ListNode struct { + * Val int + * Next *ListNode + * } + */ +func deleteDuplicates(head *ListNode) *ListNode { + var pre *ListNode + cur := head + + for cur != nil && cur.Next != nil { + if cur.Val != cur.Next.Val { + pre = cur + } else { + for cur.Next != nil && cur.Next.Val == cur.Val { + cur = cur.Next + } + if pre != nil { + pre.Next = cur.Next + } else { + head = cur.Next + } + } + cur = cur.Next + } + + return head +} diff --git a/Medium/L835.go b/Medium/L835.go new file mode 100644 index 0000000..773c45a --- /dev/null +++ b/Medium/L835.go @@ -0,0 +1,39 @@ +package Medium + +func largestOverlap(img1 [][]int, img2 [][]int) int { + ans := 0 + + for row := -len(img1); row < len(img1); row++ { + for col := -len(img1[0]); col < len(img1[0]); col++ { + max := overlap(img1, img2, row, col) + if max > ans { + ans = max + } + } + } + + return ans +} + +func overlap(img1, img2 [][]int, rowOffset, colOffset int) int { + ans := 0 + for row := 0; row < len(img1); row++ { + for col := 0; col < len(img1[0]); col++ { + if isValid(row, col, rowOffset, colOffset, img1) { + if img1[row][col] == 1 && img2[row+rowOffset][col+colOffset] == 1 { + ans++ + } + } + } + } + + return ans +} + +func isValid(row, col, rowOffset, colOffset int, img [][]int) bool { + return row+rowOffset >= 0 && + row+rowOffset < len(img) && + col+colOffset >= 0 && + col+colOffset < len(img) +} +Console diff --git a/Medium/L838.go b/Medium/L838.go new file mode 100644 index 0000000..1702452 --- /dev/null +++ b/Medium/L838.go @@ -0,0 +1,36 @@ +package Medium + +func pushDominoes(dominoes string) string { + arr := []byte(dominoes) + L, R := -1, -1 + for i := 0; i <= len(dominoes); i++ { + if i == len(arr) || arr[i] == 'R' { + if R > L { + for R < i { + arr[R] = 'R' + R++ + } + } + R = i + } else if arr[i] == 'L' { + if L > R || R == -1 && L == -1 { + L++ + for L < i { + arr[L] = 'L' + L++ + } + } else { + L = i + lo, hi := R+1, L-1 + for lo < hi { + arr[lo] = 'R' + arr[hi] = 'L' + lo++ + hi-- + } + } + } + } + + return string(arr) +} diff --git a/Medium/L848.go b/Medium/L848.go new file mode 100644 index 0000000..4a64e5c --- /dev/null +++ b/Medium/L848.go @@ -0,0 +1,20 @@ +package Medium + +func shiftingLetters(s string, shifts []int) string { + var sb strings.Builder + shift := 0 + for i := len(s) - 1; i >= 0; i-- { + shift = (shift + shifts[i]) % 26 + sb.WriteByte(byte((int(s[i]-'a')+shift)%26 + 'a')) + } + + return reverse(sb.String()) +} + +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) +} diff --git a/Medium/L849.go b/Medium/L849.go new file mode 100644 index 0000000..5337839 --- /dev/null +++ b/Medium/L849.go @@ -0,0 +1,34 @@ +package Medium + +func maxDistToClosest(seats []int) int { + dist, j := math.MinInt32, -1 + + if seats[0] == 1 { + j = 0 + } + + for i := 1; i < len(seats); i++ { + if seats[i] == 1 { + if j == -1 { + dist = max(dist, i) + } else { + dist = max(dist, (i-j)/2) + } + j = i + } + } + + if seats[len(seats)-1] == 0 { + dist = max(dist, len(seats)-1-j) + } + + return dist +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L852.go b/Medium/L852.go new file mode 100644 index 0000000..008d975 --- /dev/null +++ b/Medium/L852.go @@ -0,0 +1,16 @@ +package Medium + +func peakIndexInMountainArray(arr []int) int { + low, high := 0, len(arr)-1 + + for low <= high { + mid := low + (high-low)/2 + if arr[mid] < arr[mid+1] { + low = mid + 1 + } else { + high = mid - 1 + } + } + + return low +} diff --git a/Medium/L856.go b/Medium/L856.go new file mode 100644 index 0000000..b72f515 --- /dev/null +++ b/Medium/L856.go @@ -0,0 +1,26 @@ +package Medium + +func scoreOfParentheses(s string) int { + var st []int + cur := 0 + + for i := 0; i < len(s); i++ { + if s[i] == '(' { + st = append(st, cur) + cur = 0 + } else { + cur = st[len(st)-1] + max(cur*2, 1) + st = st[:len(st)-1] + } + } + + return cur +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} 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/L863.go b/Medium/L863.go new file mode 100644 index 0000000..9c4931f --- /dev/null +++ b/Medium/L863.go @@ -0,0 +1,55 @@ +package Medium + +func distanceK(root *TreeNode, target *TreeNode, k int) []int { + var ( + res []int + find func(root, target *TreeNode) + search func(root *TreeNode, distance int) + ) + mp := make(map[*TreeNode]int) + + find = func(root, target *TreeNode) { + if root == nil { + return + } + + if root == target { + mp[root] = 0 + return + } + + find(root.Left, target) + if val, ok := mp[root.Left]; ok { + mp[root] = val + 1 + return + } + + find(root.Right, target) + if val, ok := mp[root.Right]; ok { + mp[root] = val + 1 + return + } + } + + search = func(root *TreeNode, distance int) { + if root == nil { + return + } + + if val, ok := mp[root]; ok { + distance = val + } + + if distance == k { + res = append(res, root.Val) + } + + search(root.Left, distance+1) + search(root.Right, distance+1) + } + + find(root, target) + search(root, 0) + + 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/L875.go b/Medium/L875.go new file mode 100644 index 0000000..ab683b7 --- /dev/null +++ b/Medium/L875.go @@ -0,0 +1,43 @@ +package Medium + +func minEatingSpeed(piles []int, h int) int { + if len(piles) == 0 { + return 0 + } + min, max, sum := math.MaxInt32, math.MinInt32, 0 + for _, p := range piles { + if p < min { + min = p + } + if p > max { + max = p + } + sum += p + } + + if h == 1 { + return sum + } + + lo, high, mid := 1, 1000000000, 0 + for lo < high { + mid = lo + (high-lo)/2 + if feasible(piles, mid, h) { + high = mid + } else { + lo = mid + 1 + } + } + + return lo +} + +func feasible(arr []int, maxSpeed, h int) bool { + time := 0 + + for _, a := range arr { + time += int(math.Ceil(float64(a) / float64(maxSpeed))) + } + + return time <= h +} diff --git a/Medium/L877.go b/Medium/L877.go new file mode 100644 index 0000000..1dfaa29 --- /dev/null +++ b/Medium/L877.go @@ -0,0 +1,54 @@ +package Medium + +func stoneGame(piles []int) bool { + m, n := len(piles), len(piles) + memo := make([][]int, m*n) + for i := 0; i < m; i++ { + memo[i] = make([]int, n) + for j := 0; j < n; j++ { + memo[i][j] = -1 + } + } + sum := 0 + for _, v := range piles { + sum += v + } + + return solve(piles, &memo, 0, len(piles)-1) > sum/2 +} + +func solve(piles []int, memo *[][]int, startIdx, endIdx int) int { + if startIdx > endIdx { + return 0 + } + + if (*memo)[startIdx][endIdx] > 0 { + return (*memo)[startIdx][endIdx] + } + + if startIdx+1 == endIdx { + (*memo)[startIdx][endIdx] = max(piles[startIdx], piles[endIdx]) + } else { + a := piles[startIdx] + min(solve(piles, memo, startIdx+2, endIdx), solve(piles, memo, startIdx+1, endIdx-1)) + b := piles[endIdx] + min(solve(piles, memo, startIdx+1, endIdx-1), solve(piles, memo, startIdx, endIdx-2)) + (*memo)[startIdx][endIdx] = max(a, b) + } + + return (*memo)[startIdx][endIdx] +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func min(a, b int) int { + if a < b { + return a + } + + return b +} diff --git a/Medium/L881.go b/Medium/L881.go new file mode 100644 index 0000000..a52756c --- /dev/null +++ b/Medium/L881.go @@ -0,0 +1,21 @@ +package Medium + +func numRescueBoats(people []int, limit int) int { + boatCnt, left, right := 0, 0, len(people)-1 + if len(people) == 0 { + return boatCnt + } + + sort.Ints(people) + + for left <= right { + sum := people[left] + people[right] + if sum <= limit { + left++ + } + boatCnt++ + right-- + } + + return boatCnt +} diff --git a/Medium/L886.go b/Medium/L886.go new file mode 100644 index 0000000..ac15e98 --- /dev/null +++ b/Medium/L886.go @@ -0,0 +1,49 @@ +package Medium + +var exists struct{} + +func possibleBipartition(n int, dislikes [][]int) bool { + if n == 0 || len(dislikes) == 0 { + return true + } + + graph := make([][]int, n+1) + for i := range graph { + graph[i] = make([]int, 0) + } + + for _, d := range dislikes { + graph[d[0]] = append(graph[d[0]], d[1]) + graph[d[1]] = append(graph[d[1]], d[0]) + } + + color := make([]int, n+1) + var q []int + for i := 0; i <= n; i++ { + if color[i] != 0 { + continue + } + q = append(q, i) + color[i] = 1 + st := make(map[int]struct{}) + + for len(q) > 0 { + node := q[0] + q = q[1:] + if _, ok := st[node]; ok { + continue + } + st[node] = exists + + for _, nei := range graph[node] { + if color[nei] != 0 && color[nei] != -color[node] { + return false + } + color[nei] = -color[node] + q = append(q, nei) + } + } + } + + return true +} diff --git a/Medium/L89.go b/Medium/L89.go new file mode 100644 index 0000000..cf51ba8 --- /dev/null +++ b/Medium/L89.go @@ -0,0 +1,14 @@ +package Medium + +func grayCode(n int) []int { + var res []int + res = append(res, 0) + for i := 0; i < n; i++ { + size := len(res) + for k := size - 1; k >= 0; k-- { + res = append(res, res[k]|1< 0 && i > start && nums[i] == nums[i-1] { + continue + } + tmp = append(tmp, nums[i]) + bt(ans, tmp, nums, i+1) + tmp = (tmp)[:len(tmp)-1] + } +} diff --git a/Medium/L904.go b/Medium/L904.go new file mode 100644 index 0000000..51d7fc8 --- /dev/null +++ b/Medium/L904.go @@ -0,0 +1,32 @@ +package Medium + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func totalFruit(fruits []int) int { + mp := make(map[int]int) + + i, j, res := 0, 0, 0 + + for j < len(fruits) { + mp[fruits[j]]++ + + if len(mp) <= 2 { + res = max(res, j - i + 1) + } else { + mp[fruits[i]]-- + if mp[fruits[i]] == 0 { + delete(mp, fruits[i]) + } + i++ + } + j++ + } + + return res +} 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/L909.go b/Medium/L909.go new file mode 100644 index 0000000..dc11c3b --- /dev/null +++ b/Medium/L909.go @@ -0,0 +1,52 @@ +package Medium + +func snakesAndLadders(board [][]int) int { + var q []int + n, move := len(board), 0 + visited := make([]bool, n*(n+1)) + q = append(q, 1) + + for ; len(q) > 0; move++ { + size := len(q) + for i := 0; i < size; i++ { + num := q[0] + q = q[1:] + + if visited[num] { + continue + } + visited[num] = true + if num == n*n { + return move + } + + for idx := 1; idx <= 6 && num+idx <= (n*n); idx++ { + next := num + idx + val := getBoardValue(next, board) + if val > 0 { + next = val + } + if !visited[next] { + q = append(q, next) + } + } + } + } + + return -1 +} + +func getBoardValue(num int, board [][]int) int { + n := len(board) + r := (num - 1) / n + + var x, y int + x = n - 1 - r + if r%2 == 0 { + y = num - 1 - (r * n) + } else { + y = n + (r * n) - num + } + + return board[x][y] +} diff --git a/Medium/L915.go b/Medium/L915.go index 3f85f26..f9ab7af 100644 --- a/Medium/L915.go +++ b/Medium/L915.go @@ -1,52 +1,19 @@ -package Medium - -func wordSubsets(A []string, B []string) []string { - var res []string - if len(A) == 0 || len(B) == 0 { - return res - } - count := make(map[rune]int) - - for _, s := range B { - tmp := getMap(s) - - for k, v := range tmp { - count[k] = max(count[k], v) - } - } - - for _, s := range A { - tmp := getMap(s) - exists := true - for k, v := range count { - if tmp[k] < v { - exists = false - break +package Medium + +func partitionDisjoint(nums []int) int { + localMax, partitionIdx := nums[0], 0 + max := localMax + + for i := range nums { + if localMax > nums[i] { + localMax = max + partitionIdx = i + } else { + if nums[i] > max { + max = nums[i] } } - - if exists { - res = append(res, s) - } - } - - return res -} - -func max(a, b int) int { - if a > b { - return a - } - - return b -} - -func getMap(s string) map[rune]int { - mp := make(map[rune]int) - - for _, c := range s { - mp[c]++ } - return mp + return partitionIdx + 1 } diff --git a/Medium/L916.go b/Medium/L916.go new file mode 100644 index 0000000..3f85f26 --- /dev/null +++ b/Medium/L916.go @@ -0,0 +1,52 @@ +package Medium + +func wordSubsets(A []string, B []string) []string { + var res []string + if len(A) == 0 || len(B) == 0 { + return res + } + count := make(map[rune]int) + + for _, s := range B { + tmp := getMap(s) + + for k, v := range tmp { + count[k] = max(count[k], v) + } + } + + for _, s := range A { + tmp := getMap(s) + exists := true + for k, v := range count { + if tmp[k] < v { + exists = false + break + } + } + + if exists { + res = append(res, s) + } + } + + return res +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} + +func getMap(s string) map[rune]int { + mp := make(map[rune]int) + + for _, c := range s { + mp[c]++ + } + + return mp +} diff --git a/Medium/L92.go b/Medium/L92.go new file mode 100644 index 0000000..e76daf9 --- /dev/null +++ b/Medium/L92.go @@ -0,0 +1,55 @@ +package Medium + +/** + * Definition for singly-linked list. + * type ListNode struct { + * Val int + * Next *ListNode + * } + */ +func reverseBetween(head *ListNode, left int, right int) *ListNode { + if head == nil || (left == right) { + return head + } + + var start, end, startPrev, endNext *ListNode + curr := head + for i := 1; i < left; i++ { + startPrev = curr + curr = curr.Next + } + + start = curr + curr = head + for i := 1; i < right; i++ { + curr = curr.Next + } + end = curr + endNext = curr.Next + reverse(start, end, left, right) + if startPrev == nil { + if endNext == nil { + return end + } + + start.Next = endNext + return end + } + + startPrev.Next = end + start.Next = endNext + + return head +} + +func reverse(start, end *ListNode, m, n int) { + var prev, tmp *ListNode + curr := start + + for i := m; i <= n; i++ { + tmp = curr + curr = curr.Next + tmp.Next = prev + prev = tmp + } +} diff --git a/Medium/L926.go b/Medium/L926.go new file mode 100644 index 0000000..c965cbb --- /dev/null +++ b/Medium/L926.go @@ -0,0 +1,18 @@ +package Medium + +func minFlipsMonoIncr(s string) int { + oneCounter, flipCounter := 0, 0 + for i := 0; i < len(s); i++ { + if s[i] == '1' { + oneCounter++ + } else { + flipCounter++ + } + + if oneCounter < flipCounter { + flipCounter = oneCounter + } + } + + return flipCounter +} diff --git a/Medium/L931.go b/Medium/L931.go new file mode 100644 index 0000000..82b428a --- /dev/null +++ b/Medium/L931.go @@ -0,0 +1,32 @@ +package Medium + +func minFallingPathSum(matrix [][]int) int { + var ( + solve func(row, col int) int + ) + cols, mp, res := len(matrix[0]), make(map[string]int), math.MaxInt32 + + solve = func(row, col int) int { + if col >= cols || col < 0 { + return math.MaxInt32 + } + + key := fmt.Sprintf("%d#%d", row, col) + if v, ok := mp[key]; ok { + return v + } + + if row == len(matrix)-1 && col < cols { + return matrix[row][col] + } + + mp[key] = matrix[row][col] + min(solve(row+1, col-1), min(solve(row+1, col), solve(row+1, col+1))) + return mp[key] + } + + for i := 0; i < cols; i++ { + res = min(res, solve(0, i)) + } + + return res +} diff --git a/Medium/L934.go b/Medium/L934.go new file mode 100644 index 0000000..848751f --- /dev/null +++ b/Medium/L934.go @@ -0,0 +1,69 @@ +package Medium + +func shortestBridge(grid [][]int) int { + m, n := len(grid), len(grid[0]) + dirs := [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + visited := make([][]bool, m) + for i := 0; i < m; i++ { + visited[i] = make([]bool, n) + } + var ( + found bool + q [][]int + dfs func(x, y int) + isValid func(x, y int) bool + ) + + isValid = func(x, y int) bool { + return x >= 0 && x < m && y >= 0 && y < n && !visited[x][y] && grid[x][y] != 0 + } + + dfs = func(x, y int) { + if !isValid(x, y) { + return + } + + visited[x][y] = true + q = append(q, []int{x, y}) + for _, d := range dirs { + dfs(x+d[0], y+d[1]) + } + } + + for i := 0; i < m; i++ { + if found { + break + } + for j := 0; j < n; j++ { + if grid[i][j] == 1 { + dfs(i, j) + found = true + break + } + } + } + + step := 0 + for len(q) > 0 { + size := len(q) + for size > 0 { + cur := q[0] + q = q[1:] + size-- + + for _, d := range dirs { + x, y := cur[0]+d[0], cur[1]+d[1] + if x >= 0 && y >= 0 && x < m && y < n && !visited[x][y] { + if grid[x][y] == 1 { + return step + } + q = append(q, []int{x, y}) + visited[x][y] = true + } + } + } + step++ + } + + return -1 +} diff --git a/Medium/L954.go b/Medium/L954.go new file mode 100644 index 0000000..8652b3c --- /dev/null +++ b/Medium/L954.go @@ -0,0 +1,39 @@ +package Medium + +func canReorderDoubled(arr []int) bool { + if len(arr) == 0 { + return true + } + sort.Ints(arr) + mp := make(map[int]int) + for _, i := range arr { + if i == 0 { + continue + } + mp[i]++ + } + + for i := range arr { + if arr[i] != 0 { + if mp[arr[i]] > 0 { + tgt := arr[i] * 2 + if arr[i] < 0 { + if arr[i]%2 != 0 { + return false + } else { + tgt = arr[i] / 2 + } + } + val, exists := mp[tgt] + if !exists || val < mp[arr[i]] { + return false + } else { + mp[tgt] = mp[tgt] - mp[arr[i]] + mp[arr[i]] = 0 + } + } + } + } + + return true +} diff --git a/Medium/L958.go b/Medium/L958.go new file mode 100644 index 0000000..ff58d6b --- /dev/null +++ b/Medium/L958.go @@ -0,0 +1,25 @@ +package Medium + +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, val=0, left=None, right=None): +# self.val = val +# self.left = left +# self.right = right +class Solution: + def isCompleteTree(self, root: Optional[TreeNode]) -> bool: + end, q = False, deque() + q.append(root) + + while q: + curr = q.popleft() + + if not curr: + end = True + else: + if end: + return False + q.append(curr.left) + q.append(curr.right) + + return True diff --git a/Medium/L96.go b/Medium/L96.go new file mode 100644 index 0000000..2073152 --- /dev/null +++ b/Medium/L96.go @@ -0,0 +1,25 @@ +package Medium + +func numTrees(n int) int { + mp := make(map[int]int) + + return solve(n, mp) +} + +func solve(n int, mp map[int]int) int { + if n == 0 || n == 1 { + return 1 + } + + sum := 0 + for i := 1; i <= n; i++ { + if _, ok := mp[i-1]; !ok { + mp[i-1] = solve(i-1, mp) + } + if _, ok := mp[n-i]; !ok { + mp[n-i] = solve(n-i, mp) + } + sum += mp[i-1] * mp[n-i] + } + return sum +} diff --git a/Medium/L973.go b/Medium/L973.go new file mode 100644 index 0000000..90e5ad1 --- /dev/null +++ b/Medium/L973.go @@ -0,0 +1,59 @@ +package Medium + +type priorityQueue [][]int + +func NewPriorityQueue() *priorityQueue { + return &priorityQueue{} +} + +func (pq priorityQueue) Len() int { + return len(pq) +} + +func (pq priorityQueue) Less(i, j int) bool { + x, y := pq.distance(pq[i][0], pq[i][1]), pq.distance(pq[j][0], pq[j][1]) + + return x > y +} + +func (pq priorityQueue) Swap(i, j int) { + pq[i], pq[j] = pq[j], pq[i] +} + +func (pq *priorityQueue) Push(x interface{}) { + *pq = append(*pq, x.([]int)) +} + +func (pq *priorityQueue) Pop() interface{} { + val := (*pq)[len(*pq)-1] + *pq = (*pq)[:len(*pq)-1] + + return val +} + +func (pq priorityQueue) distance(x, y int) int { + return x*x + y*y +} + +func kClosest(points [][]int, k int) [][]int { + var res [][]int + if len(points) == 0 { + return res + } + + pq := NewPriorityQueue() + heap.Init(pq) + + for _, p := range points { + heap.Push(pq, p) + if pq.Len() > k { + heap.Pop(pq) + } + } + + for pq.Len() > 0 { + res = append(res, heap.Pop(pq).([]int)) + } + + return res +} diff --git a/Medium/L974.go b/Medium/L974.go new file mode 100644 index 0000000..70c0a0b --- /dev/null +++ b/Medium/L974.go @@ -0,0 +1,18 @@ +package Medium + +func subarraysDivByK(nums []int, k int) int { + mp := make(map[int]int) + mp[0] = 1 + cnt, sum := 0, 0 + + for _, n := range nums { + sum = (sum + n) % k + if sum < 0 { + sum += k + } + cnt += mp[sum] + mp[sum]++ + } + + return cnt +} diff --git a/Medium/L978.go b/Medium/L978.go new file mode 100644 index 0000000..8ac0afc --- /dev/null +++ b/Medium/L978.go @@ -0,0 +1,30 @@ +package Medium + +func maxTurbulenceSize(arr []int) int { + inc, dec, result := 1, 1, 1 + + for i := 1; i < len(arr); i++ { + if arr[i] < arr[i-1] { + dec = inc + 1 + ince = 1 + } else if arr[i] > arr[i-1] { + inc = dec + 1 + dec = 1 + } else { + inc = 1 + dec = 1 + } + + result = max(result, max(dec, inc)) + } + + return result +} + +func max(a, b int) int { + if a > b { + return a + } + + return b +} diff --git a/Medium/L985.go b/Medium/L985.go new file mode 100644 index 0000000..a2e70ad --- /dev/null +++ b/Medium/L985.go @@ -0,0 +1,35 @@ +package Medium + +func sumEvenAfterQueries(nums []int, queries [][]int) []int { + sum := 0 + + for _, n := range nums { + if n%2 == 0 { + sum += n + } + } + + var ret []int + for _, q := range queries { + x, y := q[1], q[0] + if abs(nums[x])%2 == 0 { + sum -= nums[x] + } + if (nums[x]+y)%2 == 0 { + sum += nums[x] + y + } + + nums[x] += y + ret = append(ret, sum) + } + + return ret +} + +func abs(a int) int { + if a < 0 { + return -1 * a + } + + return a +} diff --git a/Medium/L986.go b/Medium/L986.go new file mode 100644 index 0000000..8c5ed11 --- /dev/null +++ b/Medium/L986.go @@ -0,0 +1,43 @@ +package Medium + +func intervalIntersection(firstList [][]int, secondList [][]int) [][]int { + var res [][]int + if len(firstList) == 0 || len(secondList) == 0 { + return res + } + + i, j, m, n := 0, 0, len(firstList), len(secondList) + max, min := math.MinInt64, math.MaxInt64 + + for i < m && j < n { + max = maximum(firstList[i][0], secondList[j][0]) + min = minimum(firstList[i][1], secondList[j][1]) + if max <= min { + res = append(res, []int{max, min}) + } + + if firstList[i][1] < secondList[j][1] { + i++ + } else { + j++ + } + } + + return res +} + +func maximum(a, b int) int { + if a > b { + return a + } + + return b +} + +func minimum(a, b int) int { + if a < b { + return a + } + + return b +} 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) +} diff --git a/Medium/L990.go b/Medium/L990.go new file mode 100644 index 0000000..dc82a8e --- /dev/null +++ b/Medium/L990.go @@ -0,0 +1,30 @@ +package Medium + +func equationsPossible(equations []string) bool { + root := make([]int, 26) + + for i := 0; i < 26; i++ { + root[i] = i + } + for _, e := range equations { + if e[1] == '=' { + root[find(int(e[0]-'a'), &root)] = find(int(e[3]-'a'), &root) + } + } + + for _, e := range equations { + if e[1] == '!' && find(int(e[0]-'a'), &root) == find(int(e[3]-'a'), &root) { + return false + } + } + + return true +} + +func find(x int, root *[]int) int { + if x != (*root)[x] { + (*root)[x] = find((*root)[x], root) + } + + return (*root)[x] +} diff --git a/Medium/L991.go b/Medium/L991.go new file mode 100644 index 0000000..f5bfd7e --- /dev/null +++ b/Medium/L991.go @@ -0,0 +1,23 @@ +package Medium + +func brokenCalc(startValue int, target int) int { + // res for counting number of operation + res := 0 + + for target > startValue { + if isOdd(target) { + // if target is odd we will make it even + target++ + } else { + // if target is even divide by 2 + target /= 2 + } + res++ + } + + return res + startValue - target +} + +func isOdd(n int) bool { + return n%2 > 0 +} diff --git a/Medium/L994.go b/Medium/L994.go new file mode 100644 index 0000000..3683a85 --- /dev/null +++ b/Medium/L994.go @@ -0,0 +1,66 @@ +package Medium + +var dirs = [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}} + +func isValid(grid [][]int, x, y int) bool { + m, n := len(grid), len(grid[0]) + + return x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 +} + +func orangesRotting(grid [][]int) int { + if len(grid) == 0 { + return 0 + } + m, n, cnt, lvl := len(grid), len(grid[0]), 0, -1 + vis := make([][]bool, m) + for i := 0; i < m; i++ { + vis[i] = make([]bool, n) + } + + var q [][]int + for i := 0; i < m; i++ { + for j := 0; j < n; j++ { + if grid[i][j] == 2 { + q = append(q, []int{i, j}) + vis[i][j] = true + } else if grid[i][j] == 1 { + cnt++ + } + } + } + + if cnt == 0 { + return cnt + } + + if len(q) == 0 || len(q) == m*n { + return -1 + } + + for len(q) > 0 { + size := len(q) + for i := 0; i < size; i++ { + c := q[0] + q = q[1:] + + for _, d := range dirs { + newX, newY := c[0]+d[0], c[1]+d[1] + if isValid(grid, newX, newY) && !vis[newX][newY] { + vis[newX][newY] = true + q = append(q, []int{newX, newY}) + cnt-- + } + } + } + lvl++ + } + + if cnt == 0 { + if lvl > 0 { + return lvl + } + } + + return -1 +} diff --git a/README.md b/README.md index 3842d82..5c4bcf9 100644 --- a/README.md +++ b/README.md @@ -3,149 +3,8 @@ Leetcode Solutions in Go Please give this repo a ⭐ if it inspires you. -## Easy -|LC #|Description| -|:-:|:-| -|[1480](https://leetcode.com/problems/running-sum-of-1d-array/)| Running Sum of 1d Array| -|[1431](https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/)| Kids With the Greatest Number of Candies| -|[1](https://leetcode.com/problems/two-sum/)| Two Sum| -|[575](https://leetcode.com/problems/distribute-candies/)| Distribute Candies| -|[1365](https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/)| How Many Numbers Are Smaller Than the Current Number| -|[1773](https://leetcode.com/problems/count-items-matching-a-rule/)| Count Items Matching a Rule| -|[645](https://leetcode.com/problems/set-mismatch/)| Set Mismatch| -|[268](https://leetcode.com/problems/missing-number/)| Missing Number| -|[160](https://leetcode.com/problems/intersection-of-two-linked-lists/)| Intersection of Two Linked Lists| -|[637](https://leetcode.com/problems/average-of-levels-in-binary-tree/)| Average of Levels in Binary Tree| -|[559](https://leetcode.com/problems/maximum-depth-of-n-ary-tree/)| Maximum Depth of N-ary Tree| -|[690](https://leetcode.com/problems/employee-importance/)| Employee Importance| -|[993](https://leetcode.com/problems/cousins-in-binary-tree/)| Cousins in Binary Tree| -|[1748](https://leetcode.com/problems/sum-of-unique-elements/)| Sum of Unique Elements| -|[232](https://leetcode.com/problems/implement-queue-using-stacks/)| Implement Queue using Stacks| -|[1332](https://leetcode.com/problems/remove-palindromic-subsequences/)| Remove Palindromic Subsequences| -|[1678](https://leetcode.com/problems/goal-parser-interpretation/)| Goal Parser Interpretation| -|[1022](https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers/)| Sum of Root To Leaf Binary Numbers| -|[404](https://leetcode.com/problems/sum-of-left-leaves/)| Sum of Left Leaves| -|[112](https://leetcode.com/problems/path-sum/)| Path Sum| -|[535](https://leetcode.com/problems/encode-and-decode-tinyurl/)| Encode and Decode TinyURL| -|[1560](https://leetcode.com/problems/most-visited-sector-in-a-circular-track/)| Most Visited Sector in a Circular Track| -|[598](https://leetcode.com/problems/range-addition-ii/)| Range Addition II| -|[762](https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation/)| Prime Number of Set Bits in Binary Representation| -|[500](https://leetcode.com/problems/keyboard-row/)| Keyboard Row| -|[1656](https://leetcode.com/problems/design-an-ordered-stream/)| Design an Ordered Stream| -|[234](https://leetcode.com/problems/palindrome-linked-list/)| Palindrome Linked List| -|[1614](https://leetcode.com/problems/maximum-nesting-depth-of-the-parentheses/)| Maximum Nesting Depth of the Parentheses| -|[1668](https://leetcode.com/problems/maximum-repeating-substring/)| Maximum Repeating Substring| -|[1704](https://leetcode.com/problems/determine-if-string-halves-are-alike/)| Determine if String Halves Are Alike| -|[953](https://leetcode.com/problems/verifying-an-alien-dictionary/)| Verifying an Alien Dictionary| -|[509](https://leetcode.com/problems/fibonacci-number/)| Fibonacci Number| -|[589](https://leetcode.com/problems/n-ary-tree-preorder-traversal/)| N-ary Tree Preorder Traversal| -|[696](https://leetcode.com/problems/count-binary-substrings/)| Count Binary Substrings| -|[326](https://leetcode.com/problems/power-of-three/)| Power of Three| -|[703](https://leetcode.com/problems/kth-largest-element-in-a-stream/)| Kth Largest Element in a Stream| -|[204](https://leetcode.com/problems/count-primes/)| Count Primes| -|[453](https://leetcode.com/problems/minimum-moves-to-equal-array-elements/)| Minimum Moves to Equal Array Elements| -|[709](https://leetcode.com/problems/to-lower-case/)| To Lower Case| +## [Easy Problems](Easy.md) -## Medium -|LC #|Description| -|:-:|:-| -|[946](https://leetcode.com/problems/validate-stack-sequences/)| Validate Stack Sequences| -|[29](https://leetcode.com/problems/divide-two-integers/)| Divide Two Integers| -|[820](https://leetcode.com/problems/short-encoding-of-words/)| Short Encoding of Words| -|[1381](https://leetcode.com/problems/design-a-stack-with-increment-operation/)| Design a Stack With Increment Operation| -|[623](https://leetcode.com/problems/add-one-row-to-tree/)| Add One Row to Tree| -|[12](https://leetcode.com/problems/integer-to-roman/)| Integer to Roman| -|[1315](https://leetcode.com/problems/sum-of-nodes-with-even-valued-grandparent/)| Sum of Nodes with Even-Valued Grandparent| -|[1302](https://leetcode.com/problems/deepest-leaves-sum/)| Deepest Leaves Sum| -|[322](https://leetcode.com/problems/coin-change/)| Coin Change| -|[1305](https://leetcode.com/problems/all-elements-in-two-binary-search-trees/)| All Elements in Two Binary Search Trees| -|[1461](https://leetcode.com/problems/check-if-a-string-contains-all-binary-codes-of-size-k/)| Check If a String Contains All Binary Codes of Size K| -|[1721](https://leetcode.com/problems/swapping-nodes-in-a-linked-list/)| Swapping Nodes in a Linked List| -|[714](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/)| Best Time to Buy and Sell Stock with Transaction Fee| -|[478](https://leetcode.com/problems/generate-random-point-in-a-circle/)| Generate Random Point in a Circle| -|[208](https://leetcode.com/problems/implement-trie-prefix-tree/)| Implement Trie (Prefix Tree)| -|[376](https://leetcode.com/problems/wiggle-subsequence/)| Wiggle Subsequence| -|[38](https://leetcode.com/problems/count-and-say/)| Count and Say| -|[146](https://leetcode.com/problems/lru-cache/)| LRU Cache| -|[1583](https://leetcode.com/problems/count-unhappy-friends/)| Count Unhappy Friends| -|[729](https://leetcode.com/problems/my-calendar-i/)| My Calendar I| -|[841](https://leetcode.com/problems/keys-and-rooms/)| Keys And Rooms| -|[113](https://leetcode.com/problems/path-sum-ii/)| Path Sum II| -|[1398](https://leetcode.com/problems/design-underground-system/)| Design Underground System| -|[1797](https://leetcode.com/problems/design-authentication-manager/)| Design Authentication Manager| -|[1798](https://leetcode.com/problems/maximum-number-of-consecutive-values-you-can-make/)| Maximum Number of Consecutive Values You Can Make| -|[966](https://leetcode.com/problems/vowel-spellchecker/)| Vowel Spellchecker| -|[1689](https://leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers/)| Partitioning Into Minimum Number Of Deci-Binary Numbers| -|[1764](https://leetcode.com/problems/form-array-by-concatenating-subarrays-of-another-array/)| Form Array by Concatenating Subarrays of Another Array| -|[923](https://leetcode.com/problems/3sum-with-multiplicity/)| 3Sum With Multiplicity| -|[417](https://leetcode.com/problems/pacific-atlantic-water-flow/)| Pacific Atlantic Water Flow| -|[916](https://leetcode.com/problems/word-subsets/)| Word Subsets| -|[5](https://leetcode.com/problems/longest-palindromic-substring/)| Longest Palindromic Substring| -|[647](https://leetcode.com/problems/palindromic-substrings/)| Palindromic Substrings| -|[971](https://leetcode.com/problems/flip-binary-tree-to-match-preorder-traversal/)| Flip Binary Tree To Match Preorder Traversal| -|[1726](https://leetcode.com/problems/tuple-with-same-product/)| Tuple with Same Product| -|[474](https://leetcode.com/problems/ones-and-zeroes/)| Ones and Zeroes| -|[1488](https://leetcode.com/problems/avoid-flood-in-the-city/)| Avoid Flood in The City| -|[947](https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/)| Most Stones Removed with Same Row or Column| -|[622](https://leetcode.com/problems/design-circular-queue/)| Design Circular Queue| -|[1670](https://leetcode.com/problems/design-front-middle-back-queue/)| Design Front Middle Back Queue| -|[494](https://leetcode.com/problems/target-sum/)| Target Sum| -|[17](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)| Letter Combinations of a Phone Number| -|[638](https://leetcode.com/problems/shopping-offers/)| Shopping Offers| -|[667](https://leetcode.com/problems/beautiful-arrangement-ii/)| Beautiful Arrangement II| -|[650](https://leetcode.com/problems/2-keys-keyboard/)| 2 Keys Keyboard| -|[801](https://leetcode.com/problems/minimum-swaps-to-make-sequences-increasing/)| Minimum Swaps To Make Sequences Increasing| -|[341](https://leetcode.com/problems/flatten-nested-list-iterator/)| Flatten Nested List Iterator| -|[86](https://leetcode.com/problems/partition-list/)| Partition List| -|[91](https://leetcode.com/problems/decode-ways/)| Decode Ways| -|[62](https://leetcode.com/problems/unique-paths/)| Unique Paths| -|[1209](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string-ii/)| Remove All Adjacent Duplicates in String II| -|[279](https://leetcode.com/problems/perfect-squares/)| Perfect Squares| -|[377](https://leetcode.com/problems/combination-sum-iv/)| Combination Sum IV| -|[120](https://leetcode.com/problems/triangle/)| Triangle| -|[554](https://leetcode.com/problems/brick-wall/)| Brick Wall| -|[48](https://leetcode.com/problems/rotate-image/)| Rotate Image| -|[935](https://leetcode.com/problems/knight-dialer/)| Knight Dialer| -|[740](https://leetcode.com/problems/delete-and-earn/)| Delete and Earn| -|[63](https://leetcode.com/problems/unique-paths-ii/)| Unique Paths II| -|[34](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/)| Find First and Last Position of Element in Sorted Array| -|[970](https://leetcode.com/problems/powerful-integers/)| Powerful Integers| -|[665](https://leetcode.com/problems/non-decreasing-array/)| Non-decreasing Array| -|[1472](https://leetcode.com/problems/design-browser-history/)| Design Browser History| -|[109](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/)| Convert Sorted List to Binary Search Tree| -|[583](https://leetcode.com/problems/delete-operation-for-two-strings/)| Delete Operation for Two Strings| -|[1423](https://leetcode.com/problems/maximum-points-you-can-obtain-from-cards/)| Maximum Points You Can Obtain from Cards| -|[304](https://leetcode.com/problems/range-sum-query-2d-immutable/)| Range Sum Query 2D - Immutable| -|[816](https://leetcode.com/problems/ambiguous-coordinates/)| Ambiguous Coordinates| -|[114](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/)| Flatten Binary Tree to Linked List| -|[1048](https://leetcode.com/problems/longest-string-chain/)| Longest String Chain| -|[213](https://leetcode.com/problems/house-robber-ii/)| House Robber II| -|[462](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/)| Minimum Moves to Equal Array Elements II| -|[890](https://leetcode.com/problems/find-and-replace-pattern/)| Find and Replace Pattern| -|[337](https://leetcode.com/problems/house-robber-iii/)| House Robber III| -|[921](https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/)| Minimum Add to Make Parentheses Valid| -|[1871](https://leetcode.com/problems/jump-game-vii/)| Jump Game VII| -|[150](https://leetcode.com/problems/evaluate-reverse-polish-notation/)| Evaluate Reverse Polish Notation| -|[318](https://leetcode.com/problems/maximum-product-of-word-lengths/)| Maximum Product of Word Lengths| -|[1695](https://leetcode.com/problems/maximum-erasure-value/)| Maximum Erasure Value| -|[1268](https://leetcode.com/problems/search-suggestions-system/)| Search Suggestions System| -|[695](https://leetcode.com/problems/max-area-of-island/)| Max Area of Island| -|[97](https://leetcode.com/problems/interleaving-string/)| Interleaving String| +## [Medium Problems](Medium.md) -## Hard -|LC #|Description| -|:-:|:-| -|[354](https://leetcode.com/problems/russian-doll-envelopes/)| Russian Doll Envelopes| -|[936](https://leetcode.com/problems/stamping-the-sequence/)| Stamping The Sequence| -|[32](https://leetcode.com/problems/longest-valid-parentheses/)| Longest Valid Parentheses| -|[1559](https://leetcode.com/problems/detect-cycles-in-2d-grid/)| Detect Cycles in 2D Grid| -|[329](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/)| Longest Increasing Path in a Matrix| -|[1192](https://leetcode.com/problems/critical-connections-in-a-network/)| Critical Connections in a Network| -|[980](https://leetcode.com/problems/unique-paths-iii/)| Unique Paths III| -|[745](https://leetcode.com/problems/prefix-and-suffix-search/)| Prefix and Suffix Search| -|[630](https://leetcode.com/problems/course-schedule-iii/)| Course Schedule III| -|[65](https://leetcode.com/problems/valid-number/)| Valid Number| -|[968](https://leetcode.com/problems/binary-tree-cameras/)| Binary Tree Cameras| -|[1473](https://leetcode.com/problems/paint-house-iii/)| Paint House III| -|[51](https://leetcode.com/problems/n-queens/)| N-Queens| -|[52](https://leetcode.com/problems/n-queens-ii/)| N-Queens II| +## [Hard Problems](Hard.md)