Optimizing Power Calculation with Recursive Divide-and-Conquer

Started learning Recursion today. At first it looked simple — just a function calling itself. But once I began writing the factorial logic, I realized the real challenge was understanding how the flow actually moves through the call stack. Things that became clear: - Every recursive function must have a clear base case. - The function doesn’t “loop” — it builds a stack of calls. - The real work often happens while returning (unwinding phase). - Without a stopping condition, recursion breaks instantly. Logic I implemented (Factorial) : if (n == 0) return 1; return n * factorial(n - 1); Simple code. But understanding why it works took more thinking than expected. Still early, but the confusion from the beginning is slowly reducing. Continuing today with deeper recursion patterns. #recursion #java #dsajourney #learninginpublic #problemSolving

Day 72/100 – LeetCode Challenge ✅ Problem: #7 Reverse Integer Difficulty: Medium Language: Java Approach: Digit Extraction with Overflow Check Time Complexity: O(log₁₀ x) Space Complexity: O(1) Key Insight: Reverse integer by repeatedly extracting last digit and building result. Critical: Check overflow before final cast using long to detect > Integer.MAX_VALUE or < Integer.MIN_VALUE. Solution Brief: Extracted digits using modulo 10. Built reversed number step by step in long to detect overflow. After loop, divided by 10 to remove extra multiplication. Checked if result fits in 32-bit integer range. Handled sign separately at the end. #LeetCode #Day72 #100DaysOfCode #Math #Java #Algorithm #CodingChallenge #ProblemSolving #ReverseInteger #MediumProblem #Overflow #DigitManipulation #DSA

Daily DSA Update – Day 26 Solved: Add Binary (LeetCode) Today’s problem was about adding two binary strings and returning their sum as a binary string. Problem: Given two binary strings a and b, return their sum as a binary string. Approach: I simulated the same process we use while doing binary addition manually. Starting from the end of both strings, I added corresponding digits along with a carry value. After calculating the sum, I appended the result bit and updated the carry. Finally, I reversed the result to get the correct binary order. Key Learning: Problems like this highlight the importance of understanding how operations work internally rather than relying on built-in conversions. What this strengthened: • String traversal from right to left • Handling carry in binary operations • Using StringBuilder for efficient string manipulation • Implementing mathematical logic in code Each daily problem adds a small but meaningful improvement in problem-solving ability. On to the next challenge. #DSA #DataStructures #Algorithms #Java #LeetCode #ProblemSolving #CodingJourney #TechLearning

Day #10 / 100 — Data Structures & Algorithms Today’s focus was on array patterns and two-pointer techniques. Problems solved: • Maximum Subarray • Container With Most Water • Minimum Size Subarray Sum • Longest Substring Without Repeating Characters • 4Sum • Maximum Width Ramp • Boats to Save People Key takeaway: Many array problems reduce to a few core ideas — sliding window, two pointers, greedy choices, or prefix-based reasoning. Recognizing these patterns is gradually making problem-solving faster and more intuitive. #100DaysOfCode #DSA #LeetCode #Java #BackendDevelopment AccioJob

Solved 1545. Find Kth Bit in Nth Binary String Instead of constructing the full binary string (which grows exponentially), I used the recursive structure of the problem: Sₙ = Sₙ₋₁ + "1" + reverse(invert(Sₙ₋₁)) If k lies in the second half, we can mirror the index and flip the bit instead of building the string. This reduces the problem iteratively until we reach the base case. Time: O(n) Space: O(1) A good example of leveraging symmetry instead of brute force. #Algorithms #BitManipulation #Recursion #Java #ProblemSolving #SoftwareEngineering

Day 19 of my Data Structures & Algorithms journey. Today’s problem: Same Tree (Binary Tree recursion) on LeetCode. At first glance it looks simple, but it teaches an important idea: Two trees are identical only if both their structure and node values match at every level. Key concept practiced today: Depth-First Search (DFS) with recursion. Step by step the logic becomes: • If both nodes are null → trees match • If one node is null → trees differ • If values differ → trees differ • Otherwise → recursively check left and right subtrees Small problems like these quietly sharpen problem-solving muscles. Consistency > intensity. #LeetCode #DSA #Java #BinaryTree #CodingJourney

Day 33/75 — Sort an Array (Merge Sort) Today’s problem required sorting an array in O(n log n) time without using built-in sort. Approach: • Divide array into two halves • Recursively sort both halves • Merge sorted halves Key idea: return merge(left, right); Merge step ensures elements are placed in sorted order. Time Complexity: O(n log n) Space Complexity: O(n) This problem reinforced the concept of Divide & Conquer. 33/75 🚀 #Day33 #DSA #MergeSort #Java #Algorithms #LeetCode

