uppala manish’s Post

🗓 Day 13 / 100 – #100DaysOfLeetCode 📌 Problem 1513: Number of Substrings With Only 1s The task was to count how many substrings in a binary string consist only of consecutive 1s. 🧠 My Approach: Identified continuous blocks of '1' in the string. For each block of length k, calculated the number of valid substrings using the formula: k × (k + 1) / 2 Summed these counts across all segments of consecutive 1s. This avoids checking all substrings individually and keeps the solution efficient and clean. 💡 Key Learning: This problem reinforces the value of recognizing sequences and using mathematical formulas to simplify substring counting. It’s a reminder that many problems can be solved much faster when we look for structure instead of brute force. One more problem, one more pattern learned 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #Strings #Algorithms #MathInCoding #LogicBuilding #DataStructures #DSA #CompetitiveProgramming #CodingJourney #SoftwareEngineering #LearningInPublic #DeveloperJourney #TechStudent #CareerGrowth #CodeEveryday #CodingCommunity #KeepLearning

🗓 Day 5 / 100 – #100DaysOfLeetCode 📌 Problem 2006: Count Number of Pairs With Absolute Difference K The task was to count the number of pairs (i, j) in an array such that the absolute difference between the two elements equals k. 🧠 My Approach: Used a hash map (Counter) to store the frequency of each element. For every number, checked how many times num + k (or equivalently num - k) appears. Accumulated the count efficiently without double-counting pairs. ⏱ Time Complexity: O(n) 💾 Space Complexity: O(n) 💡 Key Learning: This problem helped strengthen my grasp of hash maps and frequency-based counting — a powerful pattern that simplifies many pair-count and difference problems. Every problem adds clarity and confidence — one step closer to mastery 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #HashMap #DataStructures #Algorithms #DSA #CodingJourney #CodingChallenge #CodeEveryday #CompetitiveProgramming #SoftwareEngineering #LearningInPublic #DeveloperJourney #TechStudent #CodingCommunity #CareerGrowth #KeepLearning #Programmer #LogicBuilding #TechCareer

🚀 Day 4/100 — Cracked LeetCode 1611: Minimum One Bit Operations to Make Integers Zero 🔥 Today’s challenge was a deep dive into bit manipulation and recursion. LeetCode 1611 looked deceptively simple—but beneath the surface, it’s a clever twist on Gray code transformations. 🔍 Problem Summary Transform an integer n into 0 using two constrained bit-flipping operations. The trick? You can only flip the rightmost bit, or flip the i-th bit if the (i-1)th is 1 and all lower bits are 0. 🧠 Key Insight This problem maps beautifully to recursive Gray code logic. For any number n, we recursively reduce it by flipping the highest set bit and subtracting the operations needed for the remainder. 📈 What I Learned Bitwise recursion can be elegant and powerful. Understanding binary patterns unlocks optimization. Python’s bit_length() is a hidden gem for bit-level logic. 🔧 Next Steps I’ll be documenting more of these insights as part of my 100-day challenge. If you’re into algorithmic puzzles or want to collaborate on clean, modular solutions—let’s connect! #100DaysOfCode #LeetCode #Python #BitManipulation #GrayCode #CodingChallenge #TechJourney #ScarBuilds

