Optimizing pow(x, n) with Binary Exponentiation

🚀 Day 2 – DSA Practice Log Today was all about strengthening fundamentals and understanding *why* solutions work, not just coding them. 🔸 Rotate Array Learned how to optimize from brute force to the reversal technique (O(n), O(1)) 🔸Fibonacci Compared iterative vs recursive 👉 Realized why iterative is preferred in interviews 🔸 Kadane’s Algorithm 💡 Game changer! 👉 Logic: Extend or restart the subarray 👉 Helps find maximum subarray sum efficiently 🧠 What I learned today: Understanding the logic > memorizing code 📈 Progress update: Getting more comfortable with patterns and problem-solving Let’s keep going 🔥 #100DaysOfCode #DSAJourney #LeetCode #Java #KeepLearning

🚀 Day 2 of My DSA Journey Today I focused on some powerful concepts that are frequently asked in coding interviews. Array Rotation Learned multiple approaches: • Brute Force (O(n*k)) • Extra Array (O(n) space) • Reversal Algorithm (O(n) time, O(1) space) ✅ Fibonacci Series Explored: • Iterative (Best → O(n) time, O(1) space) • Recursive (Simple but inefficient) Kadane’s Algorithm One of the most important algorithms! 👉 Used to find maximum subarray sum in O(n) time 💡 Key takeaway: “Don’t carry negative sum — reset and move forward.” 📌 Practiced problems: • Rotate Array • Fibonacci Number • Maximum Subarray Consistency > Perfection. Day by day improvement 💪 #DSA #LeetCode #CodingJourney #Java #ProblemSolving

Solved LeetCode #5 — Longest Palindromic Substring. Problem: Given a string, return the longest substring that reads the same forward and backward. Approach Used: Expand Around Center Every palindrome has a center. For each index in the string, I expand outward to check two cases: • Odd-length palindromes (single center) • Even-length palindromes (two centers) While characters match, expand left and right and track the longest palindrome found. Complexity • Time Complexity: O(n²) • Space Complexity: O(1) Consistent problem solving builds pattern recognition for interviews. #LeetCode #DSA #Algorithms #CodingInterview #SoftwareEngineering #Java

🚀 Day 14 of My LeetCode Journey Today I solved Merge Intervals (LeetCode 56). Problem: Given a collection of intervals, merge all overlapping intervals and return the non-overlapping intervals that cover all the intervals. Approach: I used a Sorting + Linear Scan technique. Steps: • First sort the intervals based on their start time • Compare each interval with the last merged interval • If they overlap, merge them by updating the end value • Otherwise, add the interval to the result list Key Concepts: • Sorting • Interval manipulation • Greedy approach Time Complexity: O(n log n) Space Complexity: O(n) This is a classic interval problem frequently asked in coding interviews. #leetcode #datastructures #algorithms #java #codinginterview #softwareengineering

Most developers first see two pointers as just an interview trick. It is not. It is one of the simplest ways to make brute-force logic become efficient thinking. In this PDF, I broke down the Two Pointer Approach from the ground up: how it works why it works where to use it how to debug it what happens at a low level and why this technique shows up again and again in real problem solving What makes two pointers powerful is not just speed. It teaches you how to control a search space intelligently instead of checking everything blindly. That is a skill far bigger than one algorithm. Once you understand the pattern, you start seeing it in: sorted array problems pair matching duplicate removal palindrome checks sliding comparisons partition-style logic and many real-world data scanning tasks The biggest mistake many developers make is memorizing the code without understanding why each pointer moves. That is exactly where confusion starts. So I wanted this post to explain the intuition first, then the mechanics, then the practical usage. Which problem made you truly understand two pointers for the first time? #Java #DataStructures #Algorithms #TwoPointers #ProblemSolving #SoftwareEngineering #CodingInterview #Programming #DeveloperLearning #deutch

