Removing Duplicate Letters in Lexicographical Order

🔥 Day 552 of #750DaysOfCode 🔥 🔐 LeetCode 2075: Decode the Slanted Ciphertext (Medium) Today’s problem looked tricky at first, but once the pattern clicked, it became super elegant 😄 🧠 Problem Understanding We are given an encoded string that was: Filled diagonally (↘) into a matrix Then read row-wise (→) 👉 Our task is to reverse this process and recover the original text. 💡 Key Insight If encoding is: ➡️ Fill diagonally ➡️ Read row-wise Then decoding is: ➡️ Read diagonally from row-wise string ⚙️ Approach ✅ Step 1: Calculate number of columns cols = encodedText.length() / rows; ✅ Step 2: Traverse diagonals starting from each column for (int startCol = 0; startCol < cols; startCol++) { int row = 0, col = startCol; while (row < rows && col < cols) { result.append(encodedText.charAt(row * cols + col)); row++; col++; } } ✅ Step 3: Remove trailing spaces 🚀 Complexity Time: O(n) Space: O(n) 🧠 What I Learned How to reverse matrix-based encoding patterns Converting 2D traversal → 1D index mapping Importance of pattern recognition in problems 📌 Takeaway Not every problem needs heavy logic. Sometimes, it's just about seeing the pattern correctly 👀 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Algorithms #SoftwareEngineering #100DaysOfCode #750DaysOfCode

Day 105: Circular Arrays & Shortest Paths 🔄 Problem 2515: Shortest Distance to Target String in a Circular Array Today’s challenge involved finding the minimum steps to reach a target string in a circular array, allowing movement in both directions. The Strategy: • Bidirectional Search: Since the array is circular, the distance can be calculated in two ways: moving forward or moving backward. • Modular Arithmetic: I used (dist + n) % n to handle the wrap-around logic seamlessly, ensuring the index stays within bounds regardless of the direction. • Optimization: By iterating once through the array and comparing the distances for every occurrence of the target, I maintained an O(N) time complexity. Sometimes the most elegant way to handle a "circular" problem is simply embracing the symmetry of the path. 🚀 #LeetCode #Java #Algorithms #ProblemSolving #DailyCode

Day 36 of Daily DSA 🚀 Solved LeetCode 443: String Compression ✅ Problem: Given an array of characters, compress it in-place using run-length encoding. Each group of consecutive repeating characters is replaced by the character followed by its count (if count > 1). The result must be stored back in the input array. Rules: * If a group's length is 1 → append only the character * If a group's length is > 1 → append character + count * Group lengths ≥ 10 are split into multiple characters * Must use only constant extra space * Return the new length of the array Approach: Used a StringBuilder to build the compressed string by tracking consecutive character counts, then wrote the result back into the input array. Steps: 1. Append the first character to StringBuilder 2. Iterate through the array counting consecutive duplicates 3. On a new character → if count > 1, append the count 4. Append the new character and reset count 5. Handle the last group after the loop 6. Write compressed characters back into the input array ⏱ Complexity: • Time: O(n) • Space: O(n) (StringBuilder) 📊 LeetCode Stats: • Runtime: 3 ms (Beats 12.04%) • Memory: 45.58 MB (Beats 42.35%) A great exercise in in-place array manipulation and run-length encoding — fundamentals that show up everywhere in data compression. #DSA #LeetCode #Java #Strings #RunLengthEncoding #CodingJourney #ProblemSolving

