https://github.com/zhongruoyu/leetcode
My LeetCode solutions.
https://github.com/zhongruoyu/leetcode
leetcode leetcode-solutions
Last synced: 3 months ago
JSON representation
My LeetCode solutions.
- Host: GitHub
- URL: https://github.com/zhongruoyu/leetcode
- Owner: ZhongRuoyu
- License: mit
- Created: 2020-11-20T08:47:00.000Z (over 5 years ago)
- Default Branch: main
- Last Pushed: 2023-02-05T08:40:11.000Z (over 3 years ago)
- Last Synced: 2025-04-22T22:41:47.720Z (about 1 year ago)
- Topics: leetcode, leetcode-solutions
- Language: C++
- Homepage:
- Size: 767 KB
- Stars: 4
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# My LeetCode Solutions
## Table of Contents
| Title | Difficulty | Related Topics | Solution |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| [1. Two Sum](https://leetcode.com/problems/two-sum/) | Easy | Array; Hash Table | [C++](problems/1-two-sum.cpp) |
| [2. Add Two Numbers](https://leetcode.com/problems/add-two-numbers/) | Medium | Linked List; Math; Recursion | [C](problems/2-add-two-numbers.c) |
| [3. Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters/) | Medium | Hash Table; String; Sliding Window | [C++](problems/3-longest-substring-without-repeating-characters.cpp) |
| [5. Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring/) | Medium | String; Dynamic Programming | [JavaScript](problems/5-longest-palindromic-substring.js) |
| [7. Reverse Integer](https://leetcode.com/problems/reverse-integer/) | Medium | Math | [C](problems/7-reverse-integer.c) |
| [8. String to Integer (atoi)](https://leetcode.com/problems/string-to-integer-atoi/) | Medium | String | [C](problems/8-string-to-integer-atoi.c) |
| [9. Palindrome Number](https://leetcode.com/problems/palindrome-number/) | Easy | Math | [C](problems/9-palindrome-number.c) |
| [11. Container With Most Water](https://leetcode.com/problems/container-with-most-water/) | Medium | Array; Two Pointers; Greedy | [C++](problems/11-container-with-most-water.cpp) |
| [12. Integer to Roman](https://leetcode.com/problems/integer-to-roman/) | Medium | Hash Table; Math; String | [C++](problems/12-integer-to-roman.cpp) |
| [13. Roman to Integer](https://leetcode.com/problems/roman-to-integer/) | Easy | Hash Table; Math; String | [C++](problems/13-roman-to-integer.cpp) |
| [14. Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/) | Easy | String | [C++](problems/14-longest-common-prefix.cpp) |
| [15. 3Sum](https://leetcode.com/problems/3sum/) | Medium | Array; Two Pointers; Sorting | [C++](problems/15-3sum.cpp) |
| [16. 3Sum Closest](https://leetcode.com/problems/3sum-closest/) | Medium | Array; Two Pointers; Sorting | [C++](problems/16-3sum-closest.cpp) |
| [17. Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/) | Medium | Hash Table; Sorting; Backtracking | [C++](problems/17-letter-combinations-of-a-phone-number.cpp) |
| [18. 4Sum](https://leetcode.com/problems/4sum/) | Medium | Array; Two Pointers; Sorting | [C++](problems/18-4sum.cpp) |
| [19. Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/) | Medium | Linked List; Two Pointers | [C++](problems/19-remove-nth-node-from-end-of-list.cpp) |
| [20. Valid Parentheses](https://leetcode.com/problems/valid-parentheses/) | Easy | String; Stack | [C++](problems/20-valid-parentheses.cpp) |
| [21. Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/) | Easy | Linked List; Recursion | [C](problems/21-merge-two-sorted-lists.c) |
| [22. Generate Parentheses](https://leetcode.com/problems/generate-parentheses/) | Medium | String; Dynamic Programming; Backtracking | [C++](problems/22-generate-parentheses.cpp) |
| [23. Merge k Sorted Lists](https://leetcode.com/problems/merge-k-sorted-lists/) | Hard | Linked List; Divide and Conquer; Heap (Priority Queue); Merge Sort | [C++](problems/23-merge-k-sorted-lists.cpp) |
| [24. Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/) | Medium | Linked List; Recursion | [C](problems/24-swap-nodes-in-pairs.c) |
| [26. Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/) | Easy | Array; Two Pointers | [C++](problems/26-remove-duplicates-from-sorted-array.cpp) |
| [27. Remove Element](https://leetcode.com/problems/remove-element/) | Easy | Array; Two Pointers | [C++](problems/27-remove-element.cpp) |
| [28. Implement strStr()](https://leetcode.com/problems/implement-strstr/) | Easy | Two Pointers; String; String Matching | [C++](problems/28-implement-strstr.cpp) |
| [29. Divide Two Integers](https://leetcode.com/problems/divide-two-integers/) | Medium | Math; Bit Manipulation | [C++](problems/29-divide-two-integers.cpp) |
| [31. Next Permutation](https://leetcode.com/problems/next-permutation/) | Medium | Array; Two Pointers | [JavaScript](problems/31-next-permutation.js) |
| [32. Longest Valid Parentheses](https://leetcode.com/problems/longest-valid-parentheses/) | Hard | String; Dynamic Programming; Stack | [Rust](problems/32-longest-valid-parentheses.rs) |
| [33. Search in Rotated Sorted Array](https://leetcode.com/problems/next-permutation/) | Medium | Array; Binary Search | [JavaScript](problems/33-search-in-rotated-sorted-array.js) |
| [34. Find First and Last Position of Element in Sorted Array](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/) | Medium | Array; Binary Search | [JavaScript](problems/34-find-first-and-last-position-of-element-in-sorted-array.js) |
| [35. Search Insert Position](https://leetcode.com/problems/search-insert-position/) | Easy | Array; Binary Search | [C++](problems/35-search-insert-position.cpp) |
| [36. Valid Sudoku](https://leetcode.com/problems/valid-sudoku/) | Medium | Array; Hash Table; Matrix | [C++](problems/36-valid-sudoku.cpp) |
| [37. Sudoku Solver](https://leetcode.com/problems/sudoku-solver/) | Hard | Array; Backtracking; Matrix | [C++](problems/37-sudoku-solver.cpp) / [JavaScript](problems/37-sudoku-solver.js) |
| [38. Count and Say](https://leetcode.com/problems/count-and-say/) | Medium | String | [C++](problems/38-count-and-say.cpp) |
| [41. First Missing Positive](https://leetcode.com/problems/first-missing-positive/) | Hard | Array; Hash Table | [C++](problems/41-first-missing-positive.cpp) |
| [42. Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/) | Hard | Array; Two Pointers; Dynamic Programming; Stack; Monotonic Stack | [C++](problems/42-trapping-rain-water.cpp) |
| [44. Wildcard Matching](https://leetcode.com/problems/wildcard-matching/) | Hard | String; Dynamic Programming; Greedy; Recursion | [Go](problems/44-wildcard-matching.go) |
| [46. Permutations](https://leetcode.com/problems/permutations/) | Medium | Array; Backtracking | [C++](problems/46-permutations.cpp) |
| [47. Permutations II](https://leetcode.com/problems/permutations-ii/) | Medium | Array; Backtracking | [C++](problems/47-permutations-ii.cpp) |
| [48. Rotate Image](https://leetcode.com/problems/rotate-image/) | Medium | Array; Math; Matrix | [C++](problems/48-rotate-image.cpp) |
| [49. Group Anagrams](https://leetcode.com/problems/group-anagrams/) | Medium | Hash Table; String; Sorting | [C++](problems/49-group-anagrams.cpp) |
| [50. Pow(x, n)](https://leetcode.com/problems/powx-n/) | Medium | Math; Recursion | [C](problems/50-powx-n.c) |
| [51. N-Queens](https://leetcode.com/problems/n-queens/) | Hard | Array; Backtracking | [C++](problems/51-n-queens.cpp) |
| [52. N-Queens II](https://leetcode.com/problems/n-queens-ii/) | Hard | Backtracking | [C++](problems/52-n-queens-ii.cpp) |
| [53. Maximum Subarray](https://leetcode.com/problems/maximum-subarray/) | Easy | Array; Divide and Conquer; Dynamic Programming | [C++](problems/53-maximum-subarray.cpp) |
| [55. Jump Game](https://leetcode.com/problems/jump-game/) | Medium | Array; Dynamic Programming; Greedy | [JavaScript](problems/55-jump-game.js) |
| [56. Merge Intervals](https://leetcode.com/problems/merge-intervals/) | Medium | Array; Sorting | [C++](problems/56-merge-intervals.cpp) |
| [58. Length of Last Word](https://leetcode.com/problems/length-of-last-word/) | Easy | String | [C++](problems/58-length-of-last-word.cpp) |
| [62. Unique Paths](https://leetcode.com/problems/unique-paths/) | Medium | Math; Dynamic Programming; Combinatorics | [C++](problems/62-unique-paths.cpp) |
| [63. Unique Paths II](https://leetcode.com/problems/unique-paths-ii/) | Medium | Array; Dynamic Programming; Matrix | [Rust](problems/63-unique-paths-ii.rs) |
| [65. Valid Number](https://leetcode.com/problems/valid-number/) | Hard | String | [C++](problems/65-valid-number.cpp) |
| [66. Plus One](https://leetcode.com/problems/plus-one/) | Easy | Array; Math | [C++](problems/66-plus-one.cpp) |
| [67. Add Binary](https://leetcode.com/problems/add-binary/) | Easy | Math; String; Bit Manipulation; Simulation | [C](problems/67-add-binary.c) |
| [68. Text Justification](https://leetcode.com/problems/text-justification/) | Hard | Array; String; Simulation | [Rust](problems/68-text-justification.rs) |
| [69. Sqrt(x)](https://leetcode.com/problems/sqrtx/) | Easy | Math; Binary Search | [C](problems/69-sqrtx.c) |
| [70. Climbing Stairs](https://leetcode.com/problems/climbing-stairs/) | Easy | Math; Dynamic Programming; Memorization | [C++](problems/70-climbing-stairs.cpp) |
| [73. Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/) | Medium | Array; Hash Table; Matrix | [JavaScript](problems/73-set-matrix-zeroes.js) |
| [74. Search a 2D Matrix](https://leetcode.com/problems/search-a-2d-matrix/) | Medium | Array; Binary Search; Matrix | [C++](problems/74-search-a-2d-matrix.cpp) |
| [75. Sort Colors](https://leetcode.com/problems/sort-colors/) | Medium | Array; Two Pointers; Sorting | [JavaScript](problems/75-sort-colors.js) |
| [78. Subsets](https://leetcode.com/problems/subsets/) | Medium | Array; Backtracking; Bit Manipulation | [JavaScript](problems/78-subsets.js) |
| [79. Word Search](https://leetcode.com/problems/word-search/) | Medium | Array; Backtracking; Matrix | [C++](problems/79-word-search.cpp) |
| [82. Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/) | Medium | Linked List; Two Pointers | [C++](problems/82-remove-duplicates-from-sorted-list-ii.cpp) |
| [83. Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list/) | Easy | Linked List | [C++](problems/83-remove-duplicates-from-sorted-list.cpp) |
| [86. Partition List](https://leetcode.com/problems/partition-list/) | Medium | Linked List; Two Pointers | [C++](problems/86-partition-list.cpp) |
| [88. Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/) | Easy | Array; Two Pointers; Sorting | [C](problems/88-merge-sorted-array.c) / [C++](problems/88-merge-sorted-array.cpp) |
| [89. Gray Code](https://leetcode.com/problems/gray-code/) | Medium | Math; Backtracking; Bit Manipulation | [C++](problems/89-gray-code.cpp) |
| [91. Decode Ways](https://leetcode.com/problems/decode-ways/) | Medium | String; Dynamic Programming | [C++](problems/91-decode-ways.cpp) |
| [93. Restore IP Addresses](https://leetcode.com/problems/restore-ip-addresses/) | Medium | String; Backtracking | [JavaScript](problems/93-restore-ip-addresses.js) |
| [94. Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/) | Easy | Stack; Tree; Depth-First Search; Binary Tree | [JavaScript](problems/94-binary-tree-inorder-traversal.js) |
| [100. Same Tree](https://leetcode.com/problems/same-tree/) | Easy | Tree; Depth-First Search; Breadth-First Search; Binary Tree | [C++](problems/100-same-tree.cpp) |
| [101. Symmetric Tree](https://leetcode.com/problems/symmetric-tree/) | Easy | Tree; Depth-First Search; Breadth-First Search; Binary Tree | [C++](problems/101-symmetric-tree.cpp) |
| [104. Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/) | Easy | Tree; Depth-First Search; Breadth-First Search; Binary Tree | [C++](problems/104-maximum-depth-of-binary-tree.cpp) |
| [108. Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/) | Easy | Array; Divide and Conquer; Tree; Binary Search Tree; Binary Tree | [C++](problems/108-convert-sorted-array-to-binary-search-tree.cpp) |
| [115. Distinct Subsequences](https://leetcode.com/problems/distinct-subsequences/) | Hard | String; Dynamic Programming | [C++](problems/115-distinct-subsequences.cpp) |
| [118. Pascal's Triangle](https://leetcode.com/problems/pascals-triangle/) | Easy | Array; Dynamic Programming | [C++](problems/118-pascals-triangle.cpp) |
| [119. Pascal's Triangle II](https://leetcode.com/problems/pascals-triangle-ii/) | Easy | Array; Dynamic Programming | [Rust](problems/119-pascals-triangle-ii.rs) |
| [120. Triangle](https://leetcode.com/problems/triangle/) | Medium | Array; Dynamic Programming | [Rust](problems/120-triangle.rs) |
| [121. Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock) | Easy | Array; Dynamic Programming | [C](problems/121-best-time-to-buy-and-sell-stock.c) / [C++](problems/121-best-time-to-buy-and-sell-stock.cpp) |
| [125. Valid Palindrome](https://leetcode.com/problems/valid-palindrome/) | Easy | Two Pointers; String | [C](problems/125-valid-palindrome.c) |
| [128. Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence/) | Medium | Array; Hash Table; Union Find | [C++](problems/128-longest-consecutive-sequence.cpp) |
| [136. Single Number](https://leetcode.com/problems/single-number/) | Easy | Array; Bit Manipulation | [C](problems/136-single-number.c) |
| [141. Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/) | Easy | Hash Table; Linked List; Two Pointers | [C++](problems/141-linked-list-cycle.cpp) |
| [146. LRU Cache](https://leetcode.com/problems/lru-cache/) | Medium | Hash Table; Linked List; Design; Doubly-Linked List | [C++](problems/146-lru-cache.cpp) |
| [150. Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/) | Medium | Array; Math; Stack | [C++](problems/150-evaluate-reverse-polish-notation.cpp) |
| [155. Min Stack](https://leetcode.com/problems/min-stack/) | Easy | Stack; Design | [C](problems/155-min-stack.c) |
| [160. Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/) | Easy | Hash Table; Linked List; Two Pointers | [C++](problems/160-intersection-of-two-linked-lists.cpp) |
| [167. Two Sum II - Input Array Is Sorted](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/) | Easy | Array; Two Pointers; Binary Search | [C++](problems/167-two-sum-ii-input-array-is-sorted.cpp) |
| [168. Excel Sheet Column Title](https://leetcode.com/problems/excel-sheet-column-title/) | Easy | Math; String | [C++](problems/168-excel-sheet-column-title.cpp) |
| [169. Majority Element](https://leetcode.com/problems/majority-element/) | Easy | Array; Hash Table; Divide and Conquer; Sorting; Counting | [C++](problems/169-majority-element.cpp) |
| [171. Excel Sheet Column Number](https://leetcode.com/problems/excel-sheet-column-number/) | Easy | Math; String | [C](problems/171-excel-sheet-column-number.c) |
| [172. Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/) | Medium | Math | [C](problems/172-factorial-trailing-zeroes.c) |
| [175. Combine Two Tables](https://leetcode.com/problems/combine-two-tables/) | Easy | Database | [MySQL](problems/175-combine-two-tables.sql) |
| [176. Second Highest Salary](https://leetcode.com/problems/second-highest-salary/) | Medium | Database | [MySQL](problems/176-second-highest-salary.sql) |
| [177. Nth Highest Salary](https://leetcode.com/problems/nth-highest-salary/) | Medium | Database | [MySQL](problems/177-nth-highest-salary.sql) |
| [178. Rank Scores](https://leetcode.com/problems/rank-scores/) | Medium | Database | [MySQL](problems/178-rank-scores.sql) |
| [179. Largest Number](https://leetcode.com/problems/largest-number/) | Medium | String; Greedy; Sorting | [Go](problems/179-largest-number.go) |
| [180. Consecutive Numbers](https://leetcode.com/problems/consecutive-numbers/) | Medium | Database | [MySQL](problems/180-consecutive-numbers.sql) |
| [181. Employees Earning More Than Their Managers](https://leetcode.com/problems/employees-earning-more-than-their-managers/) | Easy | Database | [MySQL](problems/181-employees-earning-more-than-their-managers.sql) |
| [182. Duplicate Emails](https://leetcode.com/problems/duplicate-emails/) | Easy | Database | [MySQL](problems/182-duplicate-emails.sql) |
| [183. Customers Who Never Order](https://leetcode.com/problems/customers-who-never-order/) | Easy | Database | [MySQL](problems/183-customers-who-never-order.sql) |
| [184. Department Highest Salary](https://leetcode.com/problems/department-highest-salary/) | Medium | Database | [MySQL](problems/184-department-highest-salary.sql) |
| [185. Department Top Three Salaries](https://leetcode.com/problems/department-top-three-salaries/) | Hard | Database | [MySQL](problems/185-department-top-three-salaries.sql) |
| [189. Rotate Array](https://leetcode.com/problems/rotate-array/) | Medium | Array; Math; Two Pointers | [C++](problems/189-rotate-array.cpp) |
| [190. Reverse Bits](https://leetcode.com/problems/reverse-bits/) | Easy | Divide and Conquer; Bit Manipulation | [C++](problems/190-reverse-bits.cpp) |
| [191. Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/) | Easy | Bit Manupulation | [C](problems/191-number-of-1-bits.c) |
| [192. Word Frequency](https://leetcode.com/problems/word-frequency/) | Medium | Shell | [Bash](problems/192-word-frequency.sh) |
| [193. Valid Phone Numbers](https://leetcode.com/problems/valid-phone-numbers/) | Easy | Shell | [Bash](problems/193-valid-phone-numbers.sh) |
| [194. Transpose File](https://leetcode.com/problems/transpose-file/) | Medium | Shell | [Bash](problems/194-transpose-file.sh) |
| [195. Tenth Line](https://leetcode.com/problems/tenth-line/) | Easy | Shell | [Bash](problems/195-tenth-line.sh) |
| [196. Delete Duplicate Emails](https://leetcode.com/problems/delete-duplicate-emails/) | Easy | Database | [MySQL](problems/196-delete-duplicate-emails.sql) |
| [197. Rising Temperature](https://leetcode.com/problems/rising-temperature/) | Easy | Database | [MySQL](problems/197-rising-temperature.sql) |
| [200. Number of Islands](https://leetcode.com/problems/number-of-islands/) | Medium | Array; Depth-First Search; Breadth-First Search; Union Find; Matrix | [C++](problems/200-number-of-islands.cpp) |
| [202. Happy Number](https://leetcode.com/problems/happy-number/) | Easy | Hash Table; Math; Two Pointers | [Go](problems/202-happy-number.go) |
| [203. Remove Linked List Elements](https://leetcode.com/problems/remove-linked-list-elements/) | Easy | Linked List; Recursion | [C++](problems/203-remove-linked-list-elements.cpp) |
| [204. Count Primes](https://leetcode.com/problems/count-primes/) | Medium | Array; Math; Enumeration; Number Theory | [C](problems/204-count-primes.c) |
| [206. Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/) | Easy | Linked List; Recursion | [C](problems/206-reverse-linked-list.c) |
| [208. Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree/) | Medium | Hash Table; String; Design; Trie | [Rust](problems/208-implement-trie-prefix-tree.rs) |
| [211. Design Add and Search Words Data Structure](https://leetcode.com/problems/design-add-and-search-words-data-structure/) | Medium | String; Depth-First Search; Design; Trie | [C++](problems/211-design-add-and-search-words-data-structure.cpp) |
| [217. Contains Duplicate](https://leetcode.com/problems/contains-duplicate/) | Easy | Array; Hash Table; Sorting | [C++](problems/217-contains-duplicate.cpp) |
| [219. Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/) | Easy | Array; Hash Table; Sliding Window | [C++](problems/219-contains-duplicate-ii.cpp) |
| [220. Contains Duplicate III](https://leetcode.com/problems/contains-duplicate-iii/) | Medium | Array; Sliding Window; Sorting; Bucket Sort; Ordered Set | [C++](problems/220-contains-duplicate-iii.cpp) |
| [221. Maximal Square](https://leetcode.com/problems/maximal-square/) | Medium | Array; Dynamic Programming; Matrix | [Rust](problems/221-maximal-square.rs) |
| [223. Rectangle Area](https://leetcode.com/problems/rectangle-area/) | Medium | Math; Geometry | [C++](problems/223-rectangle-area.cpp) |
| [226. Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/) | Easy | Tree; Depth-First Search; Breadth-First Search; Binary Tree | [C](problems/226-invert-binary-tree.c) |
| [228. Summary Ranges](https://leetcode.com/problems/summary-ranges/) | Easy | Array | [C++](problems/228-summary-ranges.cpp) |
| [231. Power of Two](https://leetcode.com/problems/power-of-two/) | Easy | Math; Bit Manipulation; Recursion | [C](problems/231-power-of-two.c) |
| [237. Delete Node in a Linked List](https://leetcode.com/problems/delete-node-in-a-linked-list/) | Easy | Linked List | [C](problems/237-delete-node-in-a-linked-list.c) |
| [238. Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/) | Medium | Array; Prefix Sum | [C++](problems/238-product-of-array-except-self.cpp) |
| [239. Sliding Window Maximum](https://leetcode.com/problems/sliding-window-maximum/) | Hard | Array; Queue; Sliding Window; Heap (Priority Queue); Monotonic Queue | [Rust](problems/239-sliding-window-maximum.rs) |
| [242. Valid Anagram](https://leetcode.com/problems/valid-anagram/) | Easy | Hash Table; String; Sorting | [Rust](problems/242-valid-anagram.rs) |
| [258. Add Digits](https://leetcode.com/problems/add-digits/) | Easy | Math; Simulation; Number Theory | [C](problems/258-add-digits.c) |
| [262. Trips and Users](https://leetcode.com/problems/trips-and-users/) | Hard | Database | [MySQL](problems/262-trips-and-users.sql) |
| [263. Ugly Number](https://leetcode.com/problems/ugly-number/) | Easy | Math | [C](problems/263-ugly-number.c) |
| [268. Missing Number](https://leetcode.com/problems/missing-number/) | Easy | Array; Hash Table; Math; Bit Manipulation; Sorting | [C](problems/268-missing-number.c) |
| [278. First Bad Version](https://leetcode.com/problems/first-bad-version/) | Easy | Binary Search; Interactive | [C++](problems/278-first-bad-version.cpp) |
| [283. Move Zeroes](https://leetcode.com/problems/move-zeroes/) | Easy | Array; Two Pointers | [C++](problems/283-move-zeroes.cpp) |
| [289. Game of Life](https://leetcode.com/problems/game-of-life/) | Medium | Array; Matrix; Simulation | [C++](problems/289-game-of-life.cpp) |
| [290. Word Pattern](https://leetcode.com/problems/word-pattern/) | Easy | Hash Table; String | [Ruby](problems/290-word-pattern.rb) |
| [292. Nim Game](https://leetcode.com/problems/nim-game/) | Easy | Math; Brainteaser; Game Theory | [C++](problems/292-nim-game.cpp) |
| [299. Bulls and Cows](https://leetcode.com/problems/bulls-and-cows/) | Medium | Hash Table; String; Counting | [Ruby](problems/299-bulls-and-cows.rb) |
| [303. Range Sum Query - Immutable](https://leetcode.com/problems/range-sum-query-immutable/) | Easy | Array; Design; Prefix Sum | [Go](problems/303-range-sum-query-immutable.go) |
| [319. Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) | Easy | Math; Brainteaser | [C++](problems/319-bulb-switcher.cpp) |
| [322. Coin Change](https://leetcode.com/problems/coin-change/) | Medium | Array; Dynamic Programming; Breadth-First Search | [Rust](problems/322-coin-change.rs) |
| [326. Power of Three](https://leetcode.com/problems/power-of-three/) | Easy | Math; Recursion | [C](problems/326-power-of-three.c) |
| [328. Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/) | Medium | Linked List | [C](problems/328-odd-even-linked-list.c) |
| [338. Counting Bits](https://leetcode.com/problems/counting-bits/) | Easy | Dynamic Programming; Bit Manipulation | [C](problems/338-counting-bits.c) |
| [342. Power of Four](https://leetcode.com/problems/power-of-four/) | Easy | Math; Bit Manipulation; Recursion | [C++](problems/342-power-of-four.cpp) |
| [344. Reverse String](https://leetcode.com/problems/reverse-string/) | Easy | Two Pointers; String; Recursion | [C](problems/344-reverse-string.c) / [C++](problems/344-reverse-string.cpp) |
| [345. Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/) | Easy | Two Pointers; String | [Ruby](problems/345-reverse-vowels-of-a-string.rb) |
| [347. Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | Medium | Array; Hash Table; Divide and Conquer; Sorting; Heap (Priority Queue); Bucket Sort; Counting; Quickselect | [Rust](problems/347-top-k-frequent-elements.rs) |
| [349. Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) | Easy | Array; Hash Table; Two Pointers; Binary Search; Sorting | [C++](problems/349-intersection-of-two-arrays.cpp) |
| [350. Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/) | Easy | Array; Hash Table; Two Pointers; Binary Search; Sorting | [C++](problems/350-intersection-of-two-arrays-ii.cpp) |
| [367. Valid Perfect Square](https://leetcode.com/problems/valid-perfect-square/) | Easy | Math; Binary Search | [C++](problems/367-valid-perfect-square.cpp) |
| [380. Insert Delete GetRandom O(1)](https://leetcode.com/problems/insert-delete-getrandom-o1/) | Medium | Array; Hash Table; Math; Design; Randomized | [Go](problems/380-insert-delete-getrandom-o1.go) |
| [381. Insert Delete GetRandom O(1) - Duplicates allowed](https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/) | Hard | Array; Hash Table; Math; Design; Randomized | [Go](problems/381-insert-delete-getrandom-o1-duplicates-allowed.go) |
| [383. Ransom Note](https://leetcode.com/problems/ransom-note/) | Easy | Hash Table; String; Counting | [C++](problems/383-ransom-note.cpp) |
| [387. First Unique Character in a String](https://leetcode.com/problems/first-unique-character-in-a-string/) | Easy | Hash Table; String; Queue; Counting | [C++](problems/387-first-unique-character-in-a-string.cpp) |
| [389. Find the Difference](https://leetcode.com/problems/find-the-difference/) | Easy | Hash Table; String; Bit Manipulation; Sorting | [C++](problems/389-find-the-difference.cpp) |
| [398. Random Pick Index](https://leetcode.com/problems/random-pick-index/) | Medium | Hash Table; Math; Reservoir Sampling; Randomized | [Rust](problems/398-random-pick-index.rs) |
| [401. Binary Watch](https://leetcode.com/problems/binary-watch/) | Easy | Backtracking; Bit Manipulation | [C++](problems/401-binary-watch.cpp) |
| [404. Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) | Easy | Tree; Depth-First Search; Breadth-First Search; Binary Tree | [C++](problems/404-sum-of-left-leaves.cpp) |
| [405. Convert a Number to Hexadecimal](https://leetcode.com/problems/convert-a-number-to-hexadecimal/) | Easy | Math; Bit Manipulation | [C++](problems/405-convert-a-number-to-hexadecimal.cpp) |
| [406. Queue Reconstruction by Height](https://leetcode.com/problems/queue-reconstruction-by-height/) | Medium | Array; Greedy; Binary Indexed Tree; Segment Tree; Sorting | [Rust](problems/406-queue-reconstruction-by-height.rs) |
| [412. Fizz Buzz](https://leetcode.com/problems/fizz-buzz/) | Easy | Math; String; Simulation | [C++](problems/412-fizz-buzz.cpp) |
| [413. Arithmetic Slices](https://leetcode.com/problems/arithmetic-slices/) | Medium | Array; Dynamic Programming | [Rust](problems/413-arithmetic-slices.rs) |
| [415. Add Strings](https://leetcode.com/problems/add-strings/) | Easy | Math; String; Simulation | [C](problems/415-add-strings.c) |
| [419. Battleships in a Board](https://leetcode.com/problems/battleships-in-a-board/) | Medium | Array; Depth-First Search; Matrix | [Rust](problems/419-battleships-in-a-board.rs) |
| [430. Flatten a Multilevel Doubly Linked List](https://leetcode.com/problems/flatten-a-multilevel-doubly-linked-list/) | Medium | Linked List; Depth-First Search; Doubly-Linked List | [C++](problems/430-flatten-a-multilevel-doubly-linked-list.cpp) |
| [434. Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string/) | Easy | String | [Rust](problems/434-number-of-segments-in-a-string.rs) |
| [438. Find All Anagrams in a String](https://leetcode.com/problems/find-all-anagrams-in-a-string/) | Medium | Hash Table; String; Sliding Window | [JavaScript](problems/438-find-all-anagrams-in-a-string.js) |
| [441. Arranging Coins](https://leetcode.com/problems/arranging-coins/) | Easy | Math; Binary Search | [C](problems/441-arranging-coins.c) |
| [442. Find All Duplicates in an Array](https://leetcode.com/problems/find-all-duplicates-in-an-array/) | Medium | Array; Hash Table | [Rust](problems/442-find-all-duplicates-in-an-array.rs) |
| [448. Find All Numbers Disappeared in an Array](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/) | Easy | Array; Hash Table | [Go](problems/448-find-all-numbers-disappeared-in-an-array.go) |
| [450. Delete Node in a BST](https://leetcode.com/problems/delete-node-in-a-bst/) | Medium | Tree; Binary Search Tree; Binary Tree | [C++](problems/450-delete-node-in-a-bst.cpp) |
| [455. Assign Cookies](https://leetcode.com/problems/assign-cookies/) | Easy | Array; Greedy; Sorting | [Go](problems/455-assign-cookies.go) |
| [458. Poor Pigs](https://leetcode.com/problems/poor-pigs/) | Hard | Math; Dynamic Programming; Combinatorics | [C++](problems/458-poor-pigs.cpp) |
| [461. Hamming Distance](https://leetcode.com/problems/hamming-distance/) | Easy | Bit Manipulation | [C++](problems/461-hamming-distance.cpp) |
| [463. Island Perimeter](https://leetcode.com/problems/island-perimeter/) | Easy | Array; Depth-First Search; Breadth-First Search; Matrix | [C++](problems/463-island-perimeter.cpp) |
| [468. Validate IP Address](https://leetcode.com/problems/validate-ip-address/) | Medium | String | [C++](problems/468-validate-ip-address.cpp) |
| [470. Implement Rand10() Using Rand7()](https://leetcode.com/problems/implement-rand10-using-rand7/) | Medium | Math; Rejection Sampling; Randomized; Probability and Statistics | [JavaScript](problems/470-implement-rand10-using-rand7.js) |
| [476. Number Complement](https://leetcode.com/problems/number-complement/) | Easy | Bit Manipulation | [C++](problems/476-number-complement.cpp) |
| [482. License Key Formatting](https://leetcode.com/problems/license-key-formatting/) | Easy | String | [Ruby](problems/482-license-key-formatting.rb) |
| [485. Max Consecutive Ones](https://leetcode.com/problems/max-consecutive-ones/) | Easy | Array | [Go](problems/485-max-consecutive-ones.go) |
| [492. Construct the Rectangle](https://leetcode.com/problems/construct-the-rectangle/) | Easy | Math | [Go](problems/492-construct-the-rectangle.go) |
| [495. Teemo Attacking](https://leetcode.com/problems/teemo-attacking/) | Easy | Array; Simulation | [C++](problems/495-teemo-attacking.cpp) |
| [500. Keyboard Row](https://leetcode.com/problems/keyboard-row/) | Easy | Array; Hash Table; String | [JavaScript](problems/500-keyboard-row.js) |
| [504. Base 7](https://leetcode.com/problems/base-7/) | Easy | Math | [Go](problems/504-base-7.go) |
| [506. Relative Ranks](https://leetcode.com/problems/relative-ranks/) | Easy | Array; Sorting; Heap (Priority Queue) | [Rust](problems/506-relative-ranks.rs) |
| [507. Perfect Number](https://leetcode.com/problems/perfect-number/) | Easy | Math | [Go](problems/507-perfect-number.go) |
| [509. Fibonacci Number](https://leetcode.com/problems/fibonacci-number/) | Easy | Math; Dynamic Programming; Recursion; Memorization | [JavaScript](problems/509-fibonacci-number.js) |
| [511. Game Play Analysis I](https://leetcode.com/problems/game-play-analysis-i/) | Easy | Database | [MySQL](problems/511-game-play-analysis-i.sql) |
| [520. Detect Capital](https://leetcode.com/problems/detect-capital/) | Easy | String | [Rust](problems/520-detect-capital.rs) |
| [521. Longest Uncommon Subsequence I](https://leetcode.com/problems/longest-uncommon-subsequence-i/) | Easy | String | [C++](problems/521-longest-uncommon-subsequence-i.cpp) |
| [535. Encode and Decode TinyURL](https://leetcode.com/problems/encode-and-decode-tinyurl/) | Medium | Hash Table; String; Design; Hash Function | [C++](problems/535-encode-and-decode-tinyurl.cpp) |
| [537. Complex Number Multiplication](https://leetcode.com/problems/complex-number-multiplication/) | Medium | Math; String; Simulation | [C](problems/537-complex-number-multiplication.c) |
| [541. Reverse String II](https://leetcode.com/problems/reverse-string-ii/) | Easy | Two Pointers; String | [Ruby](problems/541-reverse-string-ii.rb) |
| [543. Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/) | Easy | Tree; Depth-First Search; Binary Tree | [JavaScript](problems/543-diameter-of-binary-tree.js) |
| [554. Brick Wall](https://leetcode.com/problems/brick-wall/) | Medium | Array; Hash Table | [C++](problems/554-brick-wall.cpp) |
| [557. Reverse Words in a String III](https://leetcode.com/problems/reverse-words-in-a-string-iii/) | Easy | Two Pointers; String | [C](problems/557-reverse-words-in-a-string-iii.c) / [C++](problems/557-reverse-words-in-a-string-iii.cpp) |
| [561. Array Partition](https://leetcode.com/problems/array-partition/) | Easy | Array; Greedy; Sorting; Counting Sort | [Rust](problems/561-array-partition.rs) |
| [566. Reshape the Matrix](https://leetcode.com/problems/reshape-the-matrix/) | Easy | Array; Matrix; Simulation | [C++](problems/566-reshape-the-matrix.cpp) |
| [575. Distribute Candies](https://leetcode.com/problems/distribute-candies/) | Easy | Array; Hash Table | [Ruby](problems/575-distribute-candies.rb) |
| [584. Find Customer Referee](https://leetcode.com/problems/find-customer-referee/) | Easy | Database | [MySQL](problems/584-find-customer-referee.sql) |
| [586. Customer Placing the Largest Number of Orders](https://leetcode.com/problems/customer-placing-the-largest-number-of-orders/) | Easy | Database | [MySQL](problems/586-customer-placing-the-largest-number-of-orders.sql) |
| [594. Longest Harmonious Subsequence](https://leetcode.com/problems/longest-harmonious-subsequence/) | Easy | Array; Hash Table; Sorting | [Ruby](problems/594-longest-harmonious-subsequence.rb) |
| [595. Big Countries](https://leetcode.com/problems/big-countries/) | Easy | Database | [MySQL](problems/595-big-countries.sql) |
| [596. Classes More Than 5 Students](https://leetcode.com/problems/classes-more-than-5-students/) | Easy | Database | [MySQL](problems/596-classes-more-than-5-students.sql) |
| [598. Range Addition II](https://leetcode.com/problems/range-addition-ii/) | Easy | Array; Math | [Go](problems/598-range-addition-ii.go) |
| [599. Minimum Index Sum of Two Lists](https://leetcode.com/problems/minimum-index-sum-of-two-lists/) | Easy | Array; Hash Table; String | [Ruby](problems/599-minimum-index-sum-of-two-lists.rb) |
| [601. Human Traffic of Stadium](https://leetcode.com/problems/human-traffic-of-stadium/) | Hard | Database | [MySQL](problems/601-human-traffic-of-stadium.sql) |
| [605. Can Place Flowers](https://leetcode.com/problems/can-place-flowers/) | Easy | Array; Greedy | [C++](problems/605-can-place-flowers.cpp) |
| [607. Sales Person](https://leetcode.com/problems/sales-person/) | Easy | Database | [MySQL](problems/607-sales-person.sql) |
| [608. Tree Node](https://leetcode.com/problems/tree-node/) | Medium | Database | [MySQL](problems/608-tree-node.sql) |
| [609. Find Duplicate File in System](https://leetcode.com/problems/find-duplicate-file-in-system/) | Medium | Array; Hash Table; String | [Rust](problems/609-find-duplicate-file-in-system.rs) |
| [617. Merge Two Binary Trees](https://leetcode.com/problems/merge-two-binary-trees/) | Easy | Tree; Depth-First Search; Breadth-First Search; Binary Tree | [C++](problems/617-merge-two-binary-trees.cpp) |
| [620. Not Boring Movies](https://leetcode.com/problems/not-boring-movies/) | Easy | Database | [MySQL](problems/620-not-boring-movies.sql) |
| [626. Exchange Seats](https://leetcode.com/problems/exchange-seats/) | Medium | Database | [MySQL](problems/626-exchange-seats.sql) |
| [627. Swap Salary](https://leetcode.com/problems/swap-salary/) | Easy | Database | [MySQL](problems/627-swap-salary.sql) |
| [628. Maximum Product of Three Numbers](https://leetcode.com/problems/maximum-product-of-three-numbers/) | Easy | Array; Math; Sorting | [Go](problems/628-maximum-product-of-three-numbers.go) |
| [643. Maximum Average Subarray I](https://leetcode.com/problems/maximum-average-subarray-i/) | Easy | Array; Sliding Window | [Ruby](problems/643-maximum-average-subarray-i.rb) |
| [645. Set Mismatch](https://leetcode.com/problems/set-mismatch/) | Easy | Array; Hash Table; Bit Manipulation; Sorting | [C++](problems/645-set-mismatch.cpp) |
| [647. Palindromic Substrings](https://leetcode.com/problems/palindromic-substrings/) | Medium | String; Dynamic Programming | [JavaScript](problems/647-palindromic-substrings.js) |
| [657. Robot Return to Origin](https://leetcode.com/problems/robot-return-to-origin/) | Easy | String; Simulation | [Rust](problems/657-robot-return-to-origin.rs) |
| [665. Non-decreasing Array](https://leetcode.com/problems/non-decreasing-array/) | Medium | Array | [C++](problems/665-non-decreasing-array.cpp) |
| [680. Valid Palindrome II](https://leetcode.com/problems/valid-palindrome-ii/) | Easy | Two Pointers; String; Greedy | [C](problems/680-valid-palindrome-ii.c) |
| [682. Baseball Game](https://leetcode.com/problems/baseball-game/) | Easy | Array; Stack; Simulation | [Rust](problems/682-baseball-game.rs) |
| [690. Employee Importance](https://leetcode.com/problems/employee-importance/) | Medium | Hash Table; Depth-First Search; Breadth-First Search | [Ruby](problems/690-employee-importance.rb) |
| [693. Binary Number with Alternating Bits](https://leetcode.com/problems/binary-number-with-alternating-bits/) | Easy | Bit Manipulation | [C++](problems/693-binary-number-with-alternating-bits.cpp) |
| [695. Max Area of Island](https://leetcode.com/problems/max-area-of-island/) | Medium | Array; Depth-First Search; Breadth-First Search; Union Find; Matrix | [Rust](problems/695-max-area-of-island.rs) |
| [697. Degree of an Array](https://leetcode.com/problems/degree-of-an-array/) | Easy | Array; Hash Table | [Ruby](problems/697-degree-of-an-array.rb) |
| [700. Search in a Binary Search Tree](https://leetcode.com/problems/search-in-a-binary-search-tree/) | Easy | Tree; Binary Search Tree; Binary Tree | [C](problems/700-search-in-a-binary-search-tree.c) |
| [703. Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream/) | Easy | Tree; Design; Binary Search Tree; Heap (Priority Queue); Binary Tree; Data Stream | [Rust](problems/703-kth-largest-element-in-a-stream.rs) |
| [704. Binary Search](https://leetcode.com/problems/binary-search/) | Easy | Array; Binary Search | [C](problems/704-binary-search.cpp) |
| [705. Design HashSet](https://leetcode.com/problems/design-hashset/) | Easy | Array; Hash Table; Linked List; Design; Hash Function | [Go](problems/705-design-hashset.go) |
| [706. Design HashMap](https://leetcode.com/problems/design-hashmap/) | Easy | Array; Hash Table; Linked List; Design; Hash Function | [C++](problems/706-design-hashmap.cpp) |
| [707. Design Linked List](https://leetcode.com/problems/design-linked-list/) | Medium | Linked List; Design | [C++](problems/707-design-linked-list.cpp) |
| [709. To Lower Case](https://leetcode.com/problems/to-lower-case/) | Easy | String | [C](problems/709-to-lower-case.c) |
| [717. 1-bit and 2-bit Characters](https://leetcode.com/problems/1-bit-and-2-bit-characters/) | Easy | Array | [C++](problems/717-1-bit-and-2-bit-characters.cpp) |
| [724. Find Pivot Index](https://leetcode.com/problems/find-pivot-index/) | Easy | Array; Prefix Sum | [C++](problems/724-find-pivot-index.cpp) |
| [728. Self Dividing Numbers](https://leetcode.com/problems/self-dividing-numbers/) | Easy | Math | [JavaScript](problems/728-self-dividing-numbers.js) |
| [739. Daily Temperatures](https://leetcode.com/problems/daily-temperatures/) | Medium | Array; Stack; Monotonic Stack | [C++](problems/739-daily-temperatures.cpp) / [JavaScript](problems/739-daily-temperatures.js) |
| [740. Delete and Earn](https://leetcode.com/problems/delete-and-earn/) | Medium | Array; Hash Table; Dynamic Programming | [JavaScript](problems/740-delete-and-earn.js) |
| [744. Find Smallest Letter Greater Than Target](https://leetcode.com/problems/