Reverse String Prefix Challenge: Java Solution

Day 46: Binary Addition from scratch! 🔢 Problem 67: Add Binary Java's BigInteger is a thing, but manual bit manipulation is just more satisfying. My approach: 1. Padded both strings to the same length using character arrays. 2. Simulated schoolbook addition from right to left. 3. Used % 2 for the result bit and / 2 for the carry. It’s a clean O(N) solution that avoids overflow and keeps the logic transparent. No shortcuts, just pure logic. 🚀 #LeetCode #Java #Binary #Algorithms #CodingChallenge #ProblemSolving

Day 44 - LeetCode Journey Solved LeetCode 917: Reverse Only Letters in Java ✅ A clean two-pointer problem that really tests your understanding of string manipulation. The goal was simple: reverse only the letters while keeping all non-letter characters in their original positions. Instead of creating extra data structures, I used two pointers from both ends. If a character is not a letter, we skip it. When both pointers land on letters, we swap them. This continues until the pointers meet. What I liked about this problem is how it teaches you to control movement smartly rather than brute forcing the solution. Key takeaways: • Two-pointer technique for efficient traversal • Handling edge cases (symbols, numbers) • Writing in-place logic without extra space • Clean and readable code ✅ All test cases passed ✅ 100% runtime performance Problems like this improve your thinking for real interview scenarios where optimization matters. #LeetCode #DSA #Java #Strings #TwoPointers #Algorithms #ProblemSolving #CodingJourney #InterviewPrep #Consistency

Day36 - LeetCode Journey Solved LeetCode 541: Reverse String II in Java ✅ This one was all about careful indexing and pattern-based string manipulation. The idea of processing the string in blocks of 2k characters and selectively reversing only the first k in each block really tests attention to detail. Using a two-pointer approach inside each segment made the logic clean and easy to follow, while handling edge cases like shorter remaining substrings kept things interesting. Key takeaways: • Stronger grasp on string traversal in fixed-size blocks • Effective use of two pointers for in-place reversal • Handling boundary conditions without extra space • Writing efficient and readable string logic Another small problem, another solid concept reinforced. Consistency really compounds over time 💪 #LeetCode #DSA #Java #Strings #TwoPointers #Algorithms #ProblemSolving #CodingPractice #InterviewPreparation #DailyCoding

🚀 Day 79 of #100DaysOfCode Solved LeetCode Problem #3634 – Minimum Removals to Balance Array ✅ This problem was a great example of how sorting + sliding window can turn a tricky constraint problem into a clean and efficient solution. The goal was to keep the largest valid subarray and remove the rest—simple idea, but execution matters. Key Takeaways: -> Sorting helps simplify balance conditions -> Sliding window is powerful for range-based constraints -> Maximizing what you keep is often better than counting what you remove -> Careful pointer movement avoids unnecessary recomputation Language: Java -> Runtime: 23 ms (Beats 100.00%) ⚡ -> Memory: 86.17 MB Consistency beats intensity. One solid problem every day. 💻🔥 #LeetCode #Java #SlidingWindow #TwoPointers #Arrays #ProblemSolving #100DaysOfCode

Day29 - LeetCode Journey Solved LeetCode 387: First Unique Character in a String in Java ✅ This problem was a clean exercise in frequency counting and string traversal. The goal was to find the first character that appears only once and return its index, or -1 if none exists. Using a frequency array made the approach straightforward. First pass to count all characters, second pass to identify the first one with a frequency of exactly one. Simple logic, but it really reinforces the idea of separating counting from decision-making. What I liked about this problem is how it highlights efficiency. Two linear passes, constant extra space, and very readable code. These patterns show up everywhere in interviews. Key takeaways: • Effective use of frequency arrays • Clear two-pass strategy • Improved understanding of string traversal • Writing optimal and interview-friendly solutions ✅ All test cases passed ✅ Solid performance with clean logic Small problems, strong foundations. On to the next one 💪 #LeetCode #Java #DSA #Strings #ProblemSolving #Algorithms #CodingJourney #InterviewPreparation #DailyPractice #Consistency

