Implement pow(x, n) using Fast Exponentiation

🧩 Day 41 — Count Primes (LeetCode 204) 📝 Problem -Given an integer n, return the number of prime numbers that are strictly less than n. 🔁 Approach -Use the Sieve of Eratosthenes algorithm: -Create a boolean array arr of size n, initialized to True. -Mark arr[0] and arr[1] as False (since 0 and 1 are not prime). -Iterate i from 2 to √n: -If arr[i] is True, mark all multiples of i as False. -Count all True values in arr — that count gives the number of primes. 📊 Complexity -Time Complexity: O(n log log n) -Space Complexity: O(n) 🔑 Concepts Practiced -Prime number sieving -Optimization using mathematical properties -Boolean array manipulation #LeetCode #Python #DSA #ProblemSolving

🚀 𝐃𝐚𝐲 𝟏𝟑 𝐨𝐟 #𝟏𝟔𝟎𝐃𝐚𝐲𝐬𝐎𝐟𝐂𝐨𝐝𝐞 — 𝐏𝐚𝐥𝐢𝐧𝐝𝐫𝐨𝐦𝐞 𝐍𝐮𝐦𝐛𝐞𝐫 | 𝐒𝐭𝐫𝐢𝐧𝐠𝐬 🧩 Today’s focus was on a simple yet classic logic check — determining if a number reads the same forward and backward. While it looks straightforward, it’s a great reminder that elegant solutions often come from clarity, not complexity. Problem: 𝐂𝐡𝐞𝐜𝐤 𝐢𝐟 𝐚𝐧 𝐢𝐧𝐭𝐞𝐠𝐞𝐫 𝐢𝐬 𝐚 𝐩𝐚𝐥𝐢𝐧𝐝𝐫𝐨𝐦𝐞. Approach: Convert the integer to a string and compare it with its reverse. Time Complexity: O(n) Space Complexity: O(n) This small exercise reinforces foundational reasoning that scales up when designing more complex systems — where reversing, mirroring, or symmetry detection shows up in data validation, pattern recognition, and even natural language tasks. 🔗 GitHub: https://lnkd.in/gaim_PJS #Python #LeetCode #CodingChallenge #160DaysOfCode #ProblemSolving #DSA #AIEngineerJourney

🧩 Day 42 — Add Digits (LeetCode 258) 📝 Problem Given an integer num, repeatedly add all its digits until the result has only one digit, and return it. 🔁 Approach -Continuously sum the digits of the number until a single-digit result remains. -Alternatively, use the digital root formula: -If num == 0, return 0. -Else, return 1 + (num - 1) % 9. 📊 Complexity -Time Complexity: O(1) -Space Complexity: O(1) 🔑 Concepts Practiced -Mathematical optimization -Modulo operation -Digital root pattern #Leetcode #python #DSA #ProblemSolving #Math #Optimization

💼 LeetCode Daily Challenge: 3354. Make Array Elements Equal to Zero Today I worked on an interesting simulation based problem that combines logical movement with mathematical reasoning. 🔍 Problem Overview: - You are given an integer array containing non-negative elements. - The task is to determine the number of valid starting positions (and directions) such that all elements become zero after performing a series of operations. - The movement involves direction reversals and decrements, making direct simulation tricky. 💡 Key Observations: - Instead of brute force simulation, prefix sum analysis helps determine valid balance points. - Each zero acts as a potential pivot; by analyzing prefix and total sums, we can efficiently identify valid selections. - The solution leverages mathematical balance conditions to avoid unnecessary computation. 📊 Complexity: Time Complexity: O(n) Space Complexity: O(1) 🎯 Takeaways: - Simulation problems often hide elegant mathematical patterns. - Prefix sums are powerful tools for deriving insights without explicit iteration over all possibilities. #LeetCode #ProblemSolving #Python #DSA #Algorithm #CodingChallenge #PrefixSum #DataStructures #LearningEveryday #Efficiency

🚀 DSA Challenge – Day 80 Problem: Maximum Distance Between Valid Pairs 🌊📏 Today’s problem tested the combination of binary search and array monotonicity — finding the farthest valid pair between two non-increasing arrays! 🧠 Problem Summary: We’re given two non-increasing arrays, nums1 and nums2. A pair (i, j) is valid if: i ≤ j, and nums1[i] ≤ nums2[j]. The goal is to find the maximum distance (j - i) among all valid pairs. ⚙️ My Approach: 1️⃣ Iterate through each element in nums1. 2️⃣ Use binary search on nums2 to find the farthest valid index satisfying the condition. 3️⃣ Keep track of the maximum j - i distance encountered. This solution leverages the sorted (non-increasing) property of arrays for logarithmic efficiency. 📈 Complexity: Time: O(n log m) → For each element in nums1, a binary search on nums2. Space: O(1) → Only a few variables used. ✨ Key Takeaway: Sometimes, monotonic properties allow you to blend binary search with iteration — turning what looks like a brute-force problem into a clean and efficient search-based solution. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Algorithms #BinarySearch #TwoPointers #CodingChallenge #Python #InterviewPrep #TechCommunity #Optimization #EfficientCode #CodeEveryday

