Encode and Decode Strings with Length-Based Encoding

Regular Expression Matching 🔗 Problem Link LeetCode – Regular Expression Matching ⸻ 📌 Problem Statement Implement regular expression matching with support for: • . → Matches any single character • * → Matches zero or more of the preceding element The matching should cover the entire input string, not partial. ⸻ 🎯 Objective Given two strings: • s → Input string • p → Pattern Return true if s matches pattern p, otherwise return false. ⸻ 🧠 Approach Used 1️⃣ Dynamic Programming (DP) We use a 2D boolean table: • dp[i][j] represents → Whether first i characters of string s match → First j characters of pattern p. ⸻ 2️⃣ Base Case • dp[0][0] = true → Empty string matches empty pattern. • Handle patterns like a*, a*b*, etc. Because * can represent zero occurrences. ⸻ 3️⃣ Pattern Matching Logic Case 1: Direct Match or . If: • Current characters are equal OR • Pattern character is . Then: • Value depends on previous diagonal state → dp[i][j] = dp[i-1][j-1] ⸻ Case 2: * Character When pattern character is *, two possibilities exist: 1. Zero occurrences Ignore previous character and * → Move two steps back in pattern 2. One or more occurrences If previous pattern character matches current string character → Stay in same pattern position → Move string pointer This is the key idea of the problem. ⸻ ⏱ Time Complexity • O(m × n) Where: • m = length of string s • n = length of pattern p ⸻ 💾 Space Complexity • O(m × n) Due to 2D DP table. ⸻ 🧩 Key Concepts Covered • Dynamic Programming • 2D DP Table • Pattern Matching • Edge Case Handling • String Manipulation ⸻ 📈 Result • Accepted on LeetCode • All test cases passed • Efficient solution using DP #java #dsa #javaprogram #array #leetcode #solution #data #structure #algorithm #javadeveloper

