https://github.com/sahilk-027/leetcode

Solutions for LeetCode Problems
https://github.com/sahilk-027/leetcode
competitive-programming leetcode
Last synced: about 2 months ago
JSON representation
Solutions for LeetCode Problems
Host: GitHub
URL: https://github.com/sahilk-027/leetcode
Owner: SahilK-027
License: mit
Archived: true
Created: 2022-09-12T12:47:17.000Z (about 3 years ago)
Default Branch: main
Last Pushed: 2023-08-02T07:49:38.000Z (about 2 years ago)
Last Synced: 2025-03-13T06:31:47.246Z (8 months ago)
Topics: competitive-programming, leetcode
Language: C++
Homepage:
Size: 1.22 MB
Stars: 12
Watchers: 1
Forks: 8
Open Issues: 0
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- Code of conduct: CODE_OF_CONDUCT.md
- Security: SECURITY.md
Awesome Lists containing this project

README

          # LeetCode

## 💠 Languages used

    

        

	    

            C++


            

            

	    

            JS


            

            

            

            Python


            

            

            

            Java


            

            

        

    

[![Typing SVG](https://readme-typing-svg.herokuapp.com?font=IBM+Plex+Sans&color=ffa115&size=25&lines=‎‎‎‎‎‎‎‎‎‎‎‎‎‎‎‎‎‎‎‎‎+👨🏻‍💻+Happy+LeetCoding!;)](https://git.io/typing-svg)

```cpp

/**

 * @brief:   This repository contains solutions for leetcode problems.

 * @param:   Takes logic

 * @return:  Solutions

*/

solutions main(logic)

{

  if(Like the repository)

  {

    Give ⭐️;

    Thanks 😊;

  }

  return (LeetCode solutions);

}

```

```diff

@@  Problems Solved So Far,... @@

```

| # | Problem Title | Difficulty | Solution |

|:---:|:---------------| :------------:| :----------:|

| 1 | Two Sum| 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1.%20Two_Sum) |

| 2 | Add Two Numbers | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2.%20Add%20Two%20Numbers) |

| 3 | Longest Substring Without Repeating Characters | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/3.%20Longest%20Substring%20Without%20Repeating%20Characters) |

| 4 | Median of Two Sorted Arrays | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/4.%20Median%20of%20Two%20Sorted%20Arrays) |

| 5 | Longest Palindromic Substring | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/5.%20Longest%20Palindromic%20Substring) |

| 6 | Zigzag Conversion | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/6.%20Zigzag%20Conversion)|

| 7 | Reverse Integer | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/7.%20Reverse%20Integer) |

| 9 | Palindrome Number | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/9.%20Palindrome%20Number)|

| 11 | Container With Most Water | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/11.%20Container%20With%20Most%20Water)|

| 13 | Roman to Integer | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/13.%20Roman%20to%20Integer)|

| 14 | Longest Common Prefix | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/14.%20Longest%20Common%20Prefix)|

| 15 | 3Sum | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/15.%203Sum)|

| 17 | Letter Combinations of a Phone Number | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/17.%20Letter%20Combinations%20of%20a%20Phone%20Number)|

| 18 | 4Sum | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/18.%204Sum)|

| 19 | Remove Nth Node From End of List | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/19.%20Remove%20Nth%20Node%20From%20End%20of%20List)|

| 20 | Valid Parentheses | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/20.%20Valid%20Parentheses)|

| 21 | Merge Two Sorted Lists | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/21.%20Merge%20Two%20Sorted%20Lists)|

| 22 | Generate Parentheses | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/22.%20Generate%20Parentheses) |

| 23 | Merge k Sorted Lists | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/23.%20Merge%20k%20Sorted%20Lists)|

| 24 | Swap Nodes in Pairs | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/24.%20Swap%20Nodes%20in%20Pairs)|

| 25 | Reverse Nodes in k-Group | 🔴 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/25.%20Reverse%20Nodes%20in%20k-Group)|

| 26 | Remove Duplicates from Sorted Array | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/26.%20Remove%20Duplicates%20from%20Sorted%20Array)|

| 27 | Remove Element | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/27.%20Remove%20Elementy)|

| 28 | Find the Index of the First Occurrence in a String | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/28.%20Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String)|

| 33 | Search in Rotated Sorted Array | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/33.%20Search%20in%20Rotated%20Sorted%20Array)|

| 34 | Find First and Last Position of Element in Sorted Array | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/34.%20Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array)|

| 35 | Search Insert Position | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/35.%20Search%20Insert%20Position)|

| 37 | Sudoku Solver | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/37.%20Sudoku%20Solver)|

| 41 | First Missing Positive | 🔴 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/41.%20First%20Missing%20Positive)|  

| 42 | Trapping Rain Water | 🔴 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/42.%20Trapping%20Rain%20Water)|

| 45 | Jump Game II | 🟡 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/45.%20Jump%20Game%20II)

| 46 | Permutations | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/46.%20Permutations)|

| 48 | Rotate Image | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/48.%20Rotate%20Image)|

| 49 | Group Anagram | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/49.%20Group%20Anagrams)|

| 50 | Pow(x, n) | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/50.%20Pow(x%2C%20n))|

| 51 | N-Queens | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/51.%20N-Queens)|

| 52 | N-Queens II | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/52.%20N-Queens%20II)|

| 53 | Maximum Subarray | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/53.%20Maximum%20Subarray)|

| 54 | Spiral Matrix | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/54.%20Spiral%20Matrix)|

| 55 | Jump Game | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/55.%20Jump%20Game)|

| 56 | Merge Intervals | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/56.%20Merge%20Intervals)|

| 57 | Insert Interval | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/57.%20Insert%20Interval)|

| 58 | Length of Last Word | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/58.%20Length%20of%20Last%20Word)|

| 59 | Spiral Matrix II | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/59.%20Spiral%20Matrix%20II)|

| 61 | Rotate List | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/61.%20Rotate%20List)|

| 62 | Unique Paths | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/62.%20Unique%20Paths)|

