LeetCode Challenge: Swapping Characters by Parity

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gdWsKciF This solution finds the maximum distance between two houses of different colors based on a key observation: the maximum distance will always involve either the first house or the last house. Instead of checking all possible pairs, which would take O(n²), the code improves the method by making a single pass through the array. It starts with an answer of 0 and goes through each index `i`. For each house, it does two checks. First, it compares the current color with the color of the first house (index 0). If they are different, the distance between them is simply `i`, and we update the maximum distance. This identifies the farthest house from the start that has a different color. Next, it compares the current color with the color of the last house (index n-1). If they are different, the distance is `(n - 1 - i)`, and we update the maximum if necessary. This identifies the farthest house from the end that has a different color. By doing this, the algorithm effectively captures the maximum possible distance without checking every pair. Since it requires only one loop through the array, the time complexity is O(n) and the space complexity is O(1). 👉 My Solution: https://lnkd.in/gg_5J_DF If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

I just returned false on a LeetCode problem… and it passed ALL 67 test cases. No loops. No base conversions. No palindrome checks. Just one line: return false; And it got accepted instantly. The problem? 2396.  Strictly Palindromic Number You had to check if a number n is a palindrome in every base from 2 to n-2. Sounds brutal, right? Then I actually read the problem properly. Here's the mind-blowing part: For any n ≥ 4, when you convert it to base (n-2), it always becomes "12". n=5 → base 3 → "12" n=6 → base 4 → "12" n=10 → base 8 → "12" "12" is never a palindrome. So it's mathematically impossible for any number ≥ 4 to be strictly palindromic. For n=1,2,3 the base range is invalid anyway. The answer is always false. The entire "hard" problem collapses into a single line of code. Lesson for every developer: Before you write clever code, ask yourself: Is this problem even possible? Sometimes the best solution isn’t optimized algorithms. It’s pure elimination.  O(1) thinking. Read the problem. Really read it. #LeetCode #ProblemSolving #SoftwareEngineering #Coding #DSA #BackendEngineering #CodingInterview #DeveloperMindset #CleanCode

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g8Xgd5wx The function goes through each word in the `queries` array. For every query word, it compares it with each word in the `dictionary`. Since all words are assumed to have the same length, it performs a character-by-character comparison. For each pair of words, a counter called `unequal` tracks how many positions have different characters. The code loops through each index of the word and increases this counter whenever the characters at the same position do not match. If the number of differing characters is 2 or less at any point, it means the query word can change into that dictionary word with at most two edits. In this case, the query word is added to the result list, and the inner loop stops early, using `break` to avoid unnecessary comparisons with other dictionary words. Finally, after checking all query words, the function returns the list of valid words that meet the condition. 👉 My Solution: https://lnkd.in/gMnYvSvx If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/gdjyFXCw First, we note that swaps aren't random; they are only allowed between specific index pairs. If index `a` can swap with `b`, and `b` can swap with `c`, then `a`, `b`, and `c` become connected. We can rearrange values freely among them. This means we need to identify groups of indices where swapping is allowed within the group. To find these groups efficiently, we use Disjoint Set Union (DSU). Each index starts in its own set. For every allowed swap pair `[x, y]`, we combine their sets. After processing all the swaps, indices that share the same parent belong to the same connected component or group. Next, we organize all indices by their DSU parent. Each group shows a set of positions where we can rearrange values without restrictions. For each group, we aim to match values from `source` to `target` as closely as possible: * First, we count how often each value appears in `source` for that group. * Then, we go through the same indices in `target`. For each value:  * If the value exists in our frequency map (meaning we have it in `source`), we use it and decrease its count.  * If it doesn't exist, it means we can't match this value in the group, contributing to the Hamming distance. By doing this for all groups, we maximize matches within each connected component, which minimizes the overall Hamming distance. 👉 My Solution: https://lnkd.in/gfx3iMut If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

🚀 LeetCode Daily Challenge 🔗 Problem: https://lnkd.in/g9SGp2Qa 💡 My thought process: First, create a mapping from each value to a sorted list of its indices using a map<int, vector<int>>. This allows for easy lookup of all positions where a value occurs. For each query index idx, it retrieves the corresponding value num. If that value appears only once, the result is -1 because no valid pair exists. In case of multiple occurrences, we use binary search on the index list of num: * upper_bound finds the next occurrence that is strictly greater than idx. * lower_bound locates the current position and checks the previous occurrence. It calculates distances in both directions: * Forward distance: either direct (next - idx) or circular wrap (n - (idx - first)). * Backward distance: either direct (idx - prev) or circular wrap (n - (last - idx)). The minimum of these distances is stored as the answer. 👉 My Solution: https://lnkd.in/gjmKVa3y If you found this breakdown helpful, feel free to ⭐ the repo or connect with me on LinkedIn 🙂🚀 #️⃣ #leetcode #cpp #dsa #coding #problemsolving #engineering #BDRM #BackendDevWithRahulMaheswari

