Next Greater Element II in Circular Array

🚀 Day 73 of My Coding Challenge Today I solved the Absolute Permutation problem, which focuses on understanding permutations and applying logical patterns to construct valid sequences efficiently. 🔹 Problem Summary Given two integers n and k, we need to generate a permutation of numbers 1 to n such that for every position i: |P[i] - i| = k If no such permutation exists, we return -1. 💡 Key Insight If k = 0, the permutation is simply 1, 2, 3, ... , n. If k ≠ 0, then n must be divisible by (2 × k). We solve it by swapping numbers in blocks of size k, alternating between adding k and subtracting k. 📚 Concepts Practiced • Permutations • Mathematical pattern recognition • Greedy construction logic • Efficient array manipulation ⚡ Time Complexity: O(n) Consistency is the key to mastering problem solving. Every day of practice improves algorithmic thinking and strengthens coding skills. #Day73 #CodingChallenge #DataStructures #Algorithms #ProblemSolving #Programming #SoftwareDevelopment #LeetCode #DeveloperJourney

🚀 Day 4 of 100 Days LeetCode Challenge. Problem: Special Positions in a Binary Matrix Today’s problem focused on matrix traversal + counting logic—simple concept, but requires careful observation. 💡 Key Insight: A position (i, j) is special if: mat[i][j] == 1 All other elements in the same row and column are 0 🔍 Efficient Approach: Count number of 1’s in each row Count number of 1’s in each column A position is special only if: Row count = 1 Column count = 1 👉 This avoids unnecessary repeated checks and improves efficiency. 🔥 What I Learned Today: Preprocessing (row & column counts) simplifies problems Avoid brute force → think in terms of frequency/counting Clean logic > complex code 📈 Challenge Progress: Day 4/100 ✅ Staying consistent! LeetCode, Matrix Problem, Arrays, Counting Technique, DSA Practice, Coding Challenge, Problem Solving, Algorithm Thinking, Optimization #100DaysOfCode #LeetCode #DSA #CodingChallenge #Matrix #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 18/60 — LeetCode Discipline Problem Solved: Valid Parentheses (Revision) Difficulty: Easy Today’s session revisited one of the most classic stack-based problems — validating whether a sequence of brackets is correctly balanced. The key idea is simple yet powerful: whenever an opening bracket appears, it is pushed onto the stack, and when a closing bracket appears, it must correctly match the most recent opening bracket. Problems like this beautifully demonstrate how the stack data structure naturally models nested structures, making it ideal for tasks involving balanced expressions and ordered matching. 💡 Focus Areas: • Reinforced stack-based problem solving • Practiced bracket matching logic • Strengthened understanding of nested structures • Improved clean implementation of stack operations • Focused on writing simple and readable logic ⚡ Performance Highlight: Achieved ~87% runtime efficiency on submission. Even the most fundamental problems continue to sharpen the foundations of algorithmic thinking. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #Stack #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers

🚀 Day 6 of 100 Days LeetCode Challenge Problem: Check if Binary String Has at Most One Segment of Ones Today’s problem is all about pattern observation in strings—simple, but easy to overthink. 💡 Key Insight: The string should contain only one continuous block of '1's. 👉 That means: Once a 0 appears after a 1, There should be no more '1's later 🔍 Simplest Trick: Just check if the pattern "01" appears more than once OR even better → check if "10" appears followed by another "1" 💡 Cleaner approach: Traverse the string Count transitions from 1 → 0 If you ever see 1 again after that → ❌ Invalid 🔥 What I Learned Today: Many problems are just pattern validation Clean logic beats complex conditions Always try to reduce the problem to a simple rule 📈 Challenge Progress: Day 6/100 ✅ Consistency building strong! LeetCode, Strings, Pattern Recognition, Greedy, DSA Practice, Coding Challenge, Problem Solving, Algorithm Thinking, Programming #100DaysOfCode #LeetCode #DSA #CodingChallenge #Strings #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