🧠 Day 38 / 100 – Recursion: Factorial of a Number (LeetCode-#509) Today’s challenge was all about recursion — one of the most elegant concepts in programming. I revisited the Factorial problem, which beautifully demonstrates how a big problem can be broken into smaller subproblems. The idea is simple: 👉 The factorial of n is n * factorial(n-1) until n becomes 1. But the real challenge lies in understanding the flow of recursive calls and how the call stack unwinds to give the final result. This problem reminded me that recursion isn’t just about repeating a function — it’s about trusting the process and thinking in terms of smaller steps to solve complex problems. 🔍 Key Learnings Every recursive function must have a base case to prevent infinite loops. The call stack stores each recursive call until it’s resolved. Recursion is a natural fit for problems that can be divided into smaller, similar subproblems. 💭 Thought of the Day Recursion teaches patience and structure. Sometimes, you need to trust that solving the smaller version of a problem will help you conquer the big one — both in code and in life 💫. 🔗 Reference Problem:https://lnkd.in/g3yNGDbJ #100DaysOfCode #Day38 #LeetCode #Python #Recursion #Factorial #ProblemSolving #CodingChallenge #Algorithms #ProgrammingMindset #DataStructures #CleanCode #LearnByDoing #TechGrowth #PythonProgramming

🗓 Day 4 / 100 – #100DaysOfLeetCode 📌 Problem 728: Self Dividing Numbers The task was to find all numbers in a given range that are self-dividing — i.e., numbers that are divisible by each of their digits and contain no zero. 🧠 My Approach: Iterated through the range of numbers. Checked each digit of a number to ensure: It’s non-zero. The original number is divisible by that digit. Collected all numbers that satisfied both conditions. ⏱ Time Complexity: O(n × d) — where d is the number of digits in each number. 💾 Space Complexity: O(1) 💡 Key Learning: This problem strengthened my understanding of digit-wise iteration and conditional logic — simple concepts that are essential for handling number-based and math-intensive problems efficiently. Small problems like these build the habit of writing clean, readable, and logical code — one step closer each day 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #LogicBuilding #Programming #DataStructures #Algorithms #DSA #CodingJourney #CodingChallenge #CodeEveryday #LearningInPublic #CompetitiveProgramming #DeveloperJourney #TechStudent #CareerGrowth #CodingCommunity #KeepLearning

💻 2011: Final Value of Variable After Performing Operations Today’s challenge was a simple yet interesting warm up problem that tests how efficiently we can track changes in a variable through a series of operations. 🧠 Concept: We start with X = 0, and perform operations like ++X, X++, --X, and X--. Each increment or decrement modifies X by 1, the task is to return the final value after performing all operations. ⚙️ Approach: - A straightforward solution: - Iterate through all operations. - Increment count by 1 for ++ or X++. - Decrement count by 1 for -- or X--. - Return the final count. Even though it’s an easy problem, it’s a great reminder that clarity and precision matter, small details in logic can make a big difference. #LeetCode #Python #CodingPractice #ProblemSolving #100DaysOfCode

🗓 Day 14 / 100 – #100DaysOfLeetCode 📌 Problem 1437: Check If All 1’s Are at Least K Places Away The goal was to determine whether every pair of consecutive 1s in the array is separated by at least k zeros. 🧠 My Approach: Traversed the array while tracking the index of the previous 1. On encountering a new 1, checked the distance from the last one. If the gap was smaller than k, the condition failed instantly. This single-pass logic keeps the solution efficient and clean. 💡 Key Learning: This problem reinforced the importance of index tracking and using simple arithmetic comparisons to validate structural constraints. It’s a great reminder that not all problems require heavy algorithms — sometimes, clarity and careful traversal are enough for an optimal solution. Small steps forward build strong reasoning over time 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #LogicBuilding #Arrays #Algorithms #DataStructures #DSA #CompetitiveProgramming #CodingJourney #SoftwareEngineering #LearningInPublic #DeveloperJourney #TechStudent #CareerGrowth #CodeEveryday #CodingCommunity #KeepLearning #Programming #TechCareer

🚀 LeetCode #1526: Minimum Number of Increments on Subarrays to Form a Target Array Today I tackled an interesting Greedy Algorithm problem that really tests your ability to spot patterns and simplify complex logic. 🧩 Problem Brief: We start with an array of zeros and can increment any subarray by 1 in one operation. The goal is to form the target array using the minimum number of operations. 💡 Key Insight: Instead of simulating every operation, focus on how much each element increases compared to the previous one; each increase represents new operations needed. ⚙️ Formula: operations = target[0] + Σ(max(0, target[i] - target[i-1])) 🧠 Complexity: Time: O(n) Space: O(1) 🎯 Takeaway: Hard problems often become simple once you recognize the pattern behind the process. #LeetCode #Python #DSA #Coding #ProblemSolving #GreedyAlgorithm #LearningEveryday

Day 31 / 100 – Add Strings (LeetCode #415) Today’s challenge was all about simulating manual addition without using any built-in integer conversions. Given two numbers as strings, the task was to return their sum — also as a string. This problem really emphasized the importance of breaking problems into small, logical steps rather than relying on shortcuts. 🔍 Key Learnings Recreated the digit-by-digit addition process using ASCII values. Practiced handling carry-over efficiently while iterating backward. Strengthened my understanding of string manipulation and arithmetic logic. 💭 Thought of the Day True problem-solving isn’t about using built-ins — it’s about understanding how things work underneath. Today reminded me that mastery grows when we rebuild the basics from scratch, not when we avoid them. 🔗 Problem Link: https://lnkd.in/gHMt9vj9 #100DaysOfCode #Day31 #LeetCode #Python #ProblemSolving #StringManipulation #Algorithms #DataStructures #CodingChallenge #CodeEveryday #TechGrowth #LearningJourney

🗓 Day 12 / 100 – #100DaysOfLeetCode 📌Problem 3234: Count the Number of Substrings With Dominant Ones A substring is considered to have dominant ones if: Number of 1s ≥ (Number of 0s)² The challenge was to count how many substrings in the binary string satisfy this condition. 🧠 My Approach: Iterated through substrings while tracking zero count and one count. Used the condition ones ≥ zeros² to determine validity. Applied early stopping when zeros became large, since the condition becomes much harder to meet as zeros grow. This pruning helped avoid unnecessary checks and made the approach more efficient. 💡 Key Learning: This problem highlights how mathematical constraints can simplify substring evaluation. Understanding how zeros grow quadratically in the condition helped shape a smarter, more optimized checking approach rather than brute-force enumeration. A great exercise in reasoning about substring properties and designing early-exit logic. Consistent effort… consistent progress 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #BinaryStrings #StringAlgorithms #Optimization #LogicBuilding #DataStructures #Algorithms #DSA #CompetitiveProgramming #CodingJourney #SoftwareEngineering #LearningInPublic #TechStudent #DeveloperJourney #CareerGrowth #CodeEveryday #CodingCommunity #KeepLearning #Programmer