674 Longest Continuous Increasing Subsequence Solution

🚀 Day 572 of #750DaysOfCode 🚀 🔍 Problem Solved: Furthest Point From Origin Today’s problem was a great example of how a simple-looking question can be solved with the right observation 👀 💡 Key Insight: We don’t need to simulate every possible movement. Instead, we just count: 'L' → moves left 'R' → moves right '_' → flexible (can be either) 👉 To maximize distance from origin, use all '_' in the direction that increases the difference the most. 🧠 Approach: Count number of 'L', 'R', and '_' Net position = R - L Add all '_' to maximize distance 👉 Final Answer = |R - L| + '_' 📈 Complexity: Time: O(n) Space: O(1) ✨ Takeaway: Sometimes, instead of exploring all possibilities, you just need to convert the problem into counts and math. Simple logic → powerful result 💪 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Algorithms #LearningEveryday

🚀 LeetCode Daily Progress – Rotate Array Kicking off today’s DSA practice, I solved the “Rotate Array” problem on LeetCode. 🔍 Problem Overview: Given an integer array, rotate the array to the right by k steps, where k is non-negative. The rotation must be done in-place without using extra space. 💡 My Approach: Used the array reversal technique for optimal performance First reversed the initial part, then the remaining part, and finally the entire array Applied k = k % n to handle cases where k is greater than array size 📈 Key Takeaway: This problem reinforced my understanding of in-place array manipulation and how clever use of reversal algorithms can optimize both time and space complexity. Consistency is building confidence step by step 💯 #LeetCode #DSA #Java #Arrays #ProblemSolving #CodingJourney #SoftwareEngineering #Consistency #Learning

🚀 LeetCode Challenge 10/50 🔍 Problem: Merge Sorted Array Today’s problem focused on efficiently merging two sorted arrays without using extra space. 💡 Approach: I used the Two Pointer technique (from the end): Started comparing elements from the back of both arrays Placed the larger element at the end of nums1 Continued this process until all elements were merged ⚡ This approach avoids unnecessary shifting and works in-place. 📊 Complexity Analysis: Time Complexity: O(m + n) Space Complexity: O(1) 📚 Key Learning: Thinking from the end can simplify problems and avoid extra operations. Two-pointer technique is extremely useful for array manipulation problems. Consistency is building confidence 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning

🚀 Day 88 — LeetCode Practice 🚀 Today’s focus was on factorization and optimization techniques. ✅ Problem solved today: 🔹 Construct the Rectangle 💡 Key learnings from today: • Understood how to find factors of a number efficiently • Learned why starting from √area gives the closest dimensions • Strengthened concepts of minimizing difference between two values • Explored how mathematical logic can optimize brute-force solutions • Improved understanding of time complexity reduction 🧠 Approach used: Started checking from √area and moved downwards to find the first factor pair. This ensures length ≥ width and minimum difference. ⚡ Time Complexity: O(√n) 📦 Space Complexity: O(1) 📈 Progress: Getting better at optimizing solutions and thinking mathematically! #Day88 #LeetCode #DSA #Java #CodingPractice #ProblemSolving #Consistency #TechGrowth

🚀 Day 571 of #750DaysOfCode 🚀 🔍 Problem Solved: Sum of Distances Today’s problem looked like a classic brute-force trap 👀 At first glance, comparing every pair gives an O(n²) solution — but with constraints up to 10⁵, that’s not going to work. 💡 Key Insight: Instead of comparing all pairs, we can: 👉 Group indices of the same value 👉 Use prefix sums to efficiently calculate distances 🧠 Approach: Group indices by value (using HashMap) For each group: Build prefix sum of indices For each index: Left contribution → i * count - sum Right contribution → sum - i * count Combine both to get final result 📈 Complexity: Time: O(n) Space: O(n) ✨ Takeaway: When you see distance-based problems: 👉 Think in terms of contributions instead of pair comparisons 👉 Prefix sums can turn expensive computations into linear time Another strong pattern added to the toolkit 💪 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #PrefixSum #Algorithms #LearningEveryday