"Day 3 is a massive win for efficiency! I dedicated the morning to mastering the Two-Pointer technique, a critical step in optimizing array algorithms. I successfully tackled two key problems, including the famous Remove Duplicates (#26), which confirmed the absolute necessity of O(1) auxiliary space optimization. Key Technical Insight: O(1) Space is King I compared different approaches for removing duplicates and confirmed the core DSA lesson: 1. The Slow/Fast Pointer method is the correct, efficient approach, achieving O(1) space and O(n) time by manipulating the array in-place. 2. Brute-force solutions using helper data structures violate the memory constraint and often lead to slow O(n^2) time complexity. The lesson is clear: Master the mechanism, don't just rely on the wrapper. Understanding this difference is essential for building scalable applications. All progress is documented and pushed. Now, the plan pivots to laying the foundation for my Python OOP skills and project architecture. #DSA #TwoPointers #Python #LeetCode #SoftwareEngineering #Consistency #O1Space"

🧩 Day 37 — Sqrt(x) (LeetCode 69) 📝 Problem -Given a non-negative integer x, return the square root of x rounded down to the nearest integer. -The returned integer should be non-negative. -You must not use any built-in exponent function or operator (e.g., pow(x, 0.5) or x ** 0.5). 🔁 Approach -Use binary search between 0 and x to find the integer square root. -At each step: -Calculate the midpoint m = l + (r - l) // 2. -If m² is greater than x, search in the left half. -If m² is less than x, move to the right half and record m as a possible answer. -If m² equals x, return m directly. -When the loop ends, res will hold the floor value of the square root. 📊 Complexity -Time Complexity: O(log x) -Space Complexity: O(1) 🔑 Concepts Practiced -Binary search on number range -Integer floor computation -Avoiding built-in power or square root functions #Leetcode #Python #DSA #Math #ProblemSolving

🧩 Day 30 — 4Sum (LeetCode 18) 📝 Problem -Given an integer array nums, return all unique quadruplets [nums[a], nums[b], nums[c], nums[d]] such that: -a, b, c, and d are distinct indices -nums[a] + nums[b] + nums[c] + nums[d] == target -Return the answer in any order. 🔁 Approach -Sort the array to handle duplicates efficiently. -Use a recursive k-sum approach that generalizes 2-sum, 3-sum, and 4-sum problems. -For k > 2, recursively reduce the problem: -Fix one number and call kSum for k - 1 on the remaining array. -Skip duplicates to avoid repeating quadruplets. -For k = 2, use the two-pointer technique: -Move pointers inward based on the sum comparison with the target. -Add valid pairs to the result and skip duplicates. -Backtrack after each recursive call to explore all possible combinations. 📊 Complexity -Time Complexity : O(n³) -Space Complexity : O(k) 🔑 Concepts Practiced -Recursive K-Sum pattern -Two-pointer technique -Sorting and duplicate handling -Backtracking with controlled search space #python #DSA #4Sum #ProblemSolving #Leetcode

🔍 Day 40 DSA Challenge – Problem #35: Search Insert Position 📌 Problem Statement: Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it should be inserted to maintain sorted order — all in O(log n) time. ⚙️ How I Solved It: Implemented a classic binary search approach to efficiently locate the target or its proper insertion point in the array. 📊 Performance Stats: ⏱ Runtime: 0 ms (⚡ beats 100%) 💾 Memory: 12.90 MB (beats 57.89%) ✅ Testcases Passed: 66 / 66 🧠 Key Insight: Binary search offers optimal performance for sorted data — letting us solve insertion/find problems with minimal comparisons. #LeetCode #Problem35 #BinarySearch #Python #DSA #100DaysOfCode #CodingJourney

Day 10 of #100DaysOfLeetCode Problem: 2. Add Two Numbers Category: Linked List / Math / Simulation Today’s challenge involved adding two non-empty linked lists that represent numbers in reverse order. Each node contains a single digit, and the goal is to return a linked list representing their sum. 🧠 Key Learnings: Traversed both linked lists simultaneously while managing a carry variable. Handled cases where one list is shorter than the other using conditional checks. Understood how to perform arithmetic operations directly through node manipulation. Strengthened my logic for digit-by-digit processing and linked list traversal. 🎯 Takeaway: Working with linked lists for mathematical operations builds strong logical thinking — especially when managing carry, edge cases, and node creation dynamically. #LeetCode #100DaysOfCode #ProblemSolving #CodingJourney #LinkedList #Python #AIEngineer #Consistency