HI CONNECTIONS I recently tackled LeetCode 120, a classic problem that perfectly demonstrates how to transform an exponential brute-force search into a linear-time Dynamic Programming solution. 🔍 The Challenge Given a triangle array, find the minimum path sum from top to bottom. For each step, you can move to the adjacent index of the row below. Example: From index i in the current row, you can move to index i or i + 1 in the next row. 🛠️ My Approach: Bottom-Up Dynamic Programming While a top-down approach (starting from the peak) is intuitive, a bottom-up approach is much cleaner because it avoids complex boundary checks at the edges of the triangle. Start at the Base: Begin with the last row of the triangle as your initial "minimum path" values. Move Upwards: For every node in the row above, the minimum path to the bottom is: Current Value + min(Left Child, Right Child) State Compression: Instead of a full 2D table, I used a 1D array (the size of the bottom row) to store and update the minimum sums in place. The Result: After reaching the top, the first element of the array contains the minimum path sum for the entire triangle. 📊 Efficiency Time Complexity: O(n^2) — Where n is the number of rows. we visit each element in the triangle exactly once. Space Complexity: O(n) — Using only a 1D array to store the bottom row's state. 💡 Key Takeaway The "Bottom-Up" mindset is a powerful tool in optimization. By starting at the destination and working back to the source, we can often simplify the logic and reduce the memory footprint of our algorithms. #LeetCode #DynamicProgramming #AlgorithmDesign #SoftwareEngineering #Optimization #ProblemSolving

Nothing sharpens problem-solving like a live coding contest under time pressure. This weekend, I competed in a LeetCode contest: • Solved 3 out of 4 problems • Completed them in under 30 minutes • Secured a Global Rank of 3588 Here’s a quick breakdown of the problems and my approach: 🧠 Problem 1 Find the first even integer that appears only once in the array. If none, return -1. Solution: Built a frequency map using unordered_map, then traversed the original array to check: Is the number even? Is its frequency exactly 1? Returned the first match. Time complexity: O(n) 🧠 Problem 2 Compute prefix GCD values (tracking max till index), then pair smallest and largest elements. Return the sum of GCDs of all pairs. Solution: Implemented optimized Euclidean GCD Tracked running maximum while building prefix array Sorted the result Paired smallest with largest Summed GCDs of each pair Required careful mathematical reasoning + greedy pairing strategy. 🧠 Problem 3 Equalize two arrays with minimum cost. Free swaps within array, cost = 1 for cross-array swap at same index. Solution: Counted frequencies in both arrays If combined frequency of any element was odd → return -1 Calculated imbalance Each cross swap fixes two mismatches Final cost = total imbalance / 2 Key insight: Think in terms of frequency balance rather than positions. These contests are a great reminder that strong DSA fundamentals directly improve structured thinking — something I use regularly while designing backend systems. How often do you practice timed problem-solving to stay sharp? #BackendDeveloper #SoftwareEngineer #Algorithms #DataStructures #LeetCode #Hiring

🚀 Ever wondered how to optimize your code with dynamic programming? Let's break it down! 🤔 Dynamic programming is a technique used to solve complex problems by breaking them down into simpler subproblems. By storing the results of subproblems, we can avoid redundant computations and improve the efficiency of our code. This is crucial for developers as it can significantly enhance the performance of algorithms, making them faster and more scalable. 👉 Here's a simple step-by-step breakdown: 1️⃣ Identify the problem and determine if it can be divided into subproblems. 2️⃣ Define a recursive function to solve each subproblem efficiently. 3️⃣ Store the results of subproblems in a data structure like an array or hashmap. 4️⃣ Write the base case to stop the recursion. 5️⃣ Implement the recursive function using memoization or tabulation. 🚨 Pro tip: Start with a brute-force solution first to understand the problem before optimizing with dynamic programming techniques. ❌ Common mistake to avoid: Forgetting to handle edge cases or not initializing the base cases correctly can lead to incorrect results. 🤔 What's your favorite dynamic programming problem to solve? Share below! ⬇️ 🌐 View my full portfolio and more dev resources at tharindunipun.lk 🚀 #DynamicProgramming #Algorithm #CodingTips #DeveloperCommunity #CodeOptimization #TechTalk #LearnToCode #ProblemSolving #DevLife #DataStructures #SoftwareEngineering