👉 Given a string of uppercase English letters, find the number of pairs (i, j) such that: A[i] = 'A' A[j] = 'G' i < j In simple terms, count how many times 'A' appears before 'G' in the string. 🔘 Brute Force Approach (O(n²)) The most straightforward way is to check every pair: for(int i = 0; i < n; i++) { if(arr[i] == 'A') { for(int j = i + 1; j < n; j++) { if(arr[j] == 'G') { ans++; } } } } ---------------------------------------------------------- 🔘 Optimized Approach (O(n)) Instead of checking every pair, we can: Keep track of how many 'A' we have seen so far. Every time we encounter a 'G', add the count of previous 'A' to the answer. int countA = 0; for(int i = 0; i < n; i++) { if(arr[i] == 'A') { countA++; } else if(arr[i] == 'G') { ans += countA; } } #Java #DSA #Algorithms #ProblemSolving #CodingInterview #InterviewPreparation #DataStructures #TimeComplexity #Optimization #SoftwareEngineering #Developers #TechCareers #CodingJourney #LearnToCode #Programming

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞: 1784.Check if Binary String Has At Most One Segment of Ones Today’s challenge was a short but insightful problem that demonstrates how recognizing patterns in a binary string can lead to an extremely elegant solution. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐮𝐦𝐦𝐚𝐫𝐲: We are given a binary string s consisting only of '0' and '1'. The task is to determine whether the string contains at most one continuous segment of '1'. In other words, once a '0' appears after a '1', there should not be another '1' later in the string. If there is more than one segment of '1', return false. Otherwise, return true. 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: The key observation is very simple. If a binary string has more than one segment of '1', the pattern "01" must appear somewhere in the string. Why? A valid string with only one segment of ones looks like: 0001111000 But an invalid string with multiple segments would look like: 11100111 Notice the transition "01" which indicates that ones started again after a zero. Therefore, the entire problem reduces to checking whether the substring "01" exists. If "01" is present → there are multiple segments of '1'. If "01" is absent → there is at most one segment. This allows us to solve the problem in a single line using the built-in string function. 𝐂𝐨𝐝𝐞 𝐒𝐧𝐢𝐩𝐩𝐞𝐭 (Java): class Solution { public boolean checkOnesSegment(String s) { return !s.contains("01"); } } 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 𝐀𝐧𝐚𝐥𝐲𝐬𝐢𝐬: Time Complexity: O(n) Space Complexity: O(1) We scan the string once to check if the pattern "01" exists. 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬: Sometimes the best solution is identifying a simple pattern instead of simulating the entire process. Understanding how transitions occur in binary strings can simplify many problems. Leveraging built-in string functions can make solutions both clean and efficient. A great reminder that even small problems can reinforce strong pattern-recognition skills. #LeetCode #DSA #Java #ProblemSolving #Algorithms #BinaryStrings #CodingPractice #Consistency #100DaysOfCode #LearningJourney

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞: 1545.Find K-th Bit in N-th Binary String Today’s challenge was a beautiful recursion + symmetry based problem. At first glance, generating the full string seems natural — but that would be inefficient for large n. The real trick lies in understanding the pattern. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐮𝐦𝐦𝐚𝐫𝐲: We are given: • An integer n • An integer k The binary string Sₙ is defined recursively: S₁ = "0" Sₙ = Sₙ₋₁ + "1" + reverse(invert(Sₙ₋₁)) We need to return the k-th bit in Sₙ. 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Instead of constructing the entire string, we observe: Length of Sₙ = (2ⁿ) − 1 The middle position is always '1'. So for any (n, k): • If k equals the middle → answer is '1' • If k is in the left half → it’s same as (n-1, k) • If k is in the right half → It mirrors the left side So we map it to position (len - k + 1) Then invert the result This reduces the problem size at every recursive call. No full string construction needed. 𝐂𝐨𝐝𝐞: class Solution { public char findKthBit(int n, int k) { if (n == 1) return '0'; int len = (1 << n) - 1; int mid = (len + 1) / 2; if (k == mid) return '1'; if (k < mid) return findKthBit(n - 1, k); char c = findKthBit(n - 1, len - k + 1); return c == '0' ? '1' : '0'; } } 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 𝐀𝐧𝐚𝐥𝐲𝐬𝐢𝐬: Time Complexity: O(n) Each recursive call reduces n by 1. Space Complexity: O(n) Due to recursion stack depth. 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬: Not every recursive definition requires full construction. Symmetry and mirroring patterns can drastically reduce computation. Understanding structure is more powerful than brute force. When you see reverse + invert patterns, think about mapping indices instead of building strings. A very satisfying recursion problem that strengthens pattern recognition and divide-and-conquer thinking. #LeetCode #DSA #Java #Recursion #DivideAndConquer #BinaryStrings #ProblemSolving #100DaysOfCode #LearningJourney

Day 74/365 – Remove Duplicate Letters Problem: Given a string s, remove duplicate letters so that each letter appears once and the result is the smallest lexicographical order possible. Example: "bcabc" → "abc" "cbacdcbc" → "acdb" 💡 Key Idea Use a Monotonic Stack to maintain characters in lexicographically smallest order. We also track: • Last occurrence of each character • Whether a character is already used in the result 🧠 Approach 1️⃣ Record the last index of each character. 2️⃣ Traverse the string. 3️⃣ Skip characters already included. 4️⃣ While stack top is bigger than current character and it appears later again, remove it to get a smaller result. 5️⃣ Push current character into the stack. 📦 Key Logic while(!stack.isEmpty() && stack.peek() > c && lastIndex[stack.peek() - 'a'] > i) { visited[stack.pop() - 'a'] = false; } This ensures: Lexicographically smallest result Each character appears only once 📊 Complexity ⏱ Time: O(n) 📦 Space: O(1) (since only 26 letters) ✨ Key Learning This is a classic Monotonic Stack + Greedy problem. Pattern to remember: 👉 Remove previous larger elements if they appear again later. This pattern appears in problems like: Smallest Subsequence Remove K Digits Monotonic stack optimization problems #Day74 #365DaysOfCode #LeetCode #MonotonicStack #GreedyAlgorithm #DataStructures #Algorithms #Java #DSA #CodingInterview