| 63 | Unique Paths II | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/63.%20Unique%20Paths%20II)|

| 64 | Minimum Path Sum | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/64.%20Minimum%20Path%20Sum)|

| 66 | Plus One | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/66.%20Plus%20One)|

| 67 | Add Binary | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/67.%20Add%20Binary)|

| 69 | Sqrt(x) | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/69.%20Sqrt(x))|

| 70 | Climbing Stairs | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/70.%20Climbing%20Stairs)|

| 71 | Simplify Path | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/71.%20Simplify%20Path)|

| 73 | Set Matrix Zeroes | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/73.%20Set%20Matrix%20Zeroes)|

| 74 | Search a 2D Matrix | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/74.%20Search%20a%202D%20Matrix)|

| 75 | Sort Colors | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/75.%20Sort%20Colors) |

| 78 | Subsets | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/78.%20Subsets)|

| 79 | Word Search | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/79.%20Word%20Search)|

| 80 | Remove Duplicates from Sorted Array II | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/80.%20Remove%20Duplicates%20from%20Sorted%20Array%20II)|

| 82 | Remove Duplicates from Sorted List II | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/82.%20Remove%20Duplicates%20from%20Sorted%20List%20II)|

| 83 | Remove Duplicates from Sorted List | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/83.%20Remove%20Duplicates%20from%20Sorted%20List)|

| 84 | Largest Rectangle in Histogram | 🔴 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/84.%20Largest%20Rectangle%20in%20Histogram)|

| 85 | Maximal Rectangle | 🔴 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/85.%20Maximal%20Rectangle)|

| 86 | Partition List | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/86.%20Partition%20List)|

| 87 | Scramble String | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/87.%20Scramble%20String)|

| 88 | Merge Sorted Array | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/88.%20Merge%20Sorted%20Array)|

| 91 | Decode Ways | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/91.%20Decode%20Ways)|

| 92 | Reverse Linked List II | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/92.%20Reverse%20Linked%20List%20II)|

| 93 | Restore IP Addresses | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/93.%20Restore%20IP%20Addresses)|

| 94 | Binary Tree Inorder Traversal | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/94.%20Binary%20Tree%20Inorder%20Traversal)|

| 96 | Unique Binary Search Trees | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/96.%20Unique%20Binary%20Search%20Trees)|

| 98 | Validate Binary Search Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/98.%20Validate%20Binary%20Search%20Tree)|

| 100 | Same Tree | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/100.%20Same%20Tree)|

| 101 | Symmetric Tree | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/101.%20Symmetric%20Tree)|

| 102 | Binary Tree Level Order Traversal | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/102.%20Binary%20Tree%20Level%20Order%20Traversal)|

| 103 | Binary Tree Zigzag Level Order Traversal | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/103.%20Binary%20Tree%20Zigzag%20Level%20Order%20Traversal)|

| 104 | Maximum Depth of Binary Tree | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/104.%20Maximum%20Depth%20of%20Binary%20Tree)|

| 105 | Construct Binary Tree from Preorder and Inorder Traversal | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/105.%20Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal)|

| 106 | Construct Binary Tree from Inorder and Postorder Traversal | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/106.%20Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal)|

| 107 | Binary Tree Level Order Traversal II | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/107.%20Binary%20Tree%20Level%20Order%20Traversal%20II)|

| 108 | Convert Sorted Array to Binary Search Tree | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/108.%20Convert%20Sorted%20Array%20to%20Binary%20Search%20Tree)|

| 109 | Convert Sorted List to Binary Search Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/109.%20Convert%20Sorted%20List%20to%20Binary%20Search%20Tree)|

| 110 | Balanced Binary Tree | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/110.%20Balanced%20Binary%20Tree)|

| 111 | Minimum Depth of Binary Tree | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/111.%20Minimum%20Depth%20of%20Binary%20Tree)|

| 112 | Path Sum | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/112.%20Path%20Sum)|

| 114 | Flatten Binary Tree to Linked List | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/114.%20Flatten%20Binary%20Tree%20to%20Linked%20List)|

| 120 | Triangle | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/120.%20Triangle)|

| 121 | Best Time to Buy and Sell Stock | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/121.%20Best%20Time%20to%20Buy%20and%20Sell%20Stock)|

| 124 | Binary Tree Maximum Path Sum | 🔴 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/124.%20Binary%20Tree%20Maximum%20Path%20Sum)|

| 129 | Sum Root to Leaf Numbers | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/129.%20Sum%20Root%20to%20Leaf%20Numbers)|

| 130 | Surrounded Regions | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/130.%20Surrounded%20Regions)|

| 131 | Palindrome Partitioning | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/131.%20Palindrome%20Partitioning)|

| 133 | Clone Graph | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/133.%20Clone%20Graph)|

| 134 | Gas Station | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/134.%20Gas%20Station)|

| 136 | Single Number | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/136.%20Single%20Number)|

| 137 | Single Number II | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/137.%20Single%20Number%20II)|

| 138 | Copy List with Random Pointer | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/138.%20Copy%20List%20with%20Random%20Pointer)|

| 140 | Word Break II | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/140.%20Word%20Break%20II)|

| 141 | Linked List Cycle | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/141.%20Linked%20List%20Cycle)|

| 142 | Linked List Cycle II | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/142.%20Linked%20List%20Cycle%20II)|

| 143 | Reorder List | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/143.%20Reorder%20List)|

| 144 | Binary Tree Preorder Traversal | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/144.%20Binary%20Tree%20Preorder%20Traversal)|

| 145 | Binary Tree Postorder Traversal | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/145.%20Binary%20Tree%20Postorder%20Traversal)|

| 146 | LRU Cache | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/146.%20LRU%20Cache)|

| 148 | Sort List | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/148.%20Sort%20List)|

| 149 | Max Points on a Line | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/149.%20Max%20Points%20on%20a%20Line)|

| 150 | Evaluate Reverse Polish Notation | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/150.%20Evaluate%20Reverse%20Polish%20Notation)|

