Pradumya Gupta’s Post

🚀 Day 9/30 | LeetCode Problem: Binary Search (704) Problem: Given a sorted array of integers nums and a target, return the index if the target exists. If not, return -1. 🧠 Approach: Binary Search Since the array is already sorted, we can apply Binary Search: Use two pointers: l (left) and r (right) Find the middle element Compare target with nums[mid] Reduce the search space by half each time This makes the solution very efficient. ⏱️ Complexity Time: O(log n) Space: O(1) 🧾 Python Code class Solution(object): def search(self, nums, target): l = 0 r = len(nums) - 1 while l <= r: mid = (l + r) // 2 if target == nums[mid]: return mid elif target < nums[mid]: r = mid - 1 else: l = mid + 1 return -1 ✅ Result Accepted ✅ Runtime: 0 ms (Beats 100%) Memory efficient 🎯 Key Learning Binary Search is a foundational algorithm used in: Search problems Optimization problems Interview questions Mastering it is essential for every developer. 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day9 #BinarySearch #Python #DSA #ProblemSolving #CodingJourney #SoftwareEngineering

❄️ takeUforward — Day 38 ✅ A Number After a Double Reversal | Number Manipulation | LeetCode Today I worked on a number manipulation problem involving reversing digits twice and checking if the result equals the original number. 💡 Problem Statement Given an integer "num", reverse the number twice and check whether the final value is equal to the original number. 🧠 Approach • Store the original number. • Reverse the number using modulo ("% 10") and division ("// 10"). • Reverse the result again. • Compare the final value with the original number. 🐍 Python Code class Solution: def isSameAfterReversals(self, num: int) -> bool: orginal = num sum_ = 0 sum2 = 0 while num > 0: last_digit = num % 10 sum_ = (sum_ * 10) + last_digit num //= 10 while sum_ > 0: lsd = sum_ % 10 sum2 = (sum2 * 10) + lsd sum_ //= 10 return True if sum2 == orginal else False ⏱ Complexity • Time: O(d) — where d is number of digits • Space: O(1) 📌 Key Learning Reversing numbers using digit extraction helps build strong fundamentals in number-based algorithms and edge case handling. 🚀 Day 38 completed — improving number manipulation skills step by step. #Python #DSA #LeetCode #ProblemSolving #CodingJourney #LearningInPublic #100DaysOfCode

🚀 Day 78 of #100DaysOfCode — Reverse Integer Challenge Hey everyone! 👋 Today's challenge is a classic: "Reverse Integer" — a problem that tests your understanding of integer manipulation, overflow handling, and edge cases with negative numbers. We need to reverse the digits of a signed 32-bit integer, but catch the overflow if the reversed number goes beyond the 32-bit range. 👨💻 What l practiced today: ✅ Digit Extraction: Using modulo and division to peel off digits. ✅ Integer Reversal: Building the reversed number step by step. ✅ Overflow Prevention: Checking boundaries before the number exceeds 32-bit limits. ✅ Sign Handling: Properly managing negative integers. 📌 Today’s Task: ✔ Given a signed 32-bit integer x. ✔ Return x with its digits reversed. ✔ If reversing causes overflow (outside [−231,231−1] [−231 ,231 −1]), return 0. ✔ You cannot use 64-bit integers for storage. Examples: Input: x = 123 → Output: 321 Input: x = -123 → Output: -321 Input: x = 120 → Output: 21 🧠 Key Insight: Reverse digits using while x != 0, but check for overflow before multiplying the reversed result by 10. Use INT_MAX and INT_MIN equivalents (or 2**31 - 1 and -2**31 in Python) to validate. 🔗 Hashtags: #100DaysOfCode #Day78 #Python #LeetCode #DSA #IntegerManipulation #OverflowHandling #MathInCode #AlgorithmPractice #LogicBuilding

🚀 LeetCode 41 – First Missing Positive (Hard) Solved the classic First Missing Positive problem using two different approaches. 🧩 Problem: Given an unsorted integer array, find the smallest missing positive integer in O(n) time and O(1) space. 🔗 Try the problem here:https://lnkd.in/gCAGSftq Approach 1: Using Hash Set 💡 Idea: Store all elements in a set and check from 1 upward to find the first missing number. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) ❌ (extra space used) 🔎 Why Not Optimal? Uses extra memory, so it doesn’t satisfy the O(1) space requirement. Approach 2: Cyclic Sort (Optimal Solution) 💡 Idea: Place each number x at index x - 1 if 1 ≤ x ≤ n. Then scan the array to find the first index where nums[i] != i+1. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) ✅ 🔥 Why This Works? We use the array itself as a hash map by placing numbers in their correct indices. Each element is swapped at most once → overall linear time. If you're preparing for interviews, this is a must-know hard-level pattern 💪 #LeetCode #Coding #DataStructures #Algorithms #DSA #Python #CodingInterview #InterviewPreparation #ProblemSolving #SoftwareDeveloper #100DaysOfCode #TechCareers #ProgrammersLife #CodeNewbie #CompetitiveProgramming

Day 52 of 1022. Sum of Root To Leaf Binary Numbers Today’s problem was a great mix of binary representation + tree traversal. Each root-to-leaf path in the binary tree forms a binary number, and the goal is to compute the sum of all those numbers efficiently. Key Insight: Instead of storing the entire path, we can build the number on the go using: ➡️ current = (current << 1) | node.val This is equivalent to: Left shift → multiply by 2 Add current bit Reached a leaf node? That means we formed one complete binary number → add it to the result. 🌱 What I practiced today: ✔ Depth First Search (DFS) ✔ Bit Manipulation in Trees ✔ Writing clean recursive logic ✔ Optimizing space by avoiding extra storage ⏱ Time Complexity: O(n) 📦 Space Complexity: O(h) – recursion stack ✨ This problem is a perfect example of how combining concepts (Trees + Bits) leads to elegant solutions. Consistency is the real key 🔑 — learning something new every single day! #Day52 LeetCode BinaryTree DSA Journey Coding JavaScript Notes #Python #ProblemSolving TechGrowth

