Dynamic Programming for Longest Common Subsequence

🚀 PART of Coding Practice – Finding the Most Frequent Element in an Array (Java) Today I worked on a classic yet important problem in Data Structures & Algorithms 👇 🔍 Problem Statement Given an array of integers, find the most frequent element (the element that appears the highest number of times). 💡 My Approach (Brute Force) I used a nested loop approach: For each element, I counted how many times it appears in the array. Tracked the maximum count. Stored the element with the highest frequency. 👉 Time Complexity: O(n²) 👉 Space Complexity: O(1) 🧠 Code Logic in Simple Words Take input array Loop through each element Count its frequency using another loop Update max frequency and result Print the most frequent element 📌 Sample Input Array: [1, 2, 2, 2, 3] ✅ Output Most Frequent Element: 2 🧪 Test Cases I Tried ✔️ Test Case 1 Input: [4, 4, 5, 5, 5, 6] Output: 5 ✔️ Test Case 2 (All Unique) Input: [1, 2, 3, 4] Output: 1 (or any first element since all frequencies are same) ✔️ Test Case 3 (Single Element) Input: [7] Output: 7 ✔️ Test Case 4 (Negative Numbers) Input: [-1, -1, -2, -2, -2] Output: -2 🤔 Can We Do It Even Better? Can you solve this problem using: HashMap? Sorting? Without extra space? ❓ Challenge for You 💬 Try solving this: Find the top 2 most frequent elements in an array. 📈 My Learning Today Importance of optimization Difference between Brute Force vs Efficient Approach How frequency-based problems are common in interviews I’m consistently improving step by step 💪 Would love your suggestions on improving this further 🙌 #Java #DSA #CodingJourney #ProblemSolving #DataStructures #100DaysOfCode #Learning #Tech #InterviewPreparation #DeveloperJourney

🚀 LeetCode #1550 | Spot the Pattern Fast! Small problem, but great for building observation skills 👀 🔢 Problem: Given an integer array "arr", return "true" if there are three consecutive odd numbers in the array. Otherwise, return "false". 👉 Example: Input: "arr = [2, 6, 4, 1, 3, 5]" Output: true (because 1, 3, 5 are consecutive odd numbers) --- 🧠 Approach: - Traverse the array - Keep a count of consecutive odd numbers - Reset count when you see an even number - If count reaches 3 → return true ✅ --- 💻 Java Code: class Solution { public boolean threeConsecutiveOdds(int[] arr) { int count = 0; for(int num : arr){ if(num % 2 != 0){ count++; if(count == 3){ return true; } } else { count = 0; } } return false; } } --- 🎯 Key Learnings: ✔ Pattern recognition in arrays ✔ Using a counter efficiently ✔ Reset logic (very important in interviews) --- 💡 Real-Life Analogy: Imagine checking rainy days ☔ - 1 rainy day → okay - 2 rainy days → still fine - 3 continuous rainy days → problem! 😄 --- 🔥 Why solve this? This question improves your ability to detect continuous patterns, which is asked a lot in interviews! --- #LeetCode #Java #DSA #Coding #ProblemSolving #Placements #SoftwareEngineer #Learning

Most people think Time Complexity means how much time a program takes to run ❌ But that’s NOT the correct way to understand it. Here’s the real explanation 👇 🔹 Time Complexity • It does NOT measure actual time (seconds/minutes) • It measures the number of operations an algorithm performs as input size (n) increases 👉 In simple words: Time Complexity = How many steps your code executes 🔹 Example: for(int i = 0; i < n; i++) { System.out.println(i); } 👉 This loop runs n times 👉 So number of operations ≈ n ✅ Time Complexity = O(n) 🔹 Another Example: for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { System.out.println(i + " " + j); } } 👉 Outer loop → n times 👉 Inner loop → n times 👉 Total operations ≈ n × n = n² ✅ Time Complexity = O(n²) --------------------------------------------- 🔹 Space Complexity • It does NOT mean total RAM of your system ❌ • It measures the extra memory used by the program 👉 In simple words: Space Complexity = How much extra space your code needs 🔹 Example: int sum = 0; 👉 Only one variable used ✅ Space Complexity = O(1) (constant space) 🔹 Another Example: int[] arr = new int[n]; 👉 Array size depends on n ✅ Space Complexity = O(n) 🔹 Why this matters? ✅ Helps you write efficient code ✅ Important for coding interviews ✅ Used in real-world systems handling large data 💡 Final Thought: It’s not about how fast your code runs on your laptop, it’s about how your code scales when input becomes huge. Save this post if you are preparing for DSA 🚀 #DSA #TimeComplexity #SpaceComplexity #CodingInterview #Programming #Java #LearnToCode