Day 36 of My DSA Journey Today I solved LeetCode 150 – Evaluate Reverse Polish Notation (RPN) on LeetCode. 📌 Problem Evaluate the value of an arithmetic expression in Reverse Polish Notation. Valid operators are: +, -, *, / Each operand may be an integer. Example: Input: ["2","1","+","3","*"] Output: 9 Explanation: (2 + 1) * 3 = 9 🧠 Approach – Stack This problem is a perfect application of the Stack data structure. Steps I followed: • Traverse the tokens array. • If the element is a number → push it onto the stack. • If it is an operator: Pop the top two elements (a and b) Perform the operation (a operator b) Push the result back into the stack • At the end, the stack contains the final result. ⏱ Time Complexity: O(n) — We process each token once 📦 Space Complexity: O(n) — Stack to store operands 💡 Key Learnings ✔ Understanding Reverse Polish Notation (Postfix Expression) ✔ Applying stack for expression evaluation ✔ Handling operator precedence implicitly using stack This problem connects DSA with compiler/interpreter concepts, which makes it even more interesting 🚀 Consistency continues — improving every day 💪 #100DaysOfCode #DSA #Stack #LeetCode #Java #ProblemSolving #CodingJourney #DeveloperJourney #Programming #SoftwareEngineering

Templates just got cleaner. ✨ Stop writing manual encoding logic in your components. Use the new URI pipes in ngx-transforms: <!-- Before --> <a [href]="sanitize(val)">Link</a> <!-- After --> <a [href]="val | encodeURIComponent">Link</a> Native performance, fully tree-shakeable.  GitHub: https://lnkd.in/dRYZts_V  #Angular #Coding #OpenSource

Have you ever spent hours debugging your code, only to find out it was a simple regex pattern issue? I've been there too. In our team, we once had a junior developer who was struggling to fix a regex pattern that wasn't matching the desired output. The core issue was that they didn't understand how regex anchors work. Regex anchors are used to match the start or end of a string, and they can save you hours of debugging time. A good rule of thumb is to always use anchors when you're sure about the position of the pattern in the string. However, a common pitfall for juniors is to misunderstand the difference between ^ and $ anchors. For example, ^ matches the start of a string, while $ matches the end. By using regex anchors correctly, you can avoid a lot of frustration and debugging time. So, the next time you're working with regex, remember to use anchors wisely. #programming #webdev #regex

⚙️ Spent 3 hours fixing asset names in UE5 today. Never again. Inherited a messy UE project? Forgotten to prefix assets as you go? 💡The Solution: I built a Python tool that handles the entire renaming process in one click. 🎯 What makes it different:  • Rules live in a Data Table (not hardcoded): anyone on the team can update prefixes without touching code  • Two-pass collision check: no silent overwrites or mid-rename crashes  • Dry run mode: preview every change before committing  • Skip folders, cancel safely anytime Built for solo devs, students, technical artists, and pipeline TDs who want BP_, SM_, T_ conventions enforced automatically. 🎨 Preview the tool and get the details here: https://lnkd.in/edyCPz3J #UnrealEngine5 #GameDevelopment #PythonScripting #TechnicalArt #GameTools

🚀 Day 28 / 128 – Coding Challenge Progress Today I worked on the classic "Square Root (x)" problem from LeetCode. 🔍 Problem Summary: Given a non-negative integer x, compute and return its square root rounded down to the nearest integer — without using built-in exponent functions. 💡 Approach I Used: I implemented a Binary Search solution to efficiently find the integer square root. Instead of checking every number, I narrowed down the answer by: Picking a middle value Comparing mid * mid with x Adjusting the search range accordingly ⚡ Why Binary Search? It reduces time complexity from O(n) to O(log n) — making the solution much faster and scalable. 🧠 Key Learning: This problem reinforced how powerful binary search is, even beyond sorted arrays — especially for mathematical computations. 📌 Progress: Day 28 complete, staying consistent and learning something new every day! #128DaysOfCode #CodingChallenge #LeetCode #JavaScript #ProblemSolving #BinarySearch #DeveloperJourney