| 151 | Reverse Words in a String | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/151.%20Reverse%20Words%20in%20a%20String)|

| 153 | Find Minimum in Rotated Sorted Array | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/153.%20Find%20Minimum%20in%20Rotated%20Sorted%20Array)|

| 160 | Intersection of Two Linked Lists | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/160.%20Intersection%20of%20Two%20Linked%20Lists)|

| 162 | Find Peak Element | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/162.%20Find%20Peak%20Element)|

| 167 | Two Sum II - Input Array Is Sorted | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/167.%20Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted)|

| 171 | Excel Sheet Column Number | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/171.%20Excel%20Sheet%20Column%20Number)|

| 172 | Factorial Trailing Zeroes | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/172.%20Factorial%20Trailing%20Zeroes)|

| 189 | Rotate Array | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/189.%20Rotate%20Array)|

| 191 | Number of 1 Bits | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/191.%20Number%20of%201%20Bits)|

| 198 | House Robber | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/198.%20House%20Robber)|

| 191 | Number of 1 Bits | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/191.%20Number%20of%201%20Bits)|

| 199 | Binary Tree Right Side View | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/199.%20Binary%20Tree%20Right%20Side%20View)|

| 200 | Number of Islands | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/200.%20Number%20of%20Islands)|

| 202 | Happy Number | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/202.%20Happy%20Number)|

| 203 | Remove Linked List Elements | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/203.%20Remove%20Linked%20List%20Elements)|

| 204 | Count Primes | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/204.%20Count%20Primes)|

| 206 | Reverse Linked List | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/206.%20Reverse%20Linked%20List)|

| 207 | Course Schedule | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/207.%20Course%20Schedule)|

| 208 | Implement Trie (Prefix Tree) | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/208.%20Implement%20Trie%20(Prefix%20Tree))|

| 211 | Design Add and Search Words Data Structure | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/211.%20Design%20Add%20and%20Search%20Words%20Data%20Structure)|

| 213 | House Robber II | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/213.%20House%20Robber%20II)|

| 215 | Kth Largest Element in an Array | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/215.%20Kth%20Largest%20Element%20in%20an%20Array)|

| 217 | Contains Duplicate | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/217.%20Contains%20Duplicate)|

| 221 | Maximal Square | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/221.%20Maximal%20Square)|

| 222 | Count Complete Tree Nodes | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/222.%20Count%20Complete%20Tree%20Nodes)|

| 226 | Invert Binary Tree | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/226.%20Invert%20Binary%20Tree)|

| 228 | Summary Ranges | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/228.%20Summary%20Ranges)|

| 230 | Kth Smallest Element in a BST | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/230.%20Kth%20Smallest%20Element%20in%20a%20BST)|

| 231 | Power of Two | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/231.%20Power%20of%20Two)|

| 232 | Implement Queue using Stacks | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/232.%20Implement%20Queue%20using%20Stacks)|

| 233 | Number of Digit One | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/233.%20Number%20of%20Digit%20One)|

| 234 | Palindrome Linked List | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/234.%20Palindrome%20Linked%20List)|

| 235 | Lowest Common Ancestor of a Binary Search Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/235.%20Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree)|

| 236 | Lowest Common Ancestor of a Binary Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/236.%20Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree)|

| 237 | Delete Node in a Linked List | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/237.%20Delete%20Node%20in%20a%20Linked%20List)|

| 238 | Product of Array Except Self | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/238.%20Product%20of%20Array%20Except%20Self)|

| 239 | Sliding Window Maximum | 🔴 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/239.%20Sliding%20Window%20Maximum)|

| 240 | Search a 2D Matrix II | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/240.%20Search%20a%202D%20Matrix%20II)|

| 242 | Valid Anagram | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/242.%20Valid%20Anagram)|

| 257 | Binary Tree Paths | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/257.%20Binary%20Tree%20Paths)|

| 258 | Add Digits | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/258.%20Add%20Digits)|

| 260 | Single Number III | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/260.%20Single%20Number%20III)|

| 263 | Ugly Number | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/263.%20Ugly%20Number)|

| 268 | Missing Number | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/268.%20Missing%20Number)|

| 273 | Integer to English Words | 🔴 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/273.%20Integer%20to%20English%20Words)|

| 278 | First Bad Version | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/278.%20First%20Bad%20Version)|

| 279 | Perfect Squares | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/279.%20Perfect%20Squares)|

| 283 | Move Zeroes | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/blob/main/290.%20Word%20Pattern/README.md)|

| 290 | Word Pattern | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/283.%20Move%20Zeroes)|

| 292 | Nim Game | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/292.%20Nim%20Game)|  

| 300 | Longest Increasing Subsequence | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/300.%20Longest%20Increasing%20Subsequence)| 

| 301 | Remove Invalid Parentheses | 🔴 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/301.%20Remove%20Invalid%20Parentheses)|

| 309 | Best Time to Buy and Sell Stock with Cooldown | 🟡 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/309.%20Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown)|

| 301 | Remove Invalid Parentheses | 🔴 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/301.%20Remove%20Invalid%20Parentheses)|

| 319 | Bulb Switcher | 🟡 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/319.%20Bulb%20Switcher)|

| 322 | Coin Change | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/322.%20Coin%20Change) |

| 326 | Power of Three | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/326.%20Power%20of%20Three)|

| 328 | Odd Even Linked List | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/328.%20Odd%20Even%20Linked%20List)|

| 338 | Counting Bits | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/338.%20Counting%20Bits)|

| 342 | Power of Four | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/342.%20Power%20of%20Four)|

| 344 | Reverse String | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/344.%20Reverse%20String)|

| 347 | Top K Frequent Elements | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/347.%20Top%20K%20Frequent%20Elements)|

| 349 | Intersection of Two Arrays | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/349.%20Intersection%20of%20Two%20Arrays)|

| 350 | Intersection of Two Arrays II | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/350.%20Intersection%20of%20Two%20Arrays%20II)|

