Mastering Debugging Skills on Day 13 of #100DaysOfCode

Hey Uplifters! 👋 Problem of the Day (09-11-2025) 2169 – Count Operations to Obtain Zero Problem in short: • You’re given two non-negative integers num1 and num2. • In one operation, if num1 >= num2, subtract num2 from num1, otherwise subtract num1 from num2. • You need to find how many operations it takes until either of them becomes zero. 💡 Intuition: • Instead of performing repeated subtractions one by one, we can simulate the process more efficiently by using division - counting how many times the smaller number fits into the larger one each time. • This optimizes the simulation and reduces unnecessary steps while still giving the correct count of operations. 🧩 Approach: • While both numbers are non-zero: • Ensure the larger number is always num1(Or check which is larger and do the division accordingly). • Count how many times the smaller number fits into the larger (num1 / num2). • Subtract the equivalent total and add that count to the result. • Continue until one of them becomes zero. Leetcode Solution: https://lnkd.in/gTiWX6ub Let’s keep learning and growing together! 🌱 #LeetCode #POTD #ProblemOfTheDay #DailyChallenge #CodingChallenge #DataStructures #Algorithms #ProblemSolving #Java #Python #CPP #LearnToCode #TechCommunity #SoftwareDevelopment #Programming #Uplifters

🚀 DSA Progress – Day 94 ✅ Problem #338: Counting Bits 🧠 Difficulty: Easy | Topics: Bit Manipulation, Dynamic Programming 🔍 Approach: Implemented a Dynamic Programming approach to efficiently count the number of 1 bits in every number from 0 to n without converting numbers to binary strings. Step 1 (Initialization): Create an array result of size n + 1, initialized to zeros. Base cases: result[0] = 0 → Binary of 0 is 0, so 0 ones. result[1] = 1 → Binary of 1 is 1, so 1 one. Step 2 (Even–Odd Relation): For every number i from 2 to n: If i is even, the number of 1s = result[i // 2] (same as half of i, because last bit is 0). If i is odd, the number of 1s = result[i // 2] + 1 (same as half, plus 1 for the last bit). Step 3 (Iterative Build): Use the above relation to fill the result array for all numbers up to n. 🕒 Time Complexity: O(n) Each number is processed once. 💾 Space Complexity: O(n) We store bit counts for all numbers from 0 to n. 📁 File: https://lnkd.in/ghuw8Vea 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem deepened my understanding of bitwise patterns and how small observations (like even–odd relationships) can lead to elegant DP-based optimizations. It showed how dynamic programming can simplify repetitive bit-counting logic and achieve linear time solutions. ✅ Day 94 complete — counted every single bit of progress, one 1️⃣ at a time! 💡⚙️💻✨ #LeetCode #DSA #Python #DynamicProgramming #BitManipulation #CountBits #100DaysOfCode #DailyCoding #InterviewPrep #GitHubJourney

