Understanding Integer Overflow in C

🎯 Day 83 of #100DaysOfCode 🔹 Problem: Count the Digits That Divide a Number – LeetCode ✨ Approach: A simple yet elegant digit-based problem! I extracted each digit of the number using modulo and division, then checked whether the digit cleanly divides the original number. Every valid digit increases the count — a perfect use-case for number breakdown and modular arithmetic. 🔢⚡ 📊 Complexity Analysis: ⏱ Time Complexity: O(d) — where d is the number of digits 💾 Space Complexity: O(1) — no extra data structures used ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 42.29 MB 🔑 Key Insight: Even basic problems sharpen precision — breaking numbers digit-by-digit reinforces strong logical thinking and clean coding habits. Sometimes the simplest loops teach the most. ✨ #LeetCode #100DaysOfCode #DSA #NumberTheory #ModularArithmetic #CleanCode #EfficientCoding #LogicBuilding #TechJourney #ProgrammingChallenge #CodingDaily

Day 9 of #30DaysOfCode 📐 From Brute Force to Ultra-Optimized: Maximum Rectangle Area Problem Just cracked an interesting geometric problem that taught me the power of micro-optimizations in competitive programming! The Challenge: Find the largest axis-aligned rectangle from a set of points where no other points lie inside or on the borders. The Journey: Started with O(n⁴) brute force approach Optimized to O(n³) using diagonal-pair strategy Applied competitive programming micro-optimizations Key Optimizations That Made the Difference: - unordered_set with reserve() → 3-5x faster lookups vs set - Bit packing coordinates → (x,y) into single 64-bit integer for faster hashing - Const references → Reduced array access overhead - Early break/continue → Eliminated wasted iterations - Direct comparison → Avoided max() function overhead The Results: ⚡ 6-8x performance improvement 💾 Same O(n) space complexity 🎯 Runs in ~100-200 operations for n ≤ 10 Key Takeaway: For small constraints, the right data structure + micro-optimizations matter more than asymptotic complexity. Sometimes it's not about changing the algorithm, but making every operation count! #CompetitiveProgramming #CPP #AlgorithmOptimization #DSA #ProblemSolving #SoftwareEngineering #CodingInterview #PerformanceOptimization Educative #educative

🚀 Day 74 – 75 Days DSA Challenge 💻 # Today, I focused on strengthening one of the most important problem-solving techniques in algorithms - Dynamic Programming (DP). # I revised all core DP concepts and successfully solved a classic LeetCode problem: Fibonacci Number. 📘 Concepts Covered: 🔹 What is Dynamic Programming? # A technique to solve problems by breaking them into overlapping subproblems. # Uses optimal substructure and memoization/tabulation to avoid repeated work. # Helps convert exponential solutions into polynomial-time ones. 🔹 DP Approaches I Practiced: # Recursive (Top-Down) with memoization # Iterative (Bottom-Up) tabulation # Space-Optimized DP for efficient memory usage # Understanding when DP is applicable by identifying patterns and recurrence relations 🔹 Problem Solved – Fibonacci Number: # Implemented the Fibonacci series using space-optimized DP (O(n) time, O(1) space). # Observed how DP transforms a slow exponential solution into an efficient linear one. # Reinforced my understanding of subproblems, transitions, and base cases. 💡 Key Takeaway: # Dynamic Programming is not just a technique - it’s a mindset. # Today’s practice helped me become more comfortable recognizing DP patterns and building efficient solutions for complex problems. #Day74 #75DaysDSAChallenge #DynamicProgramming #DP #LeetCode #Fibonacci #Algorithms #DataStructures #ProblemSolving #CodingJourney #TechLearning #Programming

