"Day 27: Generated Parentheses with Java Backtracking"

🚀 Day 29 of 100 Days of LeetCode 📘 Problem: Combination Sum 💻 Language: Java ✅ Status: Accepted — Runtime ⚡ 2 ms (Beats 86%) Today’s problem was all about backtracking — exploring all possible combinations to reach a target sum. It’s a perfect blend of recursion, decision-making, and pruning unnecessary paths 🧠 ✨ Key Learnings: Backtracking is like exploring a maze — try, backtrack, and try again until you find the exit 🌀 Each recursive call represents a “choice point” — include or skip the element Clean recursion with controlled base cases leads to clarity and precision This problem reminded me how persistence works in both code and life: 💬 “Sometimes, the path to the solution is not straightforward — you just need to keep exploring.” #Day29 #100DaysOfCode #LeetCode #Java #Backtracking #Recursion #DSA #ProblemSolving #CodingJourney #SoftwareDevelopment #KeepLearning #CodeEveryday

🚀 Day 34 of 100 Days of LeetCode 📘 Problem: Merge Intervals 💻 Language: Java ✅ Status: Accepted — Runtime ⚡ 8 ms (Beats 86%) Today’s challenge was all about mastering interval merging, an essential concept for solving scheduling and range-based problems efficiently 🧩 By sorting intervals and carefully merging overlapping ones, I learned how crucial boundaries and comparisons are — both in coding and in life. ✨ Key Learnings: Sorting simplifies complex interval logic Smart use of conditions avoids unnecessary comparisons Handling edge cases builds precision thinking ⚙️ 💬 “Merge where it makes sense — in code and in life.” #Day34 #100DaysOfCode #LeetCode #Java #DSA #ProblemSolving #Algorithms #CodingJourney #SoftwareDevelopment #KeepLearning #CodeEveryday

Day 45 of #50DaysOfLeetCodeChallenge Today's Problem: Sort characters in a string by their frequency. -Approach: First, I counted the frequency of each character in the string using a HashMap. Then, I used a Max-Heap (PriorityQueue) to sort the characters based on their frequencies. Finally, I built the result string by repeating each character according to its count. It was interesting to see how Java’s collections can simplify what seems like a complex problem at first! -Key Takeaways: HashMaps make counting elements fast and easy. PriorityQueue (Max-Heap) is perfect when we need to sort dynamically by priority. #Java #DSA #ProblemSolving #CodingJourney #50Days #CodeToLearn

🚀 Day 53 | DSA with Java Today, I solved the Aggressive Cows Problem — another classic example of Binary Search on Answers. 🐄🏠 --- 🔹 Problem Statement: Given n stalls at different positions and c cows: Place the cows in stalls so that the minimum distance between any two cows is maximized. Find the largest minimum distance possible. Example: Input: stalls = [1,2,4,8,9], c = 3 Output: 3 ✅ (Place cows at positions 1, 4, 8) --- ⚙️ Approach – Binary Search on Answers 1. Sort the stalls array. 2. Search in the distance range [1, max(stalls) - min(stalls)]. 3. For each mid distance, check if it’s possible to place all cows maintaining at least mid distance. 4. Adjust the search space based on feasibility: If possible → try larger distance Else → try smaller distance Time Complexity: O(n × log(maxDistance)) Space Complexity: O(1) --- 🧠 Learning Outcomes: ✅ Practiced Binary Search on Answers in a spatial context ✅ Strengthened logical thinking with feasibility functions ✅ Similar patterns as Book Allocation and Painters Partition --- #DSA #Java #BinarySearch #AggressiveCows #ProblemSolving #Coding #Programming #100DaysOfCode #GitHub #LogicBuilding

🌟 Day 93 of #100DaysOfCodingChallenge 🌟 🔹 Problem: 442. Find All Duplicates in an Array 🔹 Platform: LeetCode 🔹 Language: Java 🔹 Difficulty Level: Medium 🧩 Problem Statement: Given an integer array nums containing numbers from 1 to n, find all the elements that appear twice in the array. 💡 Intuition: To identify duplicates efficiently, I used two HashSets — one to store visited elements and another to store duplicates when an element is already seen. This method makes the solution concise and easy to understand while maintaining good performance. ✅ Time Complexity: O(n) ✅ Space Complexity: O(n) 🚀 Key Takeaway: Sometimes, clarity and simplicity in code matter more than optimization — this approach is easy to implement and perfectly suitable for most scenarios. #Day93 #LeetCode #100DaysOfCode #Java #ProblemSolving #CodingChallenge #DSA #LearnByCoding #WomenInTech