Today’s random problem was 3310. Remove Methods From Project The problem asks us to determine which methods can be safely removed from a project without breaking any dependencies. Each method may invoke other methods, and if a method is removed, any method depending on it directly or indirectly may also be affected. Key Insight: Methods form a directed graph where edges represent invocations. A method can only be removed if none of the remaining methods depend on it. Instead of checking dependencies repeatedly, we can precompute the indegree of each method (number of methods calling it) and track all methods reachable from the target method. Problem Is Tricky Because of Dependencies: Reachability: Removing a method affects all methods it calls directly or indirectly. Dependency Awareness: Methods with incoming edges from outside the removable set cannot be removed. Mutation Order: We must traverse the graph carefully to avoid corrupting dependency counts during processing. My Approach: I used a DFS-based solution: First DFS: Traverse the graph starting from the target method. Collect all reachable methods into a set. Reduce indegrees of the methods called by each visited method to simulate “removal.” Decision Step: If any reachable method still has incoming edges after DFS, none of the methods can be removed safely, so we keep all methods. Otherwise, we remove all methods not in the reachable set. Complexity: Time: O(n + m) (each method and each invocation visited once) Space: O(n + m) (graph + recursion stack + reachable set) #LeetCode #CodingChallenge #SoftwareEngineering #Java #DataStructures #Algorithms #Graph #DFS #ProblemSolving #TechInterviewPrep

 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞 – 𝐃𝐞𝐜𝐨𝐝𝐞 𝐭𝐡𝐞 𝐒𝐥𝐚𝐧𝐭𝐞𝐝 𝐂𝐢𝐩𝐡𝐞𝐫𝐭𝐞𝐱𝐭 (𝐌𝐞𝐝𝐢𝐮𝐦) Today’s problem was a 𝐟𝐮𝐧 𝐦𝐚𝐭𝐫𝐢𝐱 𝐭𝐫𝐚𝐯𝐞𝐫𝐬𝐚𝐥 + 𝐬𝐢𝐦𝐮𝐥𝐚𝐭𝐢𝐨𝐧 𝐜𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐋𝐢𝐧𝐤 : https://lnkd.in/gsSCrJbr 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐋𝐢𝐧𝐤 : https://lnkd.in/gMhqhD6M The idea behind the encoding process: The original text is written 𝐝𝐢𝐚𝐠𝐨𝐧𝐚𝐥𝐥𝐲 𝐢𝐧 𝐚 𝐦𝐚𝐭𝐫𝐢𝐱 with a fixed number of rows. The matrix is then read row by row to produce the encoded string. To decode it, we reverse the process: 🔹 𝐊𝐞𝐲 𝐎𝐛𝐬𝐞𝐫𝐯𝐚𝐭𝐢𝐨𝐧𝐬 If n = encodedText.length() and we know rows, then cols = n / rows Characters of the original text lie on diagonals starting from each column in the first row. Traverse diagonally (row++, col++) from each starting column. 🔹 𝐒𝐭𝐞𝐩𝐬 Compute the number of columns. For every column c, traverse diagonally down-right. Map the matrix index using r * cols + c. Build the result string. Remove trailing spaces at the end. 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 Time: O(n) Space: O(n) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲: Whenever you see a matrix encoding problem, think about how the data was written and reverse the traversal pattern. #LeetCode #CodingInterview #DataStructures #Algorithms #Java #ProblemSolving #DailyCodingChallenge

🚀 Day 565 of #750DaysOfCode 🚀 🔍 Problem Solved: Minimum Absolute Distance Between Mirror Pairs Today’s problem was all about identifying mirror pairs in an array — where reversing one number equals another — and finding the minimum index distance between such pairs. 💡 Key Insight: Instead of brute force (O(n²)), we can optimize using a HashMap to track previously seen reversed values. 🧠 Approach: Traverse the array once For each number: Check if it already exists in the map → update minimum distance Compute its reverse Store the reversed number with its index Return the minimum distance, or -1 if no pair exists 📊 Complexity: Time: O(n × d) → d = number of digits Space: O(n) 🔥 Takeaway: Using a reverse transformation + hashmap lookup converts a nested loop problem into a linear scan — a classic optimization pattern! #Day565 #750DaysOfCode #LeetCode #Java #DataStructures #Algorithms #CodingJourney #HashMap #ProblemSolving

