3Sum Problem: Brute Force to Optimal Approach

Day: 57/365 📌 LeetCode POTD: Special Positions in a Binary Matrix Easy Key takeaways/Learnings from this problem: 1. This one shows how precomputing row and column counts makes checking each cell super easy. 2. Instead of re-scanning the whole row and column every time, count once and reuse smartly. 3. Good reminder that brute force can often be optimized with a tiny bit of preprocessing. 4. Clean implementation and careful condition checking matter more than complex algorithms here. #POTD #365DaysOfCode #DSA #Java #ProblemSolving #LearningInPublic #Consistency 🥷

🚀 #100DaysOfCode – Day 39 Update Today I solved an interesting array problem. 🔹 Problem: Longest Consecutive Sequence in an Array ⸻ ✅ Approach 1 — Brute Force 📌 Core Idea: • Pick each element and try to build a consecutive sequence from it. • For every element x, check if x + 1, x + 2, … exists in the array. ⸻ ✅ Algorithm Steps: 1️⃣ Traverse each element in the array. 2️⃣ For every element, initialize count = 1 and current = arr[i]. 3️⃣ Run a loop to check if current + 1 exists in the array. 4️⃣ If found: • Increment count • Update current = current + 1 5️⃣ After the loop, update the maximum length. ⸻ ⏱ Time Complexity: O(N²) (due to repeated searching) 💾 Space Complexity: O(1) ⸻ 💡 Key Learning: Brute force works but is inefficient due to repeated searches. Next step is to optimize using sorting or HashSet for better performance. #Day39 #100DaysOfCode #DSA #Java #Arrays #ProblemSolving #CodingJourney

Solved a matrix problem : checking whether one matrix can be obtained from another using rotations. At first it looked a bit tricky, but the key idea was simple: 👉 A 90° rotation can be done using transpose + reverse each row This makes the solution clean and efficient (O(n²)) and is a useful pattern to remember for similar problems. #DataStructures #Algorithms #DSA #Java #LeetCode #ProblemSolving #SoftwareEngineering

Day 83/100 – LeetCode Challenge ✅ Problem: #46 Permutations Difficulty: Medium Language: Java Approach: Backtracking with Swapping Time Complexity: O(n × n!) Space Complexity: O(n) for recursion stack Key Insight: Generate all permutations by fixing each element at current position and recursively permuting remaining elements. Use swapping to avoid extra space for visited tracking. Solution Brief: Base case: When index i reaches end, add current array as permutation. Recursive case: For each position j from i to end: Swap elements at i and j Recurse on i + 1 Swap back (backtrack) to restore original order #LeetCode #Day83 #100DaysOfCode #Backtracking #Java #Algorithm #CodingChallenge #ProblemSolving #Permutations #MediumProblem #Recursion #Swapping #DSA

Day 35/75 — Generate Parentheses (Backtracking) Today’s problem was about generating all valid combinations of parentheses. Instead of brute force, I used backtracking with constraints. Key conditions: • Add '(' if open < n • Add ')' if close < open Base case: if (open == n && close == n) This ensures only valid sequences are generated. Time Complexity: ~ O(2ⁿ) Space Complexity: O(n) This problem helped strengthen my understanding of recursive decision trees. 35/75 🚀 #Day35 #DSA #Backtracking #Java #Algorithms #LeetCode

Day 8 Today I solved “Check if Binary String Has at Most One Segment of Ones” on LeetCode. At first glance, the problem looks simple: Given a binary string, check whether it contains only one continuous segment of '1's. Example: "110" → Valid (one segment of 1s) "1001" → Invalid (two separate segments of 1s) While solving it, I realized an interesting observation: 👉 If a binary string has more than one segment of 1s, the pattern "01" must appear before another "1". So instead of counting segments explicitly, we can simply check whether '01' appears and is followed by another '1'. This turns the problem into a very efficient linear scan with O(n) time complexity. 💡 Key takeaway: Sometimes the simplest solution comes from recognizing patterns in the string rather than simulating the whole process. Also happy to see my solution running at 0 ms runtime (100% faster) 🚀 #LeetCode #DSA #ProblemSolving #Java #CodingJourney #BinaryStrings

Day 13/100 – LeetCode Challenge Problem: Linked List Cycle Today’s problem was about detecting whether a cycle exists in a linked list. Approach: Used Floyd’s Cycle Detection Algorithm (Tortoise and Hare). slow pointer moves one step fast pointer moves two steps If a cycle exists, both pointers will eventually meet If fast reaches null, the list has no cycle Complexity: Time: O(n) Space: O(1) Concepts Practiced: Linked List traversal Two-pointer technique Cycle detection algorithm #100DaysOfCode #LeetCode #DSA #Java #LinkedList #ProblemSolving #CodingJourney

Day 52 of #100DaysOfLeetCode 🚀 Solved Balanced Binary Tree (Easy) 🌳 Learned how to efficiently check if a binary tree is height-balanced using a single DFS traversal. Instead of recalculating heights multiple times (O(n²)), optimized it to O(n) by combining height calculation with balance checking. 💡 Key takeaway: Return -1 early when imbalance is detected to avoid unnecessary computations. #LeetCode #DSA #Java #CodingJourney

🚀 Day 55 of #100DaysOfCode Solved 147. Insertion Sort List on LeetCode 🔗 🧠 Key Insight: We apply the classic Insertion Sort, but on a linked list instead of an array. The challenge is handling pointer manipulation efficiently. ⚙️ Approach: 1️⃣ Create a dummy node to act as the start of the sorted list 2️⃣ Traverse the original list node by node 3️⃣ For each node: Find its correct position in the sorted part Insert it there by updating pointers 🔁 This builds a sorted list incrementally ⏱️ Time Complexity: O(n²) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #LinkedList #Sorting #Java #InterviewPrep #CodingJourney

🚀 #100DaysOfCode – Day 37 Update Today I solved an array problem using a brute force approach. 🔹 Problem: Leaders in an Array (A leader is an element greater than all elements to its right.) ⸻ ✅ Approach — Brute Force 📌 Core Idea: For every element, check if there is any greater element on its right side. ⸻ ✅ Algorithm Steps: 1️⃣ Run an outer loop from i = 0 to i < n. 2️⃣ Assume current element is a leader → flag = true. 3️⃣ Run an inner loop from j = i + 1 to j < n. 4️⃣ If arr[i] < arr[j] → 👉 Set flag = false and break the loop. 5️⃣ After inner loop, if flag == true → 👉 arr[i] is a leader, print/store it. ⸻ ⏱ Time Complexity: O(N²) 💾 Space Complexity: O(1) ⸻ 💡 Key Learning: Brute force helps in understanding the problem clearly. Next step is to optimize it using a right-to-left traversal approach. #Day37 #100DaysOfCode #DSA #Java #Arrays #ProblemSolving #CodingJourney