Day 40 on LeetCode — Longest Consecutive Sequence ✅ Today’s challenge was about finding the longest sequence of consecutive numbers in an unsorted array. 🔹 Approach Used in My Solution In my implementation, I first sorted the array, which makes consecutive numbers appear next to each other. After sorting, I traversed the array once to track the current streak of consecutive numbers. Key points in the logic: • Skip duplicates to avoid breaking the sequence • Increase the counter when the current number is exactly previous + 1 • Reset the counter when the sequence breaks and update the longest streak This approach keeps the implementation simple, readable, and effective. ⚡ Complexity: • Time Complexity: O(n log n) due to sorting • Space Complexity: O(1) (excluding sorting space) 💡 Key Takeaways: • Sorting can simplify many sequence detection problems • Careful handling of duplicates is important in consecutive sequence problems • Reinforces writing clean traversal logic after preprocessing #LeetCode #DSA #Algorithms #DataStructures #Arrays #Sorting #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 14 of 100 Days LeetCode Challenge Problem: The K-th Lexicographical String of All Happy Strings of Length n Today’s problem is a perfect blend of Backtracking + Lexicographical Ordering 🔥 💡 Key Insight: A happy string: Uses only 'a', 'b', 'c' No two adjacent characters are the same 👉 Instead of generating all strings blindly, we: Build valid strings using backtracking Maintain lexicographical order naturally 🔍 Core Approach: 1️⃣ Backtracking (DFS) Start building string character by character At each step: Choose from 'a', 'b', 'c' Skip if same as previous character 2️⃣ Lexicographical Order Always try characters in order: 'a' → 'b' → 'c' 3️⃣ Stop Early Once we reach the k-th string, stop recursion 👉 If total strings < k → return "" 🔥 What I Learned Today: Backtracking is powerful for constraint-based generation Ordering decisions early helps avoid extra sorting Early stopping = major optimization 📈 Challenge Progress: Day 14/100 ✅ 2 weeks strong! LeetCode, Backtracking, Recursion, Lexicographical Order, Strings, DFS, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Backtracking #Recursion #Strings #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

Practicing Dynamic Programming Through a one of the most popular Problem While practicing problems on LeetCode, I recently worked on the Climbing Stairs problem. At first glance, the problem is simple: You can climb either 1 step or 2 steps at a time. How many distinct ways can you reach the top of n stairs? I started with the most natural idea --> recursion. The recurrence relation is straightforward: f(n) = f(n-1) + f(n-2) Meaning, to reach step n, you must come either from step n-1 or step n-2. But while analyzing the recursion, I noticed something important: many subproblems were being solved repeatedly(it is known as overlapping subproblem). For example, f(3) or f(2) gets calculated multiple times inside the recursion tree. That observation led me to explore Dynamic Programming approaches. I ended up implementing the solution in four different ways: 1. Recursion (Brute Force) Time Complexity: O(2^n) Space Complexity: O(n) (recursion stack) 2. Memoization (Top-Down Dynamic Programming) Time Complexity: O(n) Space Complexity: O(n) 3. Tabulation (Bottom-Up Dynamic Programming) Time Complexity: O(n) Space Complexity: O(n) 4. Space Optimized Dynamic Programming Time Complexity: O(n) Space Complexity: O(1) Since each state only depends on the previous two values, the DP array can be reduced to just two variables. Interestingly, the pattern behind this problem follows the Fibonacci sequence. Problems like this are a great reminder that sometimes the goal is not just to solve the problem, but to understand how different approaches affect efficiency. Still learning, still exploring. If you have suggestions or improvements to this approach, I’d love to hear them. #DynamicProgramming #Algorithms #DSA #LeetCode #Cpp #ProblemSolving