🚀 Day 4 of My DSA with Java Journey 📘 Problem: Square of a Sorted Array 🧩 Topic: Two Pointers 💻 Language: Java ⚙️ Approach: Two Pointer Technique (O(n)) 🔍 What I Learned: Handling both negative and positive numbers while keeping the array sorted after squaring — optimized using two pointers instead of sorting after squaring. ✨ Key Takeaway: Think in terms of pointers and comparisons, not just brute force — that’s how optimization begins. #Java #DSA #LeetCode #TwoPointers #CodingJourney #100DaysOfCode #PlacementPrep #LearnInPublic #CodingCommunity #JavaDeveloper

🌟 Day 86 of #100DaysOfCodingChallenge 🌟 🚀 Problem: 561. Array Partition 💻 Language: Java Today’s challenge was about maximizing the sum of the minimum values in n pairs formed from an array of 2n integers. 🧩 Approach: 1️⃣ Sort the array in ascending order. 2️⃣ Take every alternate element (starting from index 0). 3️⃣ Add them up — this gives the maximum possible sum of mins in all pairs. 🧠 Key Insight: When the array is sorted, pairing adjacent elements ensures the smallest numbers are always matched optimally, leading to the maximum possible result. 📊 Example: Input → [1,4,3,2] Sorted → [1,2,3,4] Pairs → (1,2), (3,4) Output → 4 ✅ ✨ Learning: Sometimes the simplest approach — sorting and selecting — can yield the most optimal result! #Day86 #LeetCode #Java #100DaysOfCode #CodingChallenge #ProblemSolving #ArrayPartition #DSA #WomenInTech #SathyabamaUniversity

Day 46 of #100DaysOfLeetCode Challenge 🚀Today’s Problem: Remove Duplicate Letters (LeetCode - Medium) Language: Java In this problem, the goal is to remove duplicate letters from a string such that every letter appears once and the result is the smallest lexicographical order possible. Concepts Covered: Stack for maintaining order Greedy approach for smallest lexicographical sequence Tracking last occurrence index of each character Boolean array to keep track of visited characters Key Takeaways: Understanding when to remove elements from the stack is crucial for optimal ordering. The combination of stack + greedy ensures both uniqueness and lexicographical minimality. #100DaysOfCode #LeetCode #Java #ProblemSolving #CodingChallenge #DSA #DevelopersJourney

✨ Day 74 of #100DaysOfCode Today, I solved LeetCode 22. Generate Parentheses using Backtracking in Java 🧠💻 📝 Problem Summary: Given n pairs of parentheses, generate all combinations of well-formed parentheses. ✅ Example: Input: n = 3 Output: ["((()))","(()())","(())()","()(())","()()()"] 💡 Key Idea: Use backtracking to build all valid strings. Keep track of the number of opening and closing brackets. Add '(' if open < n. Add ')' if close < open. When the string reaches length 2 * n, it's a valid combination. 🚀 Learning: Backtracking is a powerful technique for exploring all valid combinations. Keeping proper state (open, close) helps prune invalid paths early. #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #Backtracking #CodingChallenge #SowmiyaCodes #PlacementPrep

Today, I explored some interesting LeetCode problems to strengthen my Java and DSA fundamentals. Here’s a quick breakdown of what I solved 👇 🔹 Problem 1: Toeplitz Matrix 🧩 Question: Check whether all diagonals from top-left to bottom-right contain the same elements. 🧠 Approach: Traverse the matrix and compare each element with its bottom-right diagonal neighbor. If any mismatch occurs, return false; otherwise, true. This ensures every diagonal maintains uniformity. 📊 Complexity: Time: O(m × n) Space: O(1) 💡 Key Learning: Strengthened understanding of 2D array traversal and pattern validation. 🔹 Problem 2: Largest Number At Least Twice of Others 🧩 Question: Find the index of the largest element if it’s at least twice as large as every other element; otherwise, return -1. 🧠 Approach: Scan the array once to find the largest and second-largest elements. Check if the largest element is ≥ 2 × (second-largest). If true, return its index; else, return -1. 📊 Complexity: Time: O(n) Space: O(1) 💡 Key Learning: Practiced efficient single-pass array traversal and comparison logic. 🔹 Problem 3: Shortest Completing Word 🧩 Question: Given a license plate string and a list of words, find the shortest word that contains all the letters (and their frequencies) from the license plate. 🧠 Approach: Clean the license plate (keep only letters, make lowercase). Count frequency of each letter. For each word, check if it fulfills the required frequency. Track and return the shortest valid word. 📊 Complexity: Time: O(k × n), where k = number of words and n = average word length Space: O(1) 💡 Key Learning: Improved string manipulation, frequency mapping, and logical optimization. 🔥 Overall Takeaway: Practicing diverse problems like these boosts my problem-solving mindset, enhances Java coding efficiency, and builds confidence in tackling real-world algorithmic challenges 💪 Profile link ->https://lnkd.in/gFH_4R9a #Java #LeetCode #ProblemSolving #DSA #CodingPractice #LearningJourney #Developer #TechSkills #CodingInJava