Finished working through Arrays & ArrayLists today. This module felt like the point where coding stopped being about Java syntax and started being about how to think. What arrays actually taught me: - indices matter more than the values themselves - in-place operations need careful planning - small boundary mistakes break logic completely - many problems are solved by reusing a few core patterns - breaking a problem into steps makes it manageable - optimization only makes sense after correctness Working with ArrayLists alongside arrays also made the trade-offs clearer — convenience vs control. Problems like rotation, sorting with pointers, and finding missing elements forced me to slow down and reason instead of guessing. This module made me more comfortable with problem-solving and showed me where I still need practice. Moving forward with a better foundation. #Java #DSA #Arrays #LearningInPublic #ProblemSolving #CodingJourney #JavaDeveloper

📝 Day 19/30 – LeetCode #33 (Search in Rotated Sorted Array) | Java This problem combines binary search with array rotation, making it more about logic than syntax. The main challenge was identifying which half of the array is sorted at every step and deciding whether the target lies within that range. By comparing boundary values and narrowing the search space accordingly, the problem can be solved efficiently in O(log n) time. This reinforced how adaptable binary search becomes when combined with careful condition checks. Another reminder that mastering patterns is far more important than memorizing solutions. #LeetCode #Java #DSA #BinarySearch #Arrays #ProblemSolving #LearningInPublic

Day 2/100 – LeetCode Challenge 🚀 Problem: #48 Rotate Image   Difficulty: Medium   Language: Java   Approach: In-Place Rotation using Transpose + Row Reversal   Time Complexity: O(n²)   Space Complexity: O(1) 🔍 Key Insight: To rotate a matrix 90° clockwise without extra space: 1️⃣ First transpose the matrix (swap across diagonal). 2️⃣ Then reverse each row. This avoids creating a new matrix and satisfies the in-place constraint. 🧠 Solution Brief: Used nested loops to transpose the matrix by swapping arr[i][j] and arr[j][i]. Then reversed each row using two pointers (start and end). Combined both operations inside a rotate() method. Achieved full rotation with constant extra space. 📌 What I Learned: Matrix problems are more about pattern recognition than brute force. Understanding transformations (transpose + reverse) makes complex problems simple. Starting my 100 Days of LeetCode journey today 💪 Consistency > Motivation. #LeetCode #Day2 #100DaysOfCode #Java #DSA #Matrix #ProblemSolving #CodingJourney #MediumProblem

🚀 Day 85 of #100DaysOfCode Solved LeetCode Problem #3713 – Longest Balanced Substring I ✅ A classic string + frequency-based problem that rewards careful iteration and validation. The goal was to find the longest substring where all present characters appear the same number of times—simple idea, but requires disciplined checking. Key Takeaways: -> Brute-force with pruning can still pass when constraints allow -> Frequency arrays are powerful for substring analysis -> Early balance checks save unnecessary computation -> Always align solution strategy with input limits Language: Java -> Runtime: 83 ms (Beats 88.95%) ⚡ -> Memory: 47.29 MB Small wins matter. Staying consistent, one problem at a time. 💻🔥 #LeetCode #Java #Strings #ProblemSolving #Algorithms #100DaysOfCode

Strings look simple until edge cases show up 👀 Day 8 / #100DaysOfCode 🚀 Solved: Valid Palindrome (LeetCode 125) 🔹 Approach: Used the two-pointer technique starting from both ends. Ignored non-alphanumeric characters and compared characters after converting the string to lowercase. Time Complexity: O(n) Space Complexity: O(1) ✔ Practiced string traversal with pointers ✔ Handled real-world edge cases (spaces, symbols, cases) ✔ Avoided extra space by working in-place 💡 Takeaway: Clean pointer logic often beats preprocessing with extra data structures. Building strong fundamentals in Java, one problem at a time. #LearnInPublic #100DaysOfCode #DSA #Java #Strings #ProblemSolving #SoftwareEngineer #CodingJourney #Consistency