Day 16 of my #30DayCodeChallenge: Navigating the Twist! The Problem: Search in Rotated Sorted Array. The Logic: While a standard Binary Search assumes a fully linear sequence, a rotated array introduces a "break point." The key is realizing that at any given mid-point, at least one half of the array must be sorted. 1. Identify the Sorted Half: In every iteration, I compare nums [left] with nums [mid]. If nums [left] <= nums [mid], the left side is sorted. Otherwise, the right side is sorted. 2. Range Check: Instead of searching blindly, I check if the target actually lies within the bounds of that sorted half. 3. The Result: By consistently discarding half of the search space based on these sorted properties, we pinpoint the target index or return -1 if it doesn't exist. Cracking the code, one rotation at a time. Onward to Day 17! #Java #Algorithms #DataStructures #BinarySearch #ProblemSolving #150DaysOfCode #SoftwareEngineering

## 🧩 Solved LeetCode 9 – Palindrome Number Today I revisited a fundamental integer manipulation problem: determining if a number reads the same forward and backward without converting it to a string. 🔍 **Problem Insight:** While string conversion makes this trivial, the real challenge is solving it mathematically. The goal is to reverse the integer (or half of it) and compare it to the original while being mindful of potential integer overflow. 💡 **Key Learnings:**  * **Negative Numbers:** Any negative number is immediately invalid (e.g., -121 becomes 121-).  * **Mathematical Reversal:** Using modulo % 10 and integer division / 10 allows us to "pop" and "push" digits.  * **Optimization:** We only need to reverse **half** of the number. Once the original number becomes less than or equal to the reversed half, we've reached the middle.  * **Edge Case Savvy:** Numbers ending in 0 (except 0 itself) cannot be palindromes. ⚙️ **Approach Used:**  1. Eliminate negative numbers and numbers ending in 0.  2. Build the reversed half of the number by iteratively taking the last digit.  3. Stop when the reversed part is \ge the remaining part.  4. Check for equality (handling odd-lengthed numbers by dividing the reversed part by 10). 📊 **Complexity:**  * **Time:** O(\log_{10}(n)) — we divide the input by 10 in every iteration.  * **Space:** O(1) — constant space used regardless of input size. 🔥 **Takeaway:** This problem is a perfect example of why we shouldn't always reach for the easiest data type conversion. Thinking in terms of pure logic and math often leads to a more memory-efficient and elegant solution. #LeetCode #Algorithms #Math #ProblemSolving #CodingJourney #Java #DataStructures #CompetitiveProgramming

🚀 Just solved the Contains Duplicate problem with a fresh perspective! Instead of going with the traditional sorting + two pointer approach, I used the property of Set (uniqueness) to achieve an O(n) time complexity solution. 💡 Approach: - Traverse the array once - Use a HashSet to track elements - If an element already exists → duplicate found ⚡ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔁 On the other hand, the sorting + two pointer approach gives: - Time: O(n log n) - Space: O(1) 👉 So it’s a classic trade-off: - Optimize time → use Set - Optimize space → use Sorting+two pointer Really enjoyed breaking down this problem and comparing approaches — small problems like this build strong intuition for bigger ones 💪 #DataStructures #Algorithms #LeetCode #Java #CodingJourney #ProblemSolving #100DaysOfCode

Day 94: Slanted Ciphertext & Loop Optimization 📟 Problem 2075: Decode the Slanted Ciphertext Today’s solve was a fun callback to the "ZigZag Conversion" problem I've tackled before. The challenge: read a string that was written diagonally across a matrix and then flattened into a single row. The Strategy: • Diagonal Traversal: The key is calculating the step size. In a slanted cipher, the next character in a diagonal is exactly columns + 1 indices away. • Refining the Loop: My first approach worked well, but I realized I could shave off execution time by adding an early exit. • The "Efficiency" Jump: By adding a simple check, if(j % column == column-1) break;—I stopped the inner loop from looking for diagonal neighbors that would logically fall outside the matrix boundaries. The Result: This small logic tweak dropped my runtime from 28ms down to 18ms, jumping from beating 56% to 97.63% of users. It’s a great reminder that even on "easier" problems, there’s always room to optimize. Seeing that performance graph move to the far left is the best kind of motivation. 🚀 #LeetCode #Java #StringManipulation #Algorithm #Optimization #DailyCode