Shubham Maurya’s Post

🚀 DSA Challenge – Day 91 Problem: K-th Permutation Sequence 🔢✨ This problem was a brilliant deep dive into mathematical reasoning and combinatorial logic, showing how understanding factorial patterns can help us find the k-th permutation without generating all permutations. 🧠 Problem Summary: Given n and k, we must return the k-th permutation sequence of numbers [1, 2, 3, …, n]. Instead of generating all n! permutations, the challenge is to find it directly and efficiently. ⚙️ My Approach: 1️⃣ Compute (n - 1)! to understand how many permutations start with each digit. 2️⃣ Use integer division (k // fact) to determine which digit should occupy the current position. 3️⃣ Update k to represent the position within the smaller block using k = k % fact. 4️⃣ Repeat the process while updating factorial and removing used digits. This way, each step mathematically determines the next digit of the permutation — no brute force, no recursion. 📈 Complexity: Time: O(n²) → Due to list operations and factorial adjustments. Space: O(n) → For storing the available digits. ✨ Key Takeaway: You don’t always need to generate all possibilities — sometimes, understanding the mathematical structure behind permutations can lead straight to the answer. 💡 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Mathematics #FactorialLogic #Permutation #Combinatorics #Algorithms #Python #Optimization #EfficientCode #InterviewPrep #TechCommunity #LearningByBuilding #CodeEveryday

📊 LeetCode Challenge: Median of Two Sorted Arrays Today’s problem was one of the most elegant and widely discussed challenges in algorithmic problem solving — finding the median of two sorted arrays. 💡 Problem Summary You’re given two sorted arrays, nums1 and nums2, and you need to find the median of the combined sorted array. The catch? You must do it in O(log(m + n)) time — meaning, no simple merging allowed 🚫 🧠 The Intuition At its heart, this is a binary search problem disguised as a math puzzle. The trick is to find a partition between the two arrays such that: Every element on the left side of the partition is less than or equal to every element on the right side. Once that partition is found — the median lies either in the middle element(s) of these partitions. 🧩 Why It’s Interesting It transforms a two-array problem into a search problem on one array. It’s a brilliant example of reducing complexity through symmetry. And it highlights how binary search can be used far beyond just finding numbers. ⏱️ Complexity Time: O(log(min(m, n))) Space: O(1) 🌱 Key Takeaway This problem reminded me that powerful solutions often come from rethinking the approach, not just optimizing the code. Sometimes, stepping back and seeing the symmetry in a problem can simplify everything. #LeetCode #DSA #ProblemSolving #BinarySearch #Algorithms #CodingChallenge #Learning

🚀 Want to level up as a programmer? Start with these 5 powerful algorithms! 💻🔥 ⿡ Sorting Algorithms – The secret to organizing and speeding up data (think QuickSort & MergeSort). ⿢ Searching Algorithms – Find anything instantly (Binary Search, Linear Search). ⿣ Recursion – The art of solving complex problems step by step. ⿤ Dynamic Programming – Work smarter, not harder — reuse past results! ⿥ Graph Algorithms – Decode networks, maps & connections (Dijkstra’s, BFS, DFS). 💡 Every coder should master these to crack interviews, optimize code & think like a pro developer! 📌 Save this for your next coding grind session. #programminglife #codingtips #algorithm #learncoding #techskills #datastructures #developerlife 

🧠 DSA Algorithms – Theory, Explanation & Code Examples (Complete Guide) 🚀 Mastering Data Structures and Algorithms (DSA) is the key to becoming an efficient and confident problem solver. Whether you’re preparing for FAANG interviews or aiming to improve your coding logic, understanding the theory behind algorithms along with their code implementations will give you a solid edge. 📘 What You’ll Learn: ✅ Algorithm Basics: Time & Space Complexity, Big O Notation ✅ Sorting Algorithms: Bubble, Selection, Insertion, Merge, Quick, Heap Sort – with code ✅ Searching Algorithms: Linear & Binary Search – logic and efficiency ✅ Recursion & Backtracking: Real-world coding examples ✅ Greedy & Dynamic Programming: Optimization techniques with explanations ✅ Graph Algorithms: BFS, DFS, Dijkstra, Kruskal, Prim’s ✅ Advanced Topics: Divide & Conquer, Sliding Window, Two Pointers, Kadane’s Algorithm 💡 Pro Tip: Don’t just memorize — focus on why an algorithm works and when to use it. Combine theory with consistent practice on platforms like LeetCode, GeeksforGeeks, and CodeStudio. 🔥 Strengthen your algorithmic thinking and write optimized, clean, and scalable code! #DSA #Algorithms #DataStructures #CodingInterview #ProblemSolving #LeetCode #DynamicProgramming #Sorting #Searching #GraphAlgorithms #Programming #TechCareer #InterviewPreparation

🚀 DSA Progress – Day 121 ✅ Problem #2147: Number of Ways to Divide a Long Corridor 🧠 Difficulty: Hard | Topics: Greedy, Strings, Combinatorics, Math 🔍 Approach: Today’s problem was a beautiful mix of counting + observation. The goal is to determine how many different ways you can place dividers in a corridor so that every section has exactly 2 seats (S). Here’s how I approached it: Step 1 (Identify Seats): Scan the corridor and record positions of every 'S'. If the number of seats is odd or zero → return 0 because you cannot form valid pairs. Step 2 (Form Seat Pairs): Seats must form natural pairs: (S1,S2), (S3,S4), (S5,S6), … Each pair will form one complete valid section. Step 3 (Count Gaps Between Pairs): Between every two consecutive pairs, we look at the plants (P) in between. These plants create possible divider positions. For example: If the gap between pairs is k, then there are k valid places to put a divider. We multiply all such gaps to get total ways. Step 4 (Modulo Multiplication): Result is taken modulo 1e9+7 to prevent overflow. This approach converts string processing into a clean combinatorial multiplication problem. 🕒 Time Complexity: O(n) — single pass for seats + gap calculation 💾 Space Complexity: O(k) — storing seat positions 📁 File: https://lnkd.in/gwmdGmTT 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem reinforced a powerful insight: 👉 When constraints group elements naturally (here: exactly 2 seats per section), the spaces between the groups often define the combinatorial answer. Counting gaps instead of simulating partitions made the solution elegant and efficient. Understanding how structure + combinatorics work together is super useful for tricky string problems. ✅ Day 121 complete — turned a corridor of chaos into mathematical order! 🪄🚪🧮✨ #LeetCode #DSA #Python #Strings #Combinatorics #Greedy #Math #DailyCoding #InterviewPrep #GitHubJourney

🚀 DSA Progress – Day 118 ✅ Problem #2654: Minimum Number of Operations to Make All Array Elements Equal to 1 🧠 Difficulty: Medium | Topics: Array, Math, GCD 🔍 Approach: Solved using mathematical logic + GCD (Greatest Common Divisor) to find the minimum number of steps required to make every element equal to 1. Step 1 (Count existing 1s): If there are already some 1s in the array, each of them can help convert others to 1. Hence, the answer is simply n - count1. Step 2 (Find first possible 1): If no 1 exists, we search for the smallest subarray whose GCD becomes 1. This is done by checking all subarrays and computing running GCDs. Once GCD = 1, that subarray length gives the number of steps needed to create the first 1. Step 3 (Total operations): After we have one 1, it takes (n - 1) more operations to make the remaining elements equal to 1. Thus, total operations = steps_to_make_first_1 + (n - 1). Step 4 (Impossible case): If no subarray’s GCD ever becomes 1, return -1. 🕒 Time Complexity: O(n²) — in the worst case, we check all subarrays. 💾 Space Complexity: O(1) — only constant extra space is used. 📁 File: https://lnkd.in/g4P7V_wH 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem taught me how mathematical reasoning using GCD properties can simplify complex array operations. It reinforced the concept that once you can generate a single 1, the rest becomes straightforward through repeated operations. Also learned how to blend number theory + optimization effectively in algorithmic thinking. ✅ Day 118 complete — turned a chaotic array into perfect harmony, one GCD at a time! 🎯✨ #LeetCode #DSA #Python #Math #GCD #Arrays #ProblemSolving #DailyCoding #InterviewPrep #GitHubJourney

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞: 2654. 𝐌𝐢𝐧𝐢𝐦𝐮𝐦 𝐍𝐮𝐦𝐛𝐞𝐫 𝐨𝐟 𝐎𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 𝐭𝐨 𝐌𝐚𝐤𝐞 𝐀𝐥𝐥 𝐀𝐫𝐫𝐚𝐲 𝐄𝐥𝐞𝐦𝐞𝐧𝐭𝐬 𝐄𝐪𝐮𝐚𝐥 𝐭𝐨 1. This problem was an excellent application of mathematical reasoning through the Euclidean Algorithm (GCD). It helped me appreciate how fundamental math concepts can simplify complex algorithmic logic and lead to optimized solutions. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐮𝐦𝐦𝐚𝐫𝐲: We are given an array of positive integers. In one operation, we can select an index i and replace either nums[i] or nums[i+1] with their GCD value. The task is to find the minimum number of operations required to make all elements equal to 1, or return -1 if it is impossible. 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Checked if the array already contains any element equal to 1. If yes, the minimum operations equal the number of elements that are not 1. If not, used a nested loop to find the shortest subarray whose GCD becomes 1 using the Euclidean Algorithm. Once such a subarray is found, it can be made 1 in (subarray length - 1) operations. The total number of operations is calculated as (subarray length - 1) + (n - 1), representing the steps to convert the rest of the array to 1. Added an early break once GCD reaches 1 for better performance. 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 𝐀𝐧𝐚𝐥𝐲𝐬𝐢𝐬: Time Complexity: O(n² * log(max(nums))) Space Complexity: O(1) 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬: Reinforced the use of the Euclidean Algorithm and recursion for GCD calculations. Understood the role of early exits in improving nested loop efficiency. Observed how mathematical insight directly enhances algorithmic problem-solving. This marks my first post in my LeetCode Daily Challenge journey. I plan to continue sharing my learnings and reasoning from each daily challenge to stay consistent and deepen my problem-solving approach. #LeetCode #DSA #Java #ProblemSolving #CodingPractice #LearningEveryday #Consistency #Algorithms #100DaysOfCode

#Day25 of My #100DaysCodingChallenge 🚀Today’s focus was on string processing and logical evaluation — tackling problems that strengthen both algorithmic thinking and text manipulation. 🔹 Problem 1: Valid Palindrome Approach: First, I removed all non-alphanumeric characters using regex and converted the string to lowercase. Then, I used a two-pointer approach (one from start, one from end) to check if the cleaned string reads the same backward and forward. ⏳ Time Complexity: O(n) 📦 Space Complexity: O(n) (due to the cleaned string) 🔹 Problem 2: Compare Vowels and Consonants (C++) Approach: Iterated through each character, counting vowels and consonants using a predefined set of vowel characters. Compared counts to print: “Yes” → if vowels > consonants “No” → if consonants > vowels “Same” → if counts are equal ⏳ Time Complexity: O(n) 📦 Space Complexity: O(1) ✨ Takeaway: String-based problems refine attention to detail, pattern recognition, and efficient pointer usage — foundational for text analytics and parsing systems. Grateful to Abhishek Kumar Sir and K.R. Mangalam University for their continued mentorship 🙌. #100DaysOfCode #DSA #ProblemSolving #StringManipulation #LeetCode #CodingChallenge #KRmangalamUniversity #Algorithms #DataStructures

⚙️ Day 72 of #100DaysOfCode ⚙️ 💡 Problem: GCD of Odd and Even Sums – LeetCode ✨ Approach: Calculated the sum of the first n odd and even numbers separately, then determined their GCD through iterative checking. A neat blend of arithmetic patterns and number theory logic! 🔢 📊 Complexity Analysis: Time Complexity: O(n)** — summing and iterating up to the limit Space Complexity: O(1)** — constant auxiliary space ✅ Runtime: 575 ms ✅ Memory: 42.79 MB 🔑 Key Insight: Even the simplest mathematical patterns can reveal deep logic — coding is where math meets creativity! ✨ #LeetCode #100DaysOfCode #ProblemSolving #DSA #NumberTheory #LogicBuilding #AlgorithmDesign #ProgrammingChallenge #Efficiency #CodeJourney #DeveloperGrowth #CodingDaily

🚀 Solving "Set Matrix Zeroes" — A Clean Way to Think About It Today I tackled one of those deceptively simple but conceptually deep problems on LeetCode: Set Matrix Zeroes (Problem #73). 🧩 The Challenge: Given an m x n matrix, if any element is 0, set its entire row and column to 0 — and do it in place (no extra matrix allowed). At first, it sounds easy... until you realize that updating zeros immediately can cause a chain reaction of incorrect updates. 🧠 My Approach: I explored two different strategies 👇 1️⃣ Using Extra Space (Intuitive) Scan the matrix, record which rows and columns contain zeroes. In a second pass, set those rows and columns to zero. ✅ Easy to understand ⚠️ Space complexity = O(m + n) 2️⃣ Optimized In-place (Constant Space) Use the first row and first column as markers. When a zero is found, mark its row and column by setting the first cell in that row and column to 0. In a second pass, use those markers to update the matrix. ✅ Time = O(m × n) ✅ Space = O(1) 💡 What I Learned The key to in-place matrix problems is preserving state while updating. Using the matrix itself as a storage structure can reduce space without losing clarity. Sometimes the hard part isn’t coding — it’s finding a way to avoid overwriting useful information. 🧩 Pattern Recognized: “In-place grid modification using marker rows and columns.” This pattern also appears in problems like Game of Life, Rotate Image, and Flood Fill. 💬 Question for my network: What’s your favorite trick for solving in-place matrix problems efficiently? #LeetCode #Python #DataStructures #Algorithms #CodingChallenge #ProblemSolving #CSstudent #TechJourney #TwoPointers #MatrixManipulation