🔥 Day 100 of #100DaysOfCode — FINAL DAY 🎯 Today’s problem: LeetCode – Reverse Linked List 🔗🔄 📌 Problem Summary You are given the head of a singly linked list. 👉 Reverse the list and return the new head. Example: [1,2,3,4,5] → [5,4,3,2,1] 🧠 Approach: Iterative (Two Pointers) We reverse the list by changing the direction of pointers. ⚙️ Logic We maintain three pointers: prev → previous node (initially null) curr → current node (starts at head) next → temporary pointer to store next node 💻 Code Insight ListNode prev = null; ListNode curr = head; while(curr != null){ ListNode temp = curr.next; curr.next = prev; prev = curr; curr = temp; } return prev; 💡 How It Works At each step: Reverse the link (curr.next = prev) Move both pointers forward Gradually, the entire list gets reversed. ⏱ Time Complexity: O(n) 💾 Space Complexity: O(1) 🚀 Performance Runtime: 0 ms Beats 100% submissions 🔥 Memory: 44.29 MB 🧠 Key Learning This is one of the most fundamental linked list problems. It teaches: Pointer manipulation In-place operations Iterative thinking 🎉 100 Days Completed! From: Arrays & Strings Sliding Window Stack & Queue Monotonic Stack Binary Search Linked Lists 👉 To building strong problem-solving skills 💪 Consistency > Motivation 🔥 🚀 What’s Next? Start Advanced DSA (Graphs / DP) Build real-world projects Contribute to Open Source (GSoC ready 💪) Practice mock interviews 💬 This journey is just the beginning. #100DaysOfCode #LeetCode #DSA #Java #CodingJourney #Consistency #InterviewPrep

Today’s challenge was all about logic and boundary management. Solving the Spiral Matrix in Java isn't just about the code; it’s about visualizing how to traverse a 2D array while keeping track of four changing boundaries (top, bottom, left, right). It’s easy to get lost in the indices, but once the logic clicks, it feels like magic. These are the kinds of problems that sharpen the mind for the rigorous interviews at companies like Google and Microsoft. One step closer to the goal! 🚀 #DSA #Java #CodingJourney #SpiralMatrix #ProblemSolving #SoftwareEngineer #DataStructures #Algorithms

Day 18/100 of DSA , (Arrays) 🚀Toady I Solved: classic 3Sum problem — and it turned out to be more about thinking than just coding. 💡 At first, brute force (three nested loops) seemed simple. But O(n³) complexity clearly isn’t scalable. 🚫 Here’s what I applied: 🔹 Sorted the array 🔹 Fixed one element at a time 🔹 Used the Two Pointer technique 🔹 Carefully handled duplicates 🔹 Optimized time complexity to O(n²) What I learned today: Problem solving isn’t about memorizing answers. It’s about training your brain to recognize patterns and make logical decisions under constraints. 🧠 Small improvements in logic create big improvements in performance. 📈 Every DSA problem I practice is a step toward stronger fundamentals and better interview confidence. 🚀 #DSA #Java #ProblemSolving #InterviewPreparation #CodingJourney #FutureDeveloper