| 352 | Data Stream as Disjoint Intervals | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/352.%20Data%20Stream%20as%20Disjoint%20Intervals)|

| 354 | Russian Doll Envelopes | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/354.%20Russian%20Doll%20Envelopes)|

| 367 | Valid Perfect Square | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/367.%20Valid%20Perfect%20Square)|

| 374 | Guess Number Higher or Lower | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/374.%20Guess%20Number%20Higher%20or%20Lower)|

| 382 | Linked List Random Node | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/382.%20Linked%20List%20Random%20Node)|

| 383 | Ransom Note | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/383.%20Ransom%20Note)|

| 387 | First Unique Character in a String | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/387.%20First%20Unique%20Character%20in%20a%20String%202%205)|

| 390 | Elimination Game | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/390.%20Elimination%20Game)|

| 392 | Is Subsequence | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/392.%20Is%20Subsequence)|

| 394 | Decode String | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/394.%20Decode%20String)|

| 404 | Sum of Left Leaves | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/404.%20Sum%20of%20Left%20Leaves)|

| 416 | Partition Equal Subset Sum | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/416.%20Partition%20Equal%20Subset%20Sum)|

| 427 | Construct Quad Tree | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/427.%20Construct%20Quad%20Tree)|

| 437 | Path Sum III | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/437.%20Path%20Sum%20III)|

| 438 | Find All Anagrams in a String | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/438.%20Find%20All%20Anagrams%20in%20a%20String)|

| 441 | Arranging Coins | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/441.%20Arranging%20Coins)|

| 442 | Find All Duplicates in an Array | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/442.%20Find%20All%20Duplicates%20in%20an%20Array)|

| 443 | String Compression | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/443.%20String%20Compression)|

| 445 | Add Two Numbers II | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/445.%20Add%20Two%20Numbers%20II)|

| 450 | Delete Node in a BST | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/450.%20Delete%20Node%20in%20a%20BST)|

| 451 | Sort Characters By Frequency | 🟡 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/451.%20Sort%20Characters%20By%20Frequency)|

| 452 | Minimum Number of Arrows to Burst Balloons | 🟡 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/452.%20Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons)|

| 460 | LFU Cache | 🔴 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/460.%20LFU%20Cache)|

| 472 | Concatenated Words | 🔴 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/472.%20Concatenated%20Words)|

| 486 | Predict The Winner | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/486.%20Predict%20the%20Winner)|

| 491 | Non-decreasing Subsequences | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/491.%20Non-decreasing%20Subsequences)|

| 496 | Next Greater Element I | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/496.%20Next%20Greater%20Element%20I)|

| 502 | IPO | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/502.%20IPO)|

| 506 | Relative Ranks | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/506.%20Relative%20Ranks)|

| 508 | Most Frequent Subtree Sum | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/508.%20Most%20Frequent%20Subtree%20Sum)|

| 509 | Fibonacci Number | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/509.%20Fibonacci%20Number)|

| 513 | Find Bottom Left Tree Value | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/513.%20Find%20Bottom%20Left%20Tree%20Value)|

| 515 | Find Largest Value in Each Tree Row | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/515.%20Find%20Largest%20Value%20in%20Each%20Tree%20Row)|

| 520 | Detect Capital | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/520.%20Detect%20Capital)|

| 530 | Minimum Absolute Difference in BST | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/530.%20Minimum%20Absolute%20Difference%20in%20BST)|

| 538 | Convert BST to Greater Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/538.%20Convert%20BST%20to%20Greater%20Tree)|

| 542 | 01 Matrix | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/542.%2001%20Matrix)|

| 543 | Diameter of Binary Tree | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/543.%20Diameter%20of%20Binary%20Tree)|

| 547 | Number of Provinces | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/547.%20Number%20of%20Provinces)|

| 557 | Reverse Words in a String III | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/557.%20Reverse%20Words%20in%20a%20String%20III)|

| 567 | Permutation in String | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/567.%20Permutation%20in%20String)|

| 563 | Binary Tree Tilt | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/563.%20Binary%20Tree%20Tilt)|

| 593 | Valid Square | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/593.%20Valid%20Square)|

| 617 | Merge Two Binary Trees | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/617.%20Merge%20Two%20Binary%20Trees)|

| 622 | Design Circular Queue | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/622.%20Design%20Circular%20Queue)|

| 632 | Smallest Range Covering Elements from K Lists | 🔴 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/632.%20Smallest%20Range%20Covering%20Elements%20from%20K%20Lists)|

| 633 | Sum of Square Numbers | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/633.%20Sum%20of%20Square%20Numbers)|

| 637 | Average of Levels in Binary Tree | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/637.%20Average%20of%20Levels%20in%20Binary%20Tree)|

| 649 | Dota2 Senate | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/649.%20Dota2%20Senate)|

| 652 | Find Duplicate Subtrees | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/652.%20Find%20Duplicate%20Subtrees)|

| 653 | Two Sum IV - Input is a BST | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/653.%20Two%20Sum%20IV%20-%20Input%20is%20a%20BST)|

| 654 | Maximum Binary Tree | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/654.%20Maximum%20Binary%20Tree)|

| 662 | Maximum Width of Binary Tree | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/662.%20Maximum%20Width%20of%20Binary%20Tree)|

| 670 | Maximum Swap | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/670.%20Maximum%20Swap)|

| 700 | Search in a Binary Search Tree | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/700.%20Search%20in%20a%20Binary%20Search%20Tree)|

| 701 | Insert into a Binary Search Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/701.%20Insert%20into%20a%20Binary%20Search%20Tree)|

| 703 | Kth Largest Element in a Stream | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/703.%20Kth%20Largest%20Element%20in%20a%20Stream)|

| 704 | Binary Search | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/704.%20Binary%20Search)|

| 705 | Design HashSet | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/705.%20Design%20HashSet)|

| 724 | Find Pivot Index | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/724.%20Find%20Pivot%20Index)| 

| 733 | Flood Fill | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/733.%20Flood%20Fill)|

| 739 | Daily Temperatures | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/739.%20Daily%20Temperatures)|