🚀 Day 70 — LeetCode Practice ✅ Problem Solved: Minimum Operations to Make Array Sum Divisible by K 💡 What I learned today: • Understood how modulus (%) helps in solving optimization problems • Learned that instead of performing operations repeatedly, we can directly use math logic • Realized that the answer depends on sum % k • Improved thinking towards efficient (O(n)) solutions 📊 Approach: • Calculated total sum of the array • Found remainder using sum % k • That remainder itself gives the minimum operations required 🎯 Key Insight: Sometimes, problems look complex but can be solved using simple mathematical observations instead of brute force 🔥 Consistency is the key — showing up every day! #Day70 #LeetCode #DSA #CodingJourney #ProblemSolving #Consistency #Java

💡 Day 57 of LeetCode Problem Solved! 🔧 🌟 Maximum Distance Between a Pair of Values 🌟 🔗 Solution Code: https://lnkd.in/gSP_QePE 🧠 Approach:  • Two-Pointer Strategy: Maintain two indices (i for nums1 and j for nums2) to scan both non-increasing arrays in a single efficient pass. • Greedy Search: If nums1[i] <= nums2[j], calculate j - i and expand j to find the maximum possible distance. If the value in nums1 is too large, move i forward. ⚡ Key Learning:  • Leveraging the non-increasing nature of arrays with two pointers eliminates the need for nested loops, reducing complexity from O(N^2) to linear O(N+M). ⏱️ Complexity:  • Time: O(n + m) • Space: O(1) #LeetCode #Java #DSA #ProblemSolving #Consistency #100DaysOfCode #CodingJourney #Algorithms #TwoPointers

🚀 LeetCode Challenge 7/50 🔍 Problem: Valid Anagram Today’s problem was about checking whether two strings are anagrams of each other efficiently. 💡 Approach: I used the Character Frequency Count method: First checked if both strings have equal length Used an array of size 26 to track character frequencies Incremented counts for one string and decremented for the other If all values are zero, both strings are anagrams ⚡ This approach avoids sorting and ensures optimal performance. 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(1) 📚 Key Learning: Using frequency arrays is a powerful technique for string problems. It helps achieve constant space complexity and improves efficiency compared to sorting-based approaches. Step by step, getting better at problem solving 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning

🚀 Day 23/100 — #100DaysOfLeetCode Another challenging day — pushing deeper into advanced Sliding Window problems 💻🔥 ✅ Problem Solved: 🔹 LeetCode 76 — Minimum Window Substring 💡 Concepts Used: Sliding Window HashMap Frequency Counting Two Pointer Optimization 🧠 Key Learning: The goal was to find the smallest substring containing all characters of another string. Key approach: Expand the window until all required characters are included. Track character frequencies carefully. Shrink the window while maintaining validity to get the minimum length. ⚡ Big Insight: Sliding Window isn’t only about longest substrings — it can also efficiently solve minimum window optimization problems. This problem really tested attention to detail and window management logic. Consistency is turning difficult problems into enjoyable challenges 🚀 #100DaysOfLeetCode #LeetCode #DSA #SlidingWindow #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic #Consistency

🚀 LeetCode Challenge 2/50 💡 Approach: Greedy Algorithm (One Pass) The naive approach checks every pair of days — that's O(n²). Instead, I used a Greedy strategy: track the minimum price seen so far and calculate the potential profit at every step! 🔍 Key Insight: → Keep updating the minimum buy price as we traverse → At each day, check if selling today gives a better profit → No extra space needed — just two variables! 📈 Complexity: ✅ Time: O(n) — single pass through the array ✅ Space: O(1) — constant space Greedy algorithms teach us that sometimes the smartest move is the simplest one — look ahead, not back! 💰 #LeetCode #DSA #GreedyAlgorithm #Java #ADA #PBL2 #LeetCodeChallenge #Day2of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #BestTimeToBuyAndSellStock