Solved Longest Common Prefix on LeetCode with Java

🚀 Day 71 of My LeetCode Journey 🚀 Problem : Valid Parentheses Today I solved Valid Parentheses, a classic stack-based problem that checks whether a sequence of brackets is balanced. 🔍 Key Idea: Use a Stack to track opening brackets. Push ( { [ onto the stack When you see a closing bracket, check if it matches the top of the stack If it doesn't match, the string is invalid In the end, stack must be empty 🧠 Concepts Practiced: Stack operations String traversal Matching bracket logic Clean conditional validation 💡 Learning: This problem reinforces how stacks are perfect for handling “last opened, first closed” scenarios. It’s simple but builds strong fundamentals for parsing and expression evaluation problems. #100DaysOfCode #LeetCode #Java #DSA #CodingJourney #Stack #ProblemSolving #LearningEveryday #TechCareer #Programmer

Introducing My Automated Contest Code Reminder! As developers, we often juggle multiple tasks — projects, classes, deadlines — and sometimes we miss competitive programming contests simply because we forget. To solve this, I built an Automated Contest Code Reminder that keeps you updated and helps you stay consistent with coding practice. 🔧 What it does: ✔ Fetches upcoming programming contests from platforms like CodeChef, CodeForces, LeetCode, etc. ✔ Sends automated reminders directly to your email/phone before the contest starts. ✔ Helps you maintain consistency, improve your rankings, and never miss a contest again. 💡 Tech Stack: Python | APIs | Automation | Scheduling Github link: https://lnkd.in/gixnHXNn

Day 26 of #100DaysOfCode 🚀 Today's problem was all about balance — literally. 🔹 LeetCode 1941 — Check if All Characters Have Equal Number of Occurrences The task: Verify whether every character in a string appears the same number of times. At first glance, it looks simple — but it's a great exercise in clean logic, frequency counting, and edge-case handling. 🧠 Approach (Java): Use an array of size 26 to store character frequencies. Track the first non-zero frequency. Compare all other non-zero counts with it. If any mismatch occurs → return false. Otherwise, the string is perfectly balanced. A small problem, but a powerful reminder that clarity > complexity. Efficient logic and readable code always scale better in the long run. 💡 Key Takeaway Mastering these bite-sized logic checks builds strong intuition for: ✔ string manipulation ✔ hashing concepts ✔ pattern consistency ✔ frequency-based problem solving These fundamentals become the building blocks for bigger DSA challenges. #100DaysOfCode #Day26 #LeetCode #DSA #JavaDeveloper #CodingJourney #ProblemSolving #Programming #Strings #Hashing #LearningEveryday #TechJourney

🎯 LeetCode Day 46 – Unique Paths (Dynamic Programming) 🚀 Today’s challenge was about finding the number of unique paths in an m x n grid — you can only move right or down. 💡 I optimized it using a 1D Dynamic Programming approach, reducing space complexity from O(m*n) to O(n). The idea: Each cell = sum of paths from top and left. By updating rows iteratively, we achieve efficiency and elegance. ⚡ Result: ✅ All 64 test cases passed ⏱ Runtime: 0 ms (beats 100%) 💾 Memory: 40.25 MB (beats 89.65%) 📈 Learning: Sometimes, optimizing space is as impactful as optimizing time! #LeetCode #Day46 #DynamicProgramming #Java #CodingJourney #ProblemSolving #50DaysOfCode

🎯 LeetCode Day 46 – Unique Paths (Dynamic Programming) 🚀 Today’s challenge was about finding the number of unique paths in an m x n grid — you can only move right or down. 💡 I optimized it using a 1D Dynamic Programming approach, reducing space complexity from O(m*n) to O(n). The idea: Each cell = sum of paths from top and left. By updating rows iteratively, we achieve efficiency and elegance. ⚡ Result: ✅ All 64 test cases passed ⏱ Runtime: 0 ms (beats 100%) 💾 Memory: 40.25 MB (beats 89.65%) 📈 Learning: Sometimes, optimizing space is as impactful as optimizing time! #LeetCode #Day46 #DynamicProgramming #Java #CodingJourney #ProblemSolving #50DaysOfCode

💥 Stop solving 500 random Leetcode questions! If you can master these 7 patterns, you can crack any DSA problem. Most developers don’t need more problems they need clarity on the patterns behind them. 🚀 Here’s what I wish I knew earlier: If you understand 1. Sliding Window 2. Two Pointers 3. Binary Search 4. Recursion 5. Dynamic Programming 6. Greedy 7. Backtracking ...then every new problem will start to look familiar. 💡 Save this post 🔖 and start with one pattern a week. Your consistency will matter more than your question count. 👇 Comment which pattern took you the longest to understand! #DSA #Java #BackendDevelopment #Leetcode #ProgrammersLife

🚀 Day 40 of My #LeetCode Challenge 🚀 📘 Problem: Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold (LeetCode #1343) 💡 Approach: Implemented the Sliding Window technique to efficiently calculate the sum of each subarray of size k. First, compute the sum of the initial k elements. Then, slide the window forward — subtract the element leaving and add the new one entering. Check if the average of the current window meets or exceeds the given threshold. This method optimizes the time complexity to O(n) by avoiding repetitive summation. ⏱️ Concepts Used: Sliding Window | Arrays | Optimization | Time Complexity 🔥 Consistency and logic go hand in hand — every day adds a new layer to my problem-solving skills! #Day40 #LeetCode #100DaysOfCode #CodingChallenge #Java #DSA #ProblemSolving #CodingJourney #TechLearning #CodeEveryday #SoftwareEngineering #ProgrammerLife #CodingCommunity #Developer #JavaProgramming #LearnToCode #TechGoals #CodeNewbie #Algorithm #DataStructures #CodingPractice

🚀 Day 06/10 of Linked List Series: Delete a Node at the Beginning 🎯 Let’s understand the concept in a simple and beginner-friendly way 👇 🧠 Algorithm (Step-by-Step): 1️⃣ Start with the head of the linked list (first node). 2️⃣ Check if the list is empty — if yes, there’s nothing to delete. 3️⃣ If not empty, move the head pointer to the next node. 4️⃣ The old head node gets disconnected automatically (deleted). 5️⃣ Return the new head of the list. 💡 In short: Deleting at the beginning simply means — 👉 “Make the second node the new head of the list.” This is one of the simplest and most common operations in Linked Lists. 🔥 Stay tuned for the next part in the series! #CodeWithLakkojuEswaraSai #CodeWithLakkojuEswaraSai_LinkedList #10000Coders #LinkedList #DataStructures #LearnCoding #JavaForBeginners #ProgrammersLife #CodingCommunity #TechLearning #CodingJourney #DSASeries #Leetcode #JavaDeveloper #FullStackDeveloper

🚀 Sharpening My DSA Skills with Java on LeetCode Lately, I’ve been consistently solving problems on LeetCode, focusing on enhancing my problem-solving, logical thinking, and Java programming skills. 💻 Each challenge helps me approach problems more efficiently and think beyond conventional logic. Here are a few recent problems I worked on 👇 🔹Maximum Product of Three Numbers 🧠 Approach: Sort the array and consider two possibilities — Product of the three largest numbers Product of the two smallest (negative) numbers with the largest number Then, take the maximum of both results. 🔹Minimum Index Sum of Two Lists 🧩 Approach: Compare all common elements between both lists and calculate their index sums. Track the minimum index sum and update the result list dynamically. 🔹Set Mismatch 📊 Approach: Use a HashMap to detect the duplicate number. Then iterate through the range 1 to n to find the missing one not present in the map. 💡 Key Takeaway: Each problem refined my understanding of data structures, algorithm design, and optimization — all essential for writing cleaner and efficient Java code. 🚀 👨💻 Check out my complete DSA journey on LeetCode: 👉 leetcode.com/u/amans_01/ #Java #LeetCode #DSA #ProblemSolving #CodingJourney #SoftwareDevelopment #LearningEveryday #JavaDeveloper

✅ Day 59 of LeetCode Medium/Hard Edition Today’s challenge was “Maximum Alternating Subsequence Sum” — a beautifully balanced dynamic programming problem that turns simple addition into an elegant alternation of signs ⚖️➕➖ 📦 Problem: Given an integer array nums, you need to choose a subsequence (not necessarily contiguous) that maximizes its alternating sum, defined as the sum of elements at even indices minus the sum of elements at odd indices. For example: nums = [4,2,5,3] → optimal subsequence [4,2,5,3] gives (4 + 5) - (2 + 3) = 4. 🔗 Problem Link: https://lnkd.in/g5M-iugB ✅ My Submission: https://lnkd.in/gUmnEyUU 💡 Thought Process: At each index, we have two choices — either include the current element (flipping the sign based on its position in the subsequence) or skip it. This naturally forms a two-state dynamic programming model: turn = 0 → we add the number (even position) turn = 1 → we subtract the number (odd position) The recurrence relation becomes: dp[i][turn] = max( (turn == 0 ? +nums[i] : -nums[i]) + dp[i+1][1-turn], dp[i+1][turn] ) Using memoization, we ensure that overlapping subproblems are efficiently reused. ⚙️ Complexity: ⏱ Time: O(n) 💾 Space: O(n) (can be optimized to O(1)) ✨ Key Insight: What makes this problem elegant is how a simple alternation pattern translates into a strategic inclusion/exclusion decision — showing the beauty of dynamic programming in managing state transitions efficiently. #LeetCodeMediumHardEdition #100DaysChallenge #DynamicProgramming #Recursion #ProblemSolving #Java #LeetCode #CodingChallenge