Solved Palindrome Partitioning II with DP in Java

Day 11 of #JavaWithDSAChallenge Problem: Palindrome String A palindrome reads the same backward and forward — for example, “abba” is a palindrome, but “abc” isn’t. Concept: We use the two-pointer approach — one pointer starts from the beginning (left), and the other from the end (right). We compare characters at both ends and move towards the center. If any pair doesn’t match, it’s not a palindrome. class Solution { boolean isPalindrome(String s) { int left = 0; int right = s.length() - 1; while (left < right) { if (s.charAt(left) != s.charAt(right)) { return false; // characters don't match } left++; right--; } return true; } } Code Explanation: left starts from index 0 and right from the last character. while (left < right) → keep comparing characters until the middle is reached. If any mismatch occurs → return false. If loop completes → all characters match → return true. Key Takeaway: The two-pointer technique makes string checking problems faster and more memory-efficient. #Java #DSA #JavaProgramming #100DaysOfCode #CodingChallenge #ProblemSolving #GirlsWhoCode #GeeksforGeeks #TechLearning #JavaDeveloper #CodeNewbie

Day 48/100 – #100DaysOfCode 🚀 | #Java #Backtracking #Recursion ✅ Problem Solved: Palindrome Partitioning (LeetCode 131) 🧩 Problem Summary: Given a string s, partition it such that every substring in the partition is a palindrome. Return all possible palindrome partitioning combinations. 💡 Approach Used: Used Backtracking to explore all possible substring splits. Key Idea: At each position, expand and check if the substring s[start…i] is a palindrome. If yes → include it and recurse for the rest of the string. If no → skip and continue searching. Helper Components: Recursive DFS function for exploring partitions. A fast palindrome-checking utility. ⚙️ Time Complexity: O(N × 2ⁿ) 📦 Space Complexity: O(N) (recursion stack + path building) ✨ Takeaway: This problem strengthens understanding of recursion tree exploration, decision branching, and string-based backtracking. #Java #LeetCode #Backtracking #Recursion #ProblemSolving #100DaysOfCode #CodingChallenge

#100DaysOfCode – Day 87 Linked List Sorting & Node Rearrangement Linked List manipulation specifically, sorting a list that contains only 0s, 1s, and 2s. Problem: Given the head of a linked list containing only 0s, 1s, and 2s, rearrange the list so that all 0s appear first, followed by all 1s, and then all 2s. Example: Input: 1 → 2 → 2 → 1 → 0 → 2 Output: 0 → 1 → 1 → 2 → 2 → 2 Created three separate dummy linked lists to store 0s, 1s, and 2s. Traversed the original list once, linking each node to its respective list. Finally, merged all three lists in order (0s → 1s → 2s). Concepts Used: Linked List traversal Pointer manipulation Dummy node technique Time Complexity: O(N) Space Complexity: O(1) Efficient linked list problems often come down to clean pointer handling and a solid understanding of list connections no extra sorting needed! #takeUforward #100DaysOfCode #Java #LinkedList #GeeksForGeeks #ProblemSolving #DSA #CodingChallenge #CodeNewbie

Day 54/100 – #100DaysOfCode 🚀 | #Java #SlidingWindow #TwoPointers ✅ Problem Solved: Count the Number of Substrings With Dominant Ones (LeetCode) 🧩 Problem Summary: You’re given a binary string. A substring is dominant if: number of 1s > number of 0s × k (where k is given). Return the total count of such substrings. 💡 Approach Used: Used an optimized Sliding Window + Two Pointers approach: Traverse with a right pointer. Adjust the left pointer whenever the substring stops being dominant. All valid windows contribute (left + 1) substrings. This avoids brute-force O(N²) and makes the solution efficient. ⚙️ Time Complexity: O(N) 📦 Space Complexity: O(1) ✨ Takeaway: Sliding window transforms heavy substring problems into clean linear-time solutions. #Java #LeetCode #SlidingWindow #TwoPointers #ProblemSolving #CodingChallenge #100DaysOfCode

#48Day of #50DaysOfCoding Staircase Pattern Problem (Java) Today, I solved the “Staircase” problem from HackerRank using Java — a simple yet visually satisfying problem that focuses on nested loops and pattern generation. Concept Used: - Nested loops to print spaces and hash symbols. - Right-aligned pattern formation using conditional structure. Logic: For each row from 1 to n: - Print (n - i) spaces. - Then print i hash symbols (#). - Move to the next line after each row. Example: For n = 4, the output is: ``` # ## ### #### ``` Complexity: - Time Complexity: O(n²) (nested loops) - Space Complexity: O(1) This problem helped reinforce how loop control and formatting logic work together to create structured patterns in programming.

Day 40/100 – #100DaysOfCode 🚀 | #Java #LeetCode #TwoPointers #DynamicProgramming ✅ Problem Solved: Longest Palindromic Substring 🟣 🧩 Problem Summary: Given a string, return the longest palindromic substring within it. The substring must read the same forward and backward. 💡 Approach Used: Expand Around Center Technique Every palindrome is centered around: A single character (odd length) Or between two characters (even length) For each index: Expand left and right while characters match. Track the longest substring during expansions. This avoids unnecessary recomputation and works efficiently. ⚙️ Time Complexity: O(n²) 📦 Space Complexity: O(1) ✨ Takeaway: Sometimes, the cleanest approach comes from observing patterns — in this case, symmetry around a center 🎯 #Java #LeetCode #TwoPointers #ExpandAroundCenter #ProblemSolving #100DaysOfCode #CodingJourney

🚀 LeetCode #344 — Reverse String (Two Pointer Approach) Solved this classic problem today! The task is simple: reverse a string in-place using O(1) extra memory — perfect for practicing the two-pointer technique. 💡 Idea: Use two pointers — one at the start and one at the end. Swap characters while moving both pointers toward the center. #LeetCode #Java #TwoPointer #ProblemSolving #CodingJourney

💡 Did you know? Using StringBuilder instead of String concatenation in loops can improve performance by up to 10x! String result = ""; for(int i=0; i<1000; i++) { result += i; // ❌ Creates 1000 String objects } StringBuilder sb = new StringBuilder(); for(int i=0; i<1000; i++) { sb.append(i); // ✅ Single object } #Java #Programming #CodeOptimization

💡 LeetCode #344 — Reverse String Today I solved LeetCode Problem 344: Reverse String 🔁 Problem Summary: Write a function that reverses a string. The input string is given as a character array s, and you must reverse it in-place (without using extra space). Key Idea: Use the two-pointer technique 👈👉 Initialize one pointer at the start (left) and another at the end (right). Swap the characters at both pointers and move them toward the center. #LeetCode #Java #DSA #TwoPointers #CodingJourney #ProblemSolving