✅ LeetCode Top Interview 150 – Day 70 Today I solved an interesting Data Structures problem on Complete Binary Trees. Key Idea: A complete binary tree has a special property where if the left height and right height of a subtree are equal, the tree is a perfect binary tree. In that case, the number of nodes can be calculated directly using the formula: Nodes = 2^h − 1 This allows us to avoid traversing every node and achieve a time complexity of O((log n)²) instead of O(n). #DataStructures #Algorithms #Java #CodingPractice #BinaryTree #ProblemSolving

Day 5 #SDE Problems involving Binary Search on Answer and Sliding Window techniques. Solved: • Aggressive Cows (classic binary search on distance problem) • Maximum Subarray Size having all subarray sums less than k Key Learning: Many optimization problems can be solved using Binary Search on the answer space by checking feasibility. Also revisited the Sliding Window approach to efficiently handle subarray sum constraints in linear time. #LeetCode #DSA #BinarySearch #SlidingWindow #Algorithms #Java #SoftwareEngineering

🚀 #60DaysOfLeetCode – Day 33 Today’s problem was Valid Parentheses, a classic stack-based problem that tests understanding of balanced expressions. 🔹 Approach Used: Stack Traverse the string character by character. Push all opening brackets (, {, [ onto the stack. For every closing bracket, check: If the stack is empty → invalid. Pop the top element and verify if it matches the corresponding opening bracket. At the end, if the stack is empty → the string is valid. 🔹 Key Learning: This problem reinforces how stacks help manage nested structures and order-sensitive operations. It’s a fundamental concept frequently asked in interviews. 🔹 Complexity: Time: O(n) Space: O(n) A simple yet powerful problem to strengthen core DSA concepts! 💻🔥 #LeetCode #DSA #Java #CodingChallenge #ProblemSolving #LearningInPublic #60DaysOfCode

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐇𝐚𝐫𝐝 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝: 𝐅𝐢𝐧𝐝 𝐭𝐡𝐞 𝐒𝐭𝐫𝐢𝐧𝐠 𝐰𝐢𝐭𝐡 𝐋𝐂𝐏 𝐐𝐮𝐞𝐬𝐭𝐢𝐨𝐧 𝐋𝐢𝐧𝐤 :https://lnkd.in/gPQ5WExk 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐋𝐢𝐧𝐤 : https://lnkd.in/gYpvYnaW Today I worked on an interesting 𝐡𝐚𝐫𝐝 𝐩𝐫𝐨𝐛𝐥𝐞𝐦: 𝐅𝐢𝐧𝐝 𝐭𝐡𝐞 𝐒𝐭𝐫𝐢𝐧𝐠 𝐰𝐢𝐭𝐡 𝐋𝐂𝐏. The problem provides an 𝐋𝐂𝐏 (𝐋𝐨𝐧𝐠𝐞𝐬𝐭 𝐂𝐨𝐦𝐦𝐨𝐧 𝐏𝐫𝐞𝐟𝐢𝐱) 𝐦𝐚𝐭𝐫𝐢𝐱 and asks us to construct the lexicographically smallest string that satisfies this matrix.  𝐊𝐞𝐲 𝐈𝐝𝐞𝐚 Instead of constructing substrings directly, the approach is: 1️⃣ Start assigning characters from 'a' onward. 2️⃣ If lcp[i][j] > 0, it means the substrings starting at i and j share the same first character. 3️⃣ Propagate the same character across positions where the LCP value indicates a match. 4️⃣ Finally, validate the entire LCP matrix using the rule: lcp[i][j] = (word[i] == word[j]) ? 1 + lcp[i+1][j+1] : 0 If any condition fails, no valid string exists.  𝐖𝐡𝐚𝐭 𝐈 𝐥𝐞𝐚𝐫𝐧𝐞𝐝 • How LCP matrices represent relationships between substrings • Constructing strings using greedy character assignment • Validating constraints using dynamic programming relations • Importance of verifying generated structures against given matrices Problems like this really sharpen string manipulation + matrix reasoning skills. Always fun pushing through Hard-level challenges! #LeetCode #DataStructures #Algorithms #CodingPractice #Java #ProblemSolving