| 740 | Delete and Earn | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/740.%20Delete%20and%20Earn)|

| 743 | Network Delay Time | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/743.%20Network%20Delay%20Time)|

| 744 | Find Smallest Letter Greater Than Target | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/744.%20Find%20Smallest%20Letter%20Greater%20Than%20Target)|

| 748 | Shortest Completing Word | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/748.%20Shortest%20Completing%20Word)|

| 779 | K-th Symbol In Grammar | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/779.%20K-th%20Symbol%20in%20Grammar)|

| 783 | Minimum Distance Between BST Nodes | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/783.%20Minimum%20Distance%20Between%20BST%20Nodes)|

| 785 | Is Graph Bipartite? | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/785.%20Is%20Graph%20Bipartite%3F)|

| 787 | Cheapest Flights Within K Stops | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/787.%20Cheapest%20Flights%20Within%20K%20Stops)|

| 790 | Domino and Tromino Tiling | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/790.%20Domino%20and%20Tromino%20Tiling)|

| 797 | All Paths From Source to Target | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/797.%20All%20Paths%20From%20Source%20to%20Target)|

| 832 | Flipping an Image | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/832.%20Flipping%20an%20Image)|

| 834 | Sum of Distances in Tree | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/834.%20Sum%20of%20Distances%20in%20Tree)|

| 837 | New 21 Game | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/837.%20New%2021%20Game)|

| 839 | Similar String Groups | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/839.%20Similar%20String%20Groups)|

| 841 | Keys and Rooms | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/841.%20Keys%20and%20Rooms)|

| 844 | Backspace String Compare | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/844.%20Backspace%20String%20Compare)|

| 852 | Peak Index in a Mountain Array | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/852.%20Peak%20Index%20in%20a%20Mountain%20Array)|

| 863 | All Nodes Distance K in Binary Tree | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/863.%20All%20Nodes%20Distance%20K%20in%20Binary%20Tree)|

| 872 | Leaf-Similar Trees | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/872.%20Leaf-Similar%20Trees)|

| 875 | Koko Eating Bananas | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/875.%20Koko%20Eating%20Bananas)|

| 876 | Middle of the Linked List | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/876.%20Middle%20of%20the%20Linked%20List)|

| 879 | Profitable Schemes | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/879.%20Profitable%20Schemes)|

| 881 | Boats to Save People | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/881.%20Boats%20to%20Save%20People)|

| 886 | Possible Bipartition | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/886.%20Possible%20Bipartition)|

| 904 | Fruit Into Baskets | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/904.%20Fruit%20Into%20Baskets)|

| 909 | Snakes and Ladders | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/909.%20Snakes%20and%20Ladders)|

| 912 | Sort An Array | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/912.%20Sort%20an%20Array)|

| 921 | Minimum Add to Make Parentheses Valid | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/921.%20Minimum%20Add%20to%20Make%20Parentheses%20Valid)|

| 926 | Flip String to Monotone Increasing | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/926.%20Flip%20String%20to%20Monotone%20Increasing)|

| 931 | Minimum Falling Path Sum | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/931.%20Minimum%20Falling%20Path%20Sum)|

| 934 | Shortest Bridge | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/934.%20Shortest%20Bridge)|

| 938 | Range Sum of BST | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/blob/main/938.%20Range%20Sum%20of%20BST)|

| 944 | Delete Columns to Make Sorted | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/944.%20Delete%20Columns%20to%20Make%20Sorted)|

| 946 | Validate Stack Sequences | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/946.%20Validate%20Stack%20Sequences)|

| 953 | Verifying an Alien Dictionary | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/953.%20Verifying%20an%20Alien%20Dictionary)|

| 958 | Check Completeness of a Binary Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/958.%20Check%20Completeness%20of%20a%20Binary%20Tree)|

| 983 | Minimum Cost For Tickets | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/983.%20Minimum%20Cost%20For%20Tickets)|

| 974 | Subarray Sums Divisible by K | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/974.%20Subarray%20Sums%20Divisible%20by%20K)|

| 977 | Squares of a Sorted Array | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/977.%20Squares%20of%20a%20Sorted%20Array)|

| 980 | Unique Paths III | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/980.%20Unique%20Paths%20III)|

| 989 | Add to Array-Form of Integer | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/989.%20Add%20to%20Array-Form%20of%20Integer)|

| 994 | Rotting Oranges | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/994.%20Rotting%20Oranges)|

| 997 | Find the Town Judge | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/997.%20Find%20the%20Town%20Judge)|

| 1003 | Check If Word Is Valid After Substitutions | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1003.%20Check%20If%20Word%20Is%20Valid%20After%20Substitutions)|

| 1008 | Construct Binary Search Tree from Preorder Traversal | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1008.%20Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal)|

| 1009 | Complement of Base 10 Integer | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1009.%20Complement%20of%20Base%2010%20Integer)|

| 1011 | Capacity To Ship Packages Within D Days | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1011.%20Capacity%20To%20Ship%20Packages%20Within%20D%20Days)|

| 1009 | Complement of Base 10 Integer | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1009.%20Complement%20of%20Base%2010%20Integer)|

| 1020 | Number of Enclaves | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1020.%20Number%20of%20Enclaves)|

| 1026 | Maximum Difference Between Node and Ancestor | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1026.%20Maximum%20Difference%20Between%20Node%20and%20Ancestor)|

| 1029 | Two City Scheduling | 🟡 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/1029.%20Two%20City%20Scheduling)| 

| 1035 | Uncrossed Lines | 🟡 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/1035.%20Uncrossed%20Lines)|

| 1038 | Binary Search Tree to Greater Sum Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1038.%20Binary%20Search%20Tree%https://github.com/SahilK-027/LeetCode/tree/main/989.%20Add%20to%20Array-Form%20of%20Integer20to%20Greater%20Sum%20Tree)|

| 1039 | Minimum Score Triangulation of Polygon | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1039.%20Minimum%20Score%20Triangulation%20of%20Polygon)|