🚀Day - 24 | Day - 8: Deep Dive into Linked Lists! Today, my DSA journey took me beyond the basics of Arrays and into the flexible world of Linked Lists. While Arrays are great, I quickly realized they have their limits—specifically when it comes to memory and efficiency. 📉 The "Array" Problem Arrays require contiguous memory, which can be a pain to allocate for large datasets. Plus, inserting or deleting elements is expensive because you have to shift everything else around. 💡 The Solution: Linked Lists A Linked List is a collection of Nodes. Each node is like a small container with two parts: Data: The actual value you want to store. Next (Address): A pointer/reference to the next node in the sequence. The list starts with a Head and ends when a node points to Null. No more shifting elements! Just update the pointers, and you're good to go. 🛠️ What I Built Today I moved from theory to implementation using Java. Here’s a snapshot of what I practiced: Structure: Defined the Node using Classes and Objects. Traversal: Mastered the while loop to navigate the list (since we don't have indexes like Arrays). Core Operations: Adding elements (at the beginning, end, and specific indexes). Removing elements (first and last). Printing the entire list. 🧠 Key Takeaway If you need fast insertions and deletions without worrying about pre-allocating memory blocks, Linked Lists are best. A big thanks to Poovizhi Mam for the clear explanation and hands-on coding practice✨ #DSA #CodingJourney #Java #DataStructures #LinkedList #LearningInPublic #SoftwareEngineering

Two Pointers pattern — done. Here's what the last few days actually taught me. 🧵 Three Sum is Two Sum with a loop around it. First time I saw Three Sum — find all triplets that sum to zero — I thought it was a completely different problem. Turns out it isn't. Fix one element i. Now you just need two numbers from the rest of the array that sum to -arr[i]. That's Two Sum. Which is Two Pointers. Which you already know. Three Sum = loop + Two Sum. Four Sum = loop + Three Sum. The pattern scales. The core never changes. --- Dutch National Flag — the hardest-looking problem with the simplest explanation. Sort an array of only 0s, 1s, and 2s. In-place. No sort(). Single pass. The instructor explained it as a teacher sorting students — toppers (0) to the front, failures (2) to the back, average (1) stays in the middle. Three pointers: low, mid, high. Mid scans the unsorted zone and decides where each element belongs. O(n) time. O(1) space. One pass. The analogy made the algorithm stick instantly. --- The real output of this pattern: a decision framework. After every question, the same signals kept showing up: → Array or linked list problem → Sorted, or sorting helps → Merge / rearrange / remove duplicates in-place → Find a pair, triplet, or quadruplet Match two or more of these → Two Pointers is almost certainly the answer. Not intuition. A repeatable framework. Next: Sliding Window. Which, turns out, is just a specific type of Two Pointers. 💻 #DSA #TwoPointers #LeetCode #Java #CodingJourney #DSAPatterns #PadhoWithPratyush Pratyush Narain

Solved the Spiral Matrix problem by traversing the matrix layer by layer. The approach uses four boundaries — top, bottom, left, and right — to systematically move in a spiral direction and collect elements. By adjusting the boundaries after each traversal (left to right, top to bottom, right to left, and bottom to top), the algorithm ensures every element is visited exactly once without repetition. Time Complexity: O(n × m)  Space Complexity: O(1) (excluding output list) Understanding boundary-based traversal patterns is important for solving matrix problems efficiently and writing clean, structured, and interview-ready code. #Java #DSA #ProblemSolving #Coding #SoftwareEngineering #LeetCode #Developers

🚀 Daily DSA Practice – Day 63 | Dynamic Programming – Longest Increasing Subsequence (Optimized) (Java) Continuing my DSA journey, today I revisited a classic problem with an optimized approach, improving time complexity significantly. 📌 Problem Solved (LeetCode): 300. Longest Increasing Subsequence (Medium) 🎯 Concept: Binary Search + Dynamic Programming Optimization 🧠 Problem Idea: Previously, I solved LIS using O(n²) DP. Today, I learned the optimized O(n log n) approach using Binary Search. Instead of storing all subsequences, we maintain a list where: Each index represents the smallest possible tail of an increasing subsequence of that length Logic If current element > last → append Else → replace using binary search 🔍 What I Practiced: ✔ Optimizing DP from O(n²) → O(n log n) ✔ Applying binary search in DP problems ✔ Understanding greedy + DP hybrid approach ✔ Improving performance for large input constraints This problem taught me how optimization techniques can make a huge difference in efficiency, which is critical in coding interviews. #DSA #LeetCode #DynamicProgramming #Java #BinarySearch #ProblemSolving #InterviewPreparation #Consistenc