Day 37: Counting Valid Permutations with LeetCode Challenge

🗓 Day 58 / 100 – #100DaysOfLeetCode 📌 Problem 66: Plus One Today’s problem was a simple but important exercise in array manipulation and edge-case handling. Given an integer represented as an array of digits, the task was to add one to the number and return the resulting digits. 🧠 My Approach: Started from the last digit and simulated the addition of 1. If the digit was less than 9, incremented it and finished. If the digit was 9, set it to 0 and carried over to the next digit. Continued this process until the carry was resolved. Handled the special case where all digits were 9 (e.g., [9,9,9]) by adding a leading 1. This approach closely mirrors how addition works in real life. 💡 Key Learning: This problem reinforced: ✔ how to simulate arithmetic operations using arrays ✔ careful handling of carry propagation ✔ the importance of edge cases, even in easy problems A good reminder that mastering fundamentals is key to solving harder problems efficiently 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #Arrays #Simulation #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

🗓 Day 47 / 100 – #100DaysOfLeetCode 📌 Problem 3783: Mirror Distance of an Integer Today’s problem was a straightforward yet satisfying one that focused on digit manipulation and basic number operations. The task was to compute the mirror distance of an integer, defined as the absolute difference between the number and its digit-reversed form. 🧠 My Approach: Observed that if the number has only a single digit, reversing it doesn’t change anything, so the mirror distance is 0. For multi-digit numbers: Converted the number to a string. Reversed the string and converted it back to an integer (automatically handling leading zeros). Calculated the absolute difference between the original number and its reverse. This results in a clean and efficient solution with minimal logic. 💡 Key Learning: This problem reinforced that: ✔ String conversion is often the simplest way to reverse digits ✔ Edge cases (like single-digit numbers or leading zeros) matter ✔ Not every problem needs complex logic — clarity is key A quick win, but an important reminder to always handle edge cases carefully 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #StringManipulation #MathInCoding #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

🗓 Day 61 / 100 – #100DaysOfLeetCode 📌 Problem 1390: Four Divisors Today’s problem combined number theory fundamentals with careful iteration. The task was to scan through an array and compute the sum of divisors only for those numbers that have exactly four distinct divisors. 🧠 My Approach: For each number in the array: Iterated from 1 to √x to find divisor pairs efficiently. Whenever i divides x, added both i and x / i to a set to ensure uniqueness. Accumulated the sum of these divisors while tracking how many unique divisors were found. After processing a number, checked: If it had exactly 4 divisors, added its divisor sum to the final answer. Otherwise, ignored it. Using the square-root optimization keeps the solution efficient even for large values. 💡 Key Learning: This problem reinforced: ✔ efficient divisor enumeration using √n optimization ✔ using sets to avoid duplicate divisors ✔ applying number theory concepts in coding problems ✔ filtering results based on strict conditions A solid reminder that understanding divisor patterns can simplify many math-based problems in DSA 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #Math #NumberTheory #Divisors #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

🗓 Day 56 / 100 – #100DaysOfLeetCode 📌 Problem 840: Magic Squares In Grid Today’s problem was about identifying 3×3 magic squares inside a grid. A magic square must contain the numbers 1 to 9 exactly once, and the sum of each row, column, and both diagonals must be the same. 🧠 My Approach: Iterated over every possible 3×3 subgrid in the matrix. For each subgrid: Verified that all numbers are in the range 1–9 and are distinct. Checked whether the sums of: all rows all columns both diagonals are equal. Counted the subgrid if it satisfied all magic square conditions. Since the grid size is small, this direct validation approach works efficiently. 💡 Key Learning: This problem reinforced: ✔ careful constraint validation before deeper checks ✔ breaking a complex condition into smaller, verifiable rules ✔ systematic scanning of submatrices in a grid It’s a great example of how attention to detail is crucial in grid-based problems. Another satisfying problem wrapped up 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #Matrix #GridProblems #Simulation #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

🗓 Day 43 / 100 – #100DaysOfLeetCode 📌 Problem 1266: Minimum Time Visiting All Points Today’s problem was a nice geometry-based challenge that required translating movement rules into a simple mathematical insight. You’re allowed to move vertically, horizontally, or diagonally in one unit of time, and the task is to compute the minimum time needed to visit all given points in order. 🧠 My Approach: Observed that moving diagonally allows reducing both x and y distances at the same time. For two consecutive points (x1, y1) and (x2, y2): This works because diagonal moves cover one unit in both directions simultaneously. Iterated through all consecutive point pairs, summing this value to get the total minimum time. 💡 Key Learning: This problem reinforced how recognizing movement constraints can lead to a very clean formula. Instead of simulating every move, understanding the geometry lets us compute the answer directly and efficiently. A great reminder that many problems become simple once the right observation clicks 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #Geometry #MathInCoding #Greedy #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

