Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/zhongruoyu/leetcode
My LeetCode solutions.
https://github.com/zhongruoyu/leetcode
leetcode leetcode-solutions
Last synced: about 2 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 (about 4 years ago)
- Default Branch: main
- Last Pushed: 2023-02-05T08:40:11.000Z (almost 2 years ago)
- Last Synced: 2024-05-01T22:29:57.545Z (8 months 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/find-smallest-letter-greater-than-target/) | Easy | Array; Binary Search | [Ruby](problems/744-find-smallest-letter-greater-than-target.rb) |
| [746. Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs/) | Easy | Array; Dynamic Programming | [JavaScript](problems/746-min-cost-climbing-stairs.js) |
| [747. Largest Number At Least Twice of Others](https://leetcode.com/problems/largest-number-at-least-twice-of-others/) | Easy | Array; Sorting | [Ruby](problems/747-largest-number-at-least-twice-of-others.rb) |
| [748. Shortest Completing Word](https://leetcode.com/problems/shortest-completing-word/) | Easy | Array; Hash Table; String | [Ruby](problems/748-shortest-completing-word.rb) |
| [762. Prime Number of Set Bits in Binary Representation](https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation/) | Easy | Math; Bit Manipulation | [C++](problems/762-prime-number-of-set-bits-in-binary-representation.cpp) |
| [763. Partition Labels](https://leetcode.com/problems/partition-labels/) | Medium | Hash Table; Two Pointers; String; Greedy | [C](problems/763-partition-labels.c) |
| [771. Jewels and Stones](https://leetcode.com/problems/jewels-and-stones/) | Easy | Hash Table; String | [C](problems/771-jewels-and-stones.c) |
| [784. Letter Case Permutation](https://leetcode.com/problems/letter-case-permutation/) | Medium | String; Backtracking; Bit Manipulation | [Rust](problems/784-letter-case-permutation.rs) |
| [796. Rotate String](https://leetcode.com/problems/rotate-string/) | Easy | String; String Matching | [C](problems/796-rotate-string.c) |
| [797. All Paths From Source to Target](https://leetcode.com/problems/all-paths-from-source-to-target/) | Medium | Backtracking; Depth-First Search; Breadth-First Search; Graph | [Rust](problems/797-all-paths-from-source-to-target.rs) |
| [804. Unique Morse Code Words](https://leetcode.com/problems/unique-morse-code-words/) | Easy | Array; Hash Table; String | [C++](problems/804-unique-morse-code-words.cpp) |
| [806. Number of Lines To Write String](https://leetcode.com/problems/number-of-lines-to-write-string/) | Easy | Array; String | [Rust](problems/806-number-of-lines-to-write-string.rs) |
| [807. Max Increase to Keep City Skyline](https://leetcode.com/problems/max-increase-to-keep-city-skyline/) | Medium | Array; Greedy; Matrix | [Rust](problems/807-max-increase-to-keep-city-skyline.rs) |
| [810. Chalkboard XOR Game](https://leetcode.com/problems/chalkboard-xor-game/) | Hard | Array; Math; Bit Manipulation; Brainteaser; Game Theory | [C++](problems/810-chalkboard-xor-game.cpp) |
| [811. Subdomain Visit Count](https://leetcode.com/problems/subdomain-visit-count/) | Medium | Array; Hash Table; String; Counting | [JavaScript](problems/811-subdomain-visit-count.js) |
| [812. Largest Triangle Area](https://leetcode.com/problems/largest-triangle-area/) | Easy | Array; Math; Geometry | [Ruby](problems/812-largest-triangle-area.rb) |
| [817. Linked List Components](https://leetcode.com/problems/linked-list-components/) | Medium | Hash Table; Linked List | [C++](problems/817-linked-list-components.cpp) |
| [819. Most Common Word](https://leetcode.com/problems/most-common-word/) | Easy | Hash Table; String; Counting | [Ruby](problems/819-most-common-word.rb) |
| [821. Shortest Distance to a Character](https://leetcode.com/problems/shortest-distance-to-a-character/) | Easy | Array; Two Pointers; String | [Rust](problems/821-shortest-distance-to-a-character.rs) |
| [824. Goat Latin](https://leetcode.com/problems/goat-latin/) | Easy | String | [Rust](problems/824-goat-latin.rs) |
| [830. Positions of Large Groups](https://leetcode.com/problems/positions-of-large-groups/) | Easy | String | [C++](problems/830-positions-of-large-groups.cpp) |
| [832. Flipping an Image](https://leetcode.com/problems/flipping-an-image/) | Easy | Array; Two Pointers; Matrix; Simulation | [Go](problems/832-flipping-an-image.go) |
| [836. Rectangle Overlap](https://leetcode.com/problems/rectangle-overlap/) | Easy | Math; Geometry | [C++](problems/836-rectangle-overlap.cpp) |
| [841. Keys and Rooms](https://leetcode.com/problems/keys-and-rooms/) | Medium | Depth-First Search; Breadth-First Search; Graph | [Rust](problems/841-keys-and-rooms.rs) |
| [844. Backspace String Compare](https://leetcode.com/problems/backspace-string-compare/) | Easy | Two Pointers; String; Stack; Simulation | [Rust](problems/844-backspace-string-compare.rs) |
| [852. Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/) | Easy | Array; Binary Search | [C++](problems/852-peak-index-in-a-mountain-array.cpp) |
| [858. Mirror Reflection](https://leetcode.com/problems/mirror-reflection/) | Medium | Math; Geometry | [Rust](problems/858-mirror-reflection.rs) |
| [859. Buddy Strings](https://leetcode.com/problems/buddy-strings/) | Easy | Hash Table; String | [Ruby](problems/859-buddy-strings.rb) |
| [860. Lemonade Change](https://leetcode.com/problems/lemonade-change/) | Easy | Array; Greedy | [C++](problems/860-lemonade-change.cpp) |
| [861. Score After Flipping Matrix](https://leetcode.com/problems/score-after-flipping-matrix/) | Medium | Array; Greedy; Bit Manipulation; Matrix | [C++](problems/861-score-after-flipping-matrix.cpp) |
| [867. Transpose Matrix](https://leetcode.com/problems/transpose-matrix/) | Easy | Array; Matrix; Simulation | [C++](problems/867-transpose-matrix.cpp) |
| [868. Binary Gap](https://leetcode.com/problems/binary-gap/) | Easy | Bit Manipulation | [Ruby](problems/868-binary-gap.rb) |
| [876. Middle of the Linked List](https://leetcode.com/problems/middle-of-the-linked-list/) | Easy | Linked List; Two Pointers | [C](problems/876-middle-of-the-linked-list.c) / [C++](problems/876-middle-of-the-linked-list.cpp) |
| [877. Stone Game](https://leetcode.com/problems/stone-game/) | Medium | Array; Math; Dynamic Programming; Game Theory | [C](problems/877-stone-game.c) |
| [883. Projection Area of 3D Shapes](https://leetcode.com/problems/projection-area-of-3d-shapes/) | Easy | Array; Math; Geometry; Matrix | [JavaScript](problems/883-projection-area-of-3d-shapes.js) |
| [884. Uncommon Words from Two Sentences](https://leetcode.com/problems/uncommon-words-from-two-sentences/) | Easy | Hash Table; String | [Rust](problems/884-uncommon-words-from-two-sentences.rs) |
| [885. Spiral Matrix III](https://leetcode.com/problems/spiral-matrix-iii/) | Medium | Array; Matrix; Simulation | [Rust](problems/885-spiral-matrix-iii.rs) |
| [888. Fair Candy Swap](https://leetcode.com/problems/fair-candy-swap/) | Easy | Array; Hash Table; Binary Search; Sorting | [Rust](problems/888-fair-candy-swap.rs) |
| [890. Find and Replace Pattern](https://leetcode.com/problems/find-and-replace-pattern/) | Medium | Array; Hash Table; String | [C](problems/890-find-and-replace-pattern.c) |
| [896. Monotonic Array](https://leetcode.com/problems/monotonic-array/) | Easy | Array | [Ruby](problems/896-monotonic-array.rb) |
| [901. Online Stock Span](https://leetcode.com/problems/online-stock-span/) | Medium | Stack; Design; Monotonic Stack; Data Stream | [JavaScript](problems/901-online-stock-span.js) |
| [905. Sort Array By Parity](https://leetcode.com/problems/sort-array-by-parity/) | Easy | Array; Two Pointers; Sorting | [Rust](problems/905-sort-array-by-parity.rs) |
| [908. Smallest Range I](https://leetcode.com/problems/smallest-range-i/) | Easy | Array; Math | [C++](problems/908-smallest-range-i.cpp) |
| [914. X of a Kind in a Deck of Cards](https://leetcode.com/problems/x-of-a-kind-in-a-deck-of-cards/) | Easy | Array; Hash Table; Math; Counting; Number Theory | [Go](problems/914-x-of-a-kind-in-a-deck-of-cards.go) |
| [917. Reverse Only Letters](https://leetcode.com/problems/reverse-only-letters/) | Easy | Two Pointers; String | [Ruby](problems/917-reverse-only-letters.rb) |
| [921. Minimum Add to Make Parentheses Valid](https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/) | Medium | String; Stack; Greedy | [Rust](problems/921-minimum-add-to-make-parentheses-valid.rs) |
| [922. Sort Array By Parity II](https://leetcode.com/problems/sort-array-by-parity-ii/) | Easy | Array; Two Pointers; Sorting | [C](problems/922-sort-array-by-parity-ii.c) |
| [925. Long Pressed Name](https://leetcode.com/problems/long-pressed-name/) | Easy | Two Pointers; String | [Rust](problems/925-long-pressed-name.rs) |
| [929. Unique Email Addresses](https://leetcode.com/problems/unique-email-addresses/) | Easy | Array; Hash Table; String | [C](problems/929-unique-email-addresses.c) |
| [933. Number of Recent Calls](https://leetcode.com/problems/number-of-recent-calls/) | Easy | Design; Queue; Data Stream | [JavaScript](problems/933-number-of-recent-calls.js) |
| [937. Reorder Data in Log Files](https://leetcode.com/problems/reorder-data-in-log-files/) | Easy | Array; String; Sorting | [JavaScript](problems/937-reorder-data-in-log-files.js) |
| [938. Range Sum of BST](https://leetcode.com/problems/range-sum-of-bst/) | Easy | Tree; Depth-First Search; Binary Search Tree; Binary Tree | [C](problems/938-range-sum-of-bst.c) |
| [941. Valid Mountain Array](https://leetcode.com/problems/valid-mountain-array/) | Easy | Array | [C++](problems/941-valid-mountain-array.cpp) |
| [942. DI String Match](https://leetcode.com/problems/di-string-match/) | Easy | Array; Math; Two Pointers; String; Greedy | [C](problems/942-di-string-match.c) |
| [950. Reveal Cards In Increasing Order](https://leetcode.com/problems/reveal-cards-in-increasing-order/) | Medium | Array; Queue; Sorting; Simulation | [Rust](problems/950-reveal-cards-in-increasing-order.rs) |
| [961. N-Repeated Element in Size 2N Array](https://leetcode.com/problems/n-repeated-element-in-size-2n-array/) | Easy | Array; Hash Table | [C++](problems/961-n-repeated-element-in-size-2n-array.cpp) |
| [965. Univalued Binary Tree](https://leetcode.com/problems/univalued-binary-tree/) | Easy | Tree; Depth-First Search; Breadth-First Search; Binary Tree | [C++](problems/965-univalued-binary-tree.cpp) |
| [976. Largest Perimeter Triangle](https://leetcode.com/problems/largest-perimeter-triangle/) | Easy | Array; Math; Greedy; Sorting | [Go](problems/976-largest-perimeter-triangle.go) |
| [977. Squares of a Sorted Array](https://leetcode.com/problems/squares-of-a-sorted-array/) | Easy | Array; Two Pointers; Sorting | [C++](problems/977-squares-of-a-sorted-array.cpp) |
| [980. Unique Paths III](https://leetcode.com/problems/unique-paths-iii/) | Hard | Array; Backtracking; Bit Manipulation; Matrix | [Rust](problems/980-unique-paths-iii.rs) |
| [985. Sum of Even Numbers After Queries](https://leetcode.com/problems/sum-of-even-numbers-after-queries/) | Medium | Array; Simulation | [Rust](problems/985-sum-of-even-numbers-after-queries.rs) |
| [986. Interval List Intersections](https://leetcode.com/problems/interval-list-intersections/) | Medium | Array; Two Pointers | [Rust](problems/986-interval-list-intersections.rs) |
| [989. Add to Array-Form of Integer](https://leetcode.com/problems/add-to-array-form-of-integer/) | Easy | Array; Math | [Go](problems/989-add-to-array-form-of-integer.go) |
| [997. Find the Town Judge](https://leetcode.com/problems/find-the-town-judge/) | Easy | Array; Hash Table; Graph | [Ruby](problems/997-find-the-town-judge.rb) |
| [1002. Find Common Characters](https://leetcode.com/problems/find-common-characters/) | Easy | Array; Hash Table; String | [Rust](problems/1002-find-common-characters.rs) |
| [1005. Maximize Sum Of Array After K Negations](https://leetcode.com/problems/maximize-sum-of-array-after-k-negations/) | Easy | Array; Greedy; Sorting | [C++](problems/1005-maximize-sum-of-array-after-k-negations.cpp) |
| [1006. Clumsy Factorial](https://leetcode.com/problems/clumsy-factorial/) | Medium | Math; Stack; Simulation | [C](problems/1006-clumsy-factorial.c) |
| [1009. Complement of Base 10 Integer](https://leetcode.com/problems/complement-of-base-10-integer/) | Easy | Bit Manupulation | [C++](problems/1009-complement-of-base-10-integer.cpp) |
| [1010. Pairs of Songs With Total Durations Divisible by 60](https://leetcode.com/problems/pairs-of-songs-with-total-durations-divisible-by-60/) | Medium | Array; Hash Table; Counting | [C++](problems/1010-pairs-of-songs-with-total-durations-divisible-by-60.cpp) |
| [1013. Partition Array Into Three Parts With Equal Sum](https://leetcode.com/problems/partition-array-into-three-parts-with-equal-sum/) | Easy | Array; Greedy | [Rust](problems/1013-partition-array-into-three-parts-with-equal-sum.rs) |
| [1017. Convert to Base -2](https://leetcode.com/problems/convert-to-base-2/) | Medium | Math | [C++](problems/1017-convert-to-base-2.cpp) |
| [1018. Binary Prefix Divisible By 5](https://leetcode.com/problems/binary-prefix-divisible-by-5/) | Easy | Array | [C++](problems/1018-binary-prefix-divisible-by-5.cpp) |
| [1020. Number of Enclaves](https://leetcode.com/problems/number-of-enclaves/) | Medium | Array; Depth-First Search; Breadth-First Search; Union Find; Matrix | [Rust](problems/1020-number-of-enclaves.rs) |
| [1021. Remove Outermost Parentheses](https://leetcode.com/problems/remove-outermost-parentheses/) | Easy | String; Stack | [C++](problems/1021-remove-outermost-parentheses.cpp) |
| [1022. Sum of Root To Leaf Binary Numbers](https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers/) | Easy | Tree; Depth-First Search; Binary Tree | [C++](problems/1022-sum-of-root-to-leaf-binary-numbers.cpp) |
| [1025. Divisor Game](https://leetcode.com/problems/divisor-game/) | Easy | Math; Dynamic Programming; Brainteaser; Game Theory | [C](problems/1025-divisor-game.c) |
| [1033. Moving Stones Until Consecutive](https://leetcode.com/problems/moving-stones-until-consecutive/) | Medium | Math; Brainteaser | [Rust](problems/1033-moving-stones-until-consecutive.rs) |
| [1037. Valid Boomerang](https://leetcode.com/problems/valid-boomerang/) | Easy | Math; Geometry | [C](problems/1037-valid-boomerang.c) |
| [1046. Last Stone Weight](https://leetcode.com/problems/last-stone-weight/) | Easy | Array; Heap (Priority Queue) | [Rust](problems/1046-last-stone-weight.rs) |
| [1047. Remove All Adjacent Duplicates In String](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/) | Easy | String; Stack | [C](problems/1047-remove-all-adjacent-duplicates-in-string.c) |
| [1050. Actors and Directors Who Cooperated At Least Three Times](https://leetcode.com/problems/actors-and-directors-who-cooperated-at-least-three-times/) | Easy | Database | [MySQL](problems/1050-actors-and-directors-who-cooperated-at-least-three-times.sql) |
| [1051. Height Checker](https://leetcode.com/problems/height-checker/) | Easy | Array; Sorting; Counting Sort | [C](problems/1051-height-checker.c) |
| [1071. Greatest Common Divisor of Strings](https://leetcode.com/problems/greatest-common-divisor-of-strings/) | Easy | Math; String | [C](problems/1071-greatest-common-divisor-of-strings.c) |
| [1078. Occurrences After Bigram](https://leetcode.com/problems/occurrences-after-bigram/) | Easy | String | [Rust](problems/1078-occurrences-after-bigram.rs) |
| [1079. Letter Tile Possibilities](https://leetcode.com/problems/letter-tile-possibilities/) | Medium | String; Backtracking | [C++](problems/1079-letter-tile-possibilities.cpp) |
| [1084. Sales Analysis III](https://leetcode.com/problems/sales-analysis-iii/) | Easy | Database | [MySQL](problems/1084-sales-analysis-iii.sql) |
| [1103. Distribute Candies to People](https://leetcode.com/problems/distribute-candies-to-people/) | Easy | Math; Simulation | [Go](problems/1103-distribute-candies-to-people.go) |
| [1108. Defanging an IP Address](https://leetcode.com/problems/defanging-an-ip-address/) | Easy | String | [C](problems/1108-defanging-an-ip-address.c) |
| [1109. Corporate Flight Bookings](https://leetcode.com/problems/corporate-flight-bookings/) | Medium | Array; Prefix Sum | [C++](problems/1109-corporate-flight-bookings.cpp) |
| [1111. Maximum Nesting Depth of Two Valid Parentheses Strings](https://leetcode.com/problems/maximum-nesting-depth-of-two-valid-parentheses-strings/) | Medium | String; Stack | [Rust](problems/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.rs) |
| [1114. Print in Order](https://leetcode.com/problems/print-in-order/) | Easy | Concurrency | [Java](problems/1114-print-in-order.java) |
| [1115. Print FooBar Alternately](https://leetcode.com/problems/print-foobar-alternately/) | Medium | Concurrency | [Java](problems/1115-print-foobar-alternately.java) |
| [1116. Print Zero Even Odd](https://leetcode.com/problems/print-zero-even-odd/) | Medium | Concurrency | [Java](problems/1116-print-zero-even-odd.java) |
| [1122. Relative Sort Array](https://leetcode.com/problems/relative-sort-array/) | Easy | Array; Hash Table; Sorting; Counting Sort | [Rust](problems/1122-relative-sort-array.rs) |
| [1128. Number of Equivalent Domino Pairs](https://leetcode.com/problems/number-of-equivalent-domino-pairs/) | Easy | Array; Hash Table; Counting | [Rust](problems/1128-number-of-equivalent-domino-pairs.rs) |
| [1137. N-th Tribonacci Number](https://leetcode.com/problems/n-th-tribonacci-number/) | Easy | Math; Dynamic Programming; Memorization | [Go](problems/1137-n-th-tribonacci-number.go) |
| [1141. User Activity for the Past 30 Days I](https://leetcode.com/problems/user-activity-for-the-past-30-days-i/) | Easy | Database | [MySQL](problems/1141-user-activity-for-the-past-30-days-i.sql) |
| [1148. Article Views I](https://leetcode.com/problems/article-views-i/) | Easy | Database | [MySQL](problems/1148-article-views-i.sql) |
| [1154. Day of the Year](https://leetcode.com/problems/day-of-the-year/) | Easy | Math; String | [C](problems/1154-day-of-the-year.c) |
| [1158. Market Analysis I](https://leetcode.com/problems/market-analysis-i/) | Medium | Database | [MySQL](problems/1158-market-analysis-i.sql) |
| [1160. Find Words That Can Be Formed by Characters](https://leetcode.com/problems/find-words-that-can-be-formed-by-characters/) | Easy | Array; Hash Table; String | [C++](problems/1160-find-words-that-can-be-formed-by-characters.cpp) |
| [1175. Prime Arrangements](https://leetcode.com/problems/prime-arrangements/) | Easy | Math | [C++](problems/1175-prime-arrangements.cpp) |
| [1179. Reformat Department Table](https://leetcode.com/problems/reformat-department-table/) | Easy | Database | [MySQL](problems/1179-reformat-department-table.sql) |
| [1184. Distance Between Bus Stops](https://leetcode.com/problems/distance-between-bus-stops/) | Easy | Array | [Rust](problems/1184-distance-between-bus-stops.rs) |
| [1185. Day of the Week](https://leetcode.com/problems/day-of-the-week/) | Easy | Math | [Go](problems/1185-day-of-the-week.go) |
| [1189. Maximum Number of Balloons](https://leetcode.com/problems/maximum-number-of-balloons/) | Easy | Hash Table; String; Counting | [C++](problems/1189-maximum-number-of-balloons.cpp) |
| [1195. Fizz Buzz Multithreaded](https://leetcode.com/problems/fizz-buzz-multithreaded/) | Medium | Concurrency | [Java](problems/1195-fizz-buzz-multithreaded.java) / [C++](problems/1195-fizz-buzz-multithreaded.cpp) |
| [1200. Minimum Absolute Difference](https://leetcode.com/problems/minimum-absolute-difference/) | Easy | Array; Sorting | [Rust](problems/1200-minimum-absolute-difference.rs) |
| [1207. Unique Number of Occurrences](https://leetcode.com/problems/unique-number-of-occurrences/) | Easy | Array; Hash Table | [C++](problems/1207-unique-number-of-occurrences.cpp) |
| [1217. Minimum Cost to Move Chips to The Same Position](https://leetcode.com/problems/minimum-cost-to-move-chips-to-the-same-position/) | Easy | Array; Math; Greedy | [Go](problems/1217-minimum-cost-to-move-chips-to-the-same-position.go) |
| [1221. Split a String in Balanced Strings](https://leetcode.com/problems/split-a-string-in-balanced-strings/) | Easy | String; Greedy; Counting | [C](problems/1221-split-a-string-in-balanced-strings.c) |
| [1222. Queens That Can Attack the King](https://leetcode.com/problems/queens-that-can-attack-the-king/) | Medium | Array; Matrix; Simulation | [Rust](problems/1222-queens-that-can-attack-the-king.rs) |
| [1226. The Dining Philosophers](https://leetcode.com/problems/the-dining-philosophers/) | Medium | Concurrency | [Java](problems/1226-the-dining-philosophers.java) |
| [1227. Airplane Seat Assignment Probability](https://leetcode.com/problems/airplane-seat-assignment-probability/) | Medium | Math; Dynamic Programming; Brainteaser; Probability and Statistics | [Rust](problems/1227-airplane-seat-assignment-probability.rs) |
| [1232. Check If It Is a Straight Line](https://leetcode.com/problems/check-if-it-is-a-straight-line/) | Easy | Array; Math; Geometry | [C](problems/1232-check-if-it-is-a-straight-line.c) |
| [1238. Circular Permutation in Binary Representation](https://leetcode.com/problems/circular-permutation-in-binary-representation/) | Medium | Math; Backtracking; Manipulation | [C](problems/1238-circular-permutation-in-binary-representation.c) |
| [1252. Cells with Odd Values in a Matrix](https://leetcode.com/problems/cells-with-odd-values-in-a-matrix/) | Easy | Array; Math; Simulation | [Rust](problems/1252-cells-with-odd-values-in-a-matrix.rs) |
| [1254. Number of Closed Islands](https://leetcode.com/problems/number-of-closed-islands/) | Medium | Array; Depth-First Search; Breadth-First Search; Union Find; Matrix | [Rust](problems/1254-number-of-closed-islands.rs) |
| [1266. Minimum Time Visiting All Points](https://leetcode.com/problems/minimum-time-visiting-all-points/) | Easy | Array; Math; Geometry | [Rust](problems/1266-minimum-time-visiting-all-points.rs) |
| [1277. Count Square Submatrices with All Ones](https://leetcode.com/problems/count-square-submatrices-with-all-ones/) | Medium | Array; Dynamic Programming; Matrix | [Rust](problems/1277-count-square-submatrices-with-all-ones.rs) |
| [1281. Subtract the Product and Sum of Digits of an Integer](https://leetcode.com/problems/subtract-the-product-and-sum-of-digits-of-an-integer/) | Easy | Math | [C](problems/1281-subtract-the-product-and-sum-of-digits-of-an-integer.c) |
| [1282. Group the People Given the Group Size They Belong To](https://leetcode.com/problems/group-the-people-given-the-group-size-they-belong-to/) | Medium | Array; Hash Table | [Rust](problems/1282-group-the-people-given-the-group-size-they-belong-to.rs) |
| [1290. Convert Binary Number in a Linked List to Integer](https://leetcode.com/problems/convert-binary-number-in-a-linked-list-to-integer/) | Easy | Linked List; Math | [C](problems/1290-convert-binary-number-in-a-linked-list-to-integer.c) |
| [1295. Find Numbers with Even Number of Digits](https://leetcode.com/problems/find-numbers-with-even-number-of-digits/) | Easy | Array | [C](problems/1295-find-numbers-with-even-number-of-digits.c) |
| [1299. Replace Elements with Greatest Element on Right Side](https://leetcode.com/problems/replace-elements-with-greatest-element-on-right-side/) | Easy | Array | [Rust](problems/1299-replace-elements-with-greatest-element-on-right-side.rs) |
| [1302. Deepest Leaves Sum](https://leetcode.com/problems/deepest-leaves-sum/) | Medium | Tree; Depth-First Search; Breadth-First Search; Binary Tree | [C++](problems/1302-deepest-leaves-sum.cpp) |
| [1304. Find N Unique Integers Sum up to Zero](https://leetcode.com/problems/find-n-unique-integers-sum-up-to-zero/) | Easy | Array; Math | [C](problems/1304-find-n-unique-integers-sum-up-to-zero.c) |
| [1309. Decrypt String from Alphabet to Integer Mapping](https://leetcode.com/problems/decrypt-string-from-alphabet-to-integer-mapping/) | Easy | String | [C](problems/1309-decrypt-string-from-alphabet-to-integer-mapping.c) |
| [1310. XOR Queries of a Subarray](https://leetcode.com/problems/xor-queries-of-a-subarray/) | Medium | Array; Bit Manipulation; Prefix Sum | [Rust](problems/1310-xor-queries-of-a-subarray.rs) |
| [1313. Decompress Run-Length Encoded List](https://leetcode.com/problems/decompress-run-length-encoded-list/) | Easy | Array | [C](problems/1313-decompress-run-length-encoded-list.c) |
| [1314. Matrix Block Sum](https://leetcode.com/problems/matrix-block-sum/) | Medium | Array; Matrix; Prefix Sum | [Rust](problems/1314-matrix-block-sum.rs) |
| [1318. Minimum Flips to Make a OR b Equal to c](https://leetcode.com/problems/minimum-flips-to-make-a-or-b-equal-to-c/) | Medium | Bit Manipulation | [Rust](problems/1318-minimum-flips-to-make-a-or-b-equal-to-c.rs) |
| [1319. Number of Operations to Make Network Connected](https://leetcode.com/problems/number-of-operations-to-make-network-connected/) | Medium | Depth-First Search; Breadth-First Search; Union Find; Graph | [C++](problems/1319-number-of-operations-to-make-network-connected.cpp) |
| [1323. Maximum 69 Number](https://leetcode.com/problems/maximum-69-number/) | Easy | Math; Greedy | [C](problems/1323-maximum-69-number.c) |
| [1329. Sort the Matrix Diagonally](https://leetcode.com/problems/sort-the-matrix-diagonally/) | Medium | Array; Sorting; Matrix | [C++](problems/1329-sort-the-matrix-diagonally.cpp) |
| [1331. Rank Transform of an Array](https://leetcode.com/problems/rank-transform-of-an-array/) | Easy | Array; Hash Table; Sorting | [C++](problems/1331-rank-transform-of-an-array.cpp) |
| [1332. Remove Palindromic Subsequences](https://leetcode.com/problems/remove-palindromic-subsequences/) | Easy | Two Pointers; String | [Rust](problems/1332-remove-palindromic-subsequences.rs) |
| [1337. The K Weakest Rows in a Matrix](https://leetcode.com/problems/the-k-weakest-rows-in-a-matrix/) | Easy | Array; Binary Search; Sorting; Heap (Priority Queue); Matrix | [C++](problems/1337-the-k-weakest-rows-in-a-matrix.cpp) |
| [1342. Number of Steps to Reduce a Number to Zero](https://leetcode.com/problems/number-of-steps-to-reduce-a-number-to-zero/) | Easy | Math; Bit Manipulation | [C](problems/1342-number-of-steps-to-reduce-a-number-to-zero.c) |
| [1344. Angle Between Hands of a Clock](https://leetcode.com/problems/angle-between-hands-of-a-clock/) | Medium | Math | [C](problems/1344-angle-between-hands-of-a-clock.c) |
| [1347. Minimum Number of Steps to Make Two Strings Anagram](https://leetcode.com/problems/minimum-number-of-steps-to-make-two-strings-anagram/) | Medium | Hash Table; String; Counting | [Rust](problems/1347-minimum-number-of-steps-to-make-two-strings-anagram.rs) |
| [1351. Count Negative Numbers in a Sorted Matrix](https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/) | Easy | Array; Binary Search; Matrix | [Rust](problems/1351-count-negative-numbers-in-a-sorted-matrix.rs) |
| [1356. Sort Integers by The Number of 1 Bits](https://leetcode.com/problems/sort-integers-by-the-number-of-1-bits/) | Easy | Array; Bit Manipulation; Sorting; Counting | [Rust](problems/1356-sort-integers-by-the-number-of-1-bits.rs) |
| [1360. Number of Days Between Two Dates](https://leetcode.com/problems/number-of-days-between-two-dates/) | Easy | Math; String | [Go](problems/1360-number-of-days-between-two-dates.go) |
| [1362. Closest Divisors](https://leetcode.com/problems/closest-divisors/) | Medium | Math | [C++](problems/1362-closest-divisors.cpp) |
| [1365. How Many Numbers Are Smaller Than the Current Number](https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/) | Easy | Array; Hash Table; Sorting; Counting | [C++](problems/1365-how-many-numbers-are-smaller-than-the-current-number.cpp) |
| [1370. Increasing Decreasing String](https://leetcode.com/problems/increasing-decreasing-string/) | Easy | Hash Table; String; Counting | [Rust](problems/1370-increasing-decreasing-string.rs) |
| [1374. Generate a String With Characters That Have Odd Counts](https://leetcode.com/problems/generate-a-string-with-characters-that-have-odd-counts/) | Easy | String | [C](problems/1374-generate-a-string-with-characters-that-have-odd-counts.c) |
| [1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://leetcode.com/problems/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/) | Easy | Tree; Depth-First Search; Breadth-First Search; Binary Tree | [C++](problems/1379-find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree.cpp) |
| [1381. Design a Stack With Increment Operation](https://leetcode.com/problems/design-a-stack-with-increment-operation/) | Medium | Array; Stack; Design | [C++](problems/1381-design-a-stack-with-increment-operation.cpp) |
| [1389. Create Target Array in the Given Order](https://leetcode.com/problems/create-target-array-in-the-given-order/) | Easy | Array; Simulation | [C++](problems/1389-create-target-array-in-the-given-order.cpp) |
| [1393. Capital Gain/Loss](https://leetcode.com/problems/capital-gainloss/) | Medium | Database | [MySQL](problems/1393-capital-gainloss.sql) |
| [1394. Find Lucky Integer in an Array](https://leetcode.com/problems/find-lucky-integer-in-an-array/) | Easy | Array; Hash Table; Counting | [Rust](problems/1394-find-lucky-integer-in-an-array.rs) |
| [1395. Count Number of Teams](https://leetcode.com/problems/count-number-of-teams/) | Medium | Array; Dynamic Programming; Binary Indexed Tree | [C](problems/1395-count-number-of-teams.c) |
| [1396. Design Underground System](https://leetcode.com/problems/design-underground-system/) | Medium | Hash Table; String; Design | [JavaScript](problems/1396-design-underground-system.js) |
| [1399. Count Largest Group](https://leetcode.com/problems/count-largest-group/) | Easy | Hash Table; Math | [Rust](problems/1399-count-largest-group.rs) |
| [1403. Minimum Subsequence in Non-Increasing Order](https://leetcode.com/problems/minimum-subsequence-in-non-increasing-order/) | Easy | Array; Greedy; Sorting | [Rust](problems/1403-minimum-subsequence-in-non-increasing-order.rs) |
| [1407. Top Travellers](https://leetcode.com/problems/top-travellers/) | Easy | Database | [MySQL](problems/1407-top-travellers.sql) |
| [1402. Reducing Dishes](https://leetcode.com/problems/reducing-dishes/) | Hard | Array; Dynamic Programming; Greedy; Sorting | [Rust](problems/1402-reducing-dishes.rs) |
| [1413. Minimum Value to Get Positive Step by Step Sum](https://leetcode.com/problems/minimum-value-to-get-positive-step-by-step-sum/) | Easy | Array; Prefix Sum | [Rust](problems/1413-minimum-value-to-get-positive-step-by-step-sum.rs) |
| [1418. Display Table of Food Orders in a Restaurant](https://leetcode.com/problems/display-table-of-food-orders-in-a-restaurant/) | Medium | Array; Hash Table; String; Sorting; Ordered Set | [Rust](problems/1418-display-table-of-food-orders-in-a-restaurant.rs) |
| [1431. Kids With the Greatest Number of Candies](https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/) | Easy | Array | [C](problems/1431-kids-with-the-greatest-number-of-candies.c) |
| [1436. Destination City](https://leetcode.com/problems/destination-city/) | Easy | Hash Table; String | [Rust](problems/1436-destination-city.rs) |
| [1447. Simplified Fractions](https://leetcode.com/problems/simplified-fractions/) | Medium | Math | [C++](problems/1447-simplified-fractions.cpp) |
| [1450. Number of Students Doing Homework at a Given Time](https://leetcode.com/problems/number-of-students-doing-homework-at-a-given-time/) | Easy | Array | [C](problems/1450-number-of-students-doing-homework-at-a-given-time.c) |
| [1455. Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://leetcode.com/problems/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/) | Easy | String; String Matching | [Rust](problems/1455-check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.rs) |
| [1460. Make Two Arrays Equal by Reversing Subarrays](https://leetcode.com/problems/make-two-arrays-equal-by-reversing-subarrays/) | Easy | Array; Hash Table; Sorting | [Rust](problems/1460-make-two-arrays-equal-by-reversing-subarrays.rs) |
| [1464. Maximum Product of Two Elements in an Array](https://leetcode.com/problems/maximum-product-of-two-elements-in-an-array/) | Easy | Array; Sorting; Heap (Priority Queue) | [C](problems/1464-maximum-product-of-two-elements-in-an-array.c) |
| [1470. Shuffle the Array](https://leetcode.com/problems/shuffle-the-array/) | Easy | Array | [C](problems/1470-shuffle-the-array.c) |
| [1472. Design Browser History](https://leetcode.com/problems/design-browser-history/) | Medium | Array; Linked List; Stack; Design; Doubly-Linked List; Data Stream | [JavaScript](problems/1472-design-browser-history.js) |
| [1475. Final Prices With a Special Discount in a Shop](https://leetcode.com/problems/final-prices-with-a-special-discount-in-a-shop/) | Easy | Array; Stack; Monotonic Stack | [Rust](problems/1475-final-prices-with-a-special-discount-in-a-shop.rs) |
| [1476. Subrectangle Queries](https://leetcode.com/problems/subrectangle-queries/) | Medium | Array; Design; Matrix | [C++](problems/1476-subrectangle-queries.cpp) |
| [1480. Running Sum of 1d Array](https://leetcode.com/problems/running-sum-of-1d-array/) | Easy | Array; Prefix Sum | [C](problems/1480-running-sum-of-1d-array.c) |
| [1484. Group Sold Products By The Date](https://leetcode.com/problems/group-sold-products-by-the-date/) | Easy | Database | [MySQL](problems/1484-group-sold-products-by-the-date.sql) |
| [1486. XOR Operation in an Array](https://leetcode.com/problems/xor-operation-in-an-array/) | Easy | Math; Bit Manipulation | [C](problems/1486-xor-operation-in-an-array.c) |
| [1492. The kth Factor of n](https://leetcode.com/problems/the-kth-factor-of-n/) | Medium | Math | [C](problems/1492-the-kth-factor-of-n.c) |
| [1502. Can Make Arithmetic Progression From Sequence](https://leetcode.com/problems/can-make-arithmetic-progression-from-sequence/) | Easy | Array; Sorting | [Rust](problems/1502-can-make-arithmetic-progression-from-sequence.rs) |
| [1503. Last Moment Before All Ants Fall Out of a Plank](https://leetcode.com/problems/last-moment-before-all-ants-fall-out-of-a-plank/) | Medium | Array; Brainteaser; Simulation | [Rust](problems/1503-last-moment-before-all-ants-fall-out-of-a-plank.rs) |
| [1512. Number of Good Pairs](https://leetcode.com/problems/number-of-good-pairs/) | Easy | Array; Hash Table; Math; Counting | [C++](problems/1512-number-of-good-pairs.cpp) |
| [1518. Water Bottles](https://leetcode.com/problems/water-bottles/) | Easy | Math; Simulation | [Go](problems/1518-water-bottles.go) |
| [1523. Count Odd Numbers in an Interval Range](https://leetcode.com/problems/count-odd-numbers-in-an-interval-range/) | Easy | Math | [C](problems/1523-count-odd-numbers-in-an-interval-range.c) |
| [1527. Patients With a Condition](https://leetcode.com/problems/patients-with-a-condition/) | Easy | Database | [MySQL](problems/1527-patients-with-a-condition.sql) |
| [1528. Shuffle String](https://leetcode.com/problems/shuffle-string/) | Easy | Array; String | [C](problems/1528-shuffle-string.c) |
| [1529. Minimum Suffix Flips](https://leetcode.com/problems/minimum-suffix-flips/) | Medium | String; Greedy | [Rust](problems/1529-minimum-suffix-flips.rs) |
| [1550. Three Consecutive Odds](https://leetcode.com/problems/three-consecutive-odds/) | Easy | Array | [C](problems/1550-three-consecutive-odds.c) |
| [1551. Minimum Operations to Make Array Equal](https://leetcode.com/problems/minimum-operations-to-make-array-equal/) | Medium | Math | [C](problems/1551-minimum-operations-to-make-array-equal.c) |
| [1557. Minimum Number of Vertices to Reach All Nodes](https://leetcode.com/problems/minimum-number-of-vertices-to-reach-all-nodes/) | Medium | Graph | [Rust](problems/1557-minimum-number-of-vertices-to-reach-all-nodes.rs) |
| [1561. Maximum Number of Coins You Can Get](https://leetcode.com/problems/maximum-number-of-coins-you-can-get/) | Medium | Array; Math; Greedy; Sorting; Game Theory | [Rust](problems/1561-maximum-number-of-coins-you-can-get.rs) |
| [1566. Detect Pattern of Length M Repeated K or More Times](https://leetcode.com/problems/detect-pattern-of-length-m-repeated-k-or-more-times/) | Easy | Array; Enumeration | [C++](problems/1566-detect-pattern-of-length-m-repeated-k-or-more-times.cpp) |
| [1572. Matrix Diagonal Sum](https://leetcode.com/problems/matrix-diagonal-sum/) | Easy | Array; Matrix | [Rust](problems/1572-matrix-diagonal-sum.rs) |
| [1576. Replace All ?'s to Avoid Consecutive Repeating Characters](https://leetcode.com/problems/replace-all-s-to-avoid-consecutive-repeating-characters/) | Easy | String | [C](problems/1576-replace-all-s-to-avoid-consecutive-repeating-characters.c) |
| [1581. Customer Who Visited but Did Not Make Any Transactions](https://leetcode.com/problems/customer-who-visited-but-did-not-make-any-transactions/) | Easy | Database | [MySQL](problems/1581-customer-who-visited-but-did-not-make-any-transactions.sql) |
| [1587. Bank Account Summary II](https://leetcode.com/problems/bank-account-summary-ii/) | Easy | Database | [MySQL](problems/1587-bank-account-summary-ii.sql) |
| [1588. Sum of All Odd Length Subarrays](https://leetcode.com/problems/sum-of-all-odd-length-subarrays/) | Easy | Array; Math; Prefix Sum | [C](problems/1588-sum-of-all-odd-length-subarrays.c) |
| [1598. Crawler Log Folder](https://leetcode.com/problems/crawler-log-folder/) | Easy | Array; String; Stack | [Rust](problems/1598-crawler-log-folder.rs) |
| [1603. Design Parking System](https://leetcode.com/problems/design-parking-system/) | Easy | Design; Simulation; Counting | [C++](problems/1603-design-parking-system.cpp) |
| [1605. Find Valid Matrix Given Row and Column Sums](https://leetcode.com/problems/find-valid-matrix-given-row-and-column-sums/) | Medium | Array; Greedy; Matrix | [Rust](problems/1605-find-valid-matrix-given-row-and-column-sums.rs) |
| [1608. Special Array With X Elements Greater Than or Equal X](https://leetcode.com/problems/special-array-with-x-elements-greater-than-or-equal-x/) | Easy | Array; Binary Search; Sorting | [C++](problems/1608-special-array-with-x-elements-greater-than-or-equal-x.cpp) |
| [1614. Maximum Nesting Depth of the Parentheses](https://leetcode.com/problems/maximum-nesting-depth-of-the-parentheses/) | Easy | String; Stack | [C++](problems/1614-maximum-nesting-depth-of-the-parentheses.cpp) |
| [1637. Widest Vertical Area Between Two Points Containing No Points](https://leetcode.com/problems/widest-vertical-area-between-two-points-containing-no-points/) | Medium | Array; Sorting | [C++](problems/1637-widest-vertical-area-between-two-points-containing-no-points.cpp) |
| [1641. Count Sorted Vowel Strings](https://leetcode.com/problems/count-sorted-vowel-strings/) | Medium | Dynamic Programming | [C](problems/1641-count-sorted-vowel-strings.c) |
| [1646. Get Maximum in Generated Array](https://leetcode.com/problems/get-maximum-in-generated-array/) | Easy | Array; Dynamic Programming; Simulation | [C++](problems/1646-get-maximum-in-generated-array.cpp) |
| [1656. Design an Ordered Stream](https://leetcode.com/problems/design-an-ordered-stream/) | Easy | Array; Hash Table; Design; Data Stream | [C++](problems/1656-design-an-ordered-stream.cpp) |
| [1662. Check If Two String Arrays are Equivalent](https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/) | Easy | Array; String | [C++](problems/1662-check-if-two-string-arrays-are-equivalent.cpp) |
| [1667. Fix Names in a Table](https://leetcode.com/problems/fix-names-in-a-table/) | Easy | Database | [MySQL](problems/1667-fix-names-in-a-table.sql) |
| [1668. Maximum Repeating Substring](https://leetcode.com/problems/maximum-repeating-substring/) | Easy | String; String Matching | [C++](problems/1668-maximum-repeating-substring.cpp) |
| [1669. Merge In Between Linked Lists](https://leetcode.com/problems/merge-in-between-linked-lists/) | Medium | Linked List | [C](problems/1669-merge-in-between-linked-lists.c) |
| [1672. Richest Customer Wealth](https://leetcode.com/problems/richest-customer-wealth/) | Easy | Array; Matrix | [C++](problems/1672-richest-customer-wealth.cpp) |
| [1678. Goal Parser Interpretation](https://leetcode.com/problems/goal-parser-interpretation/) | Easy | String | [C++](problems/1678-goal-parser-interpretation.cpp) |
| [1680. Concatenation of Consecutive Binary Numbers](https://leetcode.com/problems/concatenation-of-consecutive-binary-numbers/) | Medium | Math; Bit Manipulation; Simulation | [C++](problems/1680-concatenation-of-consecutive-binary-numbers.cpp) |
| [1684. Count the Number of Consistent Strings](https://leetcode.com/problems/count-the-number-of-consistent-strings/) | Easy | Array; Hash Table; String; Bit Manipulation | [C++](problems/1684-count-the-number-of-consistent-strings.cpp) |
| [1688. Count of Matches in Tournament](https://leetcode.com/problems/count-of-matches-in-tournament/) | Easy | Math; Simulation | [C++](problems/1688-count-of-matches-in-tournament.cpp) |
| [1689. Partitioning Into Minimum Number Of Deci-Binary Numbers](https://leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers/) | Medium | String; Greedy | [C++](problems/1689-partitioning-into-minimum-number-of-deci-binary-numbers.cpp) |
| [1693. Daily Leads and Partners](https://leetcode.com/problems/daily-leads-and-partners/) | Easy | Database | [MySQL](problems/1693-daily-leads-and-partners.sql) |
| [1694. Reformat Phone Number](https://leetcode.com/problems/reformat-phone-number/) | Easy | String | [C++](problems/1694-reformat-phone-number.cpp) |
| [1700. Number of Students Unable to Eat Lunch](https://leetcode.com/problems/number-of-students-unable-to-eat-lunch/) | Easy | Array; Stack; Queue; Simulation | [C++](problems/1700-number-of-students-unable-to-eat-lunch.cpp) |
| [1704. Determine if String Halves Are Alike](https://leetcode.com/problems/determine-if-string-halves-are-alike/) | Easy | String; Counting | [C++](problems/1704-determine-if-string-halves-are-alike.cpp) |
| [1706. Where Will the Ball Fall](https://leetcode.com/problems/where-will-the-ball-fall/) | Medium | Array; Dynamic Programming; Depth-First Search; Matrix; Simulation | [Go](problems/1706-where-will-the-ball-fall.go) |
| [1710. Maximum Units on a Truck](https://leetcode.com/problems/maximum-units-on-a-truck/) | Easy | Array; Greedy; Sorting | [C++](problems/1710-maximum-units-on-a-truck.cpp) |
| [1716. Calculate Money in Leetcode Bank](https://leetcode.com/problems/calculate-money-in-leetcode-bank/) | Easy | Math | [C++](problems/1716-calculate-money-in-leetcode-bank.cpp) |
| [1720. Decode XORed Array](https://leetcode.com/problems/decode-xored-array/) | Easy | Array; Bit Manipulation | [C++](problems/1720-decode-xored-array.cpp) |
| [1721. Swapping Nodes in a Linked List](https://leetcode.com/problems/swapping-nodes-in-a-linked-list/) | Medium | Linked List; Two Pointers | [C++](problems/1721-swapping-nodes-in-a-linked-list.cpp) |
| [1725. Number Of Rectangles That Can Form The Largest Square](https://leetcode.com/problems/number-of-rectangles-that-can-form-the-largest-square/) | Easy | Array | [C++](problems/1725-number-of-rectangles-that-can-form-the-largest-square.cpp) |
| [1726. Tuple with Same Product](https://leetcode.com/problems/tuple-with-same-product/) | Medium | Array; Hash Table | [C++](problems/1726-tuple-with-same-product.cpp) |
| [1729. Find Followers Count](https://leetcode.com/problems/find-followers-count/) | Easy | Database | [MySQL](problems/1729-find-followers-count.sql) |
| [1732. Find the Highest Altitude](https://leetcode.com/problems/find-the-highest-altitude/) | Easy | Array; Prefix Sum | [C++](problems/1732-find-the-highest-altitude.cpp) |
| [1736. Latest Time by Replacing Hidden Digits](https://leetcode.com/problems/latest-time-by-replacing-hidden-digits/) | Easy | String; Greedy | [C++](problems/1736-latest-time-by-replacing-hidden-digits.cpp) |
| [1741. Find Total Time Spent by Each Employee](https://leetcode.com/problems/find-total-time-spent-by-each-employee/) | Easy | Database | [MySQL](problems/1741-find-total-time-spent-by-each-employee.sql) |
| [1742. Maximum Number of Balls in a Box](https://leetcode.com/problems/maximum-number-of-balls-in-a-box/) | Easy | Hash Table; Math; Counting | [C++](problems/1742-maximum-number-of-balls-in-a-box.cpp) |
| [1748. Sum of Unique Elements](https://leetcode.com/problems/sum-of-unique-elements/) | Easy | Array; Hash Table; Counting | [C++](problems/1748-sum-of-unique-elements.cpp) |
| [1752. Check if Array Is Sorted and Rotated](https://leetcode.com/problems/check-if-array-is-sorted-and-rotated/) | Easy | Array | [C++](problems/1752-check-if-array-is-sorted-and-rotated.cpp) |
| [1757. Recyclable and Low Fat Products](https://leetcode.com/problems/recyclable-and-low-fat-products/) | Easy | Database | [MySQL](problems/1757-recyclable-and-low-fat-products.sql) |
| [1758. Minimum Changes To Make Alternating Binary String](https://leetcode.com/problems/minimum-changes-to-make-alternating-binary-string/) | Easy | String | [C++](problems/1758-minimum-changes-to-make-alternating-binary-string.cpp) |
| [1768. Merge Strings Alternately](https://leetcode.com/problems/merge-strings-alternately/) | Easy | Two Pointers; String | [C++](problems/1768-merge-strings-alternately.cpp) |
| [1769. Minimum Number of Operations to Move All Balls to Each Box](https://leetcode.com/problems/minimum-number-of-operations-to-move-all-balls-to-each-box/) | Medium | Array; String | [Rust](problems/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.rs) |
| [1773. Count Items Matching a Rule](https://leetcode.com/problems/count-items-matching-a-rule/) | Easy | Array; String | [C++](problems/1773-count-items-matching-a-rule.cpp) |
| [1779. Find Nearest Point That Has the Same X or Y Coordinate](https://leetcode.com/problems/find-nearest-point-that-has-the-same-x-or-y-coordinate/) | Easy | Array | [C++](problems/1779-find-nearest-point-that-has-the-same-x-or-y-coordinate.cpp) |
| [1784. Check if Binary String Has at Most One Segment of Ones](https://leetcode.com/problems/check-if-binary-string-has-at-most-one-segment-of-ones/) | Easy | String | [C++](problems/1784-check-if-binary-string-has-at-most-one-segment-of-ones.cpp) |
| [1790. Check if One String Swap Can Make Strings Equal](https://leetcode.com/problems/check-if-one-string-swap-can-make-strings-equal/) | Easy | Hash Table; String; Counting | [C++](problems/1790-check-if-one-string-swap-can-make-strings-equal.cpp) |
| [1791. Find Center of Star Graph](https://leetcode.com/problems/find-center-of-star-graph/submissions/) | Easy | Graph | [Rust](problems/1791-find-center-of-star-graph.rs) |
| [1795. Rearrange Products Table](https://leetcode.com/problems/rearrange-products-table/) | Easy | Database | [MySQL](problems/1795-rearrange-products-table.sql) |
| [1796. Second Largest Digit in a String](https://leetcode.com/problems/second-largest-digit-in-a-string/) | Easy | Hash Table; String | [C++](problems/1796-second-largest-digit-in-a-string.cpp) |
| [1797. Design Authentication Manager](https://leetcode.com/problems/design-authentication-manager/) | Medium | Hash Table; Design | [JavaScript](problems/1797-design-authentication-manager.js) |
| [1800. Maximum Ascending Subarray Sum](https://leetcode.com/problems/maximum-ascending-subarray-sum/) | Easy | Array | [C++](problems/1800-maximum-ascending-subarray-sum.cpp) |
| [1807. Evaluate the Bracket Pairs of a String](https://leetcode.com/problems/evaluate-the-bracket-pairs-of-a-string/) | Medium | Array; Hash Table; String | [Rust](problems/1807-evaluate-the-bracket-pairs-of-a-string.rs) |
| [1812. Determine Color of a Chessboard Square](https://leetcode.com/problems/determine-color-of-a-chessboard-square/) | Easy | Math; String | [C++](problems/1812-determine-color-of-a-chessboard-square.cpp) |
| [1816. Truncate Sentence](https://leetcode.com/problems/truncate-sentence/) | Easy | Array; String | [Rust](problems/1816-truncate-sentence.rs) |
| [1817. Finding the Users Active Minutes](https://leetcode.com/problems/finding-the-users-active-minutes/) | Medium | Array; Hash Table | [Rust](problems/1817-finding-the-users-active-minutes.rs) |
| [1822. Sign of the Product of an Array](https://leetcode.com/problems/sign-of-the-product-of-an-array/) | Easy | Array; Math | [C++](problems/1822-sign-of-the-product-of-an-array.cpp) |
| [1823. Find the Winner of the Circular Game](https://leetcode.com/problems/find-the-winner-of-the-circular-game/) | Medium | Array; Math; Recursion; Queue; Simulation | [Rust](problems/1823-find-the-winner-of-the-circular-game.rs) |
| [1827. Minimum Operations to Make the Array Increasing](https://leetcode.com/problems/sign-of-the-product-of-an-array/) | Easy | Array; Greedy | [Rust](problems/1827-minimum-operations-to-make-the-array-increasing.rs) |
| [1828. Queries on Number of Points Inside a Circle](https://leetcode.com/problems/queries-on-number-of-points-inside-a-circle/) | Medium | Array; Math; Geometry | [C++](problems/1828-queries-on-number-of-points-inside-a-circle.cpp) |
| [1829. Maximum XOR for Each Query](https://leetcode.com/problems/maximum-xor-for-each-query/) | Medium | Array; Bit Manipulation; Prefix Sum | [Rust](problems/1829-maximum-xor-for-each-query.rs) |
| [1832. Check if the Sentence Is Pangram](https://leetcode.com/problems/check-if-the-sentence-is-pangram/) | Easy | Hash Table; String | [Rust](problems/1832-check-if-the-sentence-is-pangram.rs) |
| [1837. Sum of Digits in Base K](https://leetcode.com/problems/sum-of-digits-in-base-k/) | Easy | Math | [C++](problems/1837-sum-of-digits-in-base-k.cpp) |
| [1844. Replace All Digits with Characters](https://leetcode.com/problems/replace-all-digits-with-characters/) | Easy | String | [C++](problems/1844-replace-all-digits-with-characters.cpp) |
| [1845. Seat Reservation Manager](https://leetcode.com/problems/seat-reservation-manager/) | Medium | Design; Heap (Priority Queue) | [JavaScript](problems/1845-seat-reservation-manager.js) |
| [1848. Minimum Distance to the Target Element](https://leetcode.com/problems/minimum-distance-to-the-target-element/) | Easy | Array | [C++](problems/1848-minimum-distance-to-the-target-element.cpp) |
| [1859. Sorting the Sentence](https://leetcode.com/problems/sorting-the-sentence/) | Easy | String; Sorting | [Rust](problems/1859-sorting-the-sentence.rs) |
| [1860. Incremental Memory Leak](https://leetcode.com/problems/incremental-memory-leak/) | Medium | Simulation | [Rust](problems/1860-incremental-memory-leak.rs) |
| [1863. Sum of All Subset XOR Totals](https://leetcode.com/problems/sum-of-all-subset-xor-totals/) | Easy | Array; Math; Backtracking; Bit Manipulation; Combinatorics | [Go](problems/1863-sum-of-all-subset-xor-totals.go) |
| [1869. Longer Contiguous Segments of Ones than Zeros](https://leetcode.com/problems/longer-contiguous-segments-of-ones-than-zeros/) | Easy | String | [C++](problems/1869-longer-contiguous-segments-of-ones-than-zeros.cpp) |
| [1873. Calculate Special Bonus](https://leetcode.com/problems/calculate-special-bonus/) | Easy | Database | [MySQL](problems/1873-calculate-special-bonus.sql) |
| [1876. Substrings of Size Three with Distinct Characters](https://leetcode.com/problems/substrings-of-size-three-with-distinct-characters/) | Easy | Hash Table; String; Sliding Window; Counting | [C++](problems/1876-substrings-of-size-three-with-distinct-characters.cpp) |
| [1877. Minimize Maximum Pair Sum in Array](https://leetcode.com/problems/minimize-maximum-pair-sum-in-array/) | Medium | Array; Two Pointers; Greedy; Sorting | [Rust](problems/1877-minimize-maximum-pair-sum-in-array.rs) |
| [1880. Check if Word Equals Summation of Two Words](https://leetcode.com/problems/check-if-word-equals-summation-of-two-words/) | Easy | String | [C++](problems/1880-check-if-word-equals-summation-of-two-words.cpp) |
| [1890. The Latest Login in 2020](https://leetcode.com/problems/the-latest-login-in-2020/) | Easy | Database | [MySQL](problems/1890-the-latest-login-in-2020.sql) |
| [1893. Check if All the Integers in a Range Are Covered](https://leetcode.com/problems/check-if-all-the-integers-in-a-range-are-covered/) | Easy | Array; Hash Table; Prefix Sum | [C++](problems/1893-check-if-all-the-integers-in-a-range-are-covered.cpp) |
| [1897. Redistribute Characters to Make All Strings Equal](https://leetcode.com/problems/redistribute-characters-to-make-all-strings-equal/) | Easy | Hash Table; String; Counting | [C++](problems/1897-redistribute-characters-to-make-all-strings-equal.cpp) |
| [1903. Largest Odd Number in String](https://leetcode.com/problems/largest-odd-number-in-string/) | Easy | Math; String; Greedy | [C++](problems/1903-largest-odd-number-in-string.cpp) |
| [1905. Count Sub Islands](https://leetcode.com/problems/count-sub-islands/) | Medium | Array; Depth-First Search; Breadth-First Search; Union Find; Matrix | [Rust](problems/1905-count-sub-islands.rs) |
| [1909. Remove One Element to Make the Array Strictly Increasing](https://leetcode.com/problems/remove-one-element-to-make-the-array-strictly-increasing/) | Easy | Array | [C++](problems/1909-remove-one-element-to-make-the-array-strictly-increasing.cpp) |
| [1910. Remove All Occurrences of a Substring](https://leetcode.com/problems/remove-all-occurrences-of-a-substring/) | Medium | String | [Rust](problems/1910-remove-all-occurrences-of-a-substring.rs) |
| [1913. Maximum Product Difference Between Two Pairs](https://leetcode.com/problems/maximum-product-difference-between-two-pairs/) | Easy | Array; Sorting | [C++](problems/1913-maximum-product-difference-between-two-pairs.cpp) |
| [1920. Build Array from Permutation](https://leetcode.com/problems/build-array-from-permutation/) | Easy | Array; Simulation | [C++](problems/1920-build-array-from-permutation.cpp) |
| [1925. Count Square Sum Triples](https://leetcode.com/problems/count-square-sum-triples/) | Easy | Math; Enumeration | [Go](problems/1925-count-square-sum-triples.go) |
| [1929. Concatenation of Array](https://leetcode.com/problems/concatenation-of-array/) | Easy | Array | [C++](problems/1929-concatenation-of-array.cpp) |
| [1935. Maximum Number of Words You Can Type](https://leetcode.com/problems/maximum-number-of-words-you-can-type/) | Easy | Hash Table; String | [C++](problems/1935-maximum-number-of-words-you-can-type.cpp) |
| [1941. Check if All Characters Have Equal Number of Occurrences](https://leetcode.com/problems/check-if-all-characters-have-equal-number-of-occurrences/) | Easy | Hash Table; String; Counting | [C++](problems/1941-check-if-all-characters-have-equal-number-of-occurrences.cpp) |
| [1945. Sum of Digits of String After Convert](https://leetcode.com/problems/sum-of-digits-of-string-after-convert/) | Easy | String; Simulation | [C++](problems/1945-sum-of-digits-of-string-after-convert.cpp) |
| [1952. Three Divisors](https://leetcode.com/problems/three-divisors/) | Easy | Math | [C++](problems/1952-three-divisors.cpp) |
| [1957. Delete Characters to Make Fancy String](https://leetcode.com/problems/delete-characters-to-make-fancy-string/) | Easy | String | [C++](problems/1957-delete-characters-to-make-fancy-string.cpp) |
| [1961. Check If String Is a Prefix of Array](https://leetcode.com/problems/check-if-string-is-a-prefix-of-array/) | Easy | Array; String | [C++](problems/1961-check-if-string-is-a-prefix-of-array.cpp) |
| [1965. Employees With Missing Information](https://leetcode.com/problems/employees-with-missing-information/) | Easy | Database | [MySQL](problems/1965-employees-with-missing-information.sql) |
| [1967. Number of Strings That Appear as Substrings in Word](https://leetcode.com/problems/number-of-strings-that-appear-as-substrings-in-word/) | Easy | String | [C++](problems/1967-number-of-strings-that-appear-as-substrings-in-word.cpp) |
| [1971. Find if Path Exists in Graph](https://leetcode.com/problems/find-if-path-exists-in-graph/) | Easy | Depth-First Search; Breadth-First Search; Graph | [C++](problems/1971-find-if-path-exists-in-graph.cpp) |
| [1974. Minimum Time to Type Word Using Special Typewriter](https://leetcode.com/problems/minimum-time-to-type-word-using-special-typewriter/) | Easy | String; Greedy | [C++](problems/1974-minimum-time-to-type-word-using-special-typewriter.cpp) |
| [1979. Find Greatest Common Divisor of Array](https://leetcode.com/problems/find-greatest-common-divisor-of-array/) | Easy | Array; Math | [C++](problems/1979-find-greatest-common-divisor-of-array.cpp) |
| [1984. Minimum Difference Between Highest and Lowest of K Scores](https://leetcode.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/) | Easy | Array; Sliding Window; Sorting | [C++](problems/1984-minimum-difference-between-highest-and-lowest-of-k-scores.cpp) |
| [1991. Find the Middle Index in Array](https://leetcode.com/problems/find-the-middle-index-in-array/) | Easy | Array; Prefix Sum | [C++](problems/1991-find-the-middle-index-in-array.cpp) |
| [2000. Reverse Prefix of Word](https://leetcode.com/problems/reverse-prefix-of-word/) | Easy | Two Pointers; String | [C++](problems/2000-reverse-prefix-of-word.cpp) |
| [2001. Number of Pairs of Interchangeable Rectangles](https://leetcode.com/problems/number-of-pairs-of-interchangeable-rectangles/) | Medium | Array; Hash Table; Math; Counting; Number Theory | [Ruby](problems/2001-number-of-pairs-of-interchangeable-rectangles.rb) |
| [2006. Count Number of Pairs With Absolute Difference K](https://leetcode.com/problems/count-number-of-pairs-with-absolute-difference-k/) | Easy | Array; Hash Table; Counting | [C++](problems/2006-count-number-of-pairs-with-absolute-difference-k.cpp) |
| [2011. Final Value of Variable After Performing Operations](https://leetcode.com/problems/final-value-of-variable-after-performing-operations/) | Easy | Array; String; Simulation | [C++](problems/2011-final-value-of-variable-after-performing-operations.cpp) |
| [2016. Maximum Difference Between Increasing Elements](https://leetcode.com/problems/maximum-difference-between-increasing-elements/) | Easy | Array | [C++](problems/2016-maximum-difference-between-increasing-elements.cpp) |
| [2022. Convert 1D Array Into 2D Array](https://leetcode.com/problems/convert-1d-array-into-2d-array/) | Easy | Array; Matrix; Simulation | [C++](problems/2022-convert-1d-array-into-2d-array.cpp) |
| [2023. Number of Pairs of Strings With Concatenation Equal to Target](https://leetcode.com/problems/number-of-pairs-of-strings-with-concatenation-equal-to-target/) | Medium | Array; String | [Rust](problems/2023-number-of-pairs-of-strings-with-concatenation-equal-to-target.rs) |
| [2027. Minimum Moves to Convert String](https://leetcode.com/problems/minimum-moves-to-convert-string/) | Easy | String; Greedy | [C++](problems/2027-minimum-moves-to-convert-string.cpp) |
| [2032. Two Out of Three](https://leetcode.com/problems/two-out-of-three/) | Easy | Array; Hash Table | [C++](problems/2032-two-out-of-three.cpp) |
| [2037. Minimum Number of Moves to Seat Everyone](https://leetcode.com/problems/minimum-number-of-moves-to-seat-everyone/) | Easy | Array; Sorting | [C++](problems/2037-minimum-number-of-moves-to-seat-everyone.cpp) |
| [2042. Check if Numbers Are Ascending in a Sentence](https://leetcode.com/problems/check-if-numbers-are-ascending-in-a-sentence/) | Easy | String | [JavaScript](problems/2042-check-if-numbers-are-ascending-in-a-sentence.js) |
| [2043. Simple Bank System](https://leetcode.com/problems/simple-bank-system/) | Medium | Array; Hash Table; Design; Simulation | [JavaScript](problems/2043-simple-bank-system.js) |
| [2044. Count Number of Maximum Bitwise-OR Subsets](https://leetcode.com/problems/count-number-of-maximum-bitwise-or-subsets/) | Medium | Array; Backtracking; Bit Manipulation | [Rust](problems/2044-count-number-of-maximum-bitwise-or-subsets.rs) |
| [2053. Kth Distinct String in an Array](https://leetcode.com/problems/kth-distinct-string-in-an-array/) | Easy | Array; Hash Table; String; Counting | [JavaScript](problems/2053-kth-distinct-string-in-an-array.js) |
| [2057. Smallest Index With Equal Value](https://leetcode.com/problems/smallest-index-with-equal-value/) | Easy | Array | [JavaScript](problems/2057-smallest-index-with-equal-value.js) |
| [2068. Check Whether Two Strings are Almost Equivalent](https://leetcode.com/problems/check-whether-two-strings-are-almost-equivalent/) | Easy | Hash Table; String; Counting | [JavaScript](problems/2068-check-whether-two-strings-are-almost-equivalent.js) |
| [2073. Time Needed to Buy Tickets](https://leetcode.com/problems/time-needed-to-buy-tickets/) | Easy | Array; Queue; Simulation | [JavaScript](problems/2073-time-needed-to-buy-tickets.js) |
| [2078. Two Furthest Houses With Different Colors](https://leetcode.com/problems/two-furthest-houses-with-different-colors/) | Easy | Array; Greedy | [JavaScript](problems/2078-two-furthest-houses-with-different-colors.js) |
| [2079. Watering Plants](https://leetcode.com/problems/watering-plants/) | Medium | Array | [Rust](problems/2079-watering-plants.rs) |
| [2085. Count Common Words With One Occurrence](https://leetcode.com/problems/count-common-words-with-one-occurrence/) | Easy | Array; Hash Table; String; Counting | [JavaScript](problems/2085-count-common-words-with-one-occurrence.js) |
| [2089. Find Target Indices After Sorting Array](https://leetcode.com/problems/find-target-indices-after-sorting-array/) | Easy | Array; Binary Search; Sorting | [JavaScript](problems/2089-find-target-indices-after-sorting-array.js) |
| [2103. Rings and Rods](https://leetcode.com/problems/rings-and-rods/) | Easy | Hash Table; String | [Go](problems/2103-rings-and-rods.go) |
| [2108. Find First Palindromic String in the Array](https://leetcode.com/problems/find-first-palindromic-string-in-the-array/) | Easy | Array; Two Pointers; String | [Go](problems/2108-find-first-palindromic-string-in-the-array.go) |
| [2114. Maximum Number of Words Found in Sentences](https://leetcode.com/problems/maximum-number-of-words-found-in-sentences/) | Easy | Array; String | [Go](problems/2114-maximum-number-of-words-found-in-sentences.go) |
| [2119. A Number After a Double Reversal](https://leetcode.com/problems/a-number-after-a-double-reversal/) | Easy | Math | [Go](problems/2119-a-number-after-a-double-reversal.go) |
| [2124. Check if All A's Appears Before All B's](https://leetcode.com/problems/check-if-all-as-appears-before-all-bs/) | Easy | String | [Go](problems/2124-check-if-all-as-appears-before-all-bs.go) |
| [2125. Number of Laser Beams in a Bank](https://leetcode.com/problems/number-of-laser-beams-in-a-bank/) | Medium | Array; Math; String; Matrix | [Rust](problems/2125-number-of-laser-beams-in-a-bank.rs) |
| [2129. Capitalize the Title](https://leetcode.com/problems/capitalize-the-title/) | Easy | String | [JavaScript](problems/2129-capitalize-the-title.js) |
| [2130. Maximum Twin Sum of a Linked List](https://leetcode.com/problems/maximum-twin-sum-of-a-linked-list/) | Medium | Linked List; Two Pointers; Stack | [C++](problems/2130-maximum-twin-sum-of-a-linked-list.cpp) |
| [2136. Earliest Possible Day of Full Bloom](https://leetcode.com/problems/earliest-possible-day-of-full-bloom/) | Hard | Array; Greedy; Sorting | [Rust](problems/2136-earliest-possible-day-of-full-bloom.rs) |
| [2138. Divide a String Into Groups of Size k](https://leetcode.com/problems/divide-a-string-into-groups-of-size-k/) | Easy | String; Simulation | [Go](problems/2138-divide-a-string-into-groups-of-size-k.go) |
| [2144. Minimum Cost of Buying Candies With Discount](https://leetcode.com/problems/minimum-cost-of-buying-candies-with-discount/) | Easy | Array; Greedy; Sorting | [Go](problems/2144-minimum-cost-of-buying-candies-with-discount.go) |
| [2148. Count Elements With Strictly Smaller and Greater Elements](https://leetcode.com/problems/count-elements-with-strictly-smaller-and-greater-elements/) | Easy | Array; Sorting | [Go](problems/2148-count-elements-with-strictly-smaller-and-greater-elements.go) |
| [2149. Rearrange Array Elements by Sign](https://leetcode.com/problems/rearrange-array-elements-by-sign/) | Medium | Array; Two Pointers; Simulation | [Go](problems/2149-rearrange-array-elements-by-sign.go) |
| [2154. Keep Multiplying Found Values by Two](https://leetcode.com/problems/keep-multiplying-found-values-by-two/) | Easy | Array; Hash Table; Sorting; Simulation | [Go](problems/2154-keep-multiplying-found-values-by-two.go) |
| [2160. Minimum Sum of Four Digit Number After Splitting Digits](https://leetcode.com/problems/minimum-sum-of-four-digit-number-after-splitting-digits/) | Easy | Math; Greedy; Sorting | [Go](problems/2160-minimum-sum-of-four-digit-number-after-splitting-digits.go) |
| [2161. Partition Array According to Given Pivot](https://leetcode.com/problems/partition-array-according-to-given-pivot/) | Medium | Array; Two Pointers; Simulation | [Rust](problems/2161-partition-array-according-to-given-pivot.rs) |
| [2164. Sort Even and Odd Indices Independently](https://leetcode.com/problems/sort-even-and-odd-indices-independently/) | Easy | Array; Sorting | [Rust](problems/2164-sort-even-and-odd-indices-independently.rs) |
| [2166. Design Bitset](https://leetcode.com/problems/design-bitset/) | Medium | Array; Hash Table; Design | [C++](problems/2166-design-bitset.cpp) |
| [2169. Count Operations to Obtain Zero](https://leetcode.com/problems/count-operations-to-obtain-zero/) | Easy | Math; Simulation | [Go](problems/2169-count-operations-to-obtain-zero.go) |
| [2181. Merge Nodes in Between Zeros](https://leetcode.com/problems/merge-nodes-in-between-zeros/) | Medium | Linked List; Simulation | [Go](problems/2181-merge-nodes-in-between-zeros.go) |
| [2185. Counting Words With a Given Prefix](https://leetcode.com/problems/counting-words-with-a-given-prefix/) | Easy | Array; String | [Go](problems/2185-counting-words-with-a-given-prefix.go) |
| [2186. Minimum Number of Steps to Make Two Strings Anagram II](https://leetcode.com/problems/minimum-number-of-steps-to-make-two-strings-anagram-ii/) | Medium | Hash Table; String; Counting | [Rust](problems/2186-minimum-number-of-steps-to-make-two-strings-anagram-ii.rs) |
| [2190. Most Frequent Number Following Key In an Array](https://leetcode.com/problems/most-frequent-number-following-key-in-an-array/) | Easy | Array; Hash Table; Counting | [Go](problems/2190-most-frequent-number-following-key-in-an-array.go) |
| [2194. Cells in a Range on an Excel Sheet](https://leetcode.com/problems/cells-in-a-range-on-an-excel-sheet/) | Easy | String | [Go](problems/2194-cells-in-a-range-on-an-excel-sheet.go) |
| [2200. Find All K-Distant Indices in an Array](https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/) | Easy | Array | [Go](problems/2200-find-all-k-distant-indices-in-an-array.go) |
| [2206. Divide Array Into Equal Pairs](https://leetcode.com/problems/divide-array-into-equal-pairs/) | Easy | Array; Hash Table; Bit Manipulation; Counting | [Go](problems/2206-divide-array-into-equal-pairs.go) |
| [2220. Minimum Bit Flips to Convert Number](https://leetcode.com/problems/minimum-bit-flips-to-convert-number/) | Easy | Bit Manipulation | [Go](problems/2220-minimum-bit-flips-to-convert-number.go) |
| [2225. Find Players With Zero or One Losses](https://leetcode.com/problems/find-players-with-zero-or-one-losses/) | Medium | Array; Hash Table; Sorting; Counting | [C++](problems/2225-find-players-with-zero-or-one-losses.cpp) |
| [2235. Add Two Integers](https://leetcode.com/problems/add-two-integers/) | Easy | Math | [Rust](problems/2235-add-two-integers.rs) |
| [2236. Root Equals Sum of Children](https://leetcode.com/problems/root-equals-sum-of-children/) | Easy | Tree; Binary Tree | [Rust](problems/2236-root-equals-sum-of-children.rs) |
| [2241. Design an ATM Machine](https://leetcode.com/problems/design-an-atm-machine/) | Medium | Array; Greedy; Design | [Go](problems/2241-design-an-atm-machine.go) |
| [2243. Calculate Digit Sum of a String](https://leetcode.com/problems/calculate-digit-sum-of-a-string/) | Easy | String; Simulation | [Go](problems/2243-calculate-digit-sum-of-a-string.go) |
| [2244. Minimum Rounds to Complete All Tasks](https://leetcode.com/problems/minimum-rounds-to-complete-all-tasks/) | Medium | Array; Hash Table; Greedy; Counting | [Go](problems/2244-minimum-rounds-to-complete-all-tasks.go) |
| [2248. Intersection of Multiple Arrays](https://leetcode.com/problems/intersection-of-multiple-arrays/) | Easy | Array; Hash Table; Counting | [Go](problems/2248-intersection-of-multiple-arrays.go) |
| [2249. Count Lattice Points Inside a Circle](https://leetcode.com/problems/count-lattice-points-inside-a-circle/) | Medium | Array; Hash Table; Math; Geometry; Enumeration | [Go](problems/2249-count-lattice-points-inside-a-circle.go) |
| [2251. Number of Flowers in Full Bloom](https://leetcode.com/problems/number-of-flowers-in-full-bloom/) | Hard | Array; Hash Table; Binary Search; Sorting; Prefix Sum; Ordered Set | [C++](problems/2251-number-of-flowers-in-full-bloom.cpp) |
| [2255. Count Prefixes of a Given String](https://leetcode.com/problems/count-prefixes-of-a-given-string/) | Easy | Array; String | [Go](problems/2255-count-prefixes-of-a-given-string.go) |
| [2264. Largest 3-Same-Digit Number in String](https://leetcode.com/problems/largest-3-same-digit-number-in-string/) | Easy | String | [Go](problems/2264-largest-3-same-digit-number-in-string.go) |
| [2265. Count Nodes Equal to Average of Subtree](https://leetcode.com/problems/count-nodes-equal-to-average-of-subtree/) | Medium | Tree; Depth-First Search; Binary Tree | [Go](problems/2265-count-nodes-equal-to-average-of-subtree.go) |
| [2275. Largest Combination With Bitwise AND Greater Than Zero](https://leetcode.com/problems/largest-combination-with-bitwise-and-greater-than-zero/) | Medium | Array; Hash Table; Bit Manipulation; Counting | [Rust](problems/2275-largest-combination-with-bitwise-and-greater-than-zero.rs) |
| [2278. Percentage of Letter in String](https://leetcode.com/problems/percentage-of-letter-in-string/) | Easy | String | [C++](problems/2278-percentage-of-letter-in-string.cpp) |
| [2283. Check if Number Has Equal Digit Count and Digit Value](https://leetcode.com/problems/check-if-number-has-equal-digit-count-and-digit-value/) | Easy | Hash Table; String; Counting | [Go](problems/2283-check-if-number-has-equal-digit-count-and-digit-value.go) |
| [2287. Rearrange Characters to Make Target String](https://leetcode.com/problems/rearrange-characters-to-make-target-string/) | Easy | Hash Table; String; Counting | [Go](problems/2287-rearrange-characters-to-make-target-string.go) |
| [2293. Min Max Game](https://leetcode.com/problems/min-max-game/) | Easy | Array; Simulation | [Go](problems/2293-min-max-game.go) |
| [2294. Partition Array Such That Maximum Difference Is K](https://leetcode.com/problems/partition-array-such-that-maximum-difference-is-k/) | Medium | Array; Greedy; Sorting | [Rust](problems/2294-partition-array-such-that-maximum-difference-is-k.rs) |
| [2299. Strong Password Checker II](https://leetcode.com/problems/strong-password-checker-ii/) | Easy | String | [C++](problems/2299-strong-password-checker-ii.cpp) |
| [2303. Calculate Amount Paid in Taxes](https://leetcode.com/problems/calculate-amount-paid-in-taxes/) | Easy | Array; Simulation | [Go](problems/2303-calculate-amount-paid-in-taxes.go) |
| [2309. Greatest English Letter in Upper and Lower Case](https://leetcode.com/problems/greatest-english-letter-in-upper-and-lower-case/) | Easy | Hash Table; String; Enumeration | [Go](problems/2309-greatest-english-letter-in-upper-and-lower-case.go) |
| [2315. Count Asterisks](https://leetcode.com/problems/count-asterisks/) | Easy | String | [Go](problems/2315-count-asterisks.go) |
| [2317. Maximum XOR After Operations](https://leetcode.com/problems/maximum-xor-after-operations/) | Medium | Array; Math; Bit Manipulation | [Rust](problems/2317-maximum-xor-after-operations.rs) |
| [2319. Check if Matrix Is X-Matrix](https://leetcode.com/problems/check-if-matrix-is-x-matrix/) | Easy | Array; Matrix | [Rust](problems/2319-check-if-matrix-is-x-matrix.rs) |
| [2325. Decode the Message](https://leetcode.com/problems/decode-the-message/) | Easy | Hash Table; String | [Go](problems/2325-decode-the-message.go) |
| [2331. Evaluate Boolean Binary Tree](https://leetcode.com/problems/evaluate-boolean-binary-tree/) | Easy | Binary Search; Tree; Depth-First Search | [Go](problems/2331-evaluate-boolean-binary-tree.go) |
| [2335. Minimum Amount of Time to Fill Cups](https://leetcode.com/problems/minimum-amount-of-time-to-fill-cups/) | Easy | Array; Greedy; Heap (Priority Queue) | [Go](problems/2335-minimum-amount-of-time-to-fill-cups.go) |
| [2336. Smallest Number in Infinite Set](https://leetcode.com/problems/smallest-number-in-infinite-set/) | Medium | Hash Table; Design; Heap (Priority Queue) | [Rust](problems/2336-smallest-number-in-infinite-set.rs) |
| [2341. Maximum Number of Pairs in Array](https://leetcode.com/problems/maximum-number-of-pairs-in-array/) | Easy | Array; Hash Table; Counting | [Go](problems/2341-maximum-number-of-pairs-in-array.go) |
| [2347. Best Poker Hand](https://leetcode.com/problems/best-poker-hand/) | Easy | Array; Hash Table; Counting | [Go](problems/2347-best-poker-hand.go) |
| [2351. First Letter to Appear Twice](https://leetcode.com/problems/first-letter-to-appear-twice/) | Easy | Hash Table; String; Counting | [Go](problems/2351-first-letter-to-appear-twice.go) |
| [2357. Make Array Zero by Subtracting Equal Amounts](https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts/) | Easy | Array; Hash Table; Sorting; Heap (Priority Queue); Simulation | [Go](problems/2357-make-array-zero-by-subtracting-equal-amounts.go) |
| [2363. Merge Similar Items](https://leetcode.com/problems/merge-similar-items/) | Easy | Array; Hash Table; Sorting; Ordered Set | [Rust](problems/2363-merge-similar-items.rs) |
| [2367. Number of Arithmetic Triplets](https://leetcode.com/problems/number-of-arithmetic-triplets/) | Easy | Array; Hash Table; Two Pointers; Enumeration | [Rust](problems/2367-number-of-arithmetic-triplets.rs) |
| [2373. Largest Local Values in a Matrix](https://leetcode.com/problems/largest-local-values-in-a-matrix/) | Easy | Array; Matrix | [Rust](problems/2373-largest-local-values-in-a-matrix.rs) |
| [2375. Construct Smallest Number From DI String](https://leetcode.com/problems/construct-smallest-number-from-di-string/) | Medium | String; Backtracking; Stack; Greedy | [Rust](problems/2375-construct-smallest-number-from-di-string.rs) |
| [2391. Minimum Amount of Time to Collect Garbage](https://leetcode.com/problems/minimum-amount-of-time-to-collect-garbage/) | Medium | Array; String; Prefix Sum | [Rust](problems/2391-minimum-amount-of-time-to-collect-garbage.rs) |
| [2395. Find Subarrays With Equal Sum](https://leetcode.com/problems/find-subarrays-with-equal-sum/) | Easy | Array; Hash Table | [Rust](problems/2395-find-subarrays-with-equal-sum.rs) |
| [2396. Strictly Palindromic Number](https://leetcode.com/problems/strictly-palindromic-number/) | Medium | Math; Two Pointers; Brainteaser | [Rust](problems/2396-strictly-palindromic-number.rs) |
| [2404. Most Frequent Even Element](https://leetcode.com/problems/most-frequent-even-element/) | Easy | Array; Hash Table; Counting | [Rust](problems/2404-most-frequent-even-element.rs) |
| [2405. Optimal Partition of String](https://leetcode.com/problems/optimal-partition-of-string/) | Medium | Hash Table; String; Greedy | [Rust](problems/2405-optimal-partition-of-string.rs) |
| [2413. Smallest Even Multiple](https://leetcode.com/problems/smallest-even-multiple/) | Easy | Math; Number Theory | [Rust](problems/2413-smallest-even-multiple.rs) |
| [2418. Sort the People](https://leetcode.com/problems/sort-the-people/) | Easy | Array; Hash Table; String; Sorting | [Rust](problems/2418-sort-the-people.rs) |
| [2425. Bitwise XOR of All Pairings](https://leetcode.com/problems/bitwise-xor-of-all-pairings/) | Medium | Array; Bit Manipulation; Brainteaser | [Rust](problems/2425-bitwise-xor-of-all-pairings.rs) |
| [2428. Maximum Sum of an Hourglass](https://leetcode.com/problems/maximum-sum-of-an-hourglass/) | Medium | Array; Matrix; Prefix Sum | [Rust](problems/2428-maximum-sum-of-an-hourglass.rs) |
| [2433. Find The Original Array of Prefix Xor](https://leetcode.com/problems/find-the-original-array-of-prefix-xor/) | Medium | Array; Bit Manipulation | [Rust](problems/2433-find-the-original-array-of-prefix-xor.rs) |
| [2441. Largest Positive Integer That Exists With Its Negative](https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/) | Easy | Array; Hash Table | [Rust](problems/2441-largest-positive-integer-that-exists-with-its-negative.rs) |
| [2442. Count Number of Distinct Integers After Reverse Operations](https://leetcode.com/problems/count-number-of-distinct-integers-after-reverse-operations/) | Medium | Array; Hash Table; Math | [Rust](problems/2442-count-number-of-distinct-integers-after-reverse-operations.rs) |
| [2446. Determine if Two Events Have Conflict](https://leetcode.com/problems/determine-if-two-events-have-conflict/) | Easy | Array; String | [Rust](problems/2446-determine-if-two-events-have-conflict.rs) |
| [2469. Convert the Temperature](https://leetcode.com/problems/convert-the-temperature/) | Easy | Math | [Rust](problems/2469-convert-the-temperature.rs) |
| [2485. Find the Pivot Integer](https://leetcode.com/problems/find-the-pivot-integer/) | Easy | Math; Prefix Sum | [Rust](problems/2485-find-the-pivot-integer.rs) |
| [2490. Circular Sentence](https://leetcode.com/problems/circular-sentence/) | Easy | String | [Rust](problems/2490-circular-sentence.rs) |
| [2496. Maximum Value of a String in an Array](https://leetcode.com/problems/maximum-value-of-a-string-in-an-array/) | Easy | Array; String | [Ruby](problems/2496-maximum-value-of-a-string-in-an-array.rb) |
| [2500. Delete Greatest Value in Each Row](https://leetcode.com/problems/delete-greatest-value-in-each-row/) | Easy | Array; Sorting; Matrix | [Ruby](problems/2500-delete-greatest-value-in-each-row.rb) |
| [2506. Count Pairs Of Similar Strings](https://leetcode.com/problems/count-pairs-of-similar-strings/) | Easy | Array; Hash Table; String | [Rust](problems/2506-count-pairs-of-similar-strings.rs) |
| [2520. Count the Digits That Divide a Number](https://leetcode.com/problems/count-the-digits-that-divide-a-number/) | Easy | Math | [Rust](problems/2520-count-the-digits-that-divide-a-number.rs) |
| [2525. Categorize Box According to Criteria](https://leetcode.com/problems/categorize-box-according-to-criteria/) | Easy | Math | [Rust](problems/2525-categorize-box-according-to-criteria.rs) |
| [2529. Maximum Count of Positive Integer and Negative Integer](https://leetcode.com/problems/maximum-count-of-positive-integer-and-negative-integer/) | Easy | Array; Binary Search; Counting | [Ruby](problems/2529-maximum-count-of-positive-integer-and-negative-integer.rb) |
| [2535. Difference Between Element Sum and Digit Sum of an Array](https://leetcode.com/problems/difference-between-element-sum-and-digit-sum-of-an-array/) | Easy | Array; Math | [Ruby](problems/2535-difference-between-element-sum-and-digit-sum-of-an-array.rb) |
| [2544. Alternating Digit Sum](https://leetcode.com/problems/alternating-digit-sum/) | Easy | Math | [Rust](problems/2544-alternating-digit-sum.rs) |
| [2545. Sort the Students by Their Kth Score](https://leetcode.com/problems/sort-the-students-by-their-kth-score/) | Medium | Array; Sorting; Matrix | [Rust](problems/2545-sort-the-students-by-their-kth-score.rs) |
| [2549. Count Distinct Numbers on Board](https://leetcode.com/problems/count-distinct-numbers-on-board/) | Easy | Array; Hash Table; Math; Simulation | [Rust](problems/2549-count-distinct-numbers-on-board.rs) |
## License
All solutions are licensed under the [MIT License](LICENCE).