| 1046 | Last Stone Weight | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1046.%20Last%20Stone%20Weight)|

| 1047 | Remove All Adjacent Duplicates In String | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1047.%20Remove%20All%20Adjacent%20Duplicates%20In%20String)|

| 1061 | Lexicographically Smallest Equivalent String | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1061.%20Lexicographically%20Smallest%20Equivalent%20String)|

| 1047 | Remove All Adjacent Duplicates In String | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1047.%20Remove%20All%20Adjacent%20Duplicates%20In%20String)|

| 1071 | Greatest Common Divisor of Strings | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1071.%20Greatest%20Common%20Divisor%20of%20Strings)|

| 1129 | Shortest Path with Alternating Colors | 🟡 |[solution](https://github.com/SahilK-027/LeetCode/tree/main/1129.%20Shortest%20Path%20with%20Alternating%20Colors)

| 1143 | Longest Common Subsequence | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1143.%20Longest%20Common%20Subsequence)|

| 1155 | Number of Dice Rolls With Target Sum | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1155.%20Number%20of%20Dice%20Rolls%20With%20Target%20Sum)|

| 1162 | As Far from Land as Possible | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1162.%20As%20Far%20from%20Land%20as%20Possible)|

| 1207 | Unique Number of Occurrences | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1207.%20Unique%20Number%20of%20Occurrences)|

| 1254 | Number of Closed Islands | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1254.%20Number%20of%20Closed%20Islands)|

| 1281 | Subtract the Product and Sum of Digits of an Integer | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1281.%20Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer)|

| 1290 | Convert Binary Number in a Linked List to Integer | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1290.%20Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer)|

| 1312 | Minimum Insertion Steps to Make a String Palindrome | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1312.%20Minimum%20Insertion%20Steps%20to%20Make%20a%20String%20Palindrome)|

| 1319 | Number of Operations to Make Network Connected | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1319.%20Number%20of%20Operations%20to%20Make%20Network%20Connected)|

| 1325 | Delete Leaves With a Given Value | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1325.%20Delete%20Leaves%20With%20a%20Given%20Value)|

| 1334 | Find the City With the Smallest Number of Neighbors at a Threshold Distance | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1334.%20Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance)|

| 1339 | Maximum Product of Splitted Binary Tree | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1339.%20Maximum%20Product%20of%20Splitted%20Binary%20Tree)|

| 1342 | Number of Steps to Reduce a Number to Zero | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1342.%20Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero)|

| 1345 | Jump Game IV | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1345.%20Jump%20Game%20IV)|

| 1342 | Number of Steps to Reduce a Number to Zero | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1342.%20Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero)|

| 1373 | Maximum Sum BST in Binary Tree | 🔴 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1373.%20Maximum%20Sum%20BST%20in%20Binary%20Tree)|

| 1382 | Balance a Binary Search Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1382.%20Balance%20a%20Binary%20Search%20Tree)|

| 1388 | Pizza With 3n Slices | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1388.%20Pizza%20With%203n%20Slices)|

| 1390 | Four Divisors | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1390.%20Four%20Divisors)|

| 1402 | Reducing Dishes | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1402.%20Reducing%20Dishes)|

| 1416 | Restore The Array | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1416.%20Restore%20The%20Array)|

| 1431 | Kids With the Greatest Number of Candies | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1431.%20Kids%20With%20the%20Greatest%20Number%20of%20Candies)|

| 1443 | Minimum Time to Collect All Apples in a Tree | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1443.%20Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree)|

| 1444 | Number of Ways of Cutting a Pizza | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1444.%20Number%20of%20Ways%20of%20Cutting%20a%20Pizza)|

| 1448 | Count Good Nodes in Binary Tree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1448.%20Count%20Good%20Nodes%20in%20Binary%20Tree)|

| 1466 | Reorder Routes to Make All Paths Lead to the City Zero | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1466.%20Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero)|

| 1470 | Shuffle the Array | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1470.%20Shuffle%20the%20Array)|

| 1472 | Design Browser History | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1472.%20Design%20Browser%20History)|

| 1487 | Making File Names Unique | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1487.%20Making%20File%20Names%20Unique)|

| 1491 | Average Salary Excluding the Minimum and Maximum Salary | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1491.%20Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary)|

| 1492 | The kth Factor of n | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1492.%20The%20kth%20Factor%20of%20n)|

| 1498 | Number of Subsequences That Satisfy the Given Sum Condition | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1498.%20Number%20of%20Subsequences%20That%20Satisfy%20the%20Given%20Sum%20Condition)|

| 1512 | Number of Good Pairs | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1512.%20Number%20of%20Good%20Pairs)|

| 1518 | Water Bottles | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1518.%20Water%20Bottles)|

| 1519 | Number of Nodes in the Sub-Tree With the Same Label | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1519.%20Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label)|

| 1523 | Count Odd Numbers in an Interval Range | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1523.%20Count%20Odd%20Numbers%20in%20an%20Interval%20Range)|

| 1539 | Kth Missing Positive Number | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1539.%20Kth%20Missing%20Positive%20Number)|

| 1544 | Make The String Great | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1544.%20Make%20The%20String%20Great)|

| 1557 | Minimum Number of Vertices to Reach All Nodes | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1557.%20Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes)|

| 1572 | Matrix Diagonal Sum | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1572.%20Matrix%20Diagonal%20Sum)|

| 1579 | Remove Max Number of Edges to Keep Graph Fully Traversable | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1579.%20Remove%20Max%20Number%20of%20Edges%20to%20Keep%20Graph%20Fully%20Traversable)|

| 1626 | Best Team With No Conflicts | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1626.%20Best%20Team%20With%20No%20Conflicts)|

| 1639 | Number of Ways to Form a Target String Given a Dictionary | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1639.%20Number%20of%20Ways%20to%20Form%20a%20Target%20String%20Given%20a%20Dictionary)|

| 1655 | Distribute Repeating Integers | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1655.%20Distribute%20Repeating%20Integers)|

