├── .github └── ISSUE_TEMPLATE │ └── add-a-problem.yml ├── .gitignore ├── CONTRIBUTING.md ├── Easy ├── 1. Two Sum │ ├── README.md │ ├── Solution.cpp │ ├── Solution.cs │ ├── Solution.java │ ├── Solution.js │ ├── Solution.php │ ├── Solution.py │ ├── Solution.rb │ └── Solution.ts ├── 101. Symmetric Tree │ ├── Solution.java │ ├── Solution.py │ └── Solution.rb ├── 104. Maximum Depth of Binary Tree │ ├── README.md │ └── Recursion - 1 │ │ ├── Solution.cpp │ │ ├── Solution.ex │ │ ├── Solution.java │ │ └── Solution.py ├── 108. Convert Sorted Array to Binary Search Tree │ ├── README.md │ ├── Solution.cpp │ ├── Solution.java │ └── Solution.py ├── 111. Minimum Depth of Binary Tree │ ├── README.md │ └── sol.py ├── 119. Pascal's Triangle II │ ├── READme.md │ └── solution.py ├── 121. Best Time to buy and sell stock │ ├── README.md │ ├── Solutioin.js │ ├── Solution.java │ └── sol.md ├── 122. Best Time to Buy and Sell Stock II │ └── 122. Best Time to Buy and Sell Stock II.cpp ├── 13. Roman to Integer │ ├── README.md │ ├── Roman to Integer.cpp │ ├── Solution.java │ └── Solution.py ├── 1337. K Weakest Rows in a Matrix │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 1342. Number of Steps to Reduce a Number to Zero │ ├── README.md │ └── Solution.java ├── 1356. Sort Integers by The Number of 1 Bits │ ├── sol.md │ └── solution.py ├── 14. Longest Common Prefix │ ├── solution.cpp │ └── solution.java ├── 141. Linked List Cycle │ ├── explanantion.md │ ├── sol.cpp │ └── sol.java ├── 141.Linked List Cycle │ ├── README.md │ ├── solution.cpp │ └── solution.java ├── 144. Binary Tree Preorder Traversal │ ├── Solution.java │ └── Solution.kt ├── 145. Binary Tree Postorder Traversal │ ├── Solution.java │ └── Solution.kt ├── 1470. Shuffle the Array │ ├── README.md │ └── Solution.java ├── 1480. Running Sum of 1d Array │ └── Solution.java ├── 1486. XOR Operation in an Array │ ├── README.md │ └── Solution.java ├── 1512. Number of Good Pairs │ ├── NoOfGP.java │ ├── explanation.md.txt │ └── sol.cpp ├── 1523. Count Odd Numbers in an Interval Range │ ├── README.md │ └── Simple Math │ │ ├── SimpleMath.cpp │ │ ├── SimpleMath.java │ │ └── SimpleMath.py ├── 1672. Richest Customer Wealth │ ├── Solution.cpp │ └── Solution.java ├── 169. Majority Element │ ├── solution.cpp │ ├── solution.java │ ├── solution.md │ └── solution.py ├── 1720. Decode XORed Array │ ├── README.md │ └── Solution.java ├── 1920. Build Array from Permutation │ └── Solution.java ├── 1929. Concatenation of Array │ ├── Solution.cpp │ └── Solution.java ├── 20. Valid Parentheses │ └── Solution.java ├── 2011. Final Value of Variable After Performing Operations │ └── Solution.java ├── 206. Reverse Linked List │ ├── Solution.java │ └── Solution.kt ├── 217. Contains Duplicate │ ├── Solution.java │ ├── Solution.js │ └── Solution.kt ├── 222. Count complete Tree Node │ ├── Solution.java │ └── sol.md ├── 226. Invert Binary Tree │ ├── Solution.java │ └── Solution.kt ├── 232. Implement Queue using Stacks │ └── MyQueue.java ├── 235. Lowest Common Ancestor of a Binary Search Tree │ └── Solution.java ├── 2373. Largest Local Values in a Matrix │ ├── README.md │ └── Solution.java ├── 242. Valid Anagram │ └── Solution.js ├── 2423. Remove Letter To Equalize Frequency │ ├── Readme.md │ └── Solution.py ├── 2591. Distribute Money to Maximum Children │ ├── Readme.md │ └── Solution.cpp ├── 26. Remove Duplicates from Sorted Array │ ├── README.md │ ├── Solution.cpp │ ├── Solution.java │ └── Solution.js ├── 2703. Return Length of Arguments Passed │ ├── README.md │ └── solution.js ├── 326. Power of Three │ ├── README.md │ └── Solution.java ├── 342. Power of Four │ ├── Approach 1 │ │ ├── Readme.md │ │ ├── Solution.cpp │ │ └── Solution.java │ ├── Solution.cpp │ └── Solution.java ├── 344. Reverse String │ ├── Solution.cpp │ ├── Solution.java │ └── Solution.js ├── 389. Find the Difference │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 392. Is Subsequence │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 557. Reverse Words in a String III │ ├── README.md │ ├── solution.dart │ ├── solution.java │ ├── solution.js │ └── solution.py ├── 58. Length of Last Word │ ├── Length_of_last_word.js │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 606. Construct String from Binary Tree │ └── README.md ├── 637. Average of Levels in Binary Tree │ ├── README.md │ ├── Solution.cpp │ ├── Solution.java │ └── Solution.py ├── 653. Two Sum IV - Input is a BST │ └── Solution.java ├── 700. Search in a Binary Search Tree │ └── Solution.java ├── 706. Design HashMap │ └── solution.js ├── 73. Set Matrix Zeroes │ └── Solution.java ├── 746.Min Cost Climbing Stairs │ ├── Min Cost Climbing Stairs.cpp │ ├── READme.md │ ├── solution.java │ └── solution.py ├── 844. Backspace String Compare │ └── Solution.js ├── 88. Merge Sorted Array │ ├── README.md │ └── Solution.cpp ├── 896. Monotonic Array │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 9. Palindrome Number │ ├── README.md │ ├── Solution.cpp │ ├── Solution.java │ ├── Solution.js │ ├── Solution.py │ └── Solution.rb ├── 905. Sort Array by Parity │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 94. Binary Tree Inorder Traversal │ ├── README.md │ ├── Solution.java │ └── Solution.rb └── README.md ├── Hard ├── 10. Regular Expression Matching │ ├── README.md │ └── sol.py ├── 1095. Find in Mountain Array │ ├── READEME.md │ └── solution.py ├── 115. Distinct Subsequences │ ├── Approach 1 │ │ ├── sol.md │ │ ├── solution.go │ │ ├── solution.py │ │ ├── solution.rust │ │ └── solution.scala │ ├── README.md │ ├── solution.cpp │ └── solution.java ├── 1203. Sort Items by Groups Respecting Dependencies │ ├── sol.java │ └── sol.md ├── 1220. Count Vowels Permutation │ ├── readme.md │ └── solution.py ├── 1269. Number of Ways to Stay in the Same Place After Some Steps │ ├── Readme.md │ └── solution.py ├── 127. Word Ladder │ ├── README.md │ └── Solution.java ├── 1326. Min no of Taps to Open to Water a Garden │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 135. Candy │ ├── Approach 1 │ │ ├── Readme.md │ │ ├── sloution.java │ │ └── solution.cpp │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 1359. Count All Valid Pickup and Delivery Options │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 1420. build array where you can find maximum exactly k comparison │ ├── Solution.cpp │ ├── Solution.java │ └── Solution.md ├── 1425. Constrained Subsequence Sum │ ├── sol.cpp │ └── sol.java ├── 1458. Max Dot Product of Two Subsequences │ ├── solution.cpp │ ├── solution.java │ ├── solution.md │ └── solution.py ├── 1489. Find Critical and Pseudo-Critical Edges in Min Spanning Tree │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 1793. Maximum Score of a Good Subarray │ ├── README.md │ └── Solution.java ├── 2009. Minimum Number of Operations to Make Array Continuous │ ├── README.md │ └── solution.py ├── 2050. Parallel Courses III │ ├── Reademe.md │ └── solution.py ├── 2141. Maximum Running Time │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 2227. Encrypt and Decrypt String │ ├── README.md │ └── solution.py ├── 2251. Number Of Flowers In Full Bloom │ ├── Solution.cpp │ ├── Solution.java │ └── Solution.md ├── 233. Number of Digit One │ ├── README.md │ └── Sol.java ├── 2366. Min Replacements to Sort an Array │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 239. Sliding Window Max │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 25. Reverse Nodes in k-Group │ └── ListNode.java ├── 273. Integer to English Words │ ├── README.md │ └── Solution.java ├── 2742. Painting the Walls │ ├── Readme.md │ └── solution.py ├── 332. Reconstruct Itinerary │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 34. Find First and Last Position of Element in Sorted Array │ ├── sol.cpp │ ├── sol.java │ ├── sol.md │ └── sol.py ├── 37.Sudoku Solver │ ├── README.md │ └── Sol3.java ├── 4. Median of Two Sorted Arrays │ ├── New approach[Arraylist] │ │ ├── Solution.java │ │ └── sol.md │ ├── New approach[add two array] │ │ └── Solution.java │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 41. First Missing Positive │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 42. Trapping Rain Water │ ├── Approach 1 │ │ ├── sol.md │ │ └── solution.py │ ├── sol.js │ └── sol.md ├── 664. Strange Printer │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 68. Test Justification │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 72. Edit Distance │ ├── Levenshtein │ │ ├── README.md │ │ ├── Solution.java │ │ └── images │ │ │ ├── finding-distance-table.png │ │ │ ├── finding-distance.png │ │ │ ├── intialization-table.png │ │ │ ├── intialization.png │ │ │ └── levenshtein-distance.png │ └── README.md ├── 76. Minimum Window Substring │ ├── README.md │ └── Sol1.java ├── 847. Shortest Path Visiting all Nodes │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 920. Number of Music Playlists │ ├── sol.cpp │ ├── sol.java │ └── sol.md └── README.md ├── LICENSE ├── Medium ├── 1048. Longest String Chain │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 1081. Smallest SubSequence of Distinct Characters │ ├── sol.java │ └── sol.md ├── 11. Container With Most Water │ ├── README.md │ ├── Solution.cpp │ └── Solution.java ├── 12. Integer To Roman │ └── Solution.js ├── 122. Best Time to Buy and Sell Stock II │ ├── sol.md │ └── solution.cpp ├── 134. Gas Station │ ├── Readme.md │ ├── Solution.cpp │ └── Solution.java ├── 134.Gas Station │ ├── solution.cpp │ ├── solution.java │ └── solution.py ├── 1361. Validate Binary Tree Nodes │ ├── Readme.md │ └── solution.py ├── 142. LinkedList Cycle II │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 1448. Count Good Nodes in Binary Tree │ ├── README.md │ └── Solution.java ├── 146. LRU Cache │ ├── README.md │ └── Solution.java ├── 15. 3sum │ ├── README.md │ ├── solution.cpp │ └── solution.java ├── 15.3Sum │ ├── Solution.java │ ├── solution.cpp │ └── solution.md ├── 1503. Last Moment Before All Ants Fall Out of a Plank │ ├── README.md │ └── Solution.java ├── 151. Reverse Words in a String │ ├── Approach 1 │ │ ├── Solution.py │ │ └── sol.md │ ├── Solution.java │ └── sol.md ├── 153. Find Minimum in Rotated Sorted Array │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 1584. Min Cost to Connect All Dots │ ├── sol.java │ └── sol.md ├── 1631. Path With Minimum Effort │ ├── sol.java │ └── sol.md ├── 1647. Min Deletions to Make Char Frequencies Unique │ ├── sol.java │ └── sol.md ├── 1658. Minimum Operations to Reduce X to Zero │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 1695. Maximum Erasure Value │ ├── README.md │ └── sol.cpp ├── 172. Factorial Trailing Zeroes │ ├── Solution.java │ └── sol.md ├── 179. Largest Number │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 18. 4Sum │ └── Solution.java ├── 189. Rotate Array │ ├── README.md │ └── Solution.java ├── 19. Remove nth Node From the End │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 1996. The Number of Weak Characters in the Game │ ├── README.md │ ├── Solution.cpp │ ├── Solution.java │ └── Solution.py ├── 2. Add Two Numbers │ ├── Approach 1 │ │ ├── Readme.md │ │ ├── Solution..cpp │ │ └── Solution.java │ ├── Solution02.java │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 200. Number of Islands │ ├── README.md │ ├── Solution.cpp │ └── Solution.java ├── 2038. Remove Colored Pieces if Both Neighbors are the Same Color │ ├── Readme.md │ ├── Solution.cpp │ └── Solution.java ├── 2038. Remove Colored Pieces if │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 204.CountPrimes │ ├── Count-Primes.java │ └── README.md ├── 215. Kth Largest Element in an Array │ ├── Solution.java │ └── Solution.md ├── 2186. Minimum Number of Steps to Make Two Strings Anagram II │ ├── Solution.java │ └── sol.md ├── 22. Generate Parentheses │ ├── README.md │ └── Solution.java ├── 229. MajorityElement-ll │ ├── README.md │ ├── Solution.cpp │ └── Solution.java ├── 238. Product of Array Except Self │ ├── sol.cpp │ └── sol.md ├── 2433. Find The Original Array of Prefix Xor │ ├── Readme.md │ └── Solution.cpp ├── 2707. Extra Chars in a String │ ├── sol.java │ └── sol.md ├── 274. H-Index │ ├── Readme.md │ ├── Solution.cpp │ └── Solution.java ├── 287. Find Duplicate Number │ ├── New Approach │ │ ├── Solution.java │ │ └── sol.md │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 29. Divide Two Integers │ ├── solution.cpp │ └── solution.md ├── 3. Longest Substring Without Repeating Characters │ └── solution.java ├── 316. Remove Duplicate Letters │ ├── sol.java │ └── sol.md ├── 328. Odd Even Linked List │ ├── README.md │ └── sol.py ├── 33. Search in Rotated Sorted Array │ ├── Solution.java │ └── Solutions.java ├── 34. First and Last Position of Element in an Array │ ├── New Approach │ │ ├── Solution.java │ │ └── sol.md │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 341. Flatten Nested List Iterator │ ├── soln.cpp │ ├── soln.java │ └── soln.py ├── 343. Integer Break │ ├── solution.cpp │ ├── solution.java │ ├── solution.md │ └── solution.py ├── 36. Valid Sudoku │ ├── README.md │ └── Solution.java ├── 380. Insert Delete GetRandom O(1) │ └── RandomizedSet.Java ├── 39. Combination Sum │ ├── README.md │ └── Solution.java ├── 40. Combination Sum II │ ├── README.md │ └── Solution.java ├── 429. N-ary Tree Level Order Traversal │ └── README.md ├── 43. Multiply Strings │ ├── README.md │ └── Solution.java ├── 456. 132 Pattern │ ├── README.md │ └── sol.py ├── 47. Permutations II │ ├── README.md │ └── Solution.java ├── 48. Rotate Image │ ├── README.md │ ├── Solution.cpp │ └── Solution.java ├── 5. Longest Palindromic String │ └── longestPalindromic.cpp ├── 5. Longest Palindromic Substring │ ├── Solution.cpp │ ├── Solution.java │ ├── Solution.md │ ├── Solution2.java │ ├── Solution2.md │ └── chiku011solution.cpp ├── 515. Find Largest Value in Each Tree Row │ ├── sol.cpp │ └── sol.md ├── 55. Jump Game │ ├── README.md │ ├── Solution.cpp │ └── Solution.java ├── 560. Subarray Sum Equals K │ ├── readme.md │ └── solution.js ├── 6. Zigzag Conversion │ ├── README.md │ ├── solution.cpp │ └── solution.java ├── 61. Rotate List │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 62. Unique Paths │ ├── sol.java │ └── sol.md ├── 63. Unique Paths II │ ├── README.md │ └── Solution.java ├── 7. Reverse Integer │ ├── Constant space approach │ │ ├── Solution.java │ │ └── Solution.md │ ├── sol.cpp │ ├── sol.java │ └── sol.md ├── 725. Split List in Parts │ ├── sol.java │ └── sol.md ├── 779. K-th Symbol in Grammar │ ├── Kth_Symbol.cpp │ ├── Kth_Symbol.java │ └── README.md ├── 8. String to Integer (atoi) │ └── Solution.js ├── 80. Remove-duplicates-from-sorted-array │ └── remove-duplicates.py ├── 814. Binary Tree Pruning │ └── README.md ├── 823. Binary Trees With Factors │ ├── README.md │ └── Solution.java ├── 853. Car Fleet │ ├── README.md │ └── Solution.js ├── 967. Numbers With Same Consecutive Differences │ ├── README.md │ ├── Solution.cpp │ ├── Solution.java │ └── Solution.py ├── 974. Subarray Sums Divisible by K │ ├── README.md │ ├── Solution.cpp │ ├── Solution.java │ └── Solution.py ├── 98. Valid BST │ ├── README.md │ ├── solution.cpp │ └── solution.java └── README.md ├── README.md └── _config.yml /.github/ISSUE_TEMPLATE/add-a-problem.yml: -------------------------------------------------------------------------------- 1 | name: "❔ Add a Problem" 2 | description: "Add a LeetCode problem." 3 | title: "[PROBLEM] 0. Problem Title" 4 | labels: 5 | # - "hacktoberfest" 6 | - "problem" 7 | body: 8 | - type: dropdown 9 | id: problem-difficulty 10 | attributes: 11 | label: Difficulty 12 | description: "The difficulty of the problem." 13 | options: 14 | - Easy 15 | - Medium 16 | - Hard 17 | validations: 18 | required: true 19 | 20 | - type: textarea 21 | id: problem-description 22 | attributes: 23 | label: Problem Description 24 | description: "The description of the problem." 25 | placeholder: "You are given..." 26 | validations: 27 | required: true 28 | 29 | - type: input 30 | id: problem-link 31 | attributes: 32 | label: Link 33 | description: "The link of the problem." 34 | placeholder: "https://leetcode.com/problems/two-sum/" 35 | validations: 36 | required: false 37 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | directories.ipynb 2 | .vscode/ 3 | lib/ -------------------------------------------------------------------------------- /Easy/1. Two Sum/Solution.cpp: -------------------------------------------------------------------------------- 1 | // Using HashMap 2 | class Solution { 3 | public: 4 | vector twoSum(vector& nums, int target) { 5 | unordered_map map; 6 | for(int i = 0; i < nums.size(); i++){ 7 | int pair = target - nums[i]; 8 | if(map.count(pair)) return {map[pair], i}; 9 | map[nums[i]] = i; 10 | } 11 | return {}; 12 | } 13 | }; 14 | -------------------------------------------------------------------------------- /Easy/1. Two Sum/Solution.cs: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public int[] TwoSum(int[] nums, int target) { 3 | Dictionary map = new Dictionary(); 4 | for (int i = 0; i < nums.Length; i++) { 5 | int complement = target - nums[i]; 6 | if (map.ContainsKey(complement)) { 7 | return new int[] { map[complement], i }; 8 | } 9 | map[nums[i]] = i; 10 | } 11 | throw new Exception("No two sum solution"); 12 | } 13 | 14 | } -------------------------------------------------------------------------------- /Easy/1. Two Sum/Solution.java: -------------------------------------------------------------------------------- 1 | // Using HashMap 2 | class Solution { 3 | public int[] twoSum(int[] nums, int target) { 4 | Map map = new HashMap(); 5 | for(int i = 0; i < nums.length; i++){ 6 | int pair = target - nums[i]; 7 | if(map.containsKey(pair)) 8 | return new int[]{map.get(pair), i}; 9 | map.put(nums[i], i); 10 | } 11 | return new int[]{}; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Easy/1. Two Sum/Solution.php: -------------------------------------------------------------------------------- 1 | List[int]: 3 | d = {} 4 | for i, num in enumerate(nums): 5 | if target - num in d: 6 | return [d[target - num], i] 7 | d[num] = i 8 | return [] 9 | -------------------------------------------------------------------------------- /Easy/1. Two Sum/Solution.rb: -------------------------------------------------------------------------------- 1 | def two_sum(nums, target) 2 | hash = {} 3 | nums.each_with_index do |num, idx| 4 | complement = target - num 5 | return [hash[complement], idx] if hash.key?(complement) 6 | hash[num] = idx 7 | end 8 | end -------------------------------------------------------------------------------- /Easy/1. Two Sum/Solution.ts: -------------------------------------------------------------------------------- 1 | function twoSum(nums: number[], target: number): number[] | void { 2 | const numToIndex = new Map(); 3 | for (let i = 0; i < nums.length; i++) { 4 | const complement = target - nums[i]; 5 | if (numToIndex.has(complement)) return [numToIndex.get(complement)!, i]; 6 | numToIndex.set(nums[i], i); 7 | } 8 | return; 9 | } 10 | -------------------------------------------------------------------------------- /Easy/101. Symmetric Tree/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public boolean isSymmetric(TreeNode root) { 3 | if(root==null) return true; 4 | return isMirror(root.left,root.right); 5 | } 6 | 7 | public boolean isMirror(TreeNode p, TreeNode q) { 8 | if(p==null && q==null) return true; 9 | if(p==null || q==null) return false; 10 | return (p.val==q.val) && isMirror(p.left,q.right) && isMirror(p.right,q.left); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Easy/101. Symmetric Tree/Solution.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | 8 | class Solution: 9 | def isSymmetric(self, root: TreeNode) -> bool: 10 | def isMirror(p, q): 11 | if not p and not q: 12 | return True 13 | if not p or not q: 14 | return False 15 | return (p.val == q.val) and isMirror(p.left, q.right) and isMirror(p.right, q.left) 16 | 17 | return isMirror(root, root) 18 | -------------------------------------------------------------------------------- /Easy/101. Symmetric Tree/Solution.rb: -------------------------------------------------------------------------------- 1 | def is_symmetric(root) 2 | return true if root.nil? 3 | queue = [root.left, root.right] 4 | while !queue.empty? 5 | left = queue.shift 6 | right = queue.shift 7 | return false if left.nil? && !right.nil? || !left.nil? && right.nil? 8 | return false if !left.nil? && !right.nil? && left.val != right.val 9 | queue.push(left.left) if !left.nil? 10 | queue.push(right.right) if !right.nil? 11 | queue.push(left.right) if !left.nil? 12 | queue.push(right.left) if !right.nil? 13 | end 14 | true 15 | end 16 | -------------------------------------------------------------------------------- /Easy/104. Maximum Depth of Binary Tree/Recursion - 1/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxDepth(TreeNode* root) { 4 | return traverse(root, 0); 5 | } 6 | 7 | int traverse(TreeNode* node, int depth) { 8 | if(!node) { 9 | return depth; 10 | } 11 | return max( 12 | traverse(node->left,depth), 13 | traverse(node->right,depth) 14 | ) + 1; 15 | } 16 | }; -------------------------------------------------------------------------------- /Easy/104. Maximum Depth of Binary Tree/Recursion - 1/Solution.ex: -------------------------------------------------------------------------------- 1 | defmodule TreeNode do 2 | defstruct val: 0, left: nil, right: nil 3 | end 4 | 5 | defmodule Solution do 6 | def max_depth(nil), do: 0 7 | def max_depth(%TreeNode{left: left, right: right}) do 8 | 1 + max(max_depth(left), max_depth(right)) 9 | end 10 | end -------------------------------------------------------------------------------- /Easy/104. Maximum Depth of Binary Tree/Recursion - 1/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int maxDepth(TreeNode root) { 3 | return traverse(root, 0); 4 | } 5 | 6 | public int traverse(TreeNode node, int depth) { 7 | if(node == null) { 8 | return depth; 9 | } 10 | return Math.max( 11 | traverse(node.left, depth), 12 | traverse(node.right, depth) 13 | ) + 1; 14 | } 15 | } -------------------------------------------------------------------------------- /Easy/104. Maximum Depth of Binary Tree/Recursion - 1/Solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxDepth(self, root: Optional[TreeNode]) -> int: 3 | return self.traverse(root, 0) 4 | 5 | def traverse(self, node: Optional[TreeNode], depth) -> int: 6 | return depth if not node else max(self.traverse(node.left, depth), self.traverse(node.right, depth)) + 1 -------------------------------------------------------------------------------- /Easy/108. Convert Sorted Array to Binary Search Tree/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | TreeNode* createBST(vector nums, int s, int e) { 4 | if (s > e) return NULL; 5 | 6 | int mid = s + (e - s) / 2; 7 | 8 | TreeNode* root = new TreeNode(nums[mid]); 9 | root->left = createBST(nums, s, mid - 1); 10 | root->right = createBST(nums, mid + 1, e); 11 | return root; 12 | } 13 | 14 | TreeNode* sortedArrayToBST(vector& nums) { 15 | int s = 0; 16 | int e = nums.size() - 1; 17 | return createBST(nums, s, e); 18 | } 19 | }; -------------------------------------------------------------------------------- /Easy/108. Convert Sorted Array to Binary Search Tree/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * public class TreeNode { 4 | * int val; 5 | * TreeNode left; 6 | * TreeNode right; 7 | * TreeNode() {} 8 | * TreeNode(int val) { this.val = val; } 9 | * TreeNode(int val, TreeNode left, TreeNode right) { 10 | * this.val = val; 11 | * this.left = left; 12 | * this.right = right; 13 | * } 14 | * } 15 | */ 16 | class Solution { 17 | public TreeNode sortedArrayToBST(int[] num) { 18 | if (num.length == 0) { 19 | return null; 20 | } 21 | TreeNode head = helper(num, 0, num.length - 1); 22 | return head; 23 | } 24 | 25 | public TreeNode helper(int[] num, int low, int high) { 26 | if (low > high) { 27 | return null; 28 | } 29 | int mid = low + (high-low)/2; 30 | TreeNode node = new TreeNode(num[mid]); 31 | node.left = helper(num, low, mid - 1); 32 | node.right = helper(num, mid + 1, high); 33 | return node; 34 | } 35 | } -------------------------------------------------------------------------------- /Easy/108. Convert Sorted Array to Binary Search Tree/Solution.py: -------------------------------------------------------------------------------- 1 | class TreeNode: 2 | def __init__(self, val=0, left=None, right=None): 3 | self.val = val 4 | self.left = left 5 | self.right = right 6 | 7 | class Solution: 8 | def sortedArrayToBST(self, nums): 9 | if not nums: 10 | return None 11 | head = self.helper(nums, 0, len(nums) - 1) 12 | return head 13 | 14 | def helper(self, nums, low, high): 15 | if low > high: 16 | return None 17 | mid = low + (high - low) // 2 18 | node = TreeNode(nums[mid]) 19 | node.left = self.helper(nums, low, mid - 1) 20 | node.right = self.helper(nums, mid + 1, high) 21 | return node 22 | 23 | -------------------------------------------------------------------------------- /Easy/111. Minimum Depth of Binary Tree/README.md: -------------------------------------------------------------------------------- 1 | # LeetCode 111. 2 | 3 | ## Problem Statement 4 | Given a binary tree, find its minimum depth. The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. Note: A leaf is a node with no children. 5 | 6 | ### Test Cases 7 | 8 | #### Example 1: 9 | - Input: root = [3,9,20,null,null,15,7] 10 | - Output: 2 11 | 12 | #### Example 2: 13 | - Input: root = [2,null,3,null,4,null,5,null,6] 14 | - Output: 5 15 | 16 | ## Solution 17 | To find the minimum depth of a binary tree, we traverse the tree in a recursive manner. We check the depth of the left and right subtrees, and if either of them is zero (indicating an empty subtree), we consider the non-empty one. We return the minimum of the depths of the left and right subtrees plus 1, which represents the minimum depth of the tree. 18 | 19 | ### Complexity 20 | - Time complexity: O(n), where n is the number of nodes in the binary tree. 21 | - Space complexity: O(h), where h is the height of the binary tree. 22 | -------------------------------------------------------------------------------- /Easy/119. Pascal's Triangle II/READme.md: -------------------------------------------------------------------------------- 1 | Given an integer rowIndex, return the rowIndexth (0-indexed) row of the Pascal's triangle. 2 | 3 | In Pascal's triangle, each number is the sum of the two numbers directly above it as shown: 4 | 5 | 6 | 7 | 8 | Example 1: 9 | 10 | Input: rowIndex = 3 11 | Output: [1,3,3,1] 12 | Example 2: 13 | 14 | Input: rowIndex = 0 15 | Output: [1] 16 | Example 3: 17 | 18 | Input: rowIndex = 1 19 | Output: [1,1] 20 | 21 | 22 | Constraints: 23 | 24 | 0 <= rowIndex <= 33 -------------------------------------------------------------------------------- /Easy/119. Pascal's Triangle II/solution.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def getRow(self, rowIndex): 3 | 4 | pascal_triangle = [[] for _ in range(rowIndex + 1)] 5 | 6 | pascal_triangle[0].append(1) 7 | 8 | 9 | for current_row in range(1, rowIndex + 1): 10 | 11 | pascal_triangle[current_row].append(1) 12 | 13 | for j in range(1, len(pascal_triangle[current_row - 1])): 14 | sum_val = pascal_triangle[current_row - 1][j] + pascal_triangle[current_row - 1][j - 1] 15 | pascal_triangle[current_row].append(sum_val) 16 | 17 | pascal_triangle[current_row].append(1) 18 | 19 | return pascal_triangle[rowIndex] -------------------------------------------------------------------------------- /Easy/121. Best Time to buy and sell stock/Solutioin.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} prices 3 | * @return {number} 4 | */ 5 | var maxProfit = function (prices) { 6 | let l = 0; 7 | let r = 1; 8 | let max = 0; 9 | let profit = 0; 10 | 11 | while (r < prices.length) { 12 | profit = prices[r] - prices[l]; 13 | if (profit > 0) { 14 | max = profit > max ? profit : max; 15 | } else { 16 | l = r; 17 | } 18 | r++; 19 | } 20 | return max; 21 | }; 22 | -------------------------------------------------------------------------------- /Easy/121. Best Time to buy and sell stock/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public int maxProfit(int[] prices) { 3 | 4 | int minprice = Integer.MAX_VALUE; 5 | int maxprofit = 0; 6 | 7 | // Iterate through the array of stock prices. 8 | for (int i=0;i maxprofit) 13 | 14 | // Calculate and update the maximum profit. 15 | maxprofit = prices[i] - minprice; 16 | } 17 | // Return the maximum profit. 18 | return maxprofit; 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Easy/122. Best Time to Buy and Sell Stock II/122. Best Time to Buy and Sell Stock II.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution { 7 | public: 8 | int maxProfit(vector& prices) { 9 | int i = 0; 10 | int j = 1; 11 | int maxProfit = 0; 12 | 13 | while(j < prices.size()){ 14 | if(prices[i] < prices[j]){ 15 | maxProfit += prices[j] - prices[i]; 16 | i++; 17 | j++; 18 | }else{ 19 | i++; 20 | j++; 21 | } 22 | } 23 | 24 | return maxProfit; 25 | } 26 | }; 27 | 28 | int main() { 29 | Solution solution; 30 | vector prices; 31 | int n; 32 | cout << "Enter the number of elements: "; 33 | cin >> n; 34 | 35 | cout << "Enter the elements: "; 36 | for (int i = 0; i < n; i++) { 37 | int price; 38 | cin >> price; 39 | prices.push_back(price); 40 | } 41 | 42 | int result = solution.maxProfit(prices); 43 | cout << "Maximum profit: " << result << endl; 44 | 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /Easy/13. Roman to Integer/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | static int num(int i){ 3 | int l=0; 4 | switch(i){ 5 | case 'I' : l= 1; 6 | break; 7 | case 'V' : l= 5; 8 | break; 9 | case 'X' : l= 10; 10 | break; 11 | case 'L' : l= 50; 12 | break; 13 | case 'C' : l= 100; 14 | break; 15 | case 'D' : l= 500; 16 | break; 17 | case 'M' : l= 1000; 18 | break; 19 | } 20 | return l; 21 | } 22 | public int romanToInt(String s) { 23 | int k1,k2; 24 | k1= num(s.charAt(s.length()-1)); 25 | int k =k1; 26 | for(int i = s.length()-2;i>=0;i--){ 27 | k2 = num(s.charAt(i)); 28 | if(k2 int: 4 | summ= 0 5 | for i in range(len(S)-1,-1,-1): 6 | num = roman[S[i]] 7 | if 3*num < summ: 8 | summ = summ-num 9 | else: 10 | summ = summ+num 11 | return summ -------------------------------------------------------------------------------- /Easy/1342. Number of Steps to Reduce a Number to Zero/Solution.java: -------------------------------------------------------------------------------- 1 | // Using Bit Manipulation 2 | class Solution { 3 | public int numberOfSteps(int num) { 4 | if(num == 0) return 0; 5 | int res = 0; 6 | while(num != 0){ 7 | res += (num & 1) == 1 ? 2 : 1; 8 | num >>= 1; 9 | } 10 | return res - 1; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Easy/1356. Sort Integers by The Number of 1 Bits/solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def solve1(x: int) -> int: 3 | count = 0 4 | while x: 5 | x &= (x - 1) 6 | count += 1 7 | return count 8 | 9 | def sortByBits(self,arr: list) -> list: 10 | return sorted(arr, key=lambda x: (Solution.solve1(x), x)) -------------------------------------------------------------------------------- /Easy/14. Longest Common Prefix/solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public String longestCommonPrefix(String[] strs) { 3 | int k=0; 4 | String result= ""; 5 | for(int i=0;i 2 | using namespace std; 3 | 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode(int x) : val(x), next(NULL) {} 8 | }; 9 | 10 | class Solution { 11 | public: 12 | bool hasCycle(ListNode *head) { 13 | 14 | ListNode *slow = head; 15 | ListNode *fast = head; 16 | 17 | while (fast != NULL && fast->next != NULL) { 18 | slow = slow->next; 19 | fast = fast->next->next; 20 | 21 | if (fast == slow) { 22 | return true; 23 | } 24 | } 25 | 26 | return false; 27 | } 28 | }; 29 | 30 | int main() { 31 | // test Solution::hasCycle 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Easy/141. Linked List Cycle/sol.java: -------------------------------------------------------------------------------- 1 | 2 | class ListNode { 3 | int val; 4 | ListNode next; 5 | 6 | ListNode(int x) { 7 | val = x; 8 | next = null; 9 | } 10 | } 11 | 12 | public class sol { 13 | public static void main(String[] args) { 14 | // call your fn here 15 | } 16 | } 17 | 18 | class Solution { 19 | public boolean hasCycle(ListNode head) { 20 | 21 | ListNode slow = head; 22 | ListNode fast = head; 23 | 24 | while (fast != null && fast.next != null) { 25 | slow = slow.next; 26 | fast = fast.next.next; 27 | 28 | if (fast == slow) { 29 | return true; 30 | } 31 | } 32 | return false; 33 | } 34 | } -------------------------------------------------------------------------------- /Easy/141.Linked List Cycle/solution.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | 10 | 11 | class Solution { 12 | public: 13 | bool hasCycle(ListNode *head) { 14 | ListNode *slow_pointer = head, *fast_pointer = head; 15 | while (fast_pointer != nullptr && fast_pointer->next != nullptr) { 16 | slow_pointer = slow_pointer->next; 17 | fast_pointer = fast_pointer->next->next; 18 | if (slow_pointer == fast_pointer) { 19 | return true; 20 | } 21 | } 22 | return false; 23 | } 24 | }; -------------------------------------------------------------------------------- /Easy/141.Linked List Cycle/solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * class ListNode { 4 | * int val; 5 | * ListNode next; 6 | * ListNode(int x) { 7 | * val = x; 8 | * next = null; 9 | * } 10 | * } 11 | */ 12 | 13 | 14 | 15 | public class Solution { 16 | public boolean hasCycle(ListNode head) { 17 | ListNode slow_pointer = head, fast_pointer = head; 18 | while (fast_pointer != null && fast_pointer.next != null) { 19 | slow_pointer = slow_pointer.next; 20 | fast_pointer = fast_pointer.next.next; 21 | if (slow_pointer == fast_pointer) { 22 | return true; 23 | } 24 | } 25 | return false; 26 | } 27 | } -------------------------------------------------------------------------------- /Easy/144. Binary Tree Preorder Traversal/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | List order = new ArrayList(); 3 | public List preorderTraversal(TreeNode root) { 4 | traverse(root); 5 | return order; 6 | } 7 | 8 | public void traverse(TreeNode root){ 9 | if (root == null) return; 10 | order.add(root.val); 11 | traverse(root.left); 12 | traverse(root.right); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Easy/144. Binary Tree Preorder Traversal/Solution.kt: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * class TreeNode(var `val`: Int) { 4 | * var left: TreeNode? = null 5 | * var right: TreeNode? = null 6 | * } 7 | */ 8 | class Solution { 9 | fun preorderTraversal(root: TreeNode?): List { 10 | val result = mutableListOf() 11 | helper(root, result) 12 | return result 13 | } 14 | 15 | fun helper(node: TreeNode?, result: MutableList) { 16 | if (node == null) return 17 | result.add(node.`val`) 18 | helper(node.left, result) 19 | helper(node.right, result) 20 | } 21 | } -------------------------------------------------------------------------------- /Easy/145. Binary Tree Postorder Traversal/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | List order = new ArrayList(); 3 | public List postorderTraversal(TreeNode root) { 4 | traverse(root); 5 | return order; 6 | } 7 | 8 | public void traverse(TreeNode root){ 9 | if(root == null) return; 10 | traverse(root.left); 11 | traverse(root.right); 12 | order.add(root.val); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Easy/145. Binary Tree Postorder Traversal/Solution.kt: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * class TreeNode(var `val`: Int = 0) { 4 | * var left: TreeNode? = null 5 | * var right: TreeNode? = null 6 | * } 7 | */ 8 | class Solution { 9 | fun postorderTraversal(root: TreeNode?): List { 10 | val result = mutableListOf() 11 | if (root == null) return result 12 | 13 | result.addAll(postorderTraversal(root.left)) 14 | result.addAll(postorderTraversal(root.right)) 15 | result.add(root.`val`) 16 | 17 | return result 18 | } 19 | } -------------------------------------------------------------------------------- /Easy/1470. Shuffle the Array/README.md: -------------------------------------------------------------------------------- 1 | # Problem #1470 ([Shuffle the Array](https://leetcode.com/problems/shuffle-the-array/)) 2 | 3 | Given the array `nums` consisting of `2n` elements in the form `[x1,x2,...,xn,y1,y2,...,yn]`. 4 | 5 | Return the array in the form `[x1,y1,x2,y2,...,xn,yn]`. 6 | -------------------------------------------------------------------------------- /Easy/1470. Shuffle the Array/Solution.java: -------------------------------------------------------------------------------- 1 | // Using new array 2 | class Solution { 3 | public int[] shuffle(int[] nums, int n) { 4 | int[] newNums = new int[nums.length]; 5 | int i = 0, j, k; 6 | while (i < nums.length) { 7 | j = i/2; 8 | k = j + n; 9 | newNums[i++] = nums[j]; 10 | newNums[i++] = nums[k]; 11 | } 12 | return newNums; 13 | } 14 | } 15 | 16 | // In-place 17 | class Solution { 18 | public int[] shuffle(int[] nums, int n) { 19 | for(int i = 0; i < n; i++){ 20 | nums[i] += nums[n + i] * 10000; 21 | } 22 | 23 | for(int i = n - 1; i >= 0; i--){ 24 | nums[2 * i + 1] = nums[i] / 10000; 25 | nums[2 * i] = nums[i] % 10000; 26 | } 27 | 28 | return nums; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /Easy/1480. Running Sum of 1d Array/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int[] runningSum(int[] nums) { 3 | int i = 1; 4 | while(i < nums.length){ 5 | nums[i] += nums[i - 1]; 6 | i++; 7 | } 8 | return nums; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /Easy/1486. XOR Operation in an Array/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int xorOperation(int n, int start) { 3 | int res = start; 4 | for(int i = 1; i < n; i++) 5 | res ^= (start + 2 * i); 6 | return res; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Easy/1512. Number of Good Pairs/NoOfGP.java: -------------------------------------------------------------------------------- 1 | public class NoOfGP{ 2 | public static void main(String[] args) { 3 | 4 | } 5 | 6 | class Solution { 7 | public int numIdenticalPairs(int[] nums) { 8 | int ans = 0; 9 | int count[] = new int[101]; 10 | 11 | for(int n:nums) 12 | { 13 | count[n]++; 14 | } 15 | for(int n:count) 16 | { 17 | ans+=(n*(n-1))/2; 18 | } 19 | return ans; 20 | } 21 | } 22 | } -------------------------------------------------------------------------------- /Easy/1512. Number of Good Pairs/explanation.md.txt: -------------------------------------------------------------------------------- 1 | Algorithm: 2 | 3 | 1)Use a count array to store the frequency of each number in the input array. 4 | 2)Iterate through the count array. 5 | 3)For each frequency n, calculate the number of identical pairs as n*(n-1)/2. 6 | 4)Keep adding this to the answer. 7 | 5)Return the answer. 8 | 9 | The reason we can calculate the number of identical pairs as n*(n-1)/2 is because we are counting each pair twice. For example, if we have two identical numbers, we can count them as a pair once for each index. But this means that we have counted them twice, so we need to divide by 2 to get the correct number of pairs. 10 | 11 | Time complexity: O(n) where n is the length of the input array. We traverse the input array only once to populate the count array. Then we traverse the count array which has size 101. So the overall time complexity is O(n). 12 | 13 | Space complexity: O(1) as we use a constant size count array. -------------------------------------------------------------------------------- /Easy/1512. Number of Good Pairs/sol.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numIdenticalPairs(std::vector& nums) { 4 | int ans = 0; 5 | std::vector count(101, 0); 6 | 7 | for (int n : nums) { 8 | count[n]++; 9 | } 10 | 11 | for (int n : count) { 12 | ans += (n * (n - 1)) / 2; 13 | } 14 | 15 | return ans; 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /Easy/1523. Count Odd Numbers in an Interval Range/Simple Math/SimpleMath.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int countOdds(int low, int high) { 4 | return low % 2 == 1 || high % 2 == 1 5 | ? (high - low)/2 + 1 6 | : (high - low)/2; 7 | } 8 | }; -------------------------------------------------------------------------------- /Easy/1523. Count Odd Numbers in an Interval Range/Simple Math/SimpleMath.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int countOdds(int low, int high) { 3 | return low % 2 == 1 || high % 2 == 1 4 | ? (high - low)/2 + 1 5 | : (high - low)/2; 6 | } 7 | } -------------------------------------------------------------------------------- /Easy/1523. Count Odd Numbers in an Interval Range/Simple Math/SimpleMath.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def countOdds(self, low: int, high: int) -> int: 3 | return (high - low)//2 + 1 if low % 2 == 1 or high % 2 == 1 else (high - low)//2 -------------------------------------------------------------------------------- /Easy/1672. Richest Customer Wealth/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maximumWealth(vector>& accounts) { 4 | int max = 0; 5 | for(int i = 0; i < accounts.size(); i++){ 6 | int sum = 0; 7 | for(int j = 0; j < accounts[i].size(); j++){ 8 | sum += accounts[i][j]; 9 | max = max > sum ? max : sum; 10 | } 11 | } 12 | return max; 13 | } 14 | }; -------------------------------------------------------------------------------- /Easy/1672. Richest Customer Wealth/Solution.java: -------------------------------------------------------------------------------- 1 | // Using Steam API 2 | class Solution { 3 | public int maximumWealth(int[][] accounts) { 4 | int max = 0; 5 | for(int[] account: accounts){ 6 | max = Math.max(max, Arrays.stream(account).sum()); 7 | } 8 | return max; 9 | } 10 | } 11 | 12 | // Using for loop 13 | class Solution { 14 | public int maximumWealth(int[][] accounts) { 15 | int max = 0; 16 | 17 | for(int i = 0; i < accounts.length; i++){ 18 | int sum = 0; 19 | for(int j = 0; j < accounts[i].length; j++){ 20 | sum += accounts[i][j]; 21 | } 22 | max = max > sum ? max : sum; 23 | } 24 | 25 | return max; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Easy/169. Majority Element/solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int majorityElement(vector& nums) { 4 | sort(nums.begin(), nums.end()); 5 | int n = nums.size(); 6 | return nums[n/2]; 7 | } 8 | }; -------------------------------------------------------------------------------- /Easy/169. Majority Element/solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int majorityElement(int[] nums) { 3 | Arrays.sort(nums); 4 | int n = nums.length; 5 | return nums[n/2]; 6 | } 7 | } -------------------------------------------------------------------------------- /Easy/169. Majority Element/solution.md: -------------------------------------------------------------------------------- 1 | # PROBLEM 2 | 3 | Given an array nums of size n, return the majority element. 4 | 5 | The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array. 6 | 7 | # EXPLANATION 8 | 9 | 1. The code begins by sorting the array nums in non-decreasing order using the sort function from the C++ Standard Library. This rearranges the elements such that identical elements are grouped together. 10 | 11 | 2. Once the array is sorted, the majority element will always be present at index n/2, where n is the size of the array. 12 | This is because the majority element occurs more than n/2 times, and when the array is sorted, it will occupy the middle position. 13 | 14 | 3. The code returns the element at index n/2 as the majority element. -------------------------------------------------------------------------------- /Easy/169. Majority Element/solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def majorityElement(self, nums: List[int]) -> int: 3 | nums.sort() 4 | n = len(nums) 5 | return nums[n//2] -------------------------------------------------------------------------------- /Easy/1720. Decode XORed Array/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int[] decode(int[] encoded, int first) { 3 | int n = encoded.length; 4 | int[] decoded = new int[n + 1]; 5 | decoded[0] = first; 6 | for(int i = 0; i < n; i++){ 7 | decoded[i + 1] = decoded[i] ^ encoded[i]; 8 | } 9 | return decoded; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Easy/1920. Build Array from Permutation/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int[] buildArray(int[] nums) { 3 | int len = nums.length, i = 0; 4 | int[] newNums = new int[len]; 5 | 6 | for(int num: nums){ 7 | newNums[i++] = nums[num]; 8 | } 9 | 10 | return newNums; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Easy/1929. Concatenation of Array/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector getConcatenation(vector& nums) { 4 | int n = nums.size(); 5 | int m = 2 * n; 6 | vector ans(m); 7 | for(int i = 0; i < n; i++){ 8 | ans[i] = nums[i]; 9 | } 10 | for(int i = 0; i < n; i++){ 11 | ans[n + i] = nums[i]; 12 | } 13 | return ans; 14 | } 15 | }; -------------------------------------------------------------------------------- /Easy/1929. Concatenation of Array/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int[] getConcatenation(int[] nums) { 3 | int len = nums.length; 4 | int[] newNums = new int[2 * len]; 5 | 6 | System.arraycopy(nums, 0, newNums, 0, len); 7 | System.arraycopy(nums, 0, newNums, len, len); 8 | 9 | return newNums; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Easy/2011. Final Value of Variable After Performing Operations/Solution.java: -------------------------------------------------------------------------------- 1 | // Using for loop 2 | 3 | class Solution { 4 | public int finalValueAfterOperations(String[] operations) { 5 | int n = 0; 6 | for(String op: operations){ 7 | if (op.charAt(1) == '+') n++; 8 | else n--; 9 | } 10 | return n; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Easy/206. Reverse Linked List/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public ListNode reverseList(ListNode head) { 3 | return reverse(head, null); 4 | } 5 | 6 | public ListNode reverse(ListNode head, ListNode prev){ 7 | if(head == null) return prev; 8 | ListNode next = head.next; 9 | head.next = prev; 10 | return reverse(next, head); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Easy/206. Reverse Linked List/Solution.kt: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * class ListNode(var `val`: Int) { 4 | * var next: ListNode? = null 5 | * } 6 | */ 7 | class Solution { 8 | fun reverseList(head: ListNode?): ListNode? { 9 | var prev: ListNode? = null 10 | var current = head 11 | while (current != null) { 12 | val next = current.next 13 | current.next = prev 14 | prev = current 15 | current = next 16 | } 17 | return prev 18 | } 19 | } -------------------------------------------------------------------------------- /Easy/217. Contains Duplicate/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public boolean containsDuplicate(int[] nums) { 3 | Set set = new HashSet(); 4 | for(int n: nums){ 5 | if(set.contains(n)) return true; 6 | set.add(n); 7 | } 8 | return false; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /Easy/217. Contains Duplicate/Solution.js: -------------------------------------------------------------------------------- 1 | var containsDuplicate = function (nums) { 2 | for (let i = nums.length - 1; i >= 0; i--) { 3 | for (let j = 0; j < i; j++) { 4 | if (nums[i] === nums[j]) { 5 | return true; 6 | } 7 | } 8 | } 9 | return false; 10 | } 11 | -------------------------------------------------------------------------------- /Easy/217. Contains Duplicate/Solution.kt: -------------------------------------------------------------------------------- 1 | class Solution { 2 | fun containsDuplicate(nums: IntArray): Boolean { 3 | val set = HashSet() 4 | for (num in nums) { 5 | if (!set.add(num)) { 6 | return true 7 | } 8 | } 9 | return false 10 | } 11 | 12 | } -------------------------------------------------------------------------------- /Easy/222. Count complete Tree Node/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public int countNodes(TreeNode root) { 3 | int count = 1; //Root itself should be counted 4 | if (root ==null) { 5 | return 0; 6 | } 7 | else { 8 | count += countNodes(root.left); 9 | count += countNodes(root.right); 10 | return count; 11 | } 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Easy/226. Invert Binary Tree/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public TreeNode invertTree(TreeNode root) { 3 | if (root == null) return root; 4 | invert(root); 5 | return root; 6 | } 7 | 8 | public void invert(TreeNode root){ 9 | if(root == null) return; 10 | TreeNode temp = root.left; 11 | root.left = root.right; 12 | root.right = temp; 13 | invert(root.left); 14 | invert(root.right); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Easy/226. Invert Binary Tree/Solution.kt: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * class TreeNode(var `val`: Int = 0) { 4 | * var left: TreeNode? = null 5 | * var right: TreeNode? = null 6 | * } 7 | */ 8 | class Solution { 9 | fun invertTree(root: TreeNode?): TreeNode? { 10 | if (root == null) return null 11 | val left = invertTree(root.left) 12 | val right = invertTree(root.right) 13 | root.left = right 14 | root.right = left 15 | return root 16 | } 17 | } -------------------------------------------------------------------------------- /Easy/235. Lowest Common Ancestor of a Binary Search Tree/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { 3 | int min = Math.min(p.val, q.val); 4 | int max = Math.max(p.val, q.val); 5 | while(root != null){ 6 | if(root.val > max){ 7 | root = root.left; 8 | } else if (root.val < min) { 9 | root = root.right; 10 | } else { 11 | return root; 12 | } 13 | } 14 | return root; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Easy/2373. Largest Local Values in a Matrix/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int[][] largestLocal(int[][] grid) { 3 | int n=grid.length; 4 | 5 | int[][] ans=new int[n-2][n-2]; 6 | 7 | for(int i=0;i bool: 5 | # Step 1: Count the frequencies of each character using Counter. 6 | c = Counter(word) 7 | 8 | # Step 2: Extract the frequencies and sort them. 9 | freq = sorted([c[i] for i in c]) 10 | 11 | # Step 3: Check if there's only one unique frequency. 12 | if len(freq) == 1: 13 | return True 14 | 15 | # Step 4: Check two conditions to determine if it's possible to make frequencies equal. 16 | # Condition 1: Minimum frequency is 1 and all other frequencies are the same. 17 | # Condition 2: All frequencies except the maximum one are the same, and max frequency is one greater. 18 | if (min(freq) == 1 and len(set(freq[1:])) == 1) or (len(set(freq[:-1])) == 1 and freq[-1] == freq[0] + 1): 19 | return True 20 | 21 | # Step 5: If none of the conditions are met, return False. 22 | return False 23 | -------------------------------------------------------------------------------- /Easy/2591. Distribute Money to Maximum Children/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int distMoney(int money, int children) { 4 | if(money < children) return -1; 5 | 6 | money -= children; //Distributing one coin to each children 7 | int ans = money/7; // only 7 coins left to make it 8 hence divide to by 7 to get the number of children with 8 coins 8 | 9 | // If number of children with 8 coins i.e ans is more than the given children then we can simply give all the remaining coins to one child and rest will have 8 coins hence returning children - 1; 10 | if(ans > children) return children - 1; 11 | 12 | int remaning = money%7; 13 | children -= ans; 14 | if((remaning > 0 && children == 0) || 15 | (remaning == 3 && children == 1)) return ans - 1; 16 | return ans; 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /Easy/26. Remove Duplicates from Sorted Array/Solution.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int removeDuplicates(vector& nums) { 7 | int c = 0; 8 | if (nums.size() == 0) { 9 | return 0; 10 | } 11 | for (int i = 0; nums[i] != nums[nums.size() - 1]; i++) { 12 | int curElm = nums[i], nuOfA = 0, pos = i + 1; 13 | while (pos < nums.size()) { 14 | if (curElm == nums[pos]) { 15 | nuOfA++; 16 | } else { 17 | break; 18 | } 19 | pos++; 20 | } 21 | if (nuOfA > 0) { 22 | shiftByNum(nums, nuOfA, i); 23 | } 24 | c++; 25 | } 26 | 27 | return c + 1; 28 | } 29 | 30 | private: 31 | void shiftByNum(vector& nums, int by, int pos) { 32 | for (int i = pos; i + by < nums.size(); i++) { 33 | nums[i] = nums[i + by]; 34 | } 35 | } 36 | }; 37 | 38 | -------------------------------------------------------------------------------- /Easy/26. Remove Duplicates from Sorted Array/Solution.js: -------------------------------------------------------------------------------- 1 | // Solution # 1 2 | const removeDuplicates = function (nums) { 3 | let uniqueCount = 1; // Initialize the count of unique elements. 4 | 5 | for (let i = 1; i < nums.length; i++) { 6 | if (nums[i] !== nums[i - 1]) { 7 | // If the current element is different from the previous element, it's a new unique element. 8 | nums[uniqueCount] = nums[i]; // Move the unique element to the next position. 9 | uniqueCount++; // Increment the count of unique elements. 10 | } 11 | } 12 | 13 | return uniqueCount; 14 | }; 15 | 16 | // Solution # 2 17 | function removeDuplicates(nums) { 18 | // Use filter to create a new array with unique elements 19 | const uniqueArray = nums.filter((value, index) => nums.indexOf(value) === index); 20 | 21 | // Copy the unique elements back to the original array 22 | for (let i = 0; i < uniqueArray.length; i++) { 23 | nums[i] = uniqueArray[i]; 24 | } 25 | return uniqueArray.length; 26 | } 27 | -------------------------------------------------------------------------------- /Easy/2703. Return Length of Arguments Passed/README.md: -------------------------------------------------------------------------------- 1 | # Problem #2703 ([Return Length of Arguments Passed](https://leetcode.com/problems/return-length-of-arguments-passed/) | Arguments, Length) 2 | 3 | 4 | Write a function `argumentsLength` that returns the count of arguments passed to it. 5 | 6 | 7 | 8 | **Example 1:** 9 | 10 | **Input**: `args = [5]` 11 | **Output**: 1 12 | **Explanation**: 13 | `argumentsLength(5);` // 1 14 | 15 | One value was passed to the function so it should return `1`. 16 | 17 | **Example 2:** 18 | 19 | **Input**: args = [{}, null, "3"] 20 | **Output**: 3 21 | **Explanation**: 22 | `argumentsLength({}, null, "3");` // 3 23 | 24 | Three values were passed to the function so it should return `3`. 25 | 26 | 27 | 28 | Constraints: 29 | 30 | `args` is a valid JSON array 31 | `0 <= args.length <= 100` 32 | -------------------------------------------------------------------------------- /Easy/2703. Return Length of Arguments Passed/solution.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @return {number} 3 | */ 4 | var argumentsLength = function (...args) { 5 | return args.length 6 | }; 7 | 8 | // Time Complexity: O(1) 9 | // Space Complexity: O(1) 10 | 11 | /** 12 | * argumentsLength(1, 2, 3); // 3 13 | */ -------------------------------------------------------------------------------- /Easy/326. Power of Three/README.md: -------------------------------------------------------------------------------- 1 | # LeetCode 326. Power of three 2 | 3 | ## Problem Description 4 | Given an integer `n`, return `true` if it is a power of three. Otherwise, return `false`. 5 | 6 | An integer n is a power of three, if there exists an integer `x` such that `n == 3x`. 7 | 8 | ## Test Cases 9 | 10 | ### Example 1: 11 | 12 | - **Input:** `n = 27` 13 | - **Output:** `true` 14 | - **Explanation:** `27 = 33` 15 | 16 | ### Example 2: 17 | 18 | - **Input:** `n = 0` 19 | - **Output:** `false` 20 | - **Explanation:** `There is no x where 3x = 0.` 21 | 22 | ### Example 3: 23 | 24 | - **Input:** `n = -1` 25 | - **Output:** `false` 26 | - **Explanation:** `There is no x where 3x = (-1).` 27 | 28 | ### Constraints: 29 | 30 | `-231 <= n <= 231 - 1` 31 | 32 | ### Link 33 | 34 | https://leetcode.com/problems/power-of-three/ 35 | -------------------------------------------------------------------------------- /Easy/326. Power of Three/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public boolean isPowerOfThree(int n) { 3 | 4 | if (n <= 0) { 5 | return false; 6 | } 7 | 8 | double logResult = Math.log10(n) / Math.log10(3); 9 | 10 | return Math.floor(logResult) == logResult; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Easy/342. Power of Four/Approach 1/Readme.md: -------------------------------------------------------------------------------- 1 | 2 | +Check if the input integer n is equal to 1. If it is, return true since 1 is a power of four. 3 | +If n is non-positive (less than or equal to 0), return false since powers of four are positive integers. 4 | +Calculate the logarithm of 'n' with a base of 4 and store the result in the variable 'logarithmBase4.' 5 | +Check if 'logarithmBase4' is an integer by comparing it to its integer cast. If they are equal, return true; otherwise, return false. 6 | 7 | Complexity 8 | 9 | --Time complexity: O(1)O(1)O(1) 10 | Since we are only doing math operations without any loops or recursion. 11 | --Space complexity: O(1)O(1)O(1) 12 | Since we are only storing constant variables. 13 | -------------------------------------------------------------------------------- /Easy/342. Power of Four/Approach 1/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isPowerOfFour(int n) { 4 | // If 'n' is 1, it is a power of four 5 | if (n == 1) 6 | return true; 7 | 8 | // If 'n' is non-positive, it cannot be a power of four 9 | if (n <= 0) 10 | return false; 11 | 12 | // Calculate the logarithm of 'n' with base 4 13 | double logarithmBase4 = log(n) / log(4); 14 | 15 | // Check if the result of the logarithmic operation is an integer 16 | return (logarithmBase4 == (int)logarithmBase4); 17 | } 18 | }; -------------------------------------------------------------------------------- /Easy/342. Power of Four/Approach 1/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public boolean isPowerOfFour(int n) { 3 | // If 'n' is 1, it is a power of four 4 | if (n == 1) 5 | return true; 6 | 7 | // If 'n' is non-positive, it cannot be a power of four 8 | if (n <= 0) 9 | return false; 10 | 11 | // Calculate the logarithm of 'n' with base 4 12 | double logarithmBase4 = Math.log(n) / Math.log(4); 13 | 14 | // Check if the result of the logarithmic operation is an integer 15 | return (logarithmBase4 == (int)logarithmBase4); 16 | } 17 | } -------------------------------------------------------------------------------- /Easy/342. Power of Four/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isPowerOfFour(int n) { 4 | return n > 0 && (n & (n - 1)) == 0 && (n & 0x55555555) != 0; 5 | } 6 | }; -------------------------------------------------------------------------------- /Easy/342. Power of Four/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public boolean isPowerOfFour(int n) { 3 | return (Math.log(n)/Math.log(4)) % 1 == 0; 4 | } 5 | } 6 | -------------------------------------------------------------------------------- /Easy/344. Reverse String/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void reverseString(vector& s) { 4 | int n = s.size(); 5 | int x = 0; 6 | int y = n - 1; 7 | while(x < y){ 8 | std::swap(s[x], s[y]); 9 | x++; 10 | y--; 11 | } 12 | } 13 | }; -------------------------------------------------------------------------------- /Easy/344. Reverse String/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public void reverseString(char[] s) { 3 | char t; 4 | int n = s.length; 5 | for(int i = 0; i < n/2; i++) { 6 | t = s[i]; 7 | s[i] = s[n - i - 1]; 8 | s[n - i - 1] = t; 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Easy/344. Reverse String/Solution.js: -------------------------------------------------------------------------------- 1 | var reverseString = function (s) { 2 | s.reverse(); 3 | return s; 4 | }; 5 | -------------------------------------------------------------------------------- /Easy/389. Find the Difference/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution { 7 | public: 8 | char findTheDifference(string s, string t) { 9 | int sum1 = helper(s); 10 | int sum2 = helper(t); 11 | int diff = sum2 - sum1; 12 | return (char) diff; 13 | } 14 | 15 | private: 16 | int helper(string s) { 17 | int sum = 0; 18 | for(char c : s) { 19 | sum += c; 20 | } 21 | return sum; 22 | } 23 | }; 24 | 25 | int main() { 26 | // call the fn here 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /Easy/389. Find the Difference/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call your fn here 4 | } 5 | 6 | class Solution { 7 | public char findTheDifference(String s, String t) { 8 | int sum1 = helper(s); 9 | int sum2 = helper(t); 10 | int diff = sum2 - sum1; 11 | return (char) diff; 12 | } 13 | 14 | int helper(String s) { 15 | return s.chars().sum(); 16 | } 17 | 18 | } 19 | } -------------------------------------------------------------------------------- /Easy/389. Find the Difference/sol.md: -------------------------------------------------------------------------------- 1 | **Algorithm:** 2 | 3 | 1. Calculate the sum of the ASCII codes of all the characters in the first string, `s`. 4 | 2. Calculate the sum of the ASCII codes of all the characters in the second string, `t`. 5 | 3. Subtract the sum of the ASCII codes of `s` from the sum of the ASCII codes of `t`. 6 | 4. Return the character represented by the difference. 7 | 8 | **Time complexity:** O(n), where n is the length of the longer string. 9 | 10 | **Space complexity:** O(1), as we only use a few constant variables. 11 | 12 | for example, consider the following two strings: 13 | 14 | s = "ABCDELMN" 15 | t = "ABCFGLMN" 16 | 17 | 18 | The sum of the ASCII codes of all the characters in `s` is: 19 | 20 | A + B + C + D + E + L + M + N = 65 + 66 + 67 + 68 + 69 + 76 + 77 + 78 = 536 21 | 22 | The sum of the ASCII codes of all the characters in `t` is: 23 | 24 | A + B + C + F + G + L + M + N = 65 + 66 + 67 + 70 + 71 + 76 + 77 + 78 = 540 25 | 26 | The difference between the sum of the ASCII codes of `t` and `s` is 540 - 536 = 4 27 | 28 | The character represented by 4 is `F`. Therefore, the function will return `F`. 29 | 30 | -------------------------------------------------------------------------------- /Easy/392. Is Subsequence/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution { 7 | public: 8 | bool isSubsequence(string s, string t) { 9 | 10 | int n1 = s.length(); 11 | int n2 = t.length(); 12 | 13 | if(n1 < 1) return true; 14 | 15 | int i = 0; 16 | int j = 0; 17 | 18 | while(i < n2){ 19 | if(t[i] == s[j]){ 20 | j++; 21 | } 22 | i++; 23 | if(j == n1) return true; 24 | } 25 | 26 | return false; 27 | } 28 | }; 29 | 30 | int main() { 31 | 32 | // call the fn here 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /Easy/392. Is Subsequence/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | } 6 | 7 | class Solution { 8 | public boolean isSubsequence(String s, String t) { 9 | int n1 = s.length(); 10 | int n2 = t.length(); 11 | 12 | if (n1 < 1) 13 | return true; 14 | int i = 0; 15 | int j = 0; 16 | 17 | while (i < n2) { 18 | if (t.charAt(i) == s.charAt(j)) { 19 | j++; 20 | } 21 | i++; 22 | if (j == n1) 23 | return true; 24 | } 25 | return false; 26 | } 27 | } -------------------------------------------------------------------------------- /Easy/557. Reverse Words in a String III/README.md: -------------------------------------------------------------------------------- 1 | Given a string s, reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order. 2 | 3 | 4 | 5 | Example 1: 6 | 7 | Input: s = "Let's take LeetCode contest" 8 | Output: "s'teL ekat edoCteeL tsetnoc" 9 | Example 2: 10 | 11 | Input: s = "God Ding" 12 | Output: "doG gniD" 13 | 14 | 15 | Constraints: 16 | 17 | 1 <= s.length <= 5 * 104 18 | s contains printable ASCII characters. 19 | s does not contain any leading or trailing spaces. 20 | There is at least one word in s. 21 | All the words in s are separated by a single space. -------------------------------------------------------------------------------- /Easy/557. Reverse Words in a String III/solution.dart: -------------------------------------------------------------------------------- 1 | class Solution { 2 | String reverseWords(String s) { 3 | String rev = ""; 4 | List words = s.split(" "); 5 | for (int i = 0 ; i< words.length; i++){ 6 | rev = rev + words[i].split("").reversed.join() + " "; 7 | } 8 | 9 | return rev.trim(); 10 | } 11 | } -------------------------------------------------------------------------------- /Easy/557. Reverse Words in a String III/solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public String reverseWords(String s) { 3 | StringBuilder res = new StringBuilder(); 4 | String[] arr = s.split(" "); 5 | for (String str : arr){ 6 | res.append(new StringBuffer(str).reverse().append(" ")); 7 | } 8 | 9 | // res.deleteCharAt(res.length() - 1); If you don't want to use trim() 10 | return res.toString().trim(); 11 | } 12 | } -------------------------------------------------------------------------------- /Easy/557. Reverse Words in a String III/solution.js: -------------------------------------------------------------------------------- 1 | const reverseWords = function(s) { 2 | //convert string to array 3 | let arrayOfs = s.split(" ") 4 | 5 | //loop over the hole array 6 | let finalstr = arrayOfs.map((item) => { 7 | //every element of array convert to a nasted array and reverser it then make it string again 8 | return item.split("").reverse().join("") 9 | }) 10 | return finalstr.join(" ") 11 | }; -------------------------------------------------------------------------------- /Easy/557. Reverse Words in a String III/solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverseWords(self, s: str) -> str: 3 | words = s.split(" ") 4 | rev= "" 5 | for word in words : 6 | rev = rev + word[::-1] + " " 7 | 8 | return rev.rstrip() 9 | -------------------------------------------------------------------------------- /Easy/58. Length of Last Word/Length_of_last_word.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var lengthOfLastWord = function(s) { 6 | s = s.trim(); 7 | 8 | const words = s.split(" "); 9 | return words[words.length - 1].length; 10 | }; 11 | -------------------------------------------------------------------------------- /Easy/58. Length of Last Word/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution { 7 | public: 8 | int lengthOfLastWord(string s) { 9 | 10 | int count = 0; 11 | int i = s.length() - 1; 12 | 13 | while(i >= 0) { 14 | char ch = s[i]; 15 | 16 | if(ch == ' ' && count == 0) { 17 | i--; 18 | continue; 19 | } 20 | 21 | if(ch != ' ') { 22 | count++; 23 | i--; 24 | } else { 25 | return count; 26 | } 27 | } 28 | 29 | return count; 30 | } 31 | }; 32 | 33 | int main() { 34 | string s = "Hello World"; 35 | 36 | Solution sol; 37 | int result = sol.lengthOfLastWord(s); 38 | 39 | cout << result << endl; 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /Easy/58. Length of Last Word/sol.java: -------------------------------------------------------------------------------- 1 | public class sol{ 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | } 6 | class Solution { 7 | public int lengthOfLastWord(String s) { 8 | int count = 0; 9 | int i = s.length() - 1; 10 | while(i >= 0){ 11 | char ch = s.charAt(i); 12 | if(ch == ' ' && count == 0){ 13 | i--; 14 | continue; 15 | } 16 | if(ch != ' '){ 17 | count++; 18 | i--; 19 | } else{ 20 | return count; 21 | } 22 | } 23 | return count; 24 | } 25 | } -------------------------------------------------------------------------------- /Easy/637. Average of Levels in Binary Tree/Solution.cpp: -------------------------------------------------------------------------------- 1 | // Breadth First Search 2 | class Solution { 3 | public: 4 | vector averageOfLevels(TreeNode* root) { 5 | vector list; 6 | queue q; 7 | q.push(root); 8 | while(!q.empty()){ 9 | int n = q.size(); 10 | double sum = 0.0; 11 | for(int i = 0; i < n; i++){ 12 | TreeNode* node = q.front(); 13 | q.pop(); 14 | sum += node->val; 15 | if(node->left) q.push(node->left); 16 | if(node->right) q.push(node->right); 17 | } 18 | list.push_back(sum/n); 19 | } 20 | return list; 21 | } 22 | }; 23 | -------------------------------------------------------------------------------- /Easy/637. Average of Levels in Binary Tree/Solution.java: -------------------------------------------------------------------------------- 1 | // Breadth First Search 2 | class Solution { 3 | public List averageOfLevels(TreeNode root) { 4 | List list = new ArrayList(); 5 | Queue q = new LinkedList(); 6 | q.add(root); 7 | while(!q.isEmpty()){ 8 | int n = q.size(); 9 | double sum = 0.0; 10 | for(int i = 0; i < n; i++){ 11 | TreeNode curr = q.poll(); 12 | sum += curr.val; 13 | if(curr.left != null) q.add(curr.left); 14 | if(curr.right != null) q.add(curr.right); 15 | } 16 | list.add(sum/n); 17 | } 18 | return list; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /Easy/637. Average of Levels in Binary Tree/Solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]: 3 | list = [] 4 | q = [root] 5 | while len(q): 6 | n = len(q) 7 | sum = 0 8 | for i in range(n): 9 | node = q.pop(0) 10 | sum += node.val 11 | if node.left: q.append(node.left) 12 | if node.right: q.append(node.right) 13 | list.append(sum/n) 14 | return list 15 | -------------------------------------------------------------------------------- /Easy/653. Two Sum IV - Input is a BST/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | Set set = new HashSet(); 3 | boolean exists = false; 4 | public boolean findTarget(TreeNode root, int k) { 5 | search(root, k); 6 | return exists; 7 | } 8 | 9 | public void search(TreeNode root, int k){ 10 | if(root == null || exists) return; 11 | if(set.contains(k - root.val)){ 12 | exists = true; 13 | return; 14 | } 15 | set.add(root.val); 16 | search(root.left, k); 17 | search(root.right, k); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Easy/700. Search in a Binary Search Tree/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | TreeNode node = null; 3 | public TreeNode searchBST(TreeNode root, int val) { 4 | traverse(root, val); 5 | return node; 6 | } 7 | 8 | public void traverse(TreeNode root, int val){ 9 | if(root == null) return; 10 | if(root.val == val) node = root; 11 | traverse(root.left, val); 12 | traverse(root.right, val); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Easy/706. Design HashMap/solution.js: -------------------------------------------------------------------------------- 1 | 2 | var MyHashMap = function() { 3 | object = {}; 4 | }; 5 | 6 | /** 7 | * @param {number} key 8 | * @param {number} value 9 | * @return {void} 10 | */ 11 | MyHashMap.prototype.put = function(key, value) { 12 | object[key] = value; 13 | }; 14 | 15 | /** 16 | * @param {number} key 17 | * @return {number} 18 | */ 19 | MyHashMap.prototype.get = function(key) { 20 | return object[key] ?? -1; 21 | }; 22 | 23 | /** 24 | * @param {number} key 25 | * @return {void} 26 | */ 27 | MyHashMap.prototype.remove = function(key) { 28 | delete object[key] 29 | }; 30 | 31 | /** 32 | * Your MyHashMap object will be instantiated and called as such: 33 | * var obj = new MyHashMap() 34 | * obj.put(key,value) 35 | * var param_2 = obj.get(key) 36 | * obj.remove(key) 37 | */ -------------------------------------------------------------------------------- /Easy/73. Set Matrix Zeroes/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public void setZeroes(int[][] matrix) { 3 | int rows = matrix.length, cols = matrix[0].length; 4 | boolean colu=true; 5 | 6 | for (int i = 0; i < rows; i++) { 7 | if (matrix[i][0] == 0) colu = false; 8 | for (int j = 1; j < cols; j++){ 9 | if (matrix[i][j] == 0){ 10 | matrix[i][0] = matrix[0][j] = 0; 11 | } 12 | } 13 | } 14 | 15 | for (int i = rows - 1; i >= 0; i--) { 16 | for (int j = cols - 1; j >= 1; j--){ 17 | if (matrix[i][0] == 0 || matrix[0][j] == 0){ 18 | matrix[i][j] = 0; 19 | } 20 | } 21 | if (colu == false) matrix[i][0] = 0; 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Easy/746.Min Cost Climbing Stairs/Min Cost Climbing Stairs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | int minCostClimbingStairs(vector& cost) { 8 | int n = cost.size(); 9 | 10 | for (int i = 2; i < n; i++) { 11 | cost[i] += min(cost[i - 1], cost[i - 2]); 12 | } 13 | 14 | return min(cost[n - 1], cost[n - 2]); 15 | } 16 | }; 17 | 18 | int main() { 19 | int n; 20 | cout << "Enter the number of steps: "; 21 | cin >> n; 22 | 23 | vector cost(n); 24 | 25 | cout << "Enter the cost for each step:" << endl; 26 | for (int i = 0; i < n; i++) { 27 | cin >> cost[i]; 28 | } 29 | 30 | Solution solution; 31 | int result = solution.minCostClimbingStairs(cost); 32 | 33 | cout << "Minimum cost to reach the top: " << result << endl; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /Easy/746.Min Cost Climbing Stairs/READme.md: -------------------------------------------------------------------------------- 1 | You are given an integer array cost where cost[i] is the cost of ith step on a staircase. Once you pay the cost, you can either climb one or two steps. 2 | 3 | You can either start from the step with index 0, or the step with index 1. 4 | 5 | Return the minimum cost to reach the top of the floor. 6 | 7 | 8 | 9 | Example 1: 10 | 11 | Input: cost = [10,15,20] 12 | Output: 15 13 | Explanation: You will start at index 1. 14 | - Pay 15 and climb two steps to reach the top. 15 | The total cost is 15. 16 | Example 2: 17 | 18 | Input: cost = [1,100,1,1,1,100,1,1,100,1] 19 | Output: 6 20 | Explanation: You will start at index 0. 21 | - Pay 1 and climb two steps to reach index 2. 22 | - Pay 1 and climb two steps to reach index 4. 23 | - Pay 1 and climb two steps to reach index 6. 24 | - Pay 1 and climb one step to reach index 7. 25 | - Pay 1 and climb two steps to reach index 9. 26 | - Pay 1 and climb one step to reach the top. 27 | The total cost is 6. -------------------------------------------------------------------------------- /Easy/746.Min Cost Climbing Stairs/solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int minCostClimbingStairs(int[] cost) { 3 | int n = cost.length; 4 | int[] dp = new int[n]; 5 | dp[0] = cost[0]; 6 | dp[1] = cost[1]; 7 | for (int i = 2; i < n; i++) { 8 | dp[i] = cost[i] + Math.min(dp[i-1], dp[i-2]); 9 | } 10 | return Math.min(dp[n-1], dp[n-2]); 11 | } 12 | } -------------------------------------------------------------------------------- /Easy/746.Min Cost Climbing Stairs/solution.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def minCostClimbingStairs(self, cost): 3 | n = len(cost) 4 | dp = [0] * (n + 1) 5 | 6 | for i in range(2, n + 1): 7 | dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]) 8 | 9 | return dp[n] -------------------------------------------------------------------------------- /Easy/844. Backspace String Compare/Solution.js: -------------------------------------------------------------------------------- 1 | // Backspace String Compare Logic Starts Here 2 | const backspaceCompare = (s, t) => { 3 | const getNextValidCharIndex = (str, index) => { 4 | let backspaceCount = 0; 5 | while (index >= 0) { 6 | if (str[index] === "#") { 7 | backspaceCount++; 8 | index--; 9 | } else if (backspaceCount > 0) { 10 | backspaceCount--; 11 | index--; 12 | } else { 13 | break; 14 | } 15 | } 16 | return index; 17 | }; 18 | 19 | let sPointer = s.length - 1; 20 | let tPointer = t.length - 1; 21 | 22 | while (sPointer >= 0 || tPointer >= 0) { 23 | sPointer = getNextValidCharIndex(s, sPointer); 24 | tPointer = getNextValidCharIndex(t, tPointer); 25 | 26 | if (sPointer < 0 && tPointer < 0) { 27 | return true; 28 | } 29 | 30 | if (sPointer < 0 || tPointer < 0 || s[sPointer] !== t[tPointer]) { 31 | return false; 32 | } 33 | 34 | sPointer--; 35 | tPointer--; 36 | } 37 | 38 | return true; 39 | }; 40 | -------------------------------------------------------------------------------- /Easy/88. Merge Sorted Array/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | void merge(vector &nums1, int m, vector &nums2, int n) 5 | { 6 | int i = m - 1; 7 | int j = n - 1; 8 | int k = m + n - 1; 9 | 10 | while (i >= 0 && j >= 0) 11 | { 12 | if (nums1[i] > nums2[j]) 13 | { 14 | nums1[k] = nums1[i]; 15 | i--; 16 | } 17 | else 18 | { 19 | nums1[k] = nums2[j]; 20 | j--; 21 | } 22 | k--; 23 | } 24 | 25 | while (j >= 0) 26 | { 27 | nums1[k] = nums2[j]; 28 | k--; 29 | j--; 30 | } 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /Easy/896. Monotonic Array/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution { 7 | public: 8 | bool isMonotonic(vector& nums) { 9 | 10 | if (nums[0] < nums[nums.size()-1]) { 11 | for (int i = 1; i < nums.size(); i++) { 12 | if (nums[i] < nums[i-1]) { 13 | return false; 14 | } 15 | } 16 | } else { 17 | for (int i = 1; i < nums.size(); i++) { 18 | if (nums[i] > nums[i-1]) { 19 | return false; 20 | } 21 | } 22 | } 23 | 24 | return true; 25 | } 26 | }; 27 | 28 | int main() { 29 | 30 | //call your fn here 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /Easy/896. Monotonic Array/sol.java: -------------------------------------------------------------------------------- 1 | public class sol{ 2 | public static void main(String[] args) { 3 | // call your fn here 4 | } 5 | } 6 | class Solution { 7 | public boolean isMonotonic(int[] nums) { 8 | if (nums[0] < nums[nums.length-1]) { 9 | for (int i = 1; i < nums.length; i++) { 10 | if (nums[i] < nums[i-1]) { 11 | return false; 12 | } 13 | } 14 | } else { 15 | for (int i = 1; i < nums.length; i++) { 16 | if (nums[i] > nums[i-1]) { 17 | return false; 18 | } 19 | } 20 | } 21 | return true; 22 | } 23 | } -------------------------------------------------------------------------------- /Easy/9. Palindrome Number/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isPalindrome(int x) { 4 | if (x < 0 || (x != 0 && x % 10 == 0)) return false; 5 | int rev = 0; 6 | while(x > rev) { 7 | rev = rev * 10 + x%10; 8 | x /= 10; 9 | } 10 | return (x == rev || x == rev/10); 11 | } 12 | }; 13 | -------------------------------------------------------------------------------- /Easy/9. Palindrome Number/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public boolean isPalindrome(int x) { 3 | if(x<0 || (x != 0 && x % 10 == 0)) return false; 4 | int rev = 0; 5 | while(x > rev){ 6 | rev = rev * 10 + x % 10; 7 | x = x/10; 8 | } 9 | return (x == rev || x == rev/10); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Easy/9. Palindrome Number/Solution.js: -------------------------------------------------------------------------------- 1 | var isPalindrome = function(x) { 2 | x = x.toString(); // Convert the input to a string 3 | return x === x.split('').reverse().join(''); 4 | }; 5 | -------------------------------------------------------------------------------- /Easy/9. Palindrome Number/Solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isPalindrome(self, x: int) -> bool: 3 | if x < 0 or (x != 0 and x % 10 == 0): 4 | return False 5 | rev = 0 6 | while x > rev: 7 | rev = rev * 10 + x % 10 8 | x //= 10 9 | return x == rev or x == rev//10 10 | -------------------------------------------------------------------------------- /Easy/9. Palindrome Number/Solution.rb: -------------------------------------------------------------------------------- 1 | def is_palindrome(x) 2 | return false if x < 0 3 | reverse = 0 4 | original = x 5 | while x > 0 6 | reverse = reverse * 10 + x % 10 7 | x /= 10 8 | end 9 | reverse == original 10 | end 11 | -------------------------------------------------------------------------------- /Easy/905. Sort Array by Parity/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution { 7 | public: 8 | vector sortArrayByParity(vector& nums) { 9 | 10 | int left = 0, right = 0; 11 | int n = nums.size(); 12 | 13 | while (right < n) { 14 | if (nums[right] % 2 == 0) { 15 | int temp = nums[left]; 16 | nums[left] = nums[right]; 17 | nums[right] = temp; 18 | left++; 19 | } 20 | right++; 21 | } 22 | 23 | return nums; 24 | } 25 | }; 26 | 27 | int main() { 28 | 29 | // call the fn here 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /Easy/905. Sort Array by Parity/sol.java: -------------------------------------------------------------------------------- 1 | public class sol{ 2 | public static void main(String[] args) { 3 | // call your fn here 4 | } 5 | } 6 | class Solution { 7 | public int[] sortArrayByParity(int[] nums) { 8 | int left = 0, right = 0; 9 | int n = nums.length; 10 | 11 | while (right < n) { 12 | if (nums[right] % 2 == 0) { 13 | int temp = nums[left]; 14 | nums[left] = nums[right]; 15 | nums[right] = temp; 16 | left++; 17 | } 18 | right++; 19 | } 20 | return nums; 21 | } 22 | } -------------------------------------------------------------------------------- /Easy/94. Binary Tree Inorder Traversal/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | List order = new ArrayList(); 3 | public List inorderTraversal(TreeNode root) { 4 | traverse(root); 5 | return order; 6 | } 7 | 8 | public void traverse(TreeNode root){ 9 | if(root == null) return; 10 | traverse(root.left); 11 | order.add(root.val); 12 | traverse(root.right); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Easy/94. Binary Tree Inorder Traversal/Solution.rb: -------------------------------------------------------------------------------- 1 | class TreeNode 2 | attr_accessor :val, :left, :right 3 | def initialize(val = 0, left = nil, right = nil) 4 | @val = val 5 | @left = left 6 | @right = right 7 | end 8 | end 9 | 10 | def inorder_traversal(root) 11 | result = [] 12 | stack = [] 13 | current = root 14 | while current || stack.length > 0 15 | while current 16 | stack.push(current) 17 | current = current.left 18 | end 19 | current = stack.pop() 20 | result << current.val 21 | current = current.right 22 | end 23 | result 24 | end -------------------------------------------------------------------------------- /Hard/115. Distinct Subsequences/Approach 1/solution.go: -------------------------------------------------------------------------------- 1 | func numDistinct(s string, t string) int { 2 | m := len(s) 3 | n := len(t) 4 | 5 | if m < n { 6 | return 0 7 | } 8 | 9 | dp := make([][]int, m+1) 10 | for i := range dp { 11 | dp[i] = make([]int, n+1) 12 | dp[i][0] = 1 13 | } 14 | 15 | for i := 1; i <= m; i++ { 16 | for j := 1; j <= n; j++ { 17 | if s[i-1] == t[j-1] { 18 | dp[i][j] = dp[i-1][j-1] + dp[i-1][j] 19 | } else { 20 | dp[i][j] = dp[i-1][j] 21 | } 22 | } 23 | } 24 | 25 | return dp[m][n] 26 | } 27 | -------------------------------------------------------------------------------- /Hard/115. Distinct Subsequences/Approach 1/solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numDistinct(self, s: str, t: str) -> int: 3 | m, n = len(s), len(t) 4 | dp = [[0] * (n + 1) for _ in range(m + 1)] 5 | 6 | for i in range(m + 1): 7 | dp[i][0] = 1 8 | 9 | for i in range(1, m + 1): 10 | for j in range(1, n + 1): 11 | if s[i - 1] == t[j - 1]: 12 | dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j] 13 | else: 14 | dp[i][j] = dp[i - 1][j] 15 | 16 | return dp[m][n] -------------------------------------------------------------------------------- /Hard/115. Distinct Subsequences/Approach 1/solution.rust: -------------------------------------------------------------------------------- 1 | impl Solution { 2 | pub fn num_distinct(s: String, t: String) -> i32 { 3 | let m = s.len(); 4 | let n = t.len(); 5 | let s_bytes = s.as_bytes(); 6 | let t_bytes = t.as_bytes(); 7 | 8 | if m < n { 9 | return 0; 10 | } 11 | 12 | let mut dp = vec![vec![0; n + 1]; m + 1]; 13 | 14 | for i in 0..=m { 15 | dp[i][0] = 1; 16 | } 17 | 18 | for i in 1..=m { 19 | for j in 1..=n { 20 | if s_bytes[i - 1] == t_bytes[j - 1] { 21 | dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; 22 | } else { 23 | dp[i][j] = dp[i - 1][j]; 24 | } 25 | } 26 | } 27 | 28 | dp[m][n] 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /Hard/115. Distinct Subsequences/Approach 1/solution.scala: -------------------------------------------------------------------------------- 1 | object Solution { 2 | def numDistinct(s: String, t: String): Int = { 3 | val m = s.length 4 | val n = t.length 5 | 6 | if (m < n) { 7 | return 0 8 | } 9 | 10 | val dp: Array[Array[Int]] = Array.fill(m + 1, n + 1)(0) 11 | for (i <- 0 to m) { 12 | dp(i)(0) = 1 13 | } 14 | 15 | for (i <- 1 to m) { 16 | for (j <- 1 to n) { 17 | if (s(i-1) == t(j-1)) { 18 | dp(i)(j) = dp(i-1)(j-1) + dp(i-1)(j) 19 | } else { 20 | dp(i)(j) = dp(i-1)(j) 21 | } 22 | } 23 | } 24 | 25 | dp(m)(n) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Hard/115. Distinct Subsequences/solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int numDistinct(String s, String t) { 3 | 4 | int[] prev = new int[t.length()+1]; 5 | prev[0]=1; 6 | 7 | for(int i =1; i<=s.length(); i++){ 8 | for(int j =t.length(); j>=1; j--){ 9 | if(s.charAt(i-1)==t.charAt(j-1)){ 10 | prev[j] = prev[j-1] + prev[j]; 11 | } 12 | } 13 | } 14 | return prev[t.length()]; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Hard/1269. Number of Ways to Stay in the Same Place After Some Steps/Readme.md: -------------------------------------------------------------------------------- 1 | You have a pointer at index 0 in an array of size arrLen. At each step, you can move 1 position to the left, 1 position to the right in the array, or stay in the same place (The pointer should not be placed outside the array at any time). 2 | 3 | Given two integers steps and arrLen, return the number of ways such that your pointer is still at index 0 after exactly steps steps. Since the answer may be too large, return it modulo 109 + 7. 4 | 5 | 6 | 7 | Example 1: 8 | 9 | Input: steps = 3, arrLen = 2 10 | Output: 4 11 | Explanation: There are 4 differents ways to stay at index 0 after 3 steps. 12 | Right, Left, Stay 13 | Stay, Right, Left 14 | Right, Stay, Left 15 | Stay, Stay, Stay 16 | Example 2: 17 | 18 | Input: steps = 2, arrLen = 4 19 | Output: 2 20 | Explanation: There are 2 differents ways to stay at index 0 after 2 steps 21 | Right, Left 22 | Stay, Stay 23 | Example 3: 24 | 25 | Input: steps = 4, arrLen = 2 26 | Output: 8 -------------------------------------------------------------------------------- /Hard/1269. Number of Ways to Stay in the Same Place After Some Steps/solution.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def numWays(self, steps, arrLen): 3 | m = steps 4 | n = min(steps // 2 + 1, arrLen) 5 | 6 | dp = [[0] * n for _ in range(m + 1)] 7 | 8 | dp[0][0] = 1 9 | mod = 10 ** 9 + 7 10 | 11 | for i in range(1, m + 1): 12 | for j in range(n): 13 | dp[i][j] = dp[i-1][j] 14 | if j > 0: 15 | dp[i][j] += dp[i-1][j-1] 16 | if j < n - 1: 17 | dp[i][j] += dp[i-1][j+1] 18 | 19 | return dp[m][0] % mod -------------------------------------------------------------------------------- /Hard/1326. Min no of Taps to Open to Water a Garden/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | class Solution 8 | { 9 | public: 10 | int minTaps(int n, vector &ranges) 11 | { 12 | 13 | vector taps(n + 1, 0); 14 | 15 | for (int i = 0; i < ranges.size(); i++) 16 | { 17 | if (ranges[i] == 0) 18 | continue; 19 | int left = max(0, i - ranges[i]); 20 | taps[left] = max(taps[left], i + ranges[i]); 21 | } 22 | 23 | int cnt = 0, end = 0, far = 0; 24 | 25 | for (int i = 0; i <= n; i++) 26 | { 27 | if (i > end) 28 | { 29 | if (far <= end) 30 | return -1; 31 | end = far; 32 | cnt++; 33 | } 34 | far = max(far, taps[i]); 35 | } 36 | 37 | return cnt + (end < n ? 1 : 0); 38 | } 39 | }; 40 | 41 | int main() 42 | { 43 | // call the fn here 44 | 45 | return 0; 46 | } -------------------------------------------------------------------------------- /Hard/1326. Min no of Taps to Open to Water a Garden/sol.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class sol { 4 | public static void main(String[] args) { 5 | // Call the fn here 6 | } 7 | 8 | public class Solution { 9 | public int minTaps(int n, int[] ranges) { 10 | int[] arr = new int[n + 1]; 11 | Arrays.fill(arr, 0); 12 | 13 | for (int i = 0; i < ranges.length; i++) { 14 | if (ranges[i] == 0) 15 | continue; 16 | int left = Math.max(0, i - ranges[i]); 17 | arr[left] = Math.max(arr[left], i + ranges[i]); 18 | } 19 | 20 | int end = 0, far_can_reach = 0, cnt = 0; 21 | for (int i = 0; i <= n; i++) { 22 | if (i > end) { 23 | if (far_can_reach <= end) 24 | return -1; 25 | end = far_can_reach; 26 | cnt++; 27 | } 28 | far_can_reach = Math.max(far_can_reach, arr[i]); 29 | } 30 | 31 | return cnt + (end < n ? 1 : 0); 32 | } 33 | } 34 | } -------------------------------------------------------------------------------- /Hard/135. Candy/Approach 1/Readme.md: -------------------------------------------------------------------------------- 1 | Strategies to Tackle the Problem 2 | 3 | Greedy Algorithm: Two-Pass Method 4 | This method takes two passes through the ratings array to ensure that each child gets the appropriate amount of candy. 5 | 6 | One-Pass Greedy Algorithm: Up-Down-Peak Method 7 | This more advanced method uses a single pass and employs three key variables—Up, Down, and Peak—to efficiently determine the minimum number of candies needed. 8 | -------------------------------------------------------------------------------- /Hard/135. Candy/Approach 1/sloution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int candy(int[] ratings) { 3 | int n = ratings.length; 4 | int[] candies = new int[n]; 5 | Arrays.fill(candies, 1); 6 | 7 | for (int i = 1; i < n; i++) { 8 | if (ratings[i] > ratings[i - 1]) { 9 | candies[i] = candies[i - 1] + 1; 10 | } 11 | } 12 | 13 | for (int i = n - 2; i >= 0; i--) { 14 | if (ratings[i] > ratings[i + 1]) { 15 | candies[i] = Math.max(candies[i], candies[i + 1] + 1); 16 | } 17 | } 18 | 19 | int totalCandies = 0; 20 | for (int candy : candies) { 21 | totalCandies += candy; 22 | } 23 | 24 | return totalCandies; 25 | } 26 | } -------------------------------------------------------------------------------- /Hard/135. Candy/Approach 1/solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int candy(std::vector& ratings) { 4 | int n = ratings.size(); 5 | std::vector candies(n, 1); 6 | 7 | for (int i = 1; i < n; ++i) { 8 | if (ratings[i] > ratings[i - 1]) { 9 | candies[i] = candies[i - 1] + 1; 10 | } 11 | } 12 | 13 | for (int i = n - 2; i >= 0; --i) { 14 | if (ratings[i] > ratings[i + 1]) { 15 | candies[i] = std::max(candies[i], candies[i + 1] + 1); 16 | } 17 | } 18 | 19 | int totalCandies = 0; 20 | for (int candy : candies) { 21 | totalCandies += candy; 22 | } 23 | 24 | return totalCandies; 25 | } 26 | }; -------------------------------------------------------------------------------- /Hard/135. Candy/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution 7 | { 8 | public: 9 | int candy(vector &ratings) 10 | { 11 | 12 | int n = ratings.size(); 13 | vector candies(n, 1); 14 | 15 | for (int i = 1; i < n; i++) 16 | { 17 | if (ratings[i] > ratings[i - 1]) 18 | { 19 | candies[i] = candies[i - 1] + 1; 20 | } 21 | } 22 | 23 | for (int i = n - 1; i > 0; i--) 24 | { 25 | if (ratings[i - 1] > ratings[i] && candies[i - 1] <= candies[i]) 26 | { 27 | candies[i - 1] = candies[i] + 1; 28 | } 29 | } 30 | 31 | int total = 0; 32 | for (int candy : candies) 33 | { 34 | total += candy; 35 | } 36 | 37 | return total; 38 | } 39 | }; 40 | 41 | int main() 42 | { 43 | 44 | // call the fn here 45 | return 0; 46 | } -------------------------------------------------------------------------------- /Hard/135. Candy/sol.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class sol { 4 | public static void main(String[] args) { 5 | // call the fn here 6 | } 7 | 8 | class Solution { 9 | public int candy(int[] arr) { 10 | int n = arr.length; 11 | int a[] = new int[n]; 12 | Arrays.fill(a, 1); 13 | for (int i = 0; i < n - 1; i++) { 14 | if (arr[i] < arr[i + 1]) { 15 | a[i + 1] = 1 + a[i]; 16 | } 17 | } 18 | for (int i = n - 1; i > 0; i--) { 19 | if (arr[i] < arr[i - 1] && a[i - 1] <= a[i]) { 20 | a[i - 1] = a[i] + 1; 21 | } 22 | } 23 | int sum = 0; 24 | for (int i : a) 25 | sum += i; 26 | return sum; 27 | } 28 | } 29 | } -------------------------------------------------------------------------------- /Hard/1359. Count All Valid Pickup and Delivery Options/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int MOD = 1000000007; 6 | 7 | class Solution 8 | { 9 | public: 10 | int countOrders(int n) 11 | { 12 | 13 | long long count = 1; 14 | 15 | for (int i = 2; i <= n; i++) 16 | { 17 | count = (count * (2 * i - 1) % MOD * i % MOD) % MOD; 18 | } 19 | 20 | return (int)count; 21 | } 22 | }; 23 | 24 | int main() 25 | { 26 | // call the fn here 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /Hard/1359. Count All Valid Pickup and Delivery Options/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | public class Solution { 7 | private static final int MOD = 1000000007; 8 | 9 | public int countOrders(int n) { 10 | long count = 1; 11 | for (int i = 2; i <= n; i++) { 12 | count = (count * (2 * i - 1) * i) % MOD; 13 | } 14 | return (int) count; 15 | } 16 | } 17 | } -------------------------------------------------------------------------------- /Hard/1420. build array where you can find maximum exactly k comparison/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | typedef long long LL; 3 | LL dp[51][101][51] = {}; 4 | public: 5 | int numOfArrays(int n, int m, int k) { 6 | int mod = 1e9+7; 7 | for (int i = 0; i <= m; ++i) dp[1][i][1] = 1; 8 | for (int i = 1; i <= n; ++i) { 9 | for (int j = 1; j <= m; ++j) { 10 | for (int t = 1; t <= k; ++t) { 11 | LL s = 0; 12 | s = (s + j * dp[i - 1][j][t]) % mod; 13 | for (int x = 1; x < j; ++x) s = (s + dp[i - 1][x][t - 1]) %mod; 14 | dp[i][j][t] = (dp[i][j][t] + s) % mod; 15 | } 16 | } 17 | } 18 | LL ans = 0; 19 | for (int i = 1; i <= m; ++i) ans = (ans + dp[n][i][k]) % mod; 20 | return ans; 21 | } 22 | }; -------------------------------------------------------------------------------- /Hard/1420. build array where you can find maximum exactly k comparison/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int numOfArrays(int n, int m, int k) { 3 | final int MODULO = 1000000007; 4 | int[][][] dp = new int[n + 1][m + 1][k + 2]; 5 | dp[0][0][0] = 1; 6 | for (int i = 0; i < n; i++) { 7 | for (int j = 0; j <= m; j++) { 8 | for (int p = 0; p <= k; p++) { 9 | for (int q = 1; q <= m; q++) { 10 | if (q > j) 11 | dp[i + 1][q][p + 1] = (dp[i + 1][q][p + 1] + dp[i][j][p]) % MODULO; 12 | else 13 | dp[i + 1][j][p] = (dp[i + 1][j][p] + dp[i][j][p]) % MODULO; 14 | } 15 | } 16 | } 17 | } 18 | int count = 0; 19 | for (int i = 1; i <= m; i++) 20 | count = (count + dp[n][i][k]) % MODULO; 21 | return count; 22 | } 23 | } -------------------------------------------------------------------------------- /Hard/1425. Constrained Subsequence Sum/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | class Solution 8 | { 9 | public: 10 | int constrainedSubsetSum(vector &nums, int k) 11 | { 12 | vector dp(nums); 13 | deque q; 14 | q.push_back(0); 15 | for (int i = 1; i < nums.size(); i++) 16 | { 17 | while (!q.empty() && q.back() < i - k) 18 | { 19 | q.pop_back(); 20 | } 21 | dp[i] = max(dp[i], dp[q.back()] + nums[i]); 22 | while (!q.empty() && dp[q.front()] <= dp[i]) 23 | { 24 | q.pop_front(); 25 | } 26 | q.push_front(i); 27 | } 28 | return *max_element(dp.begin(), dp.end()); 29 | } 30 | }; -------------------------------------------------------------------------------- /Hard/1425. Constrained Subsequence Sum/sol.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class sol { 4 | public static void main(String[] args) { 5 | // call the fn here 6 | } 7 | class Solution { 8 | public int constrainedSubsetSum(int[] nums, int k) { 9 | int[] dp = Arrays.copyOf(nums, nums.length); 10 | Deque q = new ArrayDeque<>(); 11 | q.offerLast(0); 12 | for (int i = 1; i < nums.length; i++) { 13 | while (!q.isEmpty() && q.peekLast() < i - k) { 14 | q.pollLast(); 15 | } 16 | dp[i] = Math.max(dp[i], dp[q.peekLast()] + nums[i]); 17 | while (!q.isEmpty() && dp[q.peekFirst()] <= dp[i]) { 18 | q.pollFirst(); 19 | } 20 | q.offerFirst(i); 21 | } 22 | int max = Integer.MIN_VALUE; 23 | for (int num : dp) { 24 | max = Math.max(max, num); 25 | } 26 | return max; 27 | } 28 | } 29 | } -------------------------------------------------------------------------------- /Hard/1458. Max Dot Product of Two Subsequences/solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxDotProduct(vector& nums1, vector& nums2) { 4 | int n = nums1.size(); 5 | int m = nums2.size(); 6 | vector> memo(n, vector(m, INT_MIN)); 7 | 8 | function dp = [&](int i, int j) { 9 | if (i == n || j == m) { 10 | return INT_MIN; 11 | } 12 | 13 | if (memo[i][j] != INT_MIN) { 14 | return memo[i][j]; 15 | } 16 | 17 | memo[i][j] = max( 18 | nums1[i] * nums2[j] + max(dp(i + 1, j + 1), 0), 19 | max(dp(i + 1, j), dp(i, j + 1)) 20 | ); 21 | 22 | return memo[i][j]; 23 | }; 24 | 25 | return dp(0, 0); 26 | } 27 | }; -------------------------------------------------------------------------------- /Hard/1458. Max Dot Product of Two Subsequences/solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int: 3 | n, m = len(nums1), len(nums2) 4 | memo = [[float('-inf')] * m for _ in range(n)] 5 | 6 | def dp(i, j): 7 | if i == n or j == m: 8 | return float('-inf') 9 | 10 | if memo[i][j] != float('-inf'): 11 | return memo[i][j] 12 | 13 | memo[i][j] = max( 14 | nums1[i] * nums2[j] + max(dp(i + 1, j + 1), 0), 15 | dp(i + 1, j), 16 | dp(i, j + 1), 17 | ) 18 | 19 | return memo[i][j] 20 | 21 | return dp(0, 0) -------------------------------------------------------------------------------- /Hard/2009. Minimum Number of Operations to Make Array Continuous/solution.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def minOperations(self, nums): 3 | n = len(nums) 4 | nums = sorted(set(nums)) 5 | ans = sys.maxsize 6 | 7 | for i, s in enumerate(nums): 8 | e = s + n - 1 9 | idx = bisect_right(nums, e) 10 | 11 | ans = min(ans, n - (idx - i)) 12 | return ans 13 | -------------------------------------------------------------------------------- /Hard/2050. Parallel Courses III/solution.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def minimumTime(self, n, relations, time): 3 | graph = [[] for _ in range(n)] 4 | 5 | for prev, next in relations: 6 | graph[prev - 1].append(next - 1) 7 | 8 | memo = [-1] * n 9 | 10 | def calculateTime(course): 11 | if memo[course] != -1: 12 | return memo[course] 13 | 14 | if not graph[course]: 15 | memo[course] = time[course] 16 | return memo[course] 17 | 18 | max_prerequisite_time = 0 19 | for prereq in graph[course]: 20 | max_prerequisite_time = max(max_prerequisite_time, calculateTime(prereq)) 21 | 22 | memo[course] = max_prerequisite_time + time[course] 23 | return memo[course] 24 | 25 | overall_min_time = 0 26 | for course in range(n): 27 | overall_min_time = max(overall_min_time, calculateTime(course)) 28 | 29 | return overall_min_time 30 | -------------------------------------------------------------------------------- /Hard/2227. Encrypt and Decrypt String/solution.py: -------------------------------------------------------------------------------- 1 | class Encrypter: 2 | 3 | def __init__(self, keys: List[str], values: List[str], dictionary: List[str]): 4 | self.ktov = {} 5 | 6 | for k, v in zip(keys, values): 7 | self.ktov[k] = v 8 | 9 | self.count = Counter(self.encrypt(x) for x in dictionary) 10 | 11 | 12 | def encrypt(self, word1: str) -> str: 13 | res = [] 14 | 15 | for x in word1: 16 | if x in self.ktov: 17 | res.append(self.ktov[x]) 18 | else: 19 | return "" 20 | 21 | return "".join(res) 22 | 23 | def decrypt(self, word2: str) -> int: 24 | return self.count[word2] -------------------------------------------------------------------------------- /Hard/2251. Number Of Flowers In Full Bloom/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector fullBloomFlowers(vector>& flowers, vector& persons) { 4 | 5 | vector start, end; 6 | 7 | for (auto& t : flowers) 8 | start.push_back(t[0]), end.push_back(t[1]); 9 | 10 | sort(start.begin(), start.end()); 11 | sort(end.begin(), end.end()); 12 | vector res; 13 | 14 | for (int t : persons) { 15 | 16 | int started = upper_bound(start.begin(), start.end(), t) - start.begin(); 17 | int ended = lower_bound(end.begin(), end.end(), t) - end.begin(); 18 | res.push_back(started - ended); 19 | 20 | } 21 | 22 | return res; 23 | 24 | } 25 | }; -------------------------------------------------------------------------------- /Hard/233. Number of Digit One/README.md: -------------------------------------------------------------------------------- 1 | # LeetCode 233.Number of Digit One 2 | 3 | 4 | ## Problem Description 5 | 6 | Given an integer `n`, count the total number of digit `1` appearing in all non-negative integers less than or equal to `n`. 7 | 8 | **Example 1:** 9 | 10 | Input: n = 13 11 | Output: 6 12 | 13 | **Example 2:** 14 | 15 | Input: n = 0 16 | Output: 0 17 | 18 | **Constraints:** 19 | 20 | `0 <= n <= 109` 21 | 22 | ### Link 23 | 24 | https://leetcode.com/problems/number-of-digit-one/ 25 | -------------------------------------------------------------------------------- /Hard/233. Number of Digit One/Sol.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int countDigitOne(int n) { 3 | int count = 0; 4 | 5 | for (long i = 1; i <= n; i *= 10) { 6 | long divider = i * 10; 7 | count += (n / divider) * i + Math.min(Math.max(n % divider - i + 1, 0), i); 8 | } 9 | 10 | return count; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Hard/2366. Min Replacements to Sort an Array/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution 7 | { 8 | public: 9 | long long minimumReplacement(vector &nums) 10 | { 11 | 12 | long long ops = 0; 13 | long long prev = nums.back(); 14 | 15 | for (int i = nums.size() - 2; i >= 0; i--) 16 | { 17 | 18 | long long num = nums[i]; 19 | long long times = (num + prev - 1) / prev; 20 | ops += times - 1; 21 | 22 | prev = num / times; 23 | } 24 | 25 | return ops; 26 | } 27 | }; 28 | 29 | int main() 30 | { 31 | // call the fn here 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Hard/2366. Min Replacements to Sort an Array/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | public class Solution { 7 | public long minimumReplacement(int[] nums) { 8 | long operations = 0; 9 | long prev_bound = nums[nums.length - 1]; 10 | 11 | for (int i = nums.length - 2; i >= 0; i--) { 12 | long num = nums[i]; 13 | long no_of_times = (num + prev_bound - 1) / prev_bound; 14 | operations += no_of_times - 1; 15 | prev_bound = num / no_of_times; 16 | } 17 | 18 | return operations; 19 | } 20 | } 21 | } -------------------------------------------------------------------------------- /Hard/239. Sliding Window Max/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | class Solution 8 | { 9 | public: 10 | vector maxSlidingWindow(vector &nums, int k) 11 | { 12 | 13 | int n = nums.size(); 14 | if (n == 0 || k <= 0) 15 | return {}; 16 | 17 | vector ans; 18 | deque dq; 19 | 20 | for (int i = 0; i < n; i++) 21 | { 22 | 23 | if (!dq.empty() && dq.front() == i - k) 24 | { 25 | dq.pop_front(); 26 | } 27 | 28 | while (!dq.empty() && nums[dq.back()] < nums[i]) 29 | { 30 | dq.pop_back(); 31 | } 32 | 33 | dq.push_back(i); 34 | 35 | if (i >= k - 1) 36 | { 37 | ans.push_back(nums[dq.front()]); 38 | } 39 | } 40 | 41 | return ans; 42 | } 43 | }; 44 | 45 | int main() 46 | { 47 | 48 | // call the fn here 49 | 50 | return 0; 51 | } -------------------------------------------------------------------------------- /Hard/239. Sliding Window Max/sol.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class sol { 3 | public static void main(String[] args) { 4 | // call the fn here 5 | } 6 | 7 | class Solution { 8 | public int[] maxSlidingWindow(int[] nums, int k) { 9 | if (nums == null || nums.length == 0 || k <= 0) { 10 | return new int[0]; 11 | } 12 | 13 | int[] ans = new int[nums.length - k + 1]; 14 | int x = 0; 15 | 16 | Deque deque = new LinkedList<>(); 17 | for (int i = 0; i < nums.length; i++) { 18 | while (!deque.isEmpty() && deque.peek() < i - k + 1) { 19 | deque.poll(); 20 | } 21 | 22 | while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) { 23 | deque.pollLast(); 24 | } 25 | 26 | deque.offer(i); 27 | 28 | if (i >= k - 1) { 29 | ans[x++] = nums[deque.peek()]; 30 | } 31 | } 32 | 33 | return ans; 34 | } 35 | } 36 | 37 | } -------------------------------------------------------------------------------- /Hard/273. Integer to English Words/README.md: -------------------------------------------------------------------------------- 1 | # LeetCode 273. Integer to English Words 2 | 3 | ## Problem Description 4 | Convert a non-negative integer num to its English words representation. 5 | 6 | ## Test Cases 7 | 8 | ### Example 1: 9 | 10 | - **Input:** `num = 123` 11 | - **Output:** `One Hundred Twenty Three` 12 | 13 | ### Example 2: 14 | 15 | - **Input:** `num = 12345` 16 | - **Output:** `Twelve Thousand Three Hundred Forty Five` 17 | 18 | ### Example 3: 19 | 20 | - **Input:** `num = 1234567` 21 | - **Output:** `One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven` 22 | 23 | ### Constraints: 24 | 25 | `0 <= num <= 231 - 1` 26 | 27 | ### Link 28 | 29 | https://leetcode.com/problems/integer-to-english-words/ 30 | -------------------------------------------------------------------------------- /Hard/2742. Painting the Walls/solution.py: -------------------------------------------------------------------------------- 1 | from numpy import inf 2 | 3 | class Solution(object): 4 | def paintWalls(self, cost, time): 5 | 6 | n = len(cost) 7 | dp = [0] + [inf] * n 8 | for c, t in zip(cost, time): 9 | for j in range(n, 0, -1): 10 | dp[j] = min(dp[j], dp[max(j - t - 1, 0)] + c) 11 | return dp[n] -------------------------------------------------------------------------------- /Hard/34. Find First and Last Position of Element in Sorted Array/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class Solution { 4 | public: 5 | std::vector searchRange(std::vector& N, int T) { 6 | int Tleft = find(T, N, 0); 7 | if (Tleft == N.size() || N[Tleft] != T) { 8 | return {-1, -1}; 9 | } 10 | return {Tleft, find(T + 1, N, Tleft) - 1}; 11 | } 12 | 13 | int find(int target, std::vector& arr, int left) { 14 | int right = arr.size() - 1; 15 | while (left <= right) { 16 | int mid = left + (right - left) / 2; 17 | if (arr[mid] < target) { 18 | left = mid + 1; 19 | } else { 20 | right = mid - 1; 21 | } 22 | } 23 | return left; 24 | } 25 | }; 26 | -------------------------------------------------------------------------------- /Hard/34. Find First and Last Position of Element in Sorted Array/sol.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class sol { 4 | public static void main(String[] args) { 5 | // call the fn here 6 | } 7 | 8 | class Solution { 9 | public int[] searchRange(int[] N, int T) { 10 | int Tleft = find(T, N, 0); 11 | if (Tleft == N.length || N[Tleft] != T) return new int[] { 12 | -1, -1 13 | }; 14 | return new int[] { 15 | Tleft, 16 | find(T + 1, N, Tleft) - 1 17 | }; 18 | } 19 | public int find(int target, int[] arr, int left) { 20 | int right = arr.length - 1; 21 | while (left <= right) { 22 | int mid = left + right >> 1; 23 | if (arr[mid] < target) left = mid + 1; 24 | else right = mid - 1; 25 | } 26 | return left; 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Hard/34. Find First and Last Position of Element in Sorted Array/sol.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def searchRange(self, N, T): 3 | Tleft = self.find(T, N, 0) 4 | if Tleft == len(N) or N[Tleft] != T: 5 | return [-1, -1] 6 | return [Tleft, self.find(T + 1, N, Tleft) - 1] 7 | 8 | def find(self, target, arr, left): 9 | right = len(arr) - 1 10 | while left <= right: 11 | mid = (left + right) // 2 12 | if arr[mid] < target: 13 | left = mid + 1 14 | else: 15 | right = mid - 1 16 | return left 17 | -------------------------------------------------------------------------------- /Hard/4. Median of Two Sorted Arrays/New approach[Arraylist]/sol.md: -------------------------------------------------------------------------------- 1 | ### `findMedianSortedArrays` Function Explanation 2 | 3 | 1. Create an `ArrayList` called `list` to merge both sorted arrays into a single list. 4 | 2. Iterate through the elements of `nums1`, and for each element, add it to the `list`. 5 | 3. Iterate through the elements of `nums2`, and for each element, add it to the `list`. This effectively combines both input arrays into a single merged list. 6 | 4. Create a variable `sum` to store the sum of all elements in the merged list. Initialize it to 0. 7 | 5. Iterate through the merged `list`, and for each element, add its value to the `sum`. 8 | 6. Calculate the average (mean) of all elements in the merged list by dividing the `sum` by the total number of elements in the list. 9 | 7. Return the calculated average (mean) as the median value of the merged sorted arrays. -------------------------------------------------------------------------------- /Hard/4. Median of Two Sorted Arrays/sol.java: -------------------------------------------------------------------------------- 1 | public class sol{ 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | } 6 | class Solution { 7 | public double findMedianSortedArrays(int[] m, int[] n) { 8 | int[] merged = new int[m.length + n.length]; 9 | int i = 0, j = 0, k = 0; 10 | 11 | while (i < m.length && j < n.length) { 12 | if (m[i] <= n[j]) { 13 | merged[k++] = m[i++]; 14 | } else { 15 | merged[k++] = n[j++]; 16 | } 17 | } 18 | 19 | while (i < m.length) { 20 | merged[k++] = m[i++]; 21 | } 22 | 23 | while (j < n.length) { 24 | merged[k++] = n[j++]; 25 | } 26 | 27 | int mid = merged.length / 2; 28 | if (merged.length % 2 == 0){ 29 | int sum = merged[mid] + merged[mid - 1]; 30 | return (double) sum / 2; 31 | } 32 | else{ 33 | return merged[mid]; 34 | } 35 | 36 | 37 | // return avg; 38 | 39 | } 40 | } -------------------------------------------------------------------------------- /Hard/41. First Missing Positive/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | class Solution { 8 | public: 9 | int firstMissingPositive(vector& nums) { 10 | 11 | int n = nums.size(); 12 | 13 | for(int i=0; i 0){ 28 | return i+1; 29 | } 30 | } 31 | 32 | return n+1; 33 | } 34 | }; 35 | 36 | int main() { 37 | 38 | /// call the fn here 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /Hard/41. First Missing Positive/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | class Solution { 7 | public int firstMissingPositive(int[] nums) { 8 | int n = nums.length; 9 | 10 | for (int i = 0; i < n; i++) { 11 | if (nums[i] <= 0) { 12 | nums[i] = n + 1; 13 | } 14 | } 15 | 16 | for (int i = 0; i < n; i++) { 17 | int num = Math.abs(nums[i]); 18 | if (num <= n) { 19 | nums[num - 1] = -Math.abs(nums[num - 1]); 20 | } 21 | } 22 | 23 | for (int i = 0; i < n; i++) { 24 | if (nums[i] > 0) { 25 | return i + 1; 26 | } 27 | } 28 | 29 | return n + 1; 30 | } 31 | } 32 | 33 | } -------------------------------------------------------------------------------- /Hard/42. Trapping Rain Water/Approach 1/solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def trap(self, height: List[int]) -> int: 3 | if not height: 4 | return 0 5 | n = len(height) 6 | lm = [0] * n 7 | rm = [0] * n 8 | 9 | lm[0] = height[0] 10 | for i in range(1, n): 11 | lm[i] = max(lm[i - 1], height[i]) 12 | 13 | rm[n - 1] = height[n - 1] 14 | for i in range(n - 2, -1, -1): 15 | rm[i] = max(rm[i + 1], height[i]) 16 | 17 | water = 0 18 | for i in range(n): 19 | water += min(lm[i], rm[i]) - height[i] 20 | 21 | return water -------------------------------------------------------------------------------- /Hard/42. Trapping Rain Water/sol.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} 3 | * @return {number} 4 | */ 5 | var trap =function (height) { 6 | if (height.length < 3) { 7 | return 0; // Not enough bars to trap water 8 | } 9 | 10 | let left = 0; 11 | let right = height.length - 1; 12 | let leftMax = 0; 13 | let rightMax = 0; 14 | let trappedWater = 0; 15 | 16 | while (left < right) { 17 | if (height[left] < height[right]) { 18 | if (height[left] >= leftMax) { 19 | leftMax = height[left]; 20 | } else { 21 | trappedWater += leftMax - height[left]; 22 | } 23 | left++; 24 | } else { 25 | if (height[right] >= rightMax) { 26 | rightMax = height[right]; 27 | } else { 28 | trappedWater += rightMax - height[right]; 29 | } 30 | right--; 31 | } 32 | } 33 | 34 | return trappedWater; 35 | }; -------------------------------------------------------------------------------- /Hard/664. Strange Printer/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | class Solution 8 | { 9 | public: 10 | int strangePrinter(string s) 11 | { 12 | 13 | int n = s.size(); 14 | vector> dp(n, vector(n, 0)); 15 | 16 | return solve(s, 0, n - 1, dp); 17 | } 18 | 19 | private: 20 | int solve(string &s, int i, int j, vector> &dp) 21 | { 22 | 23 | if (i > j) 24 | return 0; 25 | 26 | if (dp[i][j] != 0) 27 | return dp[i][j]; 28 | 29 | int ans = solve(s, i, j - 1, dp) + 1; 30 | 31 | for (int k = i; k < j; k++) 32 | { 33 | if (s[k] == s[j]) 34 | { 35 | ans = min(ans, solve(s, i, k, dp) + solve(s, k + 1, j - 1, dp)); 36 | } 37 | } 38 | 39 | return dp[i][j] = ans; 40 | } 41 | }; 42 | 43 | int main() 44 | { 45 | // call the fn here 46 | return 0; 47 | } -------------------------------------------------------------------------------- /Hard/664. Strange Printer/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | class Solution { 7 | public int strangePrinter(String s) { 8 | int n = s.length(); 9 | int[][] temp = new int[n][n]; 10 | return minTurns(s, 0, n - 1, temp); 11 | } 12 | 13 | int minTurns(String s, int start, int end, int[][] temp) { 14 | if (start > end) { 15 | return 0; 16 | } 17 | 18 | if (temp[start][end] > 0) { 19 | return temp[start][end]; 20 | } 21 | 22 | int turns = minTurns(s, start, end - 1, temp) + 1; 23 | for (int i = start; i < end; i++) { 24 | if (s.charAt(i) == s.charAt(end)) { 25 | turns = Math.min(turns, minTurns(s, start, i, temp) + minTurns(s, i + 1, end - 1, temp)); 26 | } 27 | } 28 | 29 | temp[start][end] = turns; 30 | return turns; 31 | } 32 | } 33 | 34 | } -------------------------------------------------------------------------------- /Hard/72. Edit Distance/Levenshtein/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int minDistance(String word1, String word2) { 3 | int row = word1.length(); 4 | int col = word2.length(); 5 | int[][] ed = new int[row + 1][col + 1]; 6 | for(int i = 0; i <= row; i++) 7 | ed[i][0] = i; 8 | for(int j = 0; j <= col; j++) 9 | ed[0][j] = j; 10 | for(int i = 1; i <= row; i++) { 11 | for(int j = 1; j <= col; j++) { 12 | if(word1.charAt(i - 1) == word2.charAt(j - 1)) { 13 | ed[i][j] = ed[i - 1][j - 1]; 14 | } else { 15 | int dia = ed[i - 1][j - 1]; 16 | int hor = ed[i][j - 1]; 17 | int ver = ed[i - 1][j]; 18 | if(dia <= hor && dia <= ver) 19 | ed[i][j] = dia; 20 | else 21 | ed[i][j] = ver < hor ? ver : hor; 22 | ed[i][j]++; 23 | } 24 | } 25 | } 26 | return ed[row][col]; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Hard/72. Edit Distance/Levenshtein/images/finding-distance-table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/godkingjay/LeetCode/5197b4843315dec9344834af1eb31fc1746d6063/Hard/72. Edit Distance/Levenshtein/images/finding-distance-table.png -------------------------------------------------------------------------------- /Hard/72. Edit Distance/Levenshtein/images/finding-distance.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/godkingjay/LeetCode/5197b4843315dec9344834af1eb31fc1746d6063/Hard/72. Edit Distance/Levenshtein/images/finding-distance.png -------------------------------------------------------------------------------- /Hard/72. Edit Distance/Levenshtein/images/intialization-table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/godkingjay/LeetCode/5197b4843315dec9344834af1eb31fc1746d6063/Hard/72. Edit Distance/Levenshtein/images/intialization-table.png -------------------------------------------------------------------------------- /Hard/72. Edit Distance/Levenshtein/images/intialization.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/godkingjay/LeetCode/5197b4843315dec9344834af1eb31fc1746d6063/Hard/72. Edit Distance/Levenshtein/images/intialization.png -------------------------------------------------------------------------------- /Hard/72. Edit Distance/Levenshtein/images/levenshtein-distance.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/godkingjay/LeetCode/5197b4843315dec9344834af1eb31fc1746d6063/Hard/72. Edit Distance/Levenshtein/images/levenshtein-distance.png -------------------------------------------------------------------------------- /Hard/920. Number of Music Playlists/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution { 7 | public: 8 | int numMusicPlaylists(int n, int goal, int k) { 9 | const int MOD = 1000000007; 10 | vector> temp(goal + 1, vector(n + 1, 0)); 11 | temp[0][0] = 1; 12 | 13 | for (int i = 1; i <= goal; i++) { 14 | for (int j = 1; j <= n; j++) { 15 | temp[i][j] = (temp[i][j] + temp[i - 1][j - 1] * (n - j + 1)) % MOD; 16 | if (j > k) { 17 | temp[i][j] = (temp[i][j] + temp[i - 1][j] * (j - k)) % MOD; 18 | } 19 | } 20 | } 21 | 22 | return static_cast(temp[goal][n]); 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /Hard/920. Number of Music Playlists/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | class Solution { 7 | private static final int MOD = 1000000007; 8 | 9 | public int numMusicPlaylists(int n, int goal, int k) { 10 | long[][] temp = new long[goal + 1][n + 1]; 11 | temp[0][0] = 1; 12 | 13 | for (int i = 1; i <= goal; i++) { 14 | for (int j = 1; j <= n; j++) { 15 | temp[i][j] = (temp[i][j] + temp[i - 1][j - 1] * (n - j + 1)) % MOD; 16 | if (j > k) { 17 | temp[i][j] = (temp[i][j] + temp[i - 1][j] * (j - k)) % MOD; 18 | } 19 | } 20 | } 21 | 22 | return (int) temp[goal][n]; 23 | } 24 | } 25 | 26 | } -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 Jarrian Gojar 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Medium/11. Container With Most Water/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxArea(vector& height) { 4 | int maxArea = 0; 5 | int leftIdx = 0, rightIdx = height.size() - 1; 6 | 7 | while(leftIdx < rightIdx){ 8 | maxArea = max(maxArea, min(height[leftIdx], height[rightIdx]) * (rightIdx - leftIdx)); 9 | if(height[leftIdx] < height[rightIdx]) 10 | leftIdx++; 11 | else 12 | rightIdx--; 13 | } 14 | 15 | return maxArea; 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /Medium/11. Container With Most Water/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int maxArea(int[] height) { 3 | int maxArea = 0; 4 | int leftIdx = 0, rightIdx = height.length-1; 5 | 6 | while(leftIdx < rightIdx){ 7 | maxArea = Math.max(maxArea, Math.min(height[leftIdx], height[rightIdx]) * (rightIdx - leftIdx)); 8 | if(height[leftIdx] < height[rightIdx]) 9 | leftIdx++; 10 | else 11 | rightIdx--; 12 | } 13 | 14 | return maxArea; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Medium/12. Integer To Roman/Solution.js: -------------------------------------------------------------------------------- 1 | const intToRoman = (num) => { 2 | const numerals = { 3 | 1: 'I', 4 | 4: 'IV', 5 | 5: 'V', 6 | 9: 'IX', 7 | 10: 'X', 8 | 40: 'XL', 9 | 50: 'L', 10 | 90: 'XC', 11 | 100: 'C', 12 | 400: 'CD', 13 | 500: 'D', 14 | 900: 'CM', 15 | 1000: 'M', 16 | }; 17 | 18 | let romanized = ''; 19 | const decimalKeys = Object.keys(numerals).reverse(); 20 | 21 | decimalKeys.forEach((key) => { 22 | while (key <= num) { 23 | romanized = romanized + numerals[key]; 24 | num = num - key; 25 | } 26 | }); 27 | return romanized; 28 | }; 29 | 30 | console.log(intToRoman(112)); 31 | -------------------------------------------------------------------------------- /Medium/122. Best Time to Buy and Sell Stock II/solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxProfit(vector& prices) { 4 | int maxProfit = 0; 5 | 6 | for (int i = 1; i < prices.size(); i++) { 7 | if (prices[i] > prices[i - 1]) { 8 | maxProfit += prices[i] - prices[i - 1]; 9 | } 10 | } 11 | 12 | return maxProfit; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /Medium/134. Gas Station/Readme.md: -------------------------------------------------------------------------------- 1 | Time Complexity 2 | O(n) 3 | 4 | Space Complexity 5 | O(1) -------------------------------------------------------------------------------- /Medium/134. Gas Station/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int canCompleteCircuit(vector& gas, vector& cost) { 4 | ios_base::sync_with_stdio(false); 5 | cin.tie(NULL); 6 | int n = cost.size(), bal = 0, start = 0, deficit = 0; 7 | 8 | for(int i = 0; i< n; i++){ 9 | bal += gas[i] - cost[i]; 10 | 11 | if(bal < 0){ 12 | 13 | deficit += bal; 14 | start = i+1; 15 | bal = 0; 16 | } 17 | } 18 | return bal + deficit >= 0 ? start : -1; 19 | } 20 | }; -------------------------------------------------------------------------------- /Medium/134. Gas Station/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int canCompleteCircuit(int[] gas, int[] cost) { 3 | int sGas = 0, sCost = 0, res = 0, total = 0; 4 | for (int i = 0; i < gas.length; i++) { 5 | sGas += gas[i]; 6 | sCost += cost[i]; 7 | } 8 | if (sGas < sCost) return -1; 9 | for (int i = 0; i < gas.length; i++) { 10 | total += gas[i] - cost[i]; 11 | if (total < 0) { 12 | total = 0; 13 | res = i + 1; 14 | } 15 | } 16 | return res; 17 | } 18 | } -------------------------------------------------------------------------------- /Medium/134.Gas Station/solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int canCompleteCircuit(vector& gas, vector& cost) { 4 | int n = gas.size(); 5 | int total_surplus = 0; 6 | int surplus = 0; 7 | int start = 0; 8 | 9 | for(int i = 0; i < n; i++){ 10 | total_surplus += gas[i] - cost[i]; 11 | surplus += gas[i] - cost[i]; 12 | if(surplus < 0){ 13 | surplus = 0; 14 | start = i + 1; 15 | } 16 | } 17 | return (total_surplus < 0) ? -1 : start; 18 | } 19 | }; 20 | 21 | 22 | -------------------------------------------------------------------------------- /Medium/134.Gas Station/solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int canCompleteCircuit(int[] gas, int[] cost) { 3 | int n = gas.length; 4 | int total_surplus = 0; 5 | int surplus = 0; 6 | int start = 0; 7 | 8 | for(int i = 0; i < n; i++){ 9 | total_surplus += gas[i] - cost[i]; 10 | surplus += gas[i] - cost[i]; 11 | if(surplus < 0){ 12 | surplus = 0; 13 | start = i + 1; 14 | } 15 | } 16 | return (total_surplus < 0) ? -1 : start; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Medium/134.Gas Station/solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int: 3 | n, total_surplus, surplus, start = len(gas), 0, 0, 0 4 | 5 | for i in range(n): 6 | total_surplus += gas[i] - cost[i] 7 | surplus += gas[i] - cost[i] 8 | if surplus < 0: 9 | surplus = 0 10 | start = i + 1 11 | return -1 if (total_surplus < 0) else start 12 | -------------------------------------------------------------------------------- /Medium/1361. Validate Binary Tree Nodes/Readme.md: -------------------------------------------------------------------------------- 1 | You have n binary tree nodes numbered from 0 to n - 1 where node i has two children leftChild[i] and rightChild[i], return true if and only if all the given nodes form exactly one valid binary tree. 2 | 3 | If node i has no left child then leftChild[i] will equal -1, similarly for the right child. 4 | 5 | Note that the nodes have no values and that we only use the node numbers in this problem. 6 | 7 | 8 | 9 | Example 1: 10 | 11 | 12 | Input: n = 4, leftChild = [1,-1,3,-1], rightChild = [2,-1,-1,-1] 13 | Output: true 14 | Example 2: 15 | 16 | 17 | Input: n = 4, leftChild = [1,-1,3,-1], rightChild = [2,3,-1,-1] 18 | Output: false 19 | Example 3: 20 | 21 | 22 | Input: n = 2, leftChild = [1,0], rightChild = [-1,-1] 23 | Output: false 24 | 25 | 26 | Constraints: 27 | 28 | n == leftChild.length == rightChild.length 29 | 1 <= n <= 104 30 | -1 <= leftChild[i], rightChild[i] <= n - 1 -------------------------------------------------------------------------------- /Medium/142. LinkedList Cycle II/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | struct ListNode 6 | { 7 | int val; 8 | ListNode *next; 9 | ListNode(int x) : val(x), next(NULL) {} 10 | }; 11 | 12 | class Solution 13 | { 14 | public: 15 | ListNode *detectCycle(ListNode *head) 16 | { 17 | 18 | ListNode *slow = head; 19 | ListNode *fast = head; 20 | 21 | while (fast != NULL && fast->next != NULL) 22 | { 23 | slow = slow->next; 24 | fast = fast->next->next; 25 | 26 | if (slow == fast) 27 | { 28 | return getStartingNode(head, slow); 29 | } 30 | } 31 | 32 | return NULL; 33 | } 34 | 35 | private: 36 | ListNode *getStartingNode(ListNode *head, ListNode *meetingPoint) 37 | { 38 | ListNode *slow = head; 39 | while (slow != meetingPoint) 40 | { 41 | slow = slow->next; 42 | meetingPoint = meetingPoint->next; 43 | } 44 | return slow; 45 | } 46 | }; 47 | 48 | int main() 49 | { 50 | 51 | // call the fn here 52 | 53 | return 0; 54 | } -------------------------------------------------------------------------------- /Medium/1448. Count Good Nodes in Binary Tree/Solution.java: -------------------------------------------------------------------------------- 1 | // Using recursion 2 | class Solution { 3 | int n = 0; 4 | public int goodNodes(TreeNode root) { 5 | goodNode(root, root.val); 6 | return n; 7 | } 8 | 9 | public void goodNode(TreeNode root, int lastMax){ 10 | if(root == null) return; 11 | if(root.val >= lastMax){ 12 | n++; 13 | lastMax = root.val; 14 | } 15 | goodNode(root.left, lastMax); 16 | goodNode(root.right, lastMax); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Medium/15. 3sum/solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public List> threeSum(int[] arr) { 3 | 4 | 5 | if (arr == null || arr.length < 3) return new ArrayList<>(); 6 | 7 | Arrays.sort(arr); 8 | Set> result = new HashSet<>(); 9 | 10 | for (int i = 0; i < arr.length - 2; i++) 11 | { 12 | 13 | int left = i + 1; 14 | int right = arr.length - 1; 15 | 16 | while (left < right) { 17 | int sum = arr[i] + arr[left] + arr[right]; 18 | 19 | if (sum == 0) { 20 | 21 | result.add(Arrays.asList(arr[i], arr[left], arr[right])); 22 | left++; 23 | right--; 24 | } else if (sum < 0) 25 | left++; 26 | else 27 | right--; 28 | 29 | } 30 | } 31 | 32 | return new ArrayList<>(result); 33 | 34 | } 35 | } -------------------------------------------------------------------------------- /Medium/15.3Sum/solution.cpp: -------------------------------------------------------------------------------- 1 | 2 | class Solution { 3 | public: 4 | std::vector> threeSum(std::vector& nums) { 5 | std::vector> result; 6 | int n = nums.size(); 7 | 8 | std::sort(nums.begin(), nums.end()); 9 | 10 | for (int i = 0; i < n - 2; ++i) { 11 | if (i > 0 && nums[i] == nums[i - 1]) { 12 | continue; 13 | } 14 | 15 | int target = -nums[i]; 16 | int left = i + 1, right = n - 1; 17 | 18 | while (left < right) { 19 | int sum = nums[left] + nums[right]; 20 | if (sum == target) { 21 | result.push_back({nums[i], nums[left], nums[right]}); 22 | while (left < right && nums[left] == nums[++left]); 23 | while (left < right && nums[right] == nums[--right]); 24 | } else if (sum < target) { 25 | left++; 26 | } else { 27 | right--; 28 | } 29 | } 30 | } 31 | 32 | return result; 33 | } 34 | }; 35 | -------------------------------------------------------------------------------- /Medium/1503. Last Moment Before All Ants Fall Out of a Plank/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int getLastMoment(int n, int[] left, int[] right) { 3 | Arrays.sort(left); 4 | Arrays.sort(right); 5 | int t1 = 0; 6 | int t2 = 0; 7 | if (left.length > 0) 8 | t1 = left[left.length - 1]; 9 | if (right.length > 0) 10 | t2 = n - right[0]; 11 | return Math.max(t1, t2); 12 | } 13 | } -------------------------------------------------------------------------------- /Medium/151. Reverse Words in a String/Approach 1/Solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverseWords(self, s: str) -> str: 3 | lists = s.split() 4 | answer = ' '.join(lists[::-1]) 5 | return answer -------------------------------------------------------------------------------- /Medium/151. Reverse Words in a String/Approach 1/sol.md: -------------------------------------------------------------------------------- 1 | 1. Split the input string **'s'** into an array of words using the split() function with space as the delimiter, and store them in the 'lists' array. 2 | 2. Reverse the order of the words in the **'lists'** array using Python slicing. 3 | 3. Join the reversed words into a single string using the **join()** function with a space character as the separator. 4 | 4. Return the reversed sentence as the result. -------------------------------------------------------------------------------- /Medium/151. Reverse Words in a String/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public String reverseWords(String s) { 3 | String [] words = s.split(" "); 4 | 5 | //StringBuilder to store the result. 6 | StringBuilder result = new StringBuilder(); 7 | 8 | int end = words.length - 1; 9 | 10 | for(int i = 0; i<= end; i++){ 11 | // Check if the current word is not empty. 12 | if(!words[i].isEmpty()) { 13 | // Insert the current word at the beginning of the 'result'. 14 | result.insert(0, words[i]); 15 | if(i < end) { 16 | // Add a space before the current word if it's not the last word. 17 | result.insert(0, " "); 18 | } 19 | } 20 | } 21 | 22 | return result.toString(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Medium/151. Reverse Words in a String/sol.md: -------------------------------------------------------------------------------- 1 | ### Simplest and Easy Approach to Understand and solve a problem 2 | 3 | 1. Split the input string 's' into an array of words using space as the delimiter, and store them in the 'words' array. 4 | 2. Create an empty StringBuilder called 'result' to store the reversed sentence. 5 | 3. Initialize the 'end' variable to the index of the last word in the 'words' array. 6 | 4. Iterate through the 'words' array in a forward order. 7 | 5. Inside the loop, check if the current word is not empty. 8 | 6. If the current word is not empty, insert it at the beginning of the 'result' StringBuilder. 9 | 7. If the current word is not the last word, add a space character before it to separate words. 10 | 8. Repeat steps 5-7 for all words in the 'words' array. 11 | 9. Convert the 'result' StringBuilder to a string using the toString() method. 12 | 10. Return the reversed sentence as the result. 13 | 14 | Example 1: 15 | 16 | Input: s = "the sky is blue" 17 | 18 | Output: "blue is sky the" 19 | 20 | Example 2: 21 | 22 | Input: s = " hello world " 23 | 24 | Output: "world hello" -------------------------------------------------------------------------------- /Medium/153. Find Minimum in Rotated Sorted Array/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution 7 | { 8 | public: 9 | int findMin(vector &nums) 10 | { 11 | 12 | int start = 0; 13 | int end = nums.size() - 1; 14 | int ans = start; 15 | 16 | while (nums[start] > nums[end]) 17 | { 18 | int mid = (start + end) / 2; 19 | 20 | if (nums[mid] <= nums[start] && nums[mid] <= nums[end]) 21 | { 22 | end = mid; 23 | } 24 | else if (nums[mid] >= nums[start] && nums[mid] >= nums[end]) 25 | { 26 | start = mid + 1; 27 | } 28 | else 29 | { 30 | return nums[mid]; 31 | } 32 | 33 | ans = start; 34 | } 35 | 36 | return nums[ans]; 37 | } 38 | }; 39 | 40 | int main() 41 | { 42 | 43 | // call the fn here 44 | 45 | return 0; 46 | } -------------------------------------------------------------------------------- /Medium/153. Find Minimum in Rotated Sorted Array/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | class Solution { 7 | public int findMin(int[] nums) { 8 | int start = 0, end = nums.length - 1, ans = start; 9 | while (nums[start] > nums[end]) { 10 | int mid = (start + end) / 2; 11 | if (nums[mid] <= nums[start] && nums[mid] <= nums[end]) { 12 | end = mid; 13 | } else if (nums[mid] >= nums[start] && nums[mid] >= nums[end]) { 14 | start = mid + 1; 15 | } else { 16 | return nums[mid]; 17 | } 18 | ans = start; 19 | } 20 | return nums[ans]; 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Medium/1631. Path With Minimum Effort/sol.md: -------------------------------------------------------------------------------- 1 | 1. Initialize a priority queue to store the nodes that need to be visited. The priority queue is sorted in descending order of the effort required to reach the node. 2 | 2. Add the source node to the priority queue with an effort of 0. 3 | 3. While the priority queue is not empty: 4 | * Pop the node with the lowest effort from the priority queue. 5 | * If the popped node is the destination node, then return the effort. 6 | * For each neighbor of the popped node: 7 | * Calculate the effort to reach the neighbor. 8 | * If the calculated effort is lower than the current effort for the neighbor, then update the effort for the neighbor and add it to the priority queue. 9 | 4. Return the effort required to reach the destination node, or -1 if the destination node is unreachable. 10 | 11 | The code implements Dijkstra's algorithm efficiently by using a priority queue to store the nodes that need to be visited. Priority queue ensures that the nodes are visited in order of increasing effort, which leads to a more efficient search. -------------------------------------------------------------------------------- /Medium/1647. Min Deletions to Make Char Frequencies Unique/sol.md: -------------------------------------------------------------------------------- 1 | Create an array to store the frequency of each character in the string. 2 | Sort the frequencies in ascending order. 3 | Initialize the deletion count to zero. 4 | Iterate over the frequencies in reverse order. 5 | If the current frequency is equal to or greater than the next frequency, then decrement the current frequency by the maximum of zero and the next frequency minus one. Update the deletion count by the difference between the previous and current frequencies. 6 | Return the deletion count. 7 | 8 | 9 | his algorithm works by greedily reducing the frequency of the most common characters until all frequencies are distinct. This ensures that the minimum number of deletions is required to achieve a unique frequency distribution. -------------------------------------------------------------------------------- /Medium/1695. Maximum Erasure Value/README.md: -------------------------------------------------------------------------------- 1 | # 1695. Maximum Erasure Value 2 | You are given an array of positive integers `nums` and want to erase a subarray containing **unique elements**. The **score** you get by erasing the subarray is equal to the **sum** of its elements. 3 | 4 | Return *the **maximum score** you can get by erasing **exactly one** subarray*. 5 | 6 | An array `b` is called to be a subarray of `a` if it forms a contiguous subsequence of `a`, that is, if it is equal to`a[l],a[l+1],...,a[r]` for some `(l,r)`. 7 | 8 | Example 1: 9 | > Input: nums = [4,2,4,5,6] 10 | > Output: 17 11 | > Explanation: The optimal subarray here is [2,4,5,6]. 12 | 13 | Example 2: 14 | > Input: nums = [5,2,1,2,5,2,1,2,5] 15 | > Output: 8 16 | > Explanation: The optimal subarray here is [5,2,1] or [1,2,5]. 17 | 18 | Constraints: 19 | * `1 <= nums.length <= 10^5` 20 | * `1 <= nums[i] <= 10^4` -------------------------------------------------------------------------------- /Medium/172. Factorial Trailing Zeroes/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public int trailingZeroes(int n) { 3 | 4 | int zero=0; 5 | 6 | for(int i=5 ; i<=n ; i=i*5){ 7 | zero = zero + n/i; 8 | } 9 | 10 | return zero; 11 | 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Medium/172. Factorial Trailing Zeroes/sol.md: -------------------------------------------------------------------------------- 1 | ### Simplest, Easy and Optimized java Solution 2 | 3 | Algorithm 4 | 1. Initialize a variable zero to 0. This variable will be used to keep track of the number of trailing zeroes. 5 | 2. Start a loop with i initialized to 5. The loop will continue as long as i is less than or equal to n. 6 | 3. Inside the loop, calculate the number of factors of 5 in n. You can do this by dividing n by i and adding the result to the zero variable. This step accounts for the number of trailing zeroes caused by the multiples of 5 in the factorial of n. 7 | 4. Multiply i by 5 in each iteration of the loop to check for the next power of 5. 8 | 5. Once the loop is finished, return the value of zero, which represents the number of trailing zeroes in the factorial of n. 9 | 10 | Example 1: 11 | 12 | Input: n = 3 13 | 14 | Output: 0 15 | 16 | Explanation: 3! = 6, no trailing zero. 17 | 18 | Example 2: 19 | 20 | Input: n = 5 21 | 22 | Output: 1 23 | 24 | Explanation: 5! = 120, one trailing zero. 25 | 26 | Example 3: 27 | 28 | 29 | Input: n = 0 30 | 31 | Output: 0 -------------------------------------------------------------------------------- /Medium/179. Largest Number/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | class Solution 8 | { 9 | public: 10 | string largestNumber(vector &nums) 11 | { 12 | 13 | vector strNums; 14 | for (int num : nums) 15 | { 16 | strNums.push_back(to_string(num)); 17 | } 18 | 19 | sort(strNums.begin(), strNums.end(), [](string &a, string &b) 20 | { return a + b > b + a; }); 21 | 22 | string ans; 23 | for (string s : strNums) 24 | { 25 | ans += s; 26 | } 27 | 28 | return ans[0] == '0' ? "0" : ans; 29 | } 30 | }; 31 | 32 | int main() 33 | { 34 | 35 | // call the fn here 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /Medium/179. Largest Number/sol.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class sol { 4 | public static void main(String[] args) { 5 | // call the fn here 6 | } 7 | 8 | class Solution { 9 | public String largestNumber(int[] nums) { 10 | String ans = ""; 11 | ArrayList list = new ArrayList<>(); 12 | 13 | for (int i = 0; i < nums.length; i++) { 14 | list.add(String.valueOf(nums[i])); 15 | } 16 | 17 | Collections.sort(list, (a, b) -> (b + a).compareTo(a + b)); 18 | 19 | for (String s : list) { 20 | ans += s; 21 | } 22 | 23 | return ans.charAt(0) == '0' ? "0" : ans; 24 | } 25 | } 26 | } -------------------------------------------------------------------------------- /Medium/189. Rotate Array/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public void rotate(int[] nums, int k) { 3 | int n=nums.length; 4 | k=k%nums.length; 5 | if(k<0){ 6 | k=k+nums.length; 7 | } 8 | int[] temp = new int[n]; 9 | // Copy elements to the temp array with the right shift 10 | for (int i = 0; i < n; i++) { 11 | temp[(i + k) % n] = nums[i]; 12 | } 13 | // Copy elements back to the original array 14 | for (int i = 0; i < n; i++) { 15 | nums[i] = temp[i]; 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Medium/19. Remove nth Node From the End/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | struct ListNode 6 | { 7 | int val; 8 | ListNode *next; 9 | 10 | ListNode() : val(0), next(nullptr) {} 11 | ListNode(int x) : val(x), next(nullptr) {} 12 | ListNode(int x, ListNode *next) : val(x), next(next) {} 13 | }; 14 | 15 | class Solution 16 | { 17 | public: 18 | ListNode *removeNthFromEnd(ListNode *head, int n) 19 | { 20 | 21 | ListNode *dummy = new ListNode(0); 22 | dummy->next = head; 23 | 24 | ListNode *first = dummy; 25 | ListNode *second = dummy; 26 | 27 | for (int i = 0; i <= n; i++) 28 | { 29 | first = first->next; 30 | } 31 | 32 | while (first != NULL) 33 | { 34 | first = first->next; 35 | second = second->next; 36 | } 37 | 38 | second->next = second->next->next; 39 | 40 | return dummy->next; 41 | } 42 | }; 43 | 44 | int main() 45 | { 46 | // call the fn here 47 | return 0; 48 | } -------------------------------------------------------------------------------- /Medium/19. Remove nth Node From the End/sol.java: -------------------------------------------------------------------------------- 1 | 2 | class ListNode { 3 | int val; 4 | ListNode next; 5 | 6 | ListNode() { 7 | } 8 | 9 | ListNode(int val) { 10 | this.val = val; 11 | } 12 | 13 | ListNode(int val, ListNode next) { 14 | this.val = val; 15 | this.next = next; 16 | } 17 | } 18 | public class sol { 19 | public static void main(String[] args) { 20 | // call the fn here 21 | } 22 | } 23 | 24 | 25 | class Solution { 26 | public ListNode removeNthFromEnd(ListNode head, int n) { 27 | ListNode dummy = new ListNode(0); 28 | dummy.next = head; 29 | ListNode first = dummy; 30 | ListNode second = dummy; 31 | 32 | for (int i = 0; i <= n; i++) { 33 | first = first.next; 34 | } 35 | 36 | while (first != null) { 37 | first = first.next; 38 | second = second.next; 39 | } 40 | 41 | second.next = second.next.next; 42 | 43 | return dummy.next; 44 | } 45 | 46 | } -------------------------------------------------------------------------------- /Medium/19. Remove nth Node From the End/sol.md: -------------------------------------------------------------------------------- 1 | 1. Create a dummy node and set its next pointer to the head of the linked list. 2 | 2. Initialize two pointers, `first` and `second`, to the dummy node. 3 | 3. Advance the `first` pointer `n + 1` nodes forward. 4 | 4. While the `first` pointer is not null: 5 | * Advance both the `first` and `second` pointers one node forward. 6 | 5. Set the `next` pointer of the `second` node to the `next` pointer of the `second.next` node. 7 | 6. Return the next pointer of the dummy node. 8 | 9 | The time complexity of the algorithm is O(n), where n is the length of the linked list. This is because the algorithm needs to traverse the linked list twice. 10 | 11 | The space complexity of the algorithm is O(1), since it only needs to store three pointers. 12 | -------------------------------------------------------------------------------- /Medium/1996. The Number of Weak Characters in the Game/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | static bool compare(vector& a, vector& b){ 4 | if(a[0] == b[0]) 5 | return a[1] < b[1]; 6 | return a[0] > b[0]; 7 | } 8 | 9 | int numberOfWeakCharacters(vector>& properties) { 10 | int n = properties.size(); 11 | int count = 0; 12 | sort(properties.begin(), properties.end(), compare); 13 | int maxN = INT_MIN; 14 | for(int i = 0; i < n; i++){ 15 | if(properties[i][1] < maxN) 16 | count++; 17 | maxN = max(maxN, properties[i][1]); 18 | } 19 | return count; 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /Medium/1996. The Number of Weak Characters in the Game/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int numberOfWeakCharacters(int[][] properties) { 3 | int n = properties.length; 4 | int count = 0; 5 | int maxN = Integer.MIN_VALUE; 6 | Arrays.sort(properties, (a, b) -> a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]); 7 | for(int i = 0; i < n; i++){ 8 | if(properties[i][1] < maxN) 9 | count++; 10 | maxN = Math.max(maxN, properties[i][1]); 11 | } 12 | return count; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Medium/1996. The Number of Weak Characters in the Game/Solution.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def numberOfWeakCharacters(self, properties): 3 | count = 0 4 | maxN = ~sys.maxint 5 | properties.sort(key=lambda x: (-x[0], x[1])) 6 | for i in range(len(properties)): 7 | if(properties[i][1] < maxN): 8 | count+=1 9 | maxN = max(maxN, properties[i][1]) 10 | return count 11 | -------------------------------------------------------------------------------- /Medium/2. Add Two Numbers/Approach 1/Readme.md: -------------------------------------------------------------------------------- 1 | It's time to sum up these node value, for that we will create one another variable let's called it sum and put the sum of l1 & l2 them into our dummy list. So, we start it from all the way left go to all the way right. 2 | Now you will ask, dude what about the carry values we get after sum up. 3 | Well, hold on i'm coming on that point don't worry. 4 | 5 | So, for that what you have to do is, we will intialize one more variable name carry if we found carry of let's say 10. First we will modulo it like carry = sum % 10 i.e. carry = 10 % 10 i.e. 0 we will add 0 into our node and after that what we will do is get the carry as carry = sum / 10 i.e. carry = 10 / 10 i.e. 1. Now we are having carry as 1. So, in the next node sum of l1 & l2 we will add carry as well. -------------------------------------------------------------------------------- /Medium/2. Add Two Numbers/Approach 1/Solution..cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { 4 | ListNode *dummy = new ListNode(0); 5 | ListNode *curr = dummy; 6 | int carry = 0; 7 | 8 | while(l1 != NULL || l2 != NULL || carry == 1){ 9 | int sum = 0; 10 | if(l1 != NULL){ 11 | sum += l1->val; 12 | l1 = l1->next; 13 | } 14 | if(l2 != NULL){ 15 | sum += l2->val; 16 | l2 = l2->next; 17 | } 18 | sum += carry; 19 | carry = sum/10; 20 | ListNode *node = new ListNode(sum % 10); 21 | curr->next = node; 22 | curr = curr->next; 23 | } 24 | return dummy->next; 25 | } 26 | }; -------------------------------------------------------------------------------- /Medium/200. Number of Islands/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numIslands(vector>& grid) { 4 | int n = 0; 5 | for(int i = 0; i < grid.size(); i++){ 6 | for(int j = 0; j < grid[0].size(); j++){ 7 | if(grid[i][j] == '1'){ 8 | n++; 9 | visitIsland(grid, i, j); 10 | } 11 | } 12 | } 13 | return n; 14 | } 15 | 16 | private: 17 | void visitIsland(vector>& grid, int r, int c){ 18 | if(r < 0 || c < 0 || r >= grid.size() || c >= grid[0].size() || grid[r][c] == '0') 19 | return; 20 | grid[r][c] = '0'; 21 | visitIsland(grid, r + 1, c); 22 | visitIsland(grid, r - 1, c); 23 | visitIsland(grid, r, c + 1); 24 | visitIsland(grid, r, c - 1); 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /Medium/200. Number of Islands/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | char[][] mat; 3 | int[] DIR = {1, 0, -1, 0, 1}; 4 | public int numIslands(char[][] grid) { 5 | int n = 0; 6 | mat = grid; 7 | int rows = mat.length; 8 | int cols = mat[0].length; 9 | for(int i = 0; i < rows; i++){ 10 | for(int j = 0; j < cols; j++){ 11 | if(mat[i][j] == '1') { 12 | visitIsland(i, j); 13 | n++; 14 | } 15 | } 16 | } 17 | return n; 18 | } 19 | 20 | public void visitIsland(int r, int c){ 21 | if(r < 0 || c < 0 || r >= mat.length || c >= mat[r].length || mat[r][c] == '0') return; 22 | mat[r][c] = '0'; 23 | for(int i = 0; i < DIR.length - 1; i++){ 24 | visitIsland(r + DIR[i], c + DIR[i + 1]); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Medium/2038. Remove Colored Pieces if Both Neighbors are the Same Color/Readme.md: -------------------------------------------------------------------------------- 1 | The given solution approach uses a Counter object to count how many valid moves Alice can make and how many valid moves Bob can make. It iterates through the input string colors to count these moves. 2 | 3 | -->The collections.Counter() is used to count the occurrences of characters in the string. 4 | -->The groupby(colors) function groups consecutive characters in the string. 5 | -->It iterates through the groups and counts how many 'A's and 'B's can be removed according to the game rules. Specifically, it counts the number of 'A's and 'B's that have at least two neighbors of the same color. 6 | -->Finally, it compares the counts of valid moves for Alice ('A') and Bob ('B'). If Alice has more valid moves, it returns True; otherwise, it returns False. 7 | 8 | The idea is that if Alice can make more valid moves than Bob, she has a winning strategy because she will eventually force Bob into a position where he can't make a move. 9 | This solution works under the assumption that both players play optimally and is a good approach to solve the problem efficiently. -------------------------------------------------------------------------------- /Medium/2038. Remove Colored Pieces if Both Neighbors are the Same Color/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool winnerOfGame(string colors) { 4 | map c; 5 | for (auto it = colors.begin(); it != colors.end(); ) { 6 | char x = *it; 7 | auto t = it; 8 | while (t != colors.end() && *t == x) { 9 | t++; 10 | } 11 | c[x] += max(int(distance(it, t) - 2), 0); 12 | it = t; 13 | } 14 | 15 | if (c['A'] > c['B']) { 16 | return true; 17 | } 18 | return false; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /Medium/2038. Remove Colored Pieces if Both Neighbors are the Same Color/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public boolean winnerOfGame(String colors) { 3 | Map c = new HashMap<>(); 4 | c.put('A', 0); 5 | c.put('B', 0); 6 | 7 | for (int i = 0; i < colors.length(); i++) { 8 | char x = colors.charAt(i); 9 | int count = 0; 10 | 11 | while (i < colors.length() && colors.charAt(i) == x) { 12 | i++; 13 | count++; 14 | } 15 | 16 | c.put(x, c.get(x) + Math.max(count - 2, 0)); 17 | i--; 18 | } 19 | 20 | return c.get('A') > c.get('B'); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Medium/2038. Remove Colored Pieces if/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | bool winnerOfGame(string colors) { 8 | int countA = 0; 9 | int countB = 0; 10 | 11 | for (int i = 1; i < colors.length() - 1; i++) { 12 | if (colors[i - 1] == colors[i] && colors[i] == colors[i + 1]) { 13 | if (colors[i] == 'A') { 14 | countA++; 15 | } else { 16 | countB++; 17 | } 18 | } 19 | } 20 | 21 | return countA > countB; 22 | } 23 | }; -------------------------------------------------------------------------------- /Medium/2038. Remove Colored Pieces if/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | class Solution { 7 | public boolean winnerOfGame(String colors) { 8 | int countA = 0; 9 | int countB = 0; 10 | for (int i = 1; i < colors.length() - 1; i++) { 11 | if (colors.charAt(i - 1) == colors.charAt(i) && colors.charAt(i) == colors.charAt(i + 1)) { 12 | if (colors.charAt(i) == 'A') { 13 | countA++; 14 | } else { 15 | countB++; 16 | } 17 | } 18 | } 19 | return countA > countB; 20 | } 21 | } 22 | } -------------------------------------------------------------------------------- /Medium/2038. Remove Colored Pieces if/sol.md: -------------------------------------------------------------------------------- 1 | 1. Initialize two variables `countA` and `countB` to keep track of the number of times the characters `A` and `B` appear in consecutive groups of three, respectively. 2 | 2. Iterate over the input string `colors`: 3 | * If the current character and the next two characters are all the same, then increment the corresponding counter `countA` or `countB` depending on the character. 4 | 3. Return `true` if `countA` is greater than `countB`, otherwise return `false`. 5 | 6 | **Example:** 7 | 8 | Consider the following input: 9 | 10 | 11 | colors = "ABBBBAA" 12 | 13 | 14 | The algorithm will work as follows: 15 | 16 | 17 | Iteration | i | colors.charAt(i - 1) | colors.charAt(i) | colors.charAt(i + 1) | countA | countB 18 | -------- | -------- | -------- | -------- | -------- | -------- | -------- 19 | 1 | 1 | A | B | B | 0 | 0 20 | 2 | 2 | B | B | B | 0 | 1 21 | 3 | 3 | B | B | A | 0 | 1 22 | 4 | 4 | B | A | A | 1 | 1 23 | 5 | 5 | A | A | A | 2 | 1 24 | 6 | 6 | A | A | B | 2 | 1 25 | 26 | 27 | The output of the algorithm is `true`, since `countA` is greater than `countB`. -------------------------------------------------------------------------------- /Medium/204.CountPrimes/Count-Primes.java: -------------------------------------------------------------------------------- 1 | /* 2 | * LeetCode 204. 3 | * Problem Statement-Given an integer n, return the number of prime numbers that are strictly less than n 4 | * 5 | * Test Cases: 6 | * 7 | * Example 1: 8 | Input: n = 10 9 | Output: 4 10 | Explanation: There are 4 prime numbers less than 10, they are 2, 3, 5, 7. 11 | 12 | Example 2: 13 | Input: n = 0 14 | Output: 0 15 | */ 16 | 17 | //Solution of Sieve of Eratosthenes approach 18 | class Solution { 19 | public int countPrimes(int n) { 20 | //using seive of eratosthenes 21 | boolean prime[]=new boolean[n+1];int c=0; 22 | Arrays.fill(prime,true); 23 | prime[0]=false; 24 | for(int i=2;i*i<=n;i++) 25 | { 26 | if(prime[i]==true) 27 | { 28 | for(int j=i*i;j<=n;j=j+i) 29 | prime[j]=false; 30 | } 31 | } 32 | for(int i=2;ipq= new PriorityQueue<>((a,b)->b-a); 4 | 5 | int n = nums.length ; 6 | 7 | for (int i = 0; i < nums.length; i++) { 8 | pq.add(nums[i]) ; 9 | } 10 | 11 | int f = k - 1 ; 12 | 13 | while (f > 0) { 14 | pq.remove() ; 15 | f-- ; 16 | } 17 | 18 | return pq.peek(); 19 | } 20 | } -------------------------------------------------------------------------------- /Medium/2186. Minimum Number of Steps to Make Two Strings Anagram II/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public int minSteps(String s, String s1) { 3 | int[] freq1 = new int[26]; 4 | int[] freq2 = new int[26]; 5 | 6 | // Count the frequency of characters in the first string 7 | for (char c : s.toCharArray()) { 8 | freq1[c - 'a']++; 9 | } 10 | 11 | // Count the frequency of characters in the second string 12 | for (char c : s1.toCharArray()) { 13 | freq2[c - 'a']++; 14 | } 15 | 16 | int delete = 0; 17 | 18 | // Calculate the difference in character frequencies 19 | for (int i = 0; i < 26; i++) { 20 | delete += Math.abs(freq1[i] - freq2[i]); 21 | } 22 | return delete; 23 | 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /Medium/2186. Minimum Number of Steps to Make Two Strings Anagram II/sol.md: -------------------------------------------------------------------------------- 1 | ### Easiest solution to understand the solution 2 | 3 | 1. Create two arrays of 26 Characters 4 | 2. Count the frequency of characters in the first string 5 | 3. Count the frequency of characters in the second string 6 | 4. Calculate the difference in character frequencies 7 | 5. Return the difference Value 8 | 9 | Example 1: 10 | 11 | Input: s = "leetcode", t = "coats" 12 | 13 | Output: 7 14 | 15 | Example 2: 16 | 17 | Input: s = "night", t = "thing" 18 | 19 | Output: 0 -------------------------------------------------------------------------------- /Medium/22. Generate Parentheses/README.md: -------------------------------------------------------------------------------- 1 |