🚀 Built My Own AI Java Code Generator 🤖💻 I recently created an AI-powered web application that generates clean and runnable Java code from simple text prompts. _____________________________________ 🛠 Tech Stack: 🐍 Python (Flask) 🌐 HTML, CSS, JavaScript 🤖 Ollama 🧠 Qwen2.5-Coder _____________________________________ 💡 How it works: You enter a Java requirement in the web interface → The backend sends the prompt to the Ollama model → The AI processes it and instantly generates structured Java code → The output is displayed directly in the browser. _____________________________________ This project helped me explore: ✔ Generative AI ✔ Local LLM integration ✔ Prompt engineering ✔ Backend–Frontend connectivity Excited to build more AI-powered developer tools 🚀 ........................................................................ #AI #Java #Python #Ollama #Qwen #WebDevelopment #GenerativeAI #SoftwareEngineering #ksr #ksrct #KSREI ........................................................................

𝐃𝐚𝐲 𝟐𝟒 – 𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 | 𝐀𝐫𝐫𝐚𝐲𝐬 🚀 Today’s problem focused on applying binary search in a 2D matrix by treating it like a flattened sorted array. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝 • Search a 2D Matrix 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝟏 – 𝐓𝐨𝐩-𝐑𝐢𝐠𝐡𝐭 𝐒𝐜𝐚𝐧 • Start from the top-right corner • Move left if the current value is greater • Move down if the current value is smaller • Time Complexity: O(n + m) 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝟐 – 𝐑𝐨𝐰-𝐖𝐢𝐬𝐞 𝐁𝐢𝐧𝐚𝐫𝐲 𝐒𝐞𝐚𝐫𝐜𝐡 • Identify the possible row • Apply binary search inside that row • Time Complexity: O(n log m) 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝟑 – 𝐅𝐥𝐚𝐭𝐭𝐞𝐧𝐞𝐝 𝐁𝐢𝐧𝐚𝐫𝐲 𝐒𝐞𝐚𝐫𝐜𝐡 • Treat matrix as a 1D sorted array • Range: 0 to (n × m − 1) • Convert index → row = mid / m, col = mid % m • Apply standard binary search 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 • A 2D matrix can be treated as 1D with index mapping • Binary search is about reducing the search space logically • Index math simplifies multidimensional problems • Choosing the right abstraction makes problems easier 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 • Time: O(log(n × m)) • Space: O(1) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲 Sometimes the trick is not searching in 2D — it’s thinking in 1D. 24 days consistent. On to Day 25 🚀 #DSA #Arrays #BinarySearch #LeetCode #Java #ProblemSolving #DailyCoding #LearningInPublic #SoftwareDeveloper

Day - 86 Binary Tree Preorder Traversal The problem - Given the root of a binary tree, return the preorder traversal of its nodes' values. In preorder traversal, we visit nodes in the order: Root → Left → Right. Brute Force - Store all nodes in an array using level-order traversal, then manually rearrange them in preorder sequence. This gives O(n²) time complexity due to repeated searching and rearranging, which is highly inefficient. Approach Used - •) Initialize ans = new ArrayList<>(). •) If root == null, return empty ans. •) Call helper function - preorder(root, ans). •) Return ans. Helper Function - •) If root != null, 1 - Add current node value: ans.add(root.val). 2 - Recursively traverse left subtree, preorder(root.left, ans). 3 - Recursively traverse right subtree, preorder(root.right, ans). Complexity - Time - O(n), where n = number of nodes. Space - O(h), where h = height of tree. Note - Preorder traversal naturally follows a recursive pattern: process the current node (Root), then recursively process the left subtree (Left), and finally the right subtree (Right). The recursion stack implicitly handles backtracking, making the implementation clean and straightforward. #DSA #Java #SoftwareEngineering #InterviewPrep #LearnToCode #CodeDaily #ProblemSolving