| 1657 | Determine if Two Strings Are Close | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1657.%20Determine%20if%20Two%20Strings%20Are%20Close)|

| 1662 | Check If Two String Arrays are Equivalent | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1662.%20Check%20If%20Two%20String%20Arrays%20are%20Equivalent)|

| 1672 | Richest Customer Wealth | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1672.%20Richest%20Customer%20Wealth)|

| 1691 | Maximum Height by Stacking Cuboids | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1691.%20Maximum%20Height%20by%20Stacking%20Cuboids)|

| 1697 | Checking Existence of Edge Length Limited Paths | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1697.%20Checking%20Existence%20of%20Edge%20Length%20Limited%20Paths)|

| 1704 | Determine if String Halves Are Alike | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1704.%20Determine%20if%20String%20Halves%20Are%20Alike)|

| 1721 | Swapping Nodes in a Linked List | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1721.%20Swapping%20Nodes%20in%20a%20Linked%20List)|

| 1723 | Find Minimum Time to Finish All Jobs | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1723.%20Find%20Minimum%20Time%20to%20Finish%20All%20Jobs)|

| 1752 | Check if Array Is Sorted and Rotated | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1752.%20Check%20if%20Array%20Is%20Sorted%20and%20Rotated)|

| 1768 | Merge Strings Alternately | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1768.%20Merge%20Strings%20Alternately)|

| 1791 | Find Center of Star Graph | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1791.%20Find%20Center%20of%20Star%20Graph)|

| 1823 | Find the Winner of the Circular Game | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1823.%20Find%20the%20Winner%20of%20the%20Circular%20Game)|

| 1822 | Sign of the Product of an Array | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1822.%20Sign%20of%20the%20Product%20of%20an%20Array)|

| 1824 | Minimum Sideway Jumps | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1824.%20Minimum%20Sideway%20Jumps)|

| 1833 | Maximum Ice Cream Bars | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1833.%20Maximum%20Ice%20Cream%20Bars)|

| 1834 | Single-Threaded CPU | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1834.%20Single-Threaded%20CPU)|

| 1857 | Largest Color Value in a Directed Graph | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1857.%20Largest%20Color%20Value%20in%20a%20Directed%20Graph)|

| 1863 | Sum of All Subset XOR Totals | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/blob/main/1863.%20Sum%20of%20All%20Subset%20XOR%20Totals)|

| 1894 | Find the Student that Will Replace the Chalk | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1894.%20Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk)|

| 1910 | Remove All Occurrences of a Substring | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/1910.%20Remove%20All%20Occurrences%20of%20a%20Substring)|

| 1962 | Remove Stones to Minimize the Total | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1962.%20Remove%20Stones%20to%20Minimize%20the%20Total)|

| 1963 | Minimum Number of Swaps to Make the String Balanced | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1963.%20Minimum%20Number%20of%20Swaps%20to%20Make%20the%20String%20Balanced)|

| 1964 | Find the Longest Valid Obstacle Course at Each Position | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1964.%20Find%20the%20Longest%20Valid%20Obstacle%20Course%20at%20Each%20Position)|

| 1971 | Find if Path Exists in Graph | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/1971.%20Find%20if%20Path%20Exists%20in%20Graph)|

| 2095 | Delete the Middle Node of a Linked List | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/2095.%20Delete%20the%20Middle%20Node%20of%20a%20Linked%20List)|

| 2130 | Maximum Twin Sum of a Linked List | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2130.%20Maximum%20Twin%20Sum%20of%20a%20Linked%20List)|

| 2140 | Solving Questions With Brainpower | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2140.%20Solving%20Questions%20With%20Brainpower)|

| 2169 | Count Operations to Obtain Zero | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2169.%20Count%20Operations%20to%20Obtain%20Zero)|

| 2181 | Merge Nodes in Between Zeros | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/2181.%20Merge%20Nodes%20in%20Between%20Zeros)|

| 2187 | Minimum Time to Complete Trips | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2187.%20Minimum%20Time%20to%20Complete%20Trips)|

| 2215 | Find the Difference of Two Arrays | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2215.%20Find%20the%20Difference%20of%20Two%20Arrays)|

| 2225 | Find Players With Zero or One Losses | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2225.%20Find%20Players%20With%20Zero%20or%20One%20Losses)|

| 2244 | Minimum Rounds to Complete All Tasks | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2244.%20Minimum%20Rounds%20to%20Complete%20All%20Tasks)|

| 2246 | Longest Path With Different Adjacent Characters | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2246.%20Longest%20Path%20With%20Different%20Adjacent%20Characters)|

| 2256 | Minimum Average Difference | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2256.%20Minimum%20Average%20Difference)|

| 2265 | Count Nodes Equal to Average of Subtree | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/2265.%20Count%20Nodes%20Equal%20to%20Average%20of%20Subtree)|

| 2279 | Maximum Bags With Full Capacity of Rocks | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2279.%20Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks)|

| 2300 | Successful Pairs of Spells and Potions | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2300.%20Successful%20Pairs%20of%20Spells%20and%20Potions)|

| 2306 | Naming a Company | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2306.%20Naming%20a%20Company)|

| 2316 | Count Unreachable Pairs of Nodes in an Undirected Graph | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2316.%20Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph)|

| 2336 | Smallest Number in Infinite Set | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2336.%20Smallest%20Number%20in%20Infinite%20Set)|

| 2348 | Number of Zero-Filled Subarrays | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2348.%20Number%20of%20Zero-Filled%20Subarrays)|

| 2359 | Find Closest Node to Given Two Nodes | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2359.%20Find%20Closest%20Node%20to%20Given%20Two%20Nodes)|

| 2360 | Longest Cycle in a Graph | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2360.%20Longest%20Cycle%20in%20a%20Graph)|

| 2367 | Number of Arithmetic Triplets | 🟢 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/2367.%20Number%20of%20Arithmetic%20Triplets)|