🗓 Day 63 / 100 – #100DaysOfLeetCode 📌 Problem 1161: Maximum Level Sum of a Binary Tree Today’s problem focused on tree traversal and level-wise aggregation. The task was to find the level in a binary tree that has the maximum sum of node values, with levels numbered starting from 1. 🧠 My Approach: Used Breadth-First Search (BFS) to traverse the tree level by level. For each level: Calculated the sum of all node values at that level. Compared it with the maximum sum seen so far. Kept track of: the current level number the level with the maximum sum Returned the smallest level number in case of a tie, as required. This level-order traversal makes the solution both intuitive and efficient. 💡 Key Learning: This problem reinforced: ✔ how BFS naturally fits level-based tree problems ✔ careful tracking of level indices during traversal ✔ handling ties correctly based on problem constraints Tree problems often become much simpler once the right traversal strategy is chosen. Another solid step forward in mastering binary tree patterns 🌳🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #BinaryTree #BFS #TreeTraversal #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

Just wrapped up Day 4 of my #PythonLearning journey! Today was all about Conditional Statements – the backbone of decision-making in programming. Key takeaways: if, elif, and else – the essential building blocks of logical flow Using comparison operators (==, >, <, etc.) to evaluate conditions Combining conditions with logical operators (and, or, not) Practical applications from basic number checks to advanced logic like leap year detection and triangle validation Projects I worked on: Positive/Negative/Zero checker Age group classifier Password authentication system Student grading logic Temperature range interpreter Divisibility tester Question for my network: What’s a real-world problem you’ve solved using conditional logic in Python? Let’s share ideas! 💬 #Python #ConditionalStatements #CodingLogic #Programming #LearnToCode #Developer #LogicBuilding #PythonBasics

Day 22 of #30DaysOfCode with Educative Challenge: Next Permutation (Medium) Core Idea: Generate the immediate next lexicographic ordering from a sequence. The Pattern: Pivot-swap-reverse - Find the longest non-increasing suffix. - Swap the pivot with the next larger element to its right. - Reverse the suffix for the smallest possible tail. Why It Works Here: The right-to-left scan identifies the first position where a smaller next permutation exists. Swapping with the smallest larger element and sorting the tail ascending gives exactly the next ordering without skipping. Production Lesson: This core technique is essential for deterministic iteration over permutations in scheduling, configuration search, and test generation, as it avoids full rebuilds when generating ordered state transitions. Edge Worth Remembering: A fully non-increasing input represents the last permutation; reversing it returns the first (smallest) ordering. #Educative #Python #SoftwareEngineering #ContinuousLearning #ProblemSolving

✨ Today I solved LeetCode 1411 — Number of Ways to Paint N×3 Grid and learned something really powerful: 👉 Sometimes the key is not solving cell-by-cell… 💡 Instead, think row-by-row and identify repeating patterns. In this problem, every row of the grid can only exist in two valid states: 🔹 All 3 colors different 🔹 Exactly 2 colors used Once you notice this, the solution becomes a simple pattern-based DP — no complex recursion, no overthinking. 🚀 Key takeaway for me: DSA is less about remembering formulas and more about recognizing patterns. If you're learning DSA: ✅ Focus on “why this works” — not just the code ✅ Break problems into simple states ✅ Look for relationships between steps Small progress. Daily consistency. That’s the game ❤️ #leetcode #dsa #codingjourney #python #problemsolving #learning

🗓 Day 41 / 100 – #100DaysOfLeetCode 📌 Problem 2110: Number of Smooth Descent Periods of a Stock Today’s problem focused on identifying and counting smooth descent periods in a stock’s price history. A smooth descent period is a contiguous segment where each day’s price decreases by exactly 1 compared to the previous day. Even a single day counts as a valid period. 🧠 My Approach: Observed that the array can be broken into maximal descending segments where prices[i] = prices[i-1] - 1. Traversed the array while maintaining the current length of a smooth descent sequence. Whenever the smooth descent condition breaks, reset the length to 1. For each position, added the current length to the answer. This works because a descent segment of length k contributes: 1+2+3+⋯+k smooth descent periods in total. 💡 Key Learning: This problem reinforced a powerful counting technique: ✔ Break the array into valid segments ✔ Count subarrays using incremental accumulation ✔ Avoid nested loops by leveraging mathematical patterns It’s a great example of turning what looks like a subarray-counting problem into a simple single-pass solution. Another solid daily problem completed 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #SlidingWindow #TwoPointers #Arrays #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning