Day 45: Longest Common Prefix in Java

#Day75 of my second #100DaysOfCode Today’s problem was more about spotting patterns than writing code. DSA • Solved Single Element in a Sorted Array (LeetCode 540, Medium) – Brute: linear scan checking pairs → O(n) – Optimal: binary search using index pattern → O(log n) • Key idea: elements appear in pairs, and the single element breaks this pattern • Used position-based logic to decide which half to search This one really showed how observing patterns can simplify the approach. #DSA #BinarySearch #LeetCode #Algorithms #Java #100DaysOfCode #WomenWhoCode #BuildInPublic #LearningInPublic

Day 36/50 🚀 Solved “Valid Parentheses” today — a classic stack problem, but a great reminder that simple concepts can be powerful when applied correctly. 💡 Key takeaway: Using a stack makes it easy to track opening brackets and validate matching pairs efficiently. Every closing bracket should correspond to the most recent unmatched opening one — LIFO in action. ⚙️ What I focused on: Clean conditional checks Avoiding unnecessary complexity Writing readable, structured code 📈 Result: Accepted ✅ Optimized runtime & solid performance On to Day 37 🔥 #50DaysOfCode #DataStructures #Algorithms #Java #LeetCode #CodingJourney

🚀 Day 60 of #100DaysOfCode Another recursion problem that initially feels tricky, but becomes much clearer once the pattern is understood. 🌱 Topic: Recursion / Divide & Conquer ✅ Problem Solved: LeetCode 779 – K-th Symbol in Grammar 🛠 Approach: Base Case: n == 1 → return 0 Observed that each row is divided into two halves: First half → same as previous row Second half → inverse of previous row Calculated midpoint: 2^(n-2) If k <= mid → go to left half Else → go to right half and invert result #100DaysOfCode #Day60 #DSA #Recursion #DivideAndConquer #LeetCode #Java #Algorithms #ProblemSolving #CodingJourney #Consistency

🚀 Day 3/100 – LeetCode Challenge 🔍 Problem: Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be inserted to maintain the sorted order. 💡 Key Concepts Used: • Binary Search • Time Complexity Optimization – O(log n) • Efficient searching in sorted arrays 📚 What I Learned: • How binary search reduces search time significantly compared to linear search • Handling edge cases when the target element is not present • Determining the correct insertion index while maintaining sorted order hashtag #100DaysOfCode #LeetCode #Java #DataStructures #Algorithms #BinarySearch #CodingJourney #ProblemSolving

🚀 Day 19/100 — #100DaysOfLeetCode Back to mastering one of the most powerful patterns in DSA — Sliding Window 💻🔥 ✅ Problem Solved: 🔹 LeetCode 1358 — Number of Substrings Containing All Three Characters 💡 Concept Used: Sliding Window + Frequency Tracking 🧠 Key Learning: The goal was to count all substrings containing 'a', 'b', and 'c'. Instead of checking every possible substring, I learned how: Expand the window until all required characters are present. Once valid, every further extension also forms valid substrings. Count substrings efficiently while shrinking the window. This converts a brute-force O(n²) approach into an optimized O(n) solution. ⚡ Big Insight: Sliding Window isn’t just about finding length — it can also be used for counting valid substrings efficiently. Consistency is slowly turning patterns into instincts 🚀 #100DaysOfLeetCode #LeetCode #DSA #SlidingWindow #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic #Consistency

🚀 Day 63 of #100DaysOfLeetCode ✅ Problem Solved: Unique Binary Search Trees (LeetCode 96) Today’s problem was a great example of how Dynamic Programming and mathematical patterns (Catalan Numbers) come together. 🔍 Key Insight: For every node chosen as root, the number of unique BSTs is: 👉 Left Subtrees × Right Subtrees This leads to the recurrence: dp[n] = Σ (dp[left] × dp[right]) 💡 What I learned: Breaking problems into smaller subproblems makes complex structures easier Recognizing patterns like Catalan Numbers is a game changer DP is not just about arrays, it's about thinking smart ⚡ Result: ✔️ Runtime: 0 ms (Beats 100%) ✔️ Clean and optimized solution Consistency is slowly turning into confidence 💪 #LeetCode #DataStructures #DynamicProgramming #CodingJourney #ProblemSolving #Java #100DaysOfCode

🚀 Day 49 of #100DaysOfCode ✅ Solved: Find the Difference 🔍 What I did: Used a clever XOR bit manipulation technique to identify the extra character between two strings efficiently. 💡 Key Learning: XOR cancels out identical characters Helps find unique elements in linear time Clean and optimal approach without extra space ⚡ Time Complexity: O(n) 📦 Space Complexity: O(1) 🎯 Takeaway: Sometimes the best solutions are not obvious — learning small tricks like XOR can make a big difference in problem solving. #Java #LeetCode #ProblemSolving #CodingJourney #100DaysChallenge #DataStructures #Algorithms

#Day76 of my second #100DaysOfCode Binary search continues to surprise me with how many variations it has. DSA • Solved Find Peak Element (LeetCode 162) – Brute: check every element → O(n) – Optimal: binary search based on slope comparison → O(log n) • Key idea: if the next element is greater, move right; else move left — a peak is guaranteed • Didn’t need to check all elements, just follow the increasing/decreasing trend Interesting how this doesn’t require a fully sorted array, yet binary search still works. #DSA #BinarySearch #LeetCode #Algorithms #Java #100DaysOfCode #WomenWhoCode #BuildInPublic #LearningInPublic

🚀 LeetCode Challenge 7/50 🔍 Problem: Valid Anagram Today’s problem was about checking whether two strings are anagrams of each other efficiently. 💡 Approach: I used the Character Frequency Count method: First checked if both strings have equal length Used an array of size 26 to track character frequencies Incremented counts for one string and decremented for the other If all values are zero, both strings are anagrams ⚡ This approach avoids sorting and ensures optimal performance. 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(1) 📚 Key Learning: Using frequency arrays is a powerful technique for string problems. It helps achieve constant space complexity and improves efficiency compared to sorting-based approaches. Step by step, getting better at problem solving 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning