LeetCode #9 Palindrome Number: Edge-Case Handling is Key

🚀 LeetCode Practice: Problem #145 – Binary Tree Postorder Traversal I recently solved LeetCode 145, a classic tree traversal problem that strengthens understanding of Depth-First Search (DFS) and recursion. 📌 Problem Statement Given the root of a binary tree, return the postorder traversal of its nodes’ values. Postorder Traversal Order: 👉 Left → Right → Root 🧠 Technique Used: Depth-First Search (Recursive Approach) Approach Explanation: If the current node is None, return. Recursively traverse the left subtree. Recursively traverse the right subtree. Visit (append) the root node value at the end. This traversal ensures that child nodes are processed before their parent node. Time Complexity: O(n) Space Complexity: O(h) (Where h is the height of the tree due to recursion stack) #LeetCode #Python #DSA #ValidAnagram #ProblemSolving #Algorithms #DataStructures #CodingPractice #100DaysOfCode #InterviewPreparation #SoftwareEngineering #DeveloperJourney #TechCommunity #LearningByDoing

🧠 LEETCODE CONSISTENCY SERIES 🚀 Day 1️⃣2️⃣ of 365 Days 🔁 📘 Topic: Number Problem 🧩 Problem: 3Sum (LeetCode #15) ⏱ Time Taken: ~65 minutes 💡 Key Idea: Sort the array first, then fix one element and use the two-pointer technique to find pairs that sum to the negative of the fixed element. Fix nums[i] Use left and right pointers to search for nums[left] + nums[right] = -nums[i] Move pointers based on sum comparison 🛠 Important Techniques Used: Sorting to simplify duplicate handling Two-pointer approach for optimized searching Skipping duplicates to ensure unique triplets only ⚠ Edge Cases Handled: Duplicate values in input array Arrays with less than 3 elements All zero case → [0,0,0] No valid triplet case → return empty list 🚀 What I learned today: How sorting enables efficient two-pointer traversal Proper duplicate removal at both index and pointer levels Reducing brute-force O(n³) to optimized O(n²) 📌 Next Goal: Solve 4Sum using similar logic Practice more problems on two pointers & hashing Consistency > Motivation 💪 🔗 GitHub: https://lnkd.in/dRGB_B8Z #DSA #LeetCode #Python #ProblemSolving #365DaysOfCode #CodingJourney

Day 47/100 – #100DaysOfLeetCode 🚀 🧩 Problem: LeetCode 191 - Number of 1 Bits (Easy) 🧠 Approach 1: Using Brian Kernighan’s Algorithm. 💻 Solution: class Solution:   def hammingWeight(self, n: int) -> int:     count = 0     while n:       n &= (n - 1)        count += 1     return count ⏱ Time | Space: O(k) | O(1) 📌 Key Takeaway: Using n & (n - 1) efficiently removes one set bit at a time, making it faster than checking every bit individually. 🧠 Approach 2: Python’s built-in binary conversion makes counting set bits simple 💻 Solution: class Solution:   def hammingWeight(self, n: int) -> int:     return bin(n).count('1') #leetcode #dsa #development #problemSolving #CodingChallenge

Day 37 of 365 days of code I tried solving a problem that I couldn't solve during the recent leetcode contest. The mistake I made was overthinking about what approach to use while solving the problem that I struggled with. literally I was bruteforcing my brain to find a soln🗿. after the contest i realised it was a simple problem lol, let me explain what the question is Qn 1) Merge adjacent equal elements You must repeatedly apply the following merge operation until no more changes can be made: If any two adjacent elements are equal, choose the leftmost such adjacent pair in the current array and replace them with a single element equal to their sum. After each merge operation, the array size decreases by 1. Repeat the process on the updated array until no more changes can be made. Return the final array after all possible merge operations. Example 1: Input: nums = [3,1,1,2] Output: [3,4] Explanation: The middle two elements are equal and merged into 1 + 1 = 2, resulting in [3, 2, 2]. The last two elements are equal and merged into 2 + 2 = 4, resulting in [3, 4]. No adjacent equal elements remain. Thus, the answer is [3, 4]. #365daysOfCode #NeetCode #leetcode #DSA #python #LeetCode #ProblemSolving #Algorithms

🚀 Day 6/30 | LeetCode Problem: Move Zeroes (283) Problem: Given an array nums, move all 0s to the end of the array while maintaining the relative order of non-zero elements. The operation must be done in-place. Approach: Traverse the array once Store all non-zero elements in one list Store all zero elements in another list Combine both lists and update the original array This approach keeps the order intact and is easy to understand. Time Complexity: O(n) Space Complexity: O(n) Python Code: class Solution(object): def moveZeroes(self, nums): a = [] b = [] for i in nums: if i == 0: a.append(i) else: b.append(i) nums[:] = b + a Example: Input: [0,1,0,3,12] Output: [1,3,12,0,0] Takeaway: Maintaining order while modifying arrays is a common requirement in real-world problems. 📌 Accepted ✅ | All test cases passed 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day6 #Python #Arrays #DSA #ProblemSolving #CodingJourney #SoftwareEngineering #TechCommunity

hi connections I just moved from Maximum Subarrays to LeetCode 167: Two Sum II. The challenge? Find two numbers that hit a target sum. The "cheat code"? The input array is already sorted. When you see "Sorted Array," your mind should immediately go to Two Pointers. The Strategy: Left Pointer: Starts at the beginning (smallest values). Right Pointer: Starts at the end (largest values). The Logic: If the sum is too low, nudge the left pointer up. If it’s too high, slide the right pointer down. Why I love this approach: Zero Extra Space: Unlike the original Two Sum, you don’t need a Hash Map. O(1) space. Speed: You only pass through the data once. O(n) time. Simplicity: It’s clean, readable, and highly optimized. Programming isn't just about solving the problem; it's about finding the most elegant way to do it by leveraging the constraints you're given. #Coding #DataStructures #Algorithms #TwoSum #Python #LeetCode #SoftwareEngineering #TwoPointers

Day 43 of 365 days of code Qn 1) simplify path approach used: stack initialize a stack 1) iterate the string path using var i from 0 to len(path) 2) ignore forward slashes 3) initialize ch="" 4) while i<len(path) and path[i] not equal to forward slash: ch+=path[i];i+=1 5) if ch==.. stack.pop elif ch== . continue else: stack.push(ch) 6)i+=1 7) pop all the element of the stack and put them in another stack 8) initialize a string starting with/ as u iterate pop the stack and add the forward slash to the popped string. #365daysOfCode #NeetCode #leetcode #DSA #python #LeetCode #ProblemSolving #Algorithms