🚀Day 12 of #75DaysofLeetcode LeetCode #11 – Container With Most Water (Medium) Today I solved the classic Two Pointer problem: Container With Most Water. 🔎 Problem Summary: Given an array height, each element represents a vertical line. The goal is to choose two lines such that together with the x-axis they form a container that holds the maximum amount of water. 💡 Key Insight: Instead of checking all pairs (O(n²)), we can use the Two Pointer Technique: ✔ Start with one pointer at the beginning and one at the end ✔ Calculate the container area using area = min(height[left], height[right]) * (right - left) ✔ Move the pointer pointing to the smaller height ✔ Keep track of the maximum area ⚡ Optimal Complexity: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 💻 Python Implementation: from typing import List class Solution: def maxArea(self, height: List[int]) -> int: left, right = 0, len(height) - 1 max_water = 0 while left < right: area = min(height[left], height[right]) * (right - left) max_water = max(max_water, area) if height[left] < height[right]: left += 1 else: right -= 1 return max_water 📚 This problem reinforced how two pointers can reduce a brute force problem from O(n²) to O(n). Consistency in solving problems daily is slowly improving my problem-solving skills and algorithmic thinking. 💪 #LeetCode #DSA #Python #TwoPointers #ProblemSolving #CodingPractice #100DaysOfCode

🚀 Day 29/181 — Optimization Mindset Today I revisited Group Anagrams and focused on improving my approach. ✅ Step 1 — Used defaultdict Learned the importance of defaultdict(list): Automatically initializes missing keys Cleaner and more Pythonic Reduces conditional checks ✅ Step 2 — Optimized the Solution Approach 1: Sorted each word and used it as a key. Time Complexity: O(N × K log K) Approach 2 (Optimized): Used character frequency count (26-size array) as the key. Converted it to a tuple for hashing. Time Complexity improved to: O(N × K) 🎯 Key Takeaway Solving a problem is good. Optimizing it is better. Understanding why it improves is best. One month of consistency completed. On to stronger patterns 💪🔥 #DSA #Optimization #HashMap #Python #LeetCode #CodingJourney #Consistency

✅ First Unique Character in a String | Hash Map | LeetCode Solved the First Unique Character in a String problem using a frequency dictionary approach. 💡 Problem Given a string s, return the index of the first non-repeating character. If it does not exist, return -1. ⚡ Approach — Hash Map • Traverse the string and store character frequencies in a dictionary. • Iterate through the dictionary to find the character with frequency 1. • Return its index using s.index(char). ⏱ Complexity • Time: O(n) • Space: O(1) (since character set is limited) 🧠 Key Learning Frequency counting is a powerful technique for string problems. Hash maps help reduce nested loops and improve efficiency. Small string problems like this build a strong foundation for advanced DSA concepts. #LeetCode #DSA #Python #HashMap #StringProblems #ProblemSolving #CodingJourney

LeetCode POTD 💫: Description: You are given an integer array nums that represents a circular array. Your task is to create a new array result of the same size, following these rules: For each index i (where 0 <= i < nums.length), perform the following independent actions: - If nums[i] > 0: Start at index i and move nums[i] steps to the right in the circular array. Set result[i] to the value of the index where you land. - If nums[i] < 0: Start at index i and move abs(nums[i]) steps to the left in the circular array. Set result[i] to the value of the index where you land. - If nums[i] == 0: Set result[i] to nums[i]. Return the new array result. Note: Since nums is circular, moving past the last element wraps around to the beginning, and moving before the first element wraps back to the end. Here's my solution: https://lnkd.in/gczPri7j #Python #DSA #Leetcode #DailyChallenge #Easy

Just solved LeetCode 862: Shortest Subarray with Sum at Least K If you've ever been trapped by a sliding window that just won't slide right, this one is for you! 👇 The Brute Force (O(N²)) The most intuitive approach is to calculate the prefix sum of the array, and then use a nested loop to check the sum of every possible subarray, keeping track of the shortest one that is >= K. The problem? The array length can be up to 10⁵. An O(N²) solution will immediately hit a Time Limit Exceeded (TLE). We need O(N). Normally, to find a shortest/longest subarray, we reach for the Sliding Window technique. But there's a catch: The array contains negative numbers. Because of negative numbers, our prefix sum is NOT monotonically increasing. The standard sliding window is completely broken here. To fix this, we need a way to track prefix sums intelligently. We can use a Double-Ended Queue (Deque) to store tuples of (prefix_sum, index) and force it to be strictly increasing (monotonic). Shrinking the window: As we iterate, we check if current_sum - smallest_prefix_sum_in_deque >= K. If it is, we found a valid subarray! We record the length, and throw away that starting index (pop left). Why? Because any future subarray using that start index would only be longer and therefore worse. Maintaining Monotonicity (Pop Right): What if our current_sum dips and is smaller than the most recent prefix sums in our deque? We can keep popping the back of queue as the older greater prefix sums work but make the subarray longer. This approach has a time complexity of O(n) and a space complexity of O(n) as well as in the worst case, the queue may contain n prefix sum where n: number of elements in the array. #LeetCode #Python #Algorithms #DataStructures #SoftwareEngineering #ProblemSolving #CodingInterviews