22. Generate Parentheses

Medium

2 |

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

3 | 4 |

 

5 |

Example 1:

6 | 
Input: n = 3
 7 | Output: ["((()))","(()())","(())()","()(())","()()()"]
 8 |

Example 2:

9 | 
Input: n = 1
10 | Output: ["()"]
11 |
12 |

 

13 |

Constraints:

14 | 15 |
    16 |
  • 1 <= n <= 8
    • 17 |
18 |
-------------------------------------------------------------------------------- /Medium/229. MajorityElement-ll/Solution.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | class Solution 8 | { 9 | public: 10 | vector majorityElement(vector& nums) { 11 | vector vec; 12 | int n= floor(nums.size()/3)+1; 13 | map mp; 14 | map::iterator it; 15 | for(int i=0;i(nums[i],1)); 19 | else it->second=mp[nums[i]]+1; 20 | } 21 | for(it=mp.begin();it!=mp.end();it++){ 22 | if(it->second>=n) 23 | vec.push_back(it->first); 24 | } 25 | return vec; 26 | } 27 | }; 28 | 29 | int main() 30 | { 31 | 32 | // call the fn here 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Medium/229. MajorityElement-ll/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution{ 2 | public List majorityElement(int[] nums) { 3 | List result = new ArrayList<>(); 4 | if(nums.length < 3){ 5 | int n = nums.length; 6 | for(int i=0; i 1 && nums[i] != nums[i+1]){ 21 | count = 1; 22 | } 23 | if(count >= gt+1){ 24 | if(!result.contains(nums[i])){ 25 | result.add(nums[i]); 26 | count = 1; 27 | } 28 | } 29 | } 30 | return result; 31 | } 32 | } -------------------------------------------------------------------------------- /Medium/2433. Find The Original Array of Prefix Xor/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector findArray(vector& pref) { 4 | int n = pref.size(); 5 | vector arr(n); 6 | 7 | arr[0] = pref[0]; // The first element of arr is equal to the first element of pref 8 | 9 | // Iterate through the pref array to find the elements of arr 10 | for (int i = 1; i < n; i++) { 11 | arr[i] = pref[i] ^ pref[i - 1]; 12 | } 13 | 14 | return arr; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /Medium/274. H-Index/Readme.md: -------------------------------------------------------------------------------- 1 | Approach 2 | -->Calculate the count of paper greater than mid. 3 | -->Now if count is greater than we increase h-index =>i=mid 4 | 5 | Complexity 6 | 1.Time complexity:O(NlogN) 7 | 2.Space complexity:O(1) 8 | -------------------------------------------------------------------------------- /Medium/274. H-Index/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int hIndex(vector& c) { 4 | int low=0 , high = c.size(); 5 | while(low < high){ 6 | int mid = (low+high+1)/2; 7 | int cnt=0; 8 | for(int i=0 ; i= mid) cnt++; 9 | if(cnt >= mid) low = mid; 10 | else high = mid-1; 11 | } 12 | return low; 13 | } 14 | }; -------------------------------------------------------------------------------- /Medium/274. H-Index/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int hIndex(int[] c) { 3 | int low=0 , high = c.length; 4 | while(low < high){ 5 | int mid = (low+high+1)/2; 6 | int cnt=0; 7 | for(int i=0 ; i= mid) cnt++; 8 | if(cnt >= mid) low = mid; 9 | else high = high=mid-1; 10 | } 11 | return low; 12 | } 13 | } -------------------------------------------------------------------------------- /Medium/287. Find Duplicate Number/New Approach/Solution.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | public class Solution { 3 | public int findDuplicate(int[] nums) { 4 | Arrays.sort(nums); 5 | 6 | for(int i=1;i 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution 7 | { 8 | public: 9 | int findDuplicate(vector &nums) 10 | { 11 | 12 | int slow = nums[0]; 13 | int fast = nums[0]; 14 | 15 | do 16 | { 17 | slow = nums[slow]; 18 | fast = nums[nums[fast]]; 19 | } while (slow != fast); 20 | 21 | fast = nums[0]; 22 | 23 | while (slow != fast) 24 | { 25 | slow = nums[slow]; 26 | fast = nums[fast]; 27 | } 28 | 29 | return slow; 30 | } 31 | }; 32 | 33 | int main() 34 | { 35 | 36 | // call the fn here 37 | return 0; 38 | } -------------------------------------------------------------------------------- /Medium/287. Find Duplicate Number/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | class Solution { 7 | public int findDuplicate(int[] arr) { 8 | int slowPtr = arr[0]; 9 | int fastPtr = arr[0]; 10 | 11 | do { 12 | fastPtr = arr[arr[fastPtr]]; 13 | slowPtr = arr[slowPtr]; 14 | } while (fastPtr != slowPtr); 15 | 16 | fastPtr = arr[0]; 17 | 18 | while (fastPtr != slowPtr) { 19 | fastPtr = arr[fastPtr]; 20 | slowPtr = arr[slowPtr]; 21 | } 22 | 23 | return fastPtr; 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Medium/29. Divide Two Integers/solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int divide(int dividend, int divisor) { 4 | 5 | //Handling corner cases 6 | if(dividend==INT_MIN && divisor==-1) return INT_MAX; 7 | if(dividend==INT_MIN && divisor==1) return INT_MIN; 8 | 9 | 10 | //Converting divisors and dividend to their positive values 11 | long int dd = abs(dividend), dv = abs(divisor); 12 | 13 | //Result Variables 14 | int res=0; 15 | while(dv<=dd) { 16 | long int mul=dv, tmp=1; 17 | while(mul<=dd-mul) { 18 | mul+=mul; 19 | tmp+=tmp; 20 | } 21 | res+=tmp; 22 | dd-=mul; 23 | } 24 | 25 | //If either of dividend or divisor is negative our result will be negative 26 | if((dividend<0&&divisor>0) || (dividend>0&&divisor<0)) return -res; 27 | 28 | return res; 29 | 30 | } 31 | }; -------------------------------------------------------------------------------- /Medium/34. First and Last Position of Element in an Array/New Approach/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public int[] searchRange(int[] nums, int target) { 3 | 4 | int n=nums.length; 5 | int arr[] =new int[2]; 6 | int arr1[] =new int[]{-1,-1}; 7 | arr[0] = -1; arr[1] = -1; 8 | for (int i = 0; i < n; i++) { 9 | if (target != nums[i]) 10 | continue; 11 | if (arr[0] == -1) 12 | arr[0] = i; 13 | arr[1] = i; 14 | } 15 | if (arr[0] != -1) { 16 | return arr; 17 | 18 | } 19 | else 20 | return arr1; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /Medium/34. First and Last Position of Element in an Array/New Approach/sol.md: -------------------------------------------------------------------------------- 1 | ### `searchRange` Function Explanation 2 | 3 | 1. Get the length of the input array `nums`. 4 | 2. Initialize an array to store the search range. 5 | 3. Initialize an array with [-1, -1] (default return value). 6 | 4. Initialize the start index of the search range as -1. 7 | 5. Initialize the end index of the search range as -1. 8 | 6. Start iterating through the input array. 9 | 7. If the current element is not the target, continue to the next element. 10 | 8. If the current element is not the target, continue to the next iteration. 11 | 9. If the start index of the search range is -1, set it to the current index. 12 | 10. Update the end index of the search range to the current index when a match is found. 13 | 11. If the start index is not -1, return the search range. 14 | 12. Return the search range containing the start and end indices of the target. 15 | 13. If no match was found, return the default [-1, -1] array. 16 | 14. Return the default search range [-1, -1] to indicate no match. -------------------------------------------------------------------------------- /Medium/341. Flatten Nested List Iterator/soln.cpp: -------------------------------------------------------------------------------- 1 | class NestedIterator { 2 | public: 3 | NestedIterator(vector &nestedList) { 4 | flatten(nestedList); 5 | current = 0; 6 | } 7 | 8 | int next() { 9 | return flatList[current++]; 10 | } 11 | 12 | bool hasNext() { 13 | return current < flatList.size(); 14 | } 15 | 16 | private: 17 | vector flatList; 18 | int current; 19 | 20 | void flatten(const vector& nestedList) { 21 | for (const auto &item : nestedList) { 22 | if (item.isInteger()) { 23 | flatList.push_back(item.getInteger()); 24 | } else { 25 | flatten(item.getList()); 26 | } 27 | } 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /Medium/341. Flatten Nested List Iterator/soln.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class NestedIterator { 4 | private List flatList; 5 | private int current; 6 | 7 | public NestedIterator(List nestedList) { 8 | flatList = new ArrayList<>(); 9 | current = 0; 10 | flatten(nestedList); 11 | } 12 | 13 | public int next() { 14 | int result = flatList.get(current); 15 | current++; 16 | return result; 17 | } 18 | 19 | public boolean hasNext() { 20 | return current < flatList.size(); 21 | } 22 | 23 | private void flatten(List nestedList) { 24 | for (NestedInteger item : nestedList) { 25 | if (item.isInteger()) { 26 | flatList.add(item.getInteger()); 27 | } else { 28 | flatten(item.getList()); 29 | } 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /Medium/341. Flatten Nested List Iterator/soln.py: -------------------------------------------------------------------------------- 1 | class NestedIterator: 2 | def __init__(self, nestedList): 3 | self.flatList = [] 4 | self.current = 0 5 | self.flatten(nestedList) 6 | 7 | def next(self): 8 | result = self.flatList[self.current] 9 | self.current += 1 10 | return result 11 | 12 | def hasNext(self): 13 | return self.current < len(self.flatList) 14 | 15 | def flatten(self, nestedList): 16 | for item in nestedList: 17 | if item.isInteger(): 18 | self.flatList.append(item.getInteger()) 19 | else: 20 | self.flatten(item.getList()) 21 | -------------------------------------------------------------------------------- /Medium/343. Integer Break/solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int integerBreak(int n) { 4 | vector dp(n + 1, 0); 5 | dp[1] = 1; 6 | for (int i = 2; i <= n; ++i) { 7 | for (int j = 1; j < i; ++j) { 8 | dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j])); 9 | } 10 | } 11 | return dp[n]; 12 | } 13 | }; -------------------------------------------------------------------------------- /Medium/343. Integer Break/solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int integerBreak(int n) { 3 | if (n <= 1) { 4 | return 0; // We can't break integers less than or equal to 1. 5 | } 6 | 7 | if (n == 2) { 8 | return 1; // Special case: 1 * 1 is the only way to break 2. 9 | } 10 | 11 | if (n == 3) { 12 | return 2; // Special case: 1 * 2 is the only way to break 3. 13 | } 14 | 15 | int product = 1; 16 | 17 | while (n > 4) { 18 | product *= 3; 19 | n -= 3; 20 | } 21 | 22 | return product * n; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Medium/343. Integer Break/solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def integerBreak(self, n: int) -> int: 3 | dp = [0] * (n + 1) 4 | dp[1] = 1 5 | for i in range(2, n + 1): 6 | dp[i] = -float('inf') 7 | for j in range(1, i): 8 | dp[i] = max(dp[i], j * (i - j), j * dp[i - j]) 9 | return dp[n] -------------------------------------------------------------------------------- /Medium/36. Valid Sudoku/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public boolean isValidSudoku(char[][] board) { 3 | for(int i = 0; i < 9; i++){ 4 | Set row = new HashSet(); 5 | Set col = new HashSet(); 6 | Set sqr = new HashSet(); 7 | for(int j = 0; j < 9; j++){ 8 | if(board[i][j] != '.' && !row.add(board[i][j])) return false; 9 | if(board[j][i] != '.' && !col.add(board[j][i])) return false; 10 | int rowIdx = 3*(i/3); 11 | int colIdx = 3*(i%3); 12 | if(board[rowIdx + j/3][colIdx + j%3] != '.' && !sqr.add(board[rowIdx + j/3][colIdx + j%3])) return false; 13 | } 14 | } 15 | return true; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Medium/40. Combination Sum II/README.md: -------------------------------------------------------------------------------- 1 | # LeetCode 40. Combination Sum II 2 | 3 | ## Problem Description 4 | Given a collection of candidate numbers (`candidates`) and a target number (`target`), find all unique combinations in `candidates` where the candidate numbers sum to `target`. 5 | 6 | Each number in `candidates` may only be used once in the combination. 7 | 8 | **Note:** The solution set must not contain duplicate combinations. 9 | 10 | ### Test Cases 11 | 12 | **Example 1:** 13 | 14 | > **Input:** candidates = [10,1,2,7,6,1,5], target = 8 15 | > 16 | > **Output:** 17 | > 18 | > [ 19 | > 20 | > [1,1,6], 21 | > 22 | > [1,2,5], 23 | > 24 | > [1,7], 25 | > 26 | > [2,6] 27 | > 28 | > ] 29 | 30 | **Example 2:** 31 | 32 | > **Input:** candidates = [2,5,2,1,2], target = 5 33 | > 34 | > **Output:** 35 | > 36 | > [ 37 | > 38 | > [1,2,2], 39 | > 40 | > [5] 41 | > 42 | > ] 43 | 44 | ### Constraints: 45 | 46 | `1 <= candidates.length <= 100` 47 | 48 | `1 <= candidates[i] <= 50` 49 | 50 | `1 <= target <= 30` 51 | 52 | ### Link 53 | 54 | https://leetcode.com/problems/combination-sum-ii/ 55 | -------------------------------------------------------------------------------- /Medium/43. Multiply Strings/README.md: -------------------------------------------------------------------------------- 1 | # LeetCode 43. Multiply Strings 2 | 3 | ## Problem Description 4 | Given a collection of candidate numbers (`candidates`) and a target number (`target`), find all unique combinations in `candidates` where the candidate numbers sum to `target`. 5 | 6 | Each number in `candidates` may only be used once in the combination. 7 | 8 | **Note:** The solution set must not contain duplicate combinations. 9 | 10 | ### Test Cases 11 | 12 | **Example 1:** 13 | 14 | > **Input:** num1 = "2", num2 = "3" 15 | > 16 | > **Output:** "6" 17 | 18 | **Example 2:** 19 | 20 | > **Input:** num1 = "123", num2 = "456" 21 | > 22 | > **Output:** "56088" 23 | 24 | 25 | **Constraints:** 26 | 27 | - `1 <= num1.length, num2.length <= 200` 28 | - `num1` and `num2` consist of digits only. 29 | - Both `num1` and `num2` do not contain any leading zero, except the number `0` itself. 30 | 31 | ### Link 32 | 33 | https://leetcode.com/problems/multiply-strings/ 34 | -------------------------------------------------------------------------------- /Medium/43. Multiply Strings/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public String multiply(String num1, String num2) { 3 | if (num1.equals("0") || num2.equals("0")) { 4 | return "0"; 5 | } 6 | int m = num1.length(); 7 | int n = num2.length(); 8 | int[] product = new int[m + n]; 9 | for (int i = m - 1; i >= 0; i--) { 10 | int digit1 = num1.charAt(i) - '0'; 11 | 12 | for (int j = n - 1; j >= 0; j--) { 13 | int digit2 = num2.charAt(j) - '0'; 14 | int multiply = digit1 * digit2; 15 | int sum = product[i + j + 1] + multiply; 16 | 17 | product[i + j] += sum / 10; 18 | product[i + j + 1] = sum % 10; 19 | } 20 | } 21 | 22 | StringBuilder sb = new StringBuilder(); 23 | 24 | for (int digit : product) { 25 | if (!(sb.length() == 0 && digit == 0)) { 26 | sb.append(digit); 27 | } 28 | } 29 | 30 | return sb.toString(); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /Medium/47. Permutations II/README.md: -------------------------------------------------------------------------------- 1 |

47. Permutations II

Medium

2 |

Given a collection of numbers, nums, that might contain duplicates, return all possible unique permutations in any order.

3 | 4 |

 

5 |

Example 1:

6 | 7 | 
Input: nums = [1,1,2]
 8 | Output:
 9 | [[1,1,2],
10 |  [1,2,1],
11 |  [2,1,1]]
12 |
13 | 14 |

Example 2:

15 | 16 | 
Input: nums = [1,2,3]
17 | Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 |
    24 |
  • 1 <= nums.length <= 8
    • 25 |
  • -10 <= nums[i] <= 10
    • 26 |
27 |
-------------------------------------------------------------------------------- /Medium/47. Permutations II/Solution.java: -------------------------------------------------------------------------------- 1 | /* 2 | This is a classic backtracking problem except that we need to check for duplicates. 3 | This is solved using two ideas: Hashset and boolean array visited. 4 | */ 5 | class Solution { 6 | List> res; 7 | Set> set = new HashSet(); 8 | public List> permuteUnique(int[] nums) { 9 | boolean[] visited = new boolean[nums.length]; 10 | backtrack(new ArrayList(), visited, nums); 11 | res = new ArrayList(set); 12 | return res; 13 | } 14 | private void backtrack(List sub,boolean[] visited,int[] nums){ 15 | if(sub.size() == nums.length){ 16 | set.add(new ArrayList(sub)); 17 | return; 18 | } 19 | for(int i=0;i>& matrix) { 4 | for(int i = 0; i < matrix.size(); i++){ 5 | for(int j = i; j < matrix[0].size(); j++){ 6 | int t = matrix[i][j]; 7 | matrix[i][j] = matrix[j][i]; 8 | matrix[j][i] = t; 9 | } 10 | } 11 | 12 | for(int i = 0; i < matrix.size(); i++){ 13 | for(int j = 0; j < matrix.size()/2; j++){ 14 | int t = matrix[i][j]; 15 | matrix[i][j] = matrix[i][matrix.size() - 1 - j]; 16 | matrix[i][matrix.size() - 1 - j] = t; 17 | } 18 | } 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /Medium/48. Rotate Image/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public void rotate(int[][] matrix) { 3 | for(int i = 0; i < matrix.length; i++){ 4 | for(int j = i; j < matrix[0].length; j++){ 5 | int t = matrix[i][j]; 6 | matrix[i][j] = matrix[j][i]; 7 | matrix[j][i] = t; 8 | } 9 | } 10 | 11 | for(int i = 0; i < matrix.length; i++){ 12 | for(int j = 0; j < matrix.length/2; j++){ 13 | int t = matrix[i][j]; 14 | matrix[i][j] = matrix[i][matrix.length - 1 - j]; 15 | matrix[i][matrix.length - 1 - j] = t; 16 | } 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Medium/5. Longest Palindromic String/longestPalindromic.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string longestPalindrome(string s) { 4 | int n = s.length(); 5 | int st = 0; 6 | int max_len = 1; 7 | 8 | if(n == 1) return s; 9 | 10 | for(int i=0; i < n-1; i++) { 11 | int l = i, r = i; 12 | while(l >= 0 && r < n && s[l] == s[r]) { 13 | l--; 14 | r++; 15 | } 16 | int len = r-l-1; 17 | if(len > max_len) { 18 | max_len = len; 19 | st = l+1; 20 | } 21 | } 22 | 23 | for(int i=0; i < n-1; i++) { 24 | int l = i, r = i+1; 25 | while(l >= 0 && r < n && s[l] == s[r]) { 26 | l--; 27 | r++; 28 | } 29 | int len = r-l-1; 30 | if(len > max_len) { 31 | max_len = len; 32 | st = l+1; 33 | } 34 | } 35 | 36 | return s.substr(st, max_len); 37 | } 38 | }; 39 | -------------------------------------------------------------------------------- /Medium/5. Longest Palindromic Substring/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public String longestPalindrome(String s) { 3 | String res=""; 4 | int reslen=0; 5 | 6 | for(int i=0;i=0 && rightreslen){ 11 | res=s.substring(left,right+1); 12 | reslen=right-left+1; 13 | } 14 | left-=1; 15 | right+=1; 16 | } 17 | 18 | // even length; 19 | left=i; 20 | right=i+1; 21 | while(left>=0 && rightreslen){ 23 | res=s.substring(left,right+1); 24 | reslen=right-left+1; 25 | } 26 | left-=1; 27 | right+=1; 28 | } 29 | } 30 | return res; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /Medium/5. Longest Palindromic Substring/Solution2.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public String longestPalindrome(String s) { 3 | if (s.length() <= 1) { 4 | return s; 5 | } 6 | 7 | int maxLen = 1; 8 | String maxStr = s.substring(0, 1); 9 | 10 | for (int i = 0; i < s.length(); i++) { 11 | for (int j = i + maxLen; j <= s.length(); j++) { 12 | if (j - i > maxLen && isPalindrome(s.substring(i, j))) { 13 | maxLen = j - i; 14 | maxStr = s.substring(i, j); 15 | } 16 | } 17 | } 18 | 19 | return maxStr; 20 | } 21 | 22 | private boolean isPalindrome(String str) { 23 | int left = 0; 24 | int right = str.length() - 1; 25 | 26 | while (left < right) { 27 | if (str.charAt(left) != str.charAt(right)) { 28 | return false; 29 | } 30 | left++; 31 | right--; 32 | } 33 | 34 | return true; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /Medium/5. Longest Palindromic Substring/chiku011solution.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | class Solution { 4 | public: 5 | bool check (int i,int j , string s){ 6 | while(i<=j){ 7 | if(s[i] != s[j]){ 8 | return false; 9 | }else{ 10 | i++; 11 | j--; 12 | } 13 | } 14 | return true; 15 | } 16 | string longestPalindrome(string s) { 17 | int maxlen=0; 18 | int index =0; 19 | for(int i =0;i maxlen){ 25 | maxlen = j-i+1; 26 | index =i; 27 | } 28 | } 29 | } 30 | } 31 | } 32 | return s.substr(index,maxlen); 33 | } 34 | }; -------------------------------------------------------------------------------- /Medium/515. Find Largest Value in Each Tree Row/sol.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector largestValues(TreeNode *root) 5 | { 6 | if (!root) 7 | return {}; 8 | 9 | std::vector result; 10 | std::queue queue; 11 | queue.push(root); 12 | 13 | while (!queue.empty()) 14 | { 15 | int curr_level_size = queue.size(); 16 | int max_val = INT_MIN; 17 | 18 | for (int i = 0; i < curr_level_size; ++i) 19 | { 20 | TreeNode *node = queue.front(); 21 | queue.pop(); 22 | max_val = std::max(max_val, node->val); 23 | 24 | if (node->left) 25 | queue.push(node->left); 26 | if (node->right) 27 | queue.push(node->right); 28 | } 29 | 30 | result.push_back(max_val); 31 | } 32 | 33 | return result; 34 | } 35 | }; 36 | -------------------------------------------------------------------------------- /Medium/55. Jump Game/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | //checking right to left if the current position can reach the last index 4 | bool canJump(vector& nums) { 5 | int minjump=0; 6 | for(int i=nums.size()-2; i>=0; i--) { 7 | minjump++; 8 | if(nums[i]>=minjump) 9 | minjump=0; 10 | } 11 | return !minjump; 12 | } 13 | }; -------------------------------------------------------------------------------- /Medium/55. Jump Game/Solution.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public boolean canJump(int[] nums) { 3 | int maxReach = 0; 4 | 5 | for (int i = 0; i < nums.length; i++) { 6 | if (i > maxReach) { 7 | return false; 8 | } 9 | 10 | maxReach = Math.max(maxReach, i + nums[i]); 11 | 12 | if (maxReach >= nums.length - 1) { 13 | return true; 14 | } 15 | } 16 | 17 | return false; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Medium/560. Subarray Sum Equals K/readme.md: -------------------------------------------------------------------------------- 1 | # Subarray Sum Equals K 2 | 3 | ## Problem 4 | 5 | Given an array of integers `nums` and an integer `k`, the task is to find and return the total number of subarrays whose sum is equal to `k`. A subarray is a contiguous non-empty sequence of elements within the array. 6 | 7 | ### Example 8 | 9 | #### Input 10 | 11 | ```javascript 12 | const nums = [1, 1, 1]; 13 | const k = 2; 14 | console.log(subarraySum(nums, k)); // Output: 2 15 | ``` 16 | 17 | The solution uses a hash table to keep track of cumulative sums. It iterates through the array, updating the cumulative sum and checking if there are subarrays with a sum of (current_sum - k). The count of such subarrays is accumulated, and the hash table is updated with the current cumulative sum. 18 | -------------------------------------------------------------------------------- /Medium/560. Subarray Sum Equals K/solution.js: -------------------------------------------------------------------------------- 1 | const subarraySum = function(nums, k) { 2 | const hashTable = { 3 | 0:1, 4 | } 5 | let sum = 0 6 | let count =0 7 | for(let i=0; i < nums.length; i++){ 8 | sum += nums[i] 9 | 10 | if([sum - k] in hashTable){ 11 | count += hashTable[sum - k] 12 | 13 | } 14 | hashTable[sum] = (hashTable[sum] || 0 ) + 1 15 | } 16 | return count 17 | }; -------------------------------------------------------------------------------- /Medium/6. Zigzag Conversion/solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public String convert(String s, int numRows) { 3 | if(numRows < 2) { 4 | return s; 5 | } 6 | String str =""; 7 | int x = s.length(); 8 | 9 | char ans[][] = new char[numRows][x]; 10 | for(int i = 0 ; i < numRows; i++) { 11 | for(int j = 0; j < x; j++) { 12 | ans[i][j] = '&'; 13 | } 14 | } 15 | for(int i = 0, changer = 1, row = 0; i < s.length(); i++) { 16 | ans[row][i] = s.charAt(i); 17 | if(row == numRows - 1) { 18 | changer = -1; 19 | } 20 | if(row == 0) { 21 | changer = 1; 22 | } 23 | row = row + changer; 24 | } 25 | for(int i = 0 ; i < numRows; i++) { 26 | for(int j = 0; j < x; j++) { 27 | if(ans[i][j] != '&') { 28 | str = str + ans[i][j]; 29 | } 30 | } 31 | } 32 | 33 | return str; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /Medium/61. Rotate List/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | struct ListNode 6 | { 7 | int val; 8 | ListNode *next; 9 | ListNode() : val(0), next(nullptr) {} 10 | ListNode(int x) : val(x), next(nullptr) {} 11 | ListNode(int x, ListNode *next) : val(x), next(next) {} 12 | }; 13 | 14 | class Solution 15 | { 16 | public: 17 | ListNode *rotateRight(ListNode *head, int k) 18 | { 19 | 20 | if (!head || !head->next) 21 | return head; 22 | 23 | int n = 1; 24 | ListNode *temp = head; 25 | while (temp->next) 26 | { 27 | n++; 28 | temp = temp->next; 29 | } 30 | 31 | temp->next = head; 32 | 33 | k = k % n; 34 | k = n - k; 35 | while (k-- > 0) 36 | { 37 | temp = temp->next; 38 | } 39 | 40 | head = temp->next; 41 | 42 | temp->next = nullptr; 43 | 44 | return head; 45 | } 46 | }; 47 | 48 | int main() 49 | { 50 | 51 | // call the fn here 52 | 53 | return 0; 54 | } -------------------------------------------------------------------------------- /Medium/62. Unique Paths/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | class Solution { 7 | public int uniquePaths(int m, int n) { 8 | int[][] temp = new int[m][n]; 9 | 10 | for (int i = 0; i < m; i++) { 11 | temp[i][0] = 1; 12 | } 13 | for (int j = 0; j < n; j++) { 14 | temp[0][j] = 1; 15 | } 16 | 17 | for (int i = 1; i < m; i++) { 18 | for (int j = 1; j < n; j++) { 19 | temp[i][j] = temp[i - 1][j] + temp[i][j - 1]; 20 | } 21 | } 22 | 23 | return temp[m - 1][n - 1]; 24 | } 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /Medium/62. Unique Paths/sol.md: -------------------------------------------------------------------------------- 1 | Summary of the algorithm: 2 | 3 | 1. Create a 2D array, `temp`, to store the number of unique paths to each cell in the grid. 4 | 2. Initialize the first row and column of `temp` to 1, since there is only one unique path to each cell in the first row and column. 5 | 3. Iterate over the remaining rows and columns of `temp`: 6 | * For each cell, calculate the number of unique paths to the cell by adding the number of unique paths to the cell to the left and the number of unique paths to the cell above. 7 | 4. Return the value of the last cell in `temp`, which is the number of unique paths to the bottom-right corner of the grid. 8 | 9 | This algorithm works by filling in the `temp` array row-by-row, starting with the first row. For each cell in the `temp` array, the algorithm calculates the number of unique paths to the cell by adding the number of unique paths to the cell to the left and the number of unique paths to the cell above. This is because the only way to reach a cell is to come from the left or from above. 10 | 11 | -------------------------------------------------------------------------------- /Medium/7. Reverse Integer/Constant space approach/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int reverse(int num) { 3 | int x = Math.abs(num); //This ensures x%10 doesn't return -ve values 4 | int n = 0; 5 | while(x>0) { 6 | if(n > (Integer.MAX_VALUE - x%10)/10) return 0; 7 | n = n*10 + x%10; 8 | x = x/10; 9 | } 10 | return num < 0 ? -n : n; 11 | } 12 | } -------------------------------------------------------------------------------- /Medium/7. Reverse Integer/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | class Solution 7 | { 8 | public: 9 | int reverse(int x) 10 | { 11 | 12 | string s = to_string(x); 13 | 14 | string reversed; 15 | int start = s[0] == '-' ? 1 : 0; 16 | 17 | for (int i = s.length() - 1; i >= start; i--) 18 | { 19 | reversed += s[i]; 20 | } 21 | 22 | try 23 | { 24 | return x >= 0 ? stoi(reversed) : -stoi(reversed); 25 | } 26 | catch (exception e) 27 | { 28 | return 0; 29 | } 30 | } 31 | }; 32 | 33 | int main() 34 | { 35 | // call the fn here 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /Medium/7. Reverse Integer/sol.java: -------------------------------------------------------------------------------- 1 | public class sol { 2 | public static void main(String[] args) { 3 | // call the fn here 4 | } 5 | 6 | class Solution { 7 | public int reverse(int x) { 8 | String s = String.valueOf(x); 9 | StringBuilder reversed = new StringBuilder(); 10 | 11 | int start = s.charAt(0) == '-' ? 1 : 0; 12 | 13 | for (int i = s.length() - 1; i >= start; i--) { 14 | reversed.append(s.charAt(i)); 15 | } 16 | 17 | try { 18 | return x >= 0 ? Integer.parseInt(reversed.toString()) : -Integer.parseInt(reversed.toString()); 19 | } catch (NumberFormatException e) { 20 | return 0; 21 | } 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Medium/779. K-th Symbol in Grammar/Kth_Symbol.cpp: -------------------------------------------------------------------------------- 1 | //Approach using recursion (explanation in readme file) 2 | 3 | class Solution { 4 | public: 5 | int kthGrammar(int n, int k) { 6 | if (n == 1) return 0; 7 | int length = 1 << (n - 2); 8 | if (k <= length) return kthGrammar(n - 1, k); 9 | else return 1 - kthGrammar(n - 1, k - length); 10 | } 11 | }; -------------------------------------------------------------------------------- /Medium/779. K-th Symbol in Grammar/Kth_Symbol.java: -------------------------------------------------------------------------------- 1 | 2 | 3 | // 779. K-th Symbol in Grammar 4 | // explanation in readme file 5 | 6 | class Solution { 7 | public int kthGrammar(int n, int k) { 8 | if (n == 1) return 0; 9 | int length = 1 << (n - 2); 10 | if (k <= length) return kthGrammar(n - 1, k); 11 | else return 1 - kthGrammar(n - 1, k - length); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Medium/8. String to Integer (atoi)/Solution.js: -------------------------------------------------------------------------------- 1 | const myAtoi = function(str) { 2 | if(str.length===0||!(parseInt(str)*parseInt(str)>=0)){ 3 | return 0; 4 | } 5 | if(parseInt(str)>2147483647){ 6 | return 2147483647; 7 | } 8 | if(parseInt(str)<-2147483648){ 9 | return -2147483648; 10 | } 11 | return parseInt(str); 12 | }; -------------------------------------------------------------------------------- /Medium/80. Remove-duplicates-from-sorted-array/remove-duplicates.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def removeDuplicates(self, nums): 3 | index = 2 4 | i = 0 5 | while (index < len(nums)): 6 | if nums[i] == nums[index]: 7 | nums.pop(index) 8 | else: 9 | i+=1 10 | index+=1 11 | return index 12 | -------------------------------------------------------------------------------- /Medium/823. Binary Trees With Factors/README.md: -------------------------------------------------------------------------------- 1 |

823. Binary Trees With Factors


2 | Medium

3 | 4 | Given an array of unique integers, arr, where each integer arr[i] is strictly greater than 1. 5 | 6 | We make a binary tree using these integers, and each number may be used for any number of times. Each non-leaf node's value should be equal to the product of the values of its children. 7 | 8 | Return the number of binary trees we can make. The answer may be too large so return the answer modulo 109 + 7. 9 |
10 | 11 | Example 1:
12 | Input: arr = [2,4]
13 | Output: 3
14 | Explanation: We can make these trees: [2], [4], [4, 2, 2] 15 |
16 | 17 | Example 2:
18 | Input: arr = [2,4,5,10
19 | Output: 7
20 | Explanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2]. 21 |
22 | 23 | Constraints:
24 | 1. <= arr.length <= 1000
25 | 2. <= arr[i] <= 109
26 | All the values of arr are unique. 27 | -------------------------------------------------------------------------------- /Medium/853. Car Fleet/Solution.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} target 3 | * @param {number[]} position 4 | * @param {number[]} speed 5 | * @return {number} 6 | */ 7 | 8 | var carFleet = function (target, position, speed) { 9 | const n = position.length; 10 | if (n === 1) return 1; 11 | 12 | const cars = new Array(n); 13 | for (let i = 0; i < n; i++) cars[i] = i; 14 | cars.sort((a, b) => position[b] - position[a]); 15 | 16 | const timeNeeded = (carIndex) => { 17 | return (target - position[cars[carIndex]]) / speed[cars[carIndex]]; 18 | }; 19 | 20 | let counter = 1; 21 | let leader = 0; 22 | for (let i = 1; i < n; i++) { 23 | if (timeNeeded(i) > timeNeeded(leader)) { 24 | leader = i; 25 | counter++; 26 | } 27 | } 28 | return counter; 29 | }; 30 | -------------------------------------------------------------------------------- /Medium/967. Numbers With Same Consecutive Differences/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector numsSameConsecDiff(int n, int k) { 4 | if(n == 1) return vector{k}; 5 | vector list; 6 | int min = pow(10, n - 1); 7 | for(int i = 1; i < 10; i++){ 8 | queue q; 9 | q.push(i); 10 | while(!q.empty()){ 11 | int num = q.front(); 12 | q.pop(); 13 | if(num >= min){ 14 | list.push_back(num); 15 | continue; 16 | } 17 | int x = num % 10; 18 | if(k > 0 && x - k >= 0) 19 | q.push(num * 10 + x - k); 20 | if(x + k < 10) 21 | q.push(num * 10 + x + k); 22 | } 23 | } 24 | return list; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /Medium/967. Numbers With Same Consecutive Differences/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int[] numsSameConsecDiff(int n, int k) { 3 | if(n == 1) return new int[]{k}; 4 | List list = new ArrayList(); 5 | int min = (int) Math.pow(10, n - 1); 6 | for(int i = 1; i < 10; i++){ 7 | Queue q = new LinkedList(); 8 | q.add(i); 9 | while(!q.isEmpty()){ 10 | int num = q.poll(); 11 | if (num >= min){ 12 | list.add(num); 13 | continue; 14 | } 15 | int x = num%10; 16 | if(k > 0 && x - k >= 0) 17 | q.add(num * 10 + x - k); 18 | if(x + k < 10) 19 | q.add(num * 10 + x + k); 20 | } 21 | } 22 | return list.stream() 23 | .mapToInt(i -> i) 24 | .toArray(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Medium/967. Numbers With Same Consecutive Differences/Solution.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numsSameConsecDiff(self, n: int, k: int) -> List[int]: 3 | list = [] 4 | min = pow(10, n - 1) 5 | for i in range (1, 10): 6 | q = [i] 7 | while len(q): 8 | num = q.pop(0) 9 | if num >= min: 10 | list.append(num) 11 | continue 12 | x = num % 10 13 | if k > 0 and x - k >= 0: 14 | q.append(num * 10 + x - k) 15 | if x + k < 10: 16 | q.append(num * 10 + x + k) 17 | return list 18 | -------------------------------------------------------------------------------- /Medium/974. Subarray Sums Divisible by K/Solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int subarraysDivByK(vector& nums, int k) { 4 | int n = nums.size(); 5 | unordered_map map; 6 | int sum = 0; 7 | int count = 0; 8 | for(int i = 0; i < n; i++) { 9 | sum += nums[i]; 10 | if(sum % k == 0) count++; 11 | int rem = sum % k; 12 | if(rem < 0) rem += k; 13 | if(map[rem]) count += map[rem]; 14 | map[rem] = map[rem] + 1; 15 | } 16 | return count; 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /Medium/974. Subarray Sums Divisible by K/Solution.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int subarraysDivByK(int[] arr, int k) { 3 | int n = arr.length; 4 | HashMap map = new HashMap<>(); 5 | int sum = 0; 6 | int count = 0; 7 | for(int i = 0; i int: 3 | n = len(nums) 4 | map = {} 5 | sum = 0 6 | count = 0 7 | for i in range(n): 8 | sum = sum + nums[i] 9 | if sum % k == 0: count = count + 1 10 | rem = sum % k 11 | if rem < 0: rem = rem + k 12 | if map.get(rem): 13 | count = count + map[rem] 14 | map[rem] = map[rem] + 1 15 | else: 16 | map[rem] = 1 17 | return count 18 | -------------------------------------------------------------------------------- /Medium/98. Valid BST/README.md: -------------------------------------------------------------------------------- 1 | 98. Validate Binary Search Tree 2 | 3 | 4 | Given the root of a binary tree, determine if it is a valid binary search tree (BST). 5 | 6 | A valid BST is defined as follows: 7 | 8 | The left 9 | subtree 10 | of a node contains only nodes with keys less than the node's key. 11 | The right subtree of a node contains only nodes with keys greater than the node's key. 12 | Both the left and right subtrees must also be binary search trees. 13 | 14 | 15 | Example 1: 16 | 17 | 18 | Input: root = [2,1,3] 19 | Output: true 20 | Example 2: 21 | 22 | 23 | Input: root = [5,1,4,null,null,3,6] 24 | Output: false 25 | Explanation: The root node's value is 5 but its right child's value is 4. 26 | 27 | 28 | Constraints: 29 | 30 | The number of nodes in the tree is in the range [1, 104]. 31 | -231 <= Node.val <= 231 - 1 -------------------------------------------------------------------------------- /Medium/98. Valid BST/solution.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void check(bool &firsttime, TreeNode* root, int &prev, bool &ans) { 4 | if (!ans) return; 5 | if (!root) return; 6 | check(firsttime, root->left, prev, ans); 7 | if (root->val <= prev && !firsttime) {ans = false; return;} 8 | else {prev = root->val; firsttime = false;} 9 | check(firsttime, root->right, prev, ans); 10 | } 11 | bool isValidBST(TreeNode* root) { 12 | int prev = INT_MIN; 13 | bool firsttime = true; 14 | bool ans = true; 15 | check(firsttime, root, prev, ans); 16 | return ans; 17 | } 18 | }; -------------------------------------------------------------------------------- /Medium/98. Valid BST/solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * public class TreeNode { 4 | * int val; 5 | * TreeNode left; 6 | * TreeNode right; 7 | * TreeNode() {} 8 | * TreeNode(int val) { this.val = val; } 9 | * TreeNode(int val, TreeNode left, TreeNode right) { 10 | * this.val = val; 11 | * this.left = left; 12 | * this.right = right; 13 | * } 14 | * } 15 | */ 16 | class Solution { 17 | public boolean isValidBST(TreeNode root) { 18 | return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE); 19 | } 20 | 21 | public boolean isValidBST(TreeNode root, long minVal, long maxVal) 22 | { 23 | if(root==null) return true; 24 | if(root.val>=maxVal || root.val<=minVal) return false; 25 | return isValidBST(root.left, minVal, root.val) && isValidBST(root.right, root.val, maxVal); 26 | } 27 | } -------------------------------------------------------------------------------- /_config.yml: -------------------------------------------------------------------------------- 1 | title: LeetCode Solutions 2 | description: Solutions to LeetCode problems, categorized by difficulty level (Easy, Medium, Hard) 3 | remote_theme: pages-themes/cayman@v0.2.0 4 | plugins: 5 | - jekyll-remote-theme 6 | --------------------------------------------------------------------------------