❄️ takeUforward — Day 22 ✅ Rearrange Array by Sign | Two Pointer Approach | LeetCode Today I solved the Rearrange Array Elements by Sign problem, which focuses on array manipulation and index control — a common interview pattern. 📌 Problem Statement Given an array nums containing equal number of positive and negative integers, rearrange the array such that: Positive numbers are placed at even indices Negative numbers are placed at odd indices Maintain the relative order of elements 🚀 Optimal Approach — Index Placement (Two Pointer Style) 💡 Idea • Use two pointers: pos starting at index 0 for positive numbers neg starting at index 1 for negative numbers • Traverse the array once • Place elements directly at correct indices in a new array ⏱ Complexity • Time: O(n) • Space: O(n) 📌 Key Learning This problem reinforces how index-based placement can simplify logic and avoid unnecessary swaps or nested loops. 🚀 Day 22 completed — strengthening array traversal and positioning logic #DSA #LeetCode #Python #ProblemSolving #CodingJourney #RestartDSA #100DaysOfCode #DailyCoding #Arrays Yaswanth Kumar D takeUforward

Just discovered "Pydantic" today and it's a game-changer! If you're building APIs in Python or dealing with data management, this library makes life so much easier. What I learned: -> Automatic data validation - no more manual checks -> Works perfectly with FastAPI -> Clean settings and config management You get validation, error handling, and type safety automatically. If you work with APIs(FastAPI) or external data, definitely check it out. Perfect Source: Chai Aur Code-Pydantic Crash Course(YouTube) #Python #Pydantic #API

🚀 Day 2 of 150 DSA Journey – Leet code 242: Valid Anagram Solved Leet code 242 – Valid Anagram ✅ - 54/54 test cases passed - ⏱ Runtime: 11 ms (Beats 96.11%) - 💾 Memory: 12.78 MB 🧠 Problem Summary: Given two strings s and t, determine whether t is an anagram of s. 🔎 Approach Used: -- Implemented a HashMap (Dictionary) based frequency counter. -- Counted character occurrences in one string. -- Decremented counts using the second string. -- Verified all frequencies return to zero. 📚 Concepts Practiced: -Hashing - Dictionary manipulation in Python - Frequency counting technique - Time & Space Complexity Analysis ⚡ Complexity: - Time Complexity: O(n) -Space Complexity: O(1)