🚀 DSA Progress – Day 99 ✅ Problem #190: Reverse Bits 🧠 Difficulty: Easy | Topics: Bit Manipulation, Binary Representation, Bitwise Operations 🔍 Approach: Implemented a bitwise manipulation method to reverse all 32 bits of an unsigned integer. This problem helps build a strong understanding of how bits can be extracted, shifted, and reassembled — a key concept in low-level programming and embedded systems. Step 1 (Initialization): Start with rev = 0 to store the reversed bits. Step 2 (Extract + Reverse): For each bit position i from 0 to 31: Extract the ith bit using (n >> i) & 1. Move that bit to its reversed position (31 - i) using (bit << (31 - i)). Combine it into rev using bitwise OR (|=). Step 3 (Return Result): After processing all bits, return the reversed number as the final result. 🕒 Time Complexity: O(32) → effectively O(1) (constant time) 💾 Space Complexity: O(1) → no extra data structures used 📁 File: https://lnkd.in/gKeNZQf9 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem deepened my understanding of bit-level operations like shifting (<<, >>) and masking (&, |). It showed how reversing bits is similar to flipping binary mirrors — a useful concept in embedded systems, graphics, and cryptographic algorithms. The challenge reinforced that mastering bitwise logic is essential for writing efficient, low-level optimized code. ✅ Day 99 complete — flipped every bit, reversed the logic, and came out enlightened! ⚡💡💻 #LeetCode #DSA #Python #BitManipulation #Binary #CodingChallenge #InterviewPrep #100DaysOfCode #DailyCoding #GitHubJourney

🎯 LeetCode Daily – Triangle (Day 113) Today’s problem deepened my understanding of Dynamic Programming on Triangular Grids, focusing on minimizing path sums efficiently. ✅ My Approach: 🔹 Problem – Triangle: • The goal was to find the minimum path sum from the top to the bottom of a triangle array. • Used Memoization (Top-Down DP) to recursively explore all paths while storing intermediate results to avoid redundant computations. • Implemented Tabulation (Bottom-Up DP) to build the solution iteratively starting from the last row and moving upward, computing the minimum path for each position using values from the row below. 🧠 Key Insight: This problem beautifully demonstrates the power of Dynamic Programming in optimizing recursive solutions. By transitioning from memoization to tabulation, the problem transforms from exponential recursion to an elegant linear-time solution. Recognizing overlapping subproblems and optimal substructure patterns is key to mastering DP on grids and triangles. 📊 Time Complexity: O(N²) 📦 Space Complexity: O(N²) #LeetCode #DSA #DynamicProgramming #ProblemSolving #DailyCoding #LearningInPublic #Day113

💡 (7th Nov 2025) Today I Learned: Patterns — Advanced (Part 1) After mastering basic star and shape patterns, today I moved into advanced pattern problems — where logic meets precision. Here’s what I learned and practiced 👇 1️⃣ Hollow Rectangle Pattern — Learning how to print borders while leaving the center blank using nested loops. 2️⃣ Dry Run: Hollow Rectangle Pattern — Understanding each iteration of i and j to visualize how the pattern is formed. 3️⃣ Inverted & Rotated Half Pyramid — Controlling spaces and stars to achieve mirrored symmetry. 4️⃣ Inverted Half Pyramid with Numbers — Introducing numerical logic within pattern loops. 5️⃣ Floyd’s Triangle Pattern — A beautiful number pattern that fills a triangle incrementally. 💬 Key Takeaway: Pattern problems aren’t just about visuals — they sharpen loop control, logic sequencing, and dry-run analysis. Every pattern teaches precision, patience, and problem-solving — three key skills for any developer. #CodingJourney #Patterns #Java #dsa #Programming #DeveloperGrowth #ApnaCollege #LearningInPublic #LogicBuilding

Leetcode problem solving day 88 today i solved problem number 222. Count Complete Tree Nodes link to problem - https://lnkd.in/gWVKj_hb below is my approch Approach 1: Linear Time count nodes recursively one by one. class Solution {  public int countNodes(TreeNode root) {   return root != null ? 1 + countNodes(root.right) + countNodes(root.left) : 0;  } } Time complexity : O(N). Space complexity :O(logN) Approach 2: Binary search Return 0 if the tree is empty. Compute the tree depth d. Return 1 if d == 0. The number of nodes in all levels but the last one is 2 to the power d−1. The number of nodes in the last level could vary from 1 to 2 to the power d. Enumerate potential nodes from 0 to 2 to the power d−1. and perform the binary search by the node index to check how many nodes are in the last level. Use the function exists(idx, d, root) to check if the node with index idx exists. Use binary search to implement exists(idx, d, root) as well. Return 2 to the power d−1 + the number of nodes in the last level. Time complexity :O(log square N) Space complexity : O(1)     #DSA  #Programming  #LeetCode #ProblemSolving #CodingJourney #TechCommunity   