✳️Day 13 of #100DaysOfCode✳️ Decoding the Logic: Two Problems, One Core Strategy I recently cleared Climbing Stairs and Fibonacci Number on LeetCode with 0ms runtime. 1️⃣ Climbing Stairs (LeetCode 70) The Problem: You are climbing a staircase. It takes n steps to reach the top. Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top? The Approach: Recursive Insight: To reach the n^{th} step, you must have come from either the (n-1)^{th} step (by taking 1 step) or the (n-2)^{th} step (by taking 2 steps). Base Cases: * If n = 0 or n = 1, there is only 1 way to be there. The Formula: Ways(n) = Ways(n-1) + Ways(n-2). 2️⃣ Fibonacci Number (LeetCode 509) The Problem: Calculate F(n), where F(n) = F(n-1) + F(n-2) for n > 1, with F(0) = 0 and F(1) = 1. The Approach: Recursive Insight: This is the "pure" mathematical version of the stairs problem. Each number is the sum of the two preceding ones. Base Cases: If n = 0, return 0. If n = 1, return 1. 🚀 Why the 0ms Runtime? In both solutions, I used Top-Down Memoization: The Problem with Simple Recursion: Without optimization, the computer recalculates the same values (like f(5)) dozens of times, leading to an exponential time complexity of O(2^n). The Memoization Fix: I introduced an array dp[]. Before calculating f(n), the code checks: "Have I solved this before?" If dp[n] is not 0, it returns the stored value instantly. If not, it calculates it once, stores it, and moves on. The Result: This simple "memory" trick brings the complexity down to O(n) linear time, making the execution nearly instantaneous. #DataStructures #Algorithms #Java #DP #SoftwareDevelopment #LeetCode

🚀 **LeetCode Problem Solved – Max Consecutive Ones III** Today I solved **Problem 1004: Max Consecutive Ones III** using the **Sliding Window technique**. 🔹 **Problem Summary** Given a binary array `nums` containing 0s and 1s and an integer `k`, we are allowed to flip at most `k` zeros to ones. The goal is to determine the **maximum number of consecutive 1s** possible after performing at most `k` flips. 🔹 **Approach** Instead of checking every possible subarray, I used the **Sliding Window (Two Pointer) approach**: • Expand the window using the right pointer • Count the number of zeros in the window • If zeros exceed `k`, move the left pointer to maintain a valid window • Track the maximum window size 🔹 **Complexity** ⏱ Time Complexity: **O(n)** 💾 Space Complexity: **O(1)** 📊 **Result** ✔ 60 / 60 Testcases Passed ⚡ Runtime: **2 ms (Beats 99.93%)** Consistent practice with **Data Structures & Algorithms** helps build strong problem-solving skills and deeper understanding of algorithmic patterns. Always open to learning better approaches or optimizations! 💡 #LeetCode #DSA #Java #SlidingWindow #ProblemSolving #CodingJourney

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞: 1784.Check if Binary String Has At Most One Segment of Ones Today’s challenge was a short but insightful problem that demonstrates how recognizing patterns in a binary string can lead to an extremely elegant solution. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐮𝐦𝐦𝐚𝐫𝐲: We are given a binary string s consisting only of '0' and '1'. The task is to determine whether the string contains at most one continuous segment of '1'. In other words, once a '0' appears after a '1', there should not be another '1' later in the string. If there is more than one segment of '1', return false. Otherwise, return true. 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: The key observation is very simple. If a binary string has more than one segment of '1', the pattern "01" must appear somewhere in the string. Why? A valid string with only one segment of ones looks like: 0001111000 But an invalid string with multiple segments would look like: 11100111 Notice the transition "01" which indicates that ones started again after a zero. Therefore, the entire problem reduces to checking whether the substring "01" exists. If "01" is present → there are multiple segments of '1'. If "01" is absent → there is at most one segment. This allows us to solve the problem in a single line using the built-in string function. 𝐂𝐨𝐝𝐞 𝐒𝐧𝐢𝐩𝐩𝐞𝐭 (Java): class Solution { public boolean checkOnesSegment(String s) { return !s.contains("01"); } } 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 𝐀𝐧𝐚𝐥𝐲𝐬𝐢𝐬: Time Complexity: O(n) Space Complexity: O(1) We scan the string once to check if the pattern "01" exists. 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬: Sometimes the best solution is identifying a simple pattern instead of simulating the entire process. Understanding how transitions occur in binary strings can simplify many problems. Leveraging built-in string functions can make solutions both clean and efficient. A great reminder that even small problems can reinforce strong pattern-recognition skills. #LeetCode #DSA #Java #ProblemSolving #Algorithms #BinaryStrings #CodingPractice #Consistency #100DaysOfCode #LearningJourney