🔥 Day 96 of #100DaysOfCode Today’s problem: LeetCode – Find Minimum in Rotated Sorted Array 🔄📉 📌 Problem Summary You are given a sorted array that has been rotated at some pivot. Example: Sorted array → [1,2,3,4,5] Rotated → [3,4,5,1,2] Goal 👉 Find the minimum element in the array. Example: Input: [3,4,5,1,2] Output: 1 🧠 Approach: Binary Search Since the array was originally sorted, we can use Binary Search to locate the rotation point. Key observation: If nums[l] < nums[r] → Subarray is already sorted → Minimum is nums[l] Otherwise: Compute middle index Compare with left boundary to decide which half to search ⚙️ Decision Logic 1️⃣ If left part is sorted → Minimum must be in right half 2️⃣ If left part is not sorted → Minimum is in left half 💡 Key Idea We are essentially searching for the rotation pivot, which contains the smallest value. ⏱ Time Complexity: O(log n) 💾 Space Complexity: O(1) 🚀 Performance Runtime: 0 ms Beats 100% submissions 🔥 Memory: 43.8 MB 🧠 Pattern Insight Common Binary Search variants: Search in Rotated Sorted Array Find Minimum in Rotated Array Peak Element Binary Search on Answer Recognizing these patterns makes solving them much faster. Only 4 days left to complete #100DaysOfCode 🚀 Consistency paying off every day. On to Day 97 🔥 #100DaysOfCode #LeetCode #BinarySearch #RotatedArray #Java #DSA #InterviewPrep

I’m sure you’ve written a “one-off” script that ended up being used regularly. And when you needed to maintain it, one year later, you couldn’t understand what the heck was going on. That’s not a “you” problem, it’s a “every Python dev” problem. Here are two things you can do about it. First, split input, processing, and output. You should be able to look at your script and see exactly where you’re taking care of input, then where the “business logic” is, and finally where the output part is happening. By clearly separating the three, your script is easier to reason about. It’s also easier to maintain it if later the business logic changes. Or if the input is suddenly done through a new API. Or if the output now needs to happen in a different format. Having a clean and clear separation of these three concerns will do wonders for you and it can be as simple as having different sections in your script. Input happens first, at the top. Then processing. Then output. That’s it. Just make sure you do one thing at a time. Here’s a tiny example of a script that mixes everything: ```py with open("file_with_numbers.txt", "r") as f: total = length = 0 for line in f: total += int(line) length += 1 print(f"Average is {total / length}.") ``` Here’s an equally tiny but simpler script that does the three things separately: ```py with open("file_with_numbers.txt", "r") as f: data = [int(line) for line in f] total = sum(data) length = len(data) print(f"Average is {total / length}.") ``` This tiny example shows WHAT the separation of concerns can look like. Second, use functions to encapsulate units of logic. And make sure your functions ONLY do one thing, and they do it right. One thing I like to do is have function names that start with a verb indicating the thing that the function does. For example, the function `compute_average` could be: ```py def compute_average(data): return sum(data) / len(data) ``` And then, the function should only do things that are related to its name. For example, the function `compute_average` should NOT look like this: ```py def compute_average(data): avg = sum(data) / len(data) print(f"Average is {avg}.") return avg ``` And that’s because the function is called “COMPUTE average”, so printing the average is unexpected. If your code does unexpected things, it’s harder to keep track of what behaves how, and that makes your code harder to maintain. Also, this is the kind of thing that you-from-the-future will curse at you-from-the-past for having done. These are two small tricks I use every day when I’m writing my code. And especially when I’m working on “one-off” scripts. You can learn these techniques, and others, in the intermediate Python course that’s starting next week. See the link in the comments 👇