| 2385 | Amount of Time for Binary Tree to Be Infected | 🟡 | [solution](https://github.com/Competitive-Programming-SK027/LeetCode/tree/main/2385.%20Amount%20of%20Time%20for%20Binary%20Tree%20to%20Be%20Infected)|

| 2389 | Longest Subsequence With Limited Sum | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2389.%20Longest%20Subsequence%20With%20Limited%20Sum)|

| 2390 | Removing Stars From a String | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2390.%20Removing%20Stars%20From%20a%20String)|

| 2405 | Optimal Partition of String | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2405.%20Optimal%20Partition%20of%20String)|

| 2421 | Number of Good Paths | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2421.%20Number%20of%20Good%20Paths)|

| 2439 | Minimize Maximum of Array | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2439.%20Minimize%20Maximum%20of%20Array)|

| 2444 | Count Subarrays With Fixed Bounds | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/blob/main/2444.%20Count%20Subarrays%20With%20Fixed%20Bounds/README.md)|

| 2466 | Count Ways To Build Good Strings | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2466.%20Count%20Ways%20To%20Build%20Good%20Strings)|

| 2469 | Convert the Temperature | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2469.%20Convert%20the%20Temperature)|

| 2472 | Maximum Number of Non-overlapping Palindrome Substrings | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2471.%20Minimum%20Number%20of%20Operations%20to%20Sort%20a%20Binary%20Tree%20by%20Level)|

| 2477 | Minimum Fuel Cost to Report to the Capital | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2477.%20Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital)|

| 2481 | Minimum Cuts to Divide a Circle | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2481.%20Minimum%20Cuts%20to%20Divide%20a%20Circle)|

| 2477 | Minimum Fuel Cost to Report to the Capital | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2477.%20Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital)|

| 2485 | Find the Pivot Integer | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2485.%20Find%20the%20Pivot%20Integer)|

| 2486 | Append Characters to String to Make Subsequence | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2486.%20Append%20Characters%20to%20String%20to%20Make%20Subsequence)|

| 2487 | Remove Nodes From Linked List | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2487.%20Remove%20Nodes%20From%20Linked%20List)|

| 2490 | Circular Sentence | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2490.%20Circular%20Sentence)|

| 2491 | Divide Players Into Teams of Equal Skill | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2491.%20Divide%20Players%20Into%20Teams%20of%20Equal%20Skill)|

| 2496 | Maximum Value of a String in an Array | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2496.%20Maximum%20Value%20of%20a%20String%20in%20an%20Array)|

| 2500 | Delete Greatest Value in Each Row | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2500.%20Delete%20Greatest%20Value%20in%20Each%20Row)|

| 2501 | Longest Square Streak in an Array | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2501.%20Longest%20Square%20Streak%20in%20an%20Array)|

| 2502 | Design Memory Allocator | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2502.%20Design%20Memory%20Allocator)|

| 2506 | Count Pairs Of Similar Strings | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2506.%20Count%20Pairs%20Of%20Similar%20Strings)|

| 2507 | Smallest Value After Replacing With Sum of Prime Factors | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2507.%20Smallest%20Value%20After%20Replacing%20With%20Sum%20of%20Prime%20Factors)|

| 2515 | Shortest Distance to Target String in a Circular Array | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2515.%20Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array)|

| 2520 | Count the Digits That Divide a Number | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2520.%20Count%20the%20Digits%20That%20Divide%20a%20Number)|

| 2521 | Distinct Prime Factors of Product of Array | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2521.%20Distinct%20Prime%20Factors%20of%20Product%20of%20Array)|

| 2523 | Closest Prime Numbers in Range | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2523.%20Closest%20Prime%20Numbers%20in%20Range)|

| 2535 | Difference Between Element Sum and Digit Sum of an Array | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2535.%20Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array)|

| 2540 | Minimum Common Value | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2540.%20Minimum%20Common%20Value)|

| 2544 | Alternating Digit Sum | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2544.%20Alternating%20Digit%20Sum)|

| 2545 | Sort the Students by Their Kth Score | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2545.%20Sort%20the%20Students%20by%20Their%20Kth%20Score)|

| 2549 | Count Distinct Numbers on Board | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2549.%20Count%20Distinct%20Numbers%20on%20Board)|

| 2551 | Put Marbles in Bags | 🔴 | [solution](https://github.com/SahilK-027/LeetCode/blob/main/2551.%20Put%20Marbles%20in%20Bags/README.md)|

| 2553 | Separate the Digits in an Array | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2553.%20Separate%20the%20Digits%20in%20an%20Array)|

| 2554 | Maximum Number of Integers to Choose From a Range I | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2554.%20Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I)|

| 2558 | Take Gifts From the Richest Pile | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2558.%20Take%20Gifts%20From%20the%20Richest%20Pile)|

| 2562 | Find the Array Concatenation Value | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2562.%20Find%20the%20Array%20Concatenation%20Value)|

| 2563 | Count the Number of Fair Pairs | 🟡 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2563.%20Count%20the%20Number%20of%20Fair%20Pairs)|

| 2570 | Merge Two 2D Arrays by Summing Values | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2570.%20Merge%20Two%202D%20Arrays%20by%20Summing%20Values)|

| 2620 | Counter | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2620.%20Counter) |

| 2665 | Counter II | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2665.%20Counter%20II) |

| 2667 | Create Hello World Function | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2667.%20Create%20Hello%20World%20Function) |

| 2696 | Minimum String Length After Removing Substrings | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2696.%20Minimum%20String%20Length%20After%20Removing%20Substrings) |

| 2697 | Lexicographically Smallest Palindrome | 🟢 | [solution](https://github.com/SahilK-027/LeetCode/tree/main/2697.%20Lexicographically%20Smallest%20Palindrome) |

## Contributors

  

    

      
_{Sahil K.}


      
_{Aaryan C.}


      
_{Nirupama R.}
     

      
_{Shashank B.}


      
_{Yash L.}


      
_{Shubham A.}
ecosyste.ms

Data

Tools

Indexes

Applications

Experiments

Awesome

https://github.com/sahilk-027/leetcode

Awesome Lists containing this project

README