🎯 LeetCode Daily – Combination Sum IV (Day 125) Today’s problem was a powerful exploration of Dynamic Programming with sequence-based combinations - Combination Sum IV. ✅ My Approach: 🔹 Problem – Combination Sum IV: • The goal was to find the number of possible ordered combinations that sum up to a given target using elements from an array. • Implemented Memoization (Top-Down DP) to recursively explore all ways to reach the target, caching results to prevent recomputation. • Then optimized with Tabulation (Bottom-Up DP), where each state dp[i] represents the number of combinations that sum to i. • For every value from 0 to target, iterated through all numbers and accumulated valid combinations. 🧠 Key Insight: Unlike the traditional Subset Sum or Coin Change problems, this problem treats order as significant, making it a classic case of permutation-based DP. The key is understanding how smaller sub-targets build up to form the total - a perfect demonstration of the power of recursive relationships. 📊 Time Complexity: O(N × Target) 📦 Space Complexity: O(Target) #LeetCode #DSA #DynamicProgramming #Combinatorics #ProblemSolving #DailyCoding #LearningInPublic #Day125

🔵 C Pointers Deep Dive – Understanding Pointer to Pointer (Double Pointer) in Action 🔵 Today, I revisited a core yet often misunderstood concept in C programming: Pointer to Pointer (or double pointer) — a feature that gives us the power to indirectly access and manipulate data at multiple memory levels. 🧠 What I did: 🔸 Wrote a simple C program demonstrating how int **q can be used to indirectly modify a variable through another pointer. 🔸 Used the dereference operator (*) twice to understand how data is accessed and updated via multiple levels of indirection. 🔸 Observed how changes made through **q reflect directly in the original variable. 🔍 Step-by-step breakdown: 1️⃣ int a = 10; → a simple integer variable. 2️⃣ int *p = &a; → p stores the address of a, making it a pointer to a. 3️⃣ int **q = &p; → q stores the address of pointer p, making it a pointer to a pointer. 4️⃣ **q = **q + 1; → dereferencing twice means we’re actually modifying the value of a indirectly — incrementing it by 1. 5️⃣ printf("%d", a); → outputs 11. 🛠 Why this matters: 🔸 Double pointers are essential for dynamic memory management, multidimensional arrays, and function pointers. 🔸 They provide deeper control over data structures like linked lists, trees, and graphs. 🔸 Understanding pointer indirection helps in writing efficient, memory-safe, and maintainable low-level code. 📌 Key Takeaway: 👉 Pointers to pointers amplify flexibility — allowing manipulation of variables, arrays, or even function addresses indirectly. 👉 Always ensure pointer initialization and dereferencing safety to avoid undefined behavior. 👉 Mastering this concept is a stepping stone toward mastering memory management in C. 🚀 Next up: 🔹 Exploring triple pointers in advanced data structures 🔹 Using double pointers for dynamic 2D arrays 🔹 Practical debugging of pointer issues with tools like Valgrind #CProgramming #Pointers #MemoryManagement #LowLevelProgramming #EmbeddedC #SystemsProgramming #CDeveloper #SoftwareEngineering #CodeTips #ProgrammingConcepts #DeveloperJourney #ComputerScience #CodingCommunity #LearningInPublic

💻 #Program3 – Prime Number Checker & Range Finder Today’s coding challenge focuses on mathematical logic and optimization 🧮 I built a C program that lets users: 1️⃣ Check if a number is prime or not 2️⃣ Print all prime numbers within a given range The program uses modular arithmetic and checks divisibility only up to the square root of each number — a neat optimization that improves performance ⚡ It also handles invalid inputs (like reversed ranges) and counts how many primes were found. 🧠 Concepts practiced: Conditional statements (switch, if-else) Loops and function calls Boolean logic (true/false) Efficient use of sqrt() for prime testing Each challenge strengthens logic and problem-solving — one program at a time 💪 #100DaysOfCode #CProgramming #LearningByDoing #CodingChallenge #ProgrammersJourney #ProblemSolving #CodeNewbie