Day 81/365 : Go basics Q1: How do you convert an integer to a string in Go?  - Use the strconv package import ( "strconv" ) func main() { i := 123 s := strconv.Itoa(i) fmt.Println(s) // "123" } Q2: Can you explain how named return values work in Go? -> Named return values allow you to predefine the return variables in the function signature, simplifying the return statements. func divide(a, b float64) (result float64, err error) { if b == 0 { err = errors.New("division by zero") return } result = a / b return } Q3: How do you use anonymous functions in Go? -- function without a name, often defined inline. func main() { add := func(a, b int) int { return a + b } fmt.Println(add(2, 3)) // Outputs 5 } #GoLang #LearningToCode #Programming #CodingJourney #TechCommunity #GoDevelopers

Hello Everyone! This is Day5 of my #30dayspythonproject. Today’s learning was all about one of the most important concepts in programming — Loops. Loops help us reduce repetitive work and make our code efficient, clean, and dynamic. I explored: 🔹 for Loop – best for iterating over sequences 🔹 while Loop – runs until a condition becomes false 🔹 Nested Loops – loops inside loops 🔹 Loop Control Statements break → stop the loop continue → skip the current iteration pass → placeholder 🔹 else with Loops – executes when loop finishes normally To practice these concepts, I built a small mini-project: ⭐ Password Strength Checker A simple program that uses loops + conditions to check if a password is Weak, Medium, or Strong. This helped me understand: How loops work internally How to combine loops with logic How to apply loops in real-world scenarios Excited to continue this journey and share more mini-projects in the coming days! 🚀💡 #LogicWhile #Python #CodingJourney #PythonDeveloper #30DaysOfCode #Learning #LoopsInPython #ProgrammingBasics #TechLearner #Day5 #MiniProjects #PythonLearning

Every programmer can make something work. But only a great programmer writes code that lasts. Good code gets the job done for today; it runs, it delivers, it solves the task at hand. Great code, however, is designed, it anticipates future changes, handles edge cases, and scales as projects grow. That’s the difference between writing scripts and building systems. It’s also the mindset we teach in Python Data Structures and Algorithms: Complete Guide, how to write clean, efficient, and future-ready code through better structure and algorithmic thinking. 💡 Because mastering programming isn’t about just knowing syntax. It’s about thinking like a problem-solver. #LearnProgrammingAcademy #timbuchalka #pythoncourse #CleanCode #softwareengineering #Programming #coding #pythondevelopers #CodingMindset

🔍Concepts in 60 Seconds: Ep-5 Ever noticed how one word can mean different things depending on the situation? That’s exactly what Polymorphism is in Object-Oriented Programming (OOP)! The term “Polymorphism” literally means “many forms”, it allows the same function or method to behave differently based on the object that’s calling it. ⁉️ Why it’s important: -Makes code flexible and dynamic -Supports reusability and extensibility -Allows us to use one interface for different underlying data types 💡 Types of Polymorphism: 1. Compile-time Polymorphism (Static Binding): Achieved using method overloading — same method name, different parameters. 2. Run-time Polymorphism (Dynamic Binding): Achieved using method overriding — child class redefines a method of the parent class. ⚙️ In simple terms: Polymorphism is like a single command that knows how to behave differently depending on who’s using it. 🧠 Next Wednesday: Let’s simplify complexity with Abstraction — showing only what’s necessary and hiding the chaos behind clean design. 🕶️ #ConceptsIn60Seconds #OOP #Polymorphism #DynamicBinding #MethodOverloading #MethodOverriding #CodeReusability #ProgrammingConcepts #ObjectOrientedProgramming #TechLearning #WednesdayWisdom #LearnWithNatlie #CodeBetter #OOPS  #StudentLearning #CSFundamentals #TechWednesdays #CSEConcepts #OOPSeries #CodingConcepts #ProgrammingBasics

💡You don’t need to build the perfect project — you just need to build something every week. I used to spend weeks planning what to build next — choosing the tech stack, naming the project, even designing the folder structure. But you know what really helped me grow as a developer? Starting small and finishing small projects consistently. Each mini-project taught me something new — from debugging errors to understanding real-world problems. Perfection can wait. Progress can’t. Start small. Keep shipping. That’s how developers grow. #Python #DevelopersJourney #Motivation #KeepBuilding #programming

Debug Smarter: How Unit Tests Help You Code Like a Pro Every professional developer knows, debugging isn’t about fixing errors, it’s about preventing them before they happen. That’s where unit tests come in. By writing small, focused tests for each part of your code, you: Catch bugs early, before they snowball into major issues Improve code reliability and performance Gain confidence every time you refactor or add new features In our Python Data Structures and Algorithms: Complete Guide, you’ll learn to write and run unit tests that make your code not just work, but last. Because real professionals don’t just code fast. They code smart. #LearnProgrammingAcademy #TimBuchalka #PythonCourse #UnitTesting #CleanCode #PythonDevelopers #ProgrammingTips #CodeQuality #softwareengineering

📅 Day 36 of #100DaysOfCode Today’s challenge was one of the most interesting and tricky recursion problems! Problem: Regular Expression Matching (LeetCode #10) 🔍 Approach: The goal is to determine if a given string text matches a pattern that includes: . → Matches any single character * → Matches zero or more occurrences of the preceding element 1️⃣ Used recursion to check character-by-character matches. 2️⃣ For each step: Checked if the current characters match (text[0] == pattern[0] or pattern[0] == '.'). If the next pattern character is *, explored two possibilities: Skip * and the previous character (zero occurrence). Use * to match one or more occurrences (consume one character from text). 3️⃣ Continued recursively until the entire text and pattern were checked. #100DaysOfCode #LeetCode #DSA #ProblemSolving #Cplusplus #CodingChallenge #Algorithms #Programming #DeveloperLife #CodeNewbie #DailyDSA #SoftwareEngineering #CodingJourney #LearningInPublic #TechCommunity #KeepLearning #Recursion #GrowthMindset #Motivation

Leetcode problem solving day 89 today i solved 124. Binary Tree Maximum Path Sum link to problem - https://lnkd.in/gSXC_ZSA below is my approch Approach 1: DFS function accepts root of the subtree as the input. if the root is null, return 0. This is the base case. If a node does not have a left or right child, then the path sum contributed by the respective subtree is 0. called the function recursively on the left and right child of the root. stored results in gain_from_left and gain_from_right, respectively. If either is negative set it to 0. this is because we don't want to include a path sum contributed by a subtree if it is negative. Updated the maximum path sum (max_sum) seen so far.  compared max_sum with the sum of the following and updated it if it is smaller. The value of the root itself. gain_from_left (0 if negative) gain_from_right (0 if negative) Returned the path sum gain contributed by the subtree. This is the maximum of the following two values. The value of the root plus gain_from_left. The value of the root plus gain_from_right. Time complexity: O(n) Space complexity: O(n)     #DSA  #Programming  #LeetCode #ProblemSolving #CodingJourney #TechCommunity