Day 3: DSA Practice with LeetCode, Focused on Algorithmic Thinking

🚀 Day 9 & 10 of My DSA Journey – Consistency Over Excuses Missed posting yesterday, but didn’t miss practicing. Over the last two days, I focused on understanding problem-solving patterns instead of just solving random questions. 🔹 What I worked on: ✔ Two Pointer Technique ✔ Sliding Window Basics ✔ Remove Duplicates from Sorted Array ✔ Move Zeroes ✔ Best Time to Buy and Sell Stock ✔ Time & Space Complexity Analysis 💡 Key Realization: DSA is not about memorizing solutions. It’s about recognizing patterns. When you understand: • When to use two pointers • How to reduce nested loops • How to optimize brute force • How to think before coding Problems start feeling structured instead of scary. Another important lesson 👇 Before writing code, spend 5 minutes thinking about: - Pattern - Edge cases - Optimal approach - Coding is easy. - Clear thinking is the real skill. Day by day, I can feel my logic improving and confidence building. Preparing seriously for placements and product-based companies 🚀 Consistency > Motivation. #DSAJourney #Day9 #Day10 #Coding #ProblemSolving #TCSNQT #Placements #Python #SoftwareEngineer #GrowthMindset

Day 19 of my #50DaysOfCode challenge is done ✅ 📌 Problem Solved Print All Prime Factors of a Number We were given an integer N. We had to print all its prime factors. This one was more number theory based. Let’s understand it simply. ◾️Imagine you want to break a number into its smallest building blocks. ◾️Those building blocks must be prime. ◾️When you multiply them back, you should get the original number. That’s prime factorization. --- 💻 Brute Force Approach 🔹️Start from 2 till n. 🔹️Check if i divides n. 🔹️If yes, check if i is prime. 🔹️If prime, add it to list. Time Complexity: Higher. Because we check many numbers. Works. But not efficient. --- 💻 Optimal Approach 🔹️Start from 2 till √n. 🔹️If i divides n, add it to list. 🔹️Keep dividing n by i in a while loop. 🔹️Remove repeated factors. 🔹️Continue till √n. 🔹️If remaining n > 1, it is also a prime factor. Time Complexity: O(√N) Space Complexity: O(√N) Much better than checking till n. --- 📚 What I learned today: ▫️We don’t need to check till n. √n is enough. ▫️Repeated division reduces unnecessary checks. ▫️Prime factor problems are about observation. ▫️Number theory concepts are important for coding interviews. Day 19 completed. Math + logic together today 🚀 #50DaysOfCode #CodingChallenge #Consistency #LearningInPublic

🚀 Day 12 of #Consistency — LeetCode Grind Continues! Today I solved Minimum Operations to Equalize Binary String — a really interesting problem that blends math reasoning, parity observation, and greedy thinking. 🔗 Problem link: https://lnkd.in/dPqcXx3N 💡 My solution: https://lnkd.in/dTcN-qcT 🧠 Key Learning Instead of simulating operations, the core idea was to analyze the count of 0s and how group operations of size k impact feasibility. The tricky part was realizing: ✅ Operations introduce parity constraints ✅ We must evaluate both odd and even operation scenarios ✅ The answer becomes a mathematical bound problem rather than a simulation problem This shift in thinking helped derive an O(n) solution with O(1) space. 📌 Takeaway Many hard problems become manageable once you: 👉 Stop thinking operationally 👉 Start thinking in terms of invariants and constraints That mindset change is what makes DSA powerful 💯 Day 12 done ✔️ On to Day 13 tomorrow 🔥 #LeetCode #DSA #ProblemSolving #CodingJourney #Consistency #SoftwareEngineering #Java #InterviewPreparation

DSA Starts Making Sense When You Learn It Pattern-Wise Many developers approach DSA by jumping between random problems. The result? Progress often feels slow and inconsistent. Effective DSA preparation comes from recognizing that most problems are built around repeating patterns. Once you understand the pattern behind a problem, solving similar questions becomes significantly easier. A Practical Preparation Strategy- • Identify core DSA patterns • Focus on mastering one pattern at a time • Solve multiple problems that follow the same logic • Move to the next pattern only after gaining confidence Fundamental DSA Patterns Every Learner Should Know 1) Sliding Window 2) Two Pointers 3) Hashing & Frequency Map 4) Prefix Sum 5) Binary Search (on array & answer) 6) Recursion & Backtracking 7) Linked List Patterns 8) Stack & Monotonic Stack 9) Heap / Priority Queue 10) Greedy 11) Dynamic Programming 12) Graph Traversal (BFS / DFS) 13) Tree Traversal 14) Bit Manipulation When you prepare DSA pattern-wise: ✔ Problem recognition becomes faster. ✔ Solutions become more structured and confident. ✔ Learning shifts from memorization to understanding. Strong DSA skills are rarely about volume. They come from mastering foundational patterns. 📌 Save this as a structured DSA preparation roadmap. hashtag #DSA #CodingInterview #Python #PlacementPreparation #LeetCode #PatternBasedDSA #PythonDeveloper #SoftwareEngineering

🔥 Day 54 of #100DaysOfCode 📌 Solved: Sort an Array (LeetCode 912) Today’s problem was all about mastering sorting fundamentals without using built-in functions — a real test of understanding core algorithms. 💡 Problem Insight: We are given an array of integers and need to sort it in ascending order with O(n log n) time complexity. 👉 This rules out simple approaches like Bubble Sort or Selection Sort ❌ 👉 Forces us to use efficient algorithms like: ✔️ Merge Sort ✔️ Quick Sort ⚙️ Approach I Used: Merge Sort 🔹 Divide the array into halves 🔹 Recursively sort both halves 🔹 Merge them in sorted order 🚀 Key Learnings: ✅ Divide & Conquer strategy ✅ Importance of time complexity ✅ Writing sorting logic from scratch (no shortcuts!) ✅ Handling edge cases while merging arrays 📊 Result: ✔️ Accepted ✅ ⏱️ Runtime: 999 ms 💾 Memory: Optimized #Day54 #LeetCode #DSA #Python #CodingJourney #100DaysOfCode #ProblemSolving #Tech #Developers #Learning

DSA Starts Making Sense When You Learn It Pattern-Wise Many developers approach DSA by jumping between random problems. The result? Progress often feels slow and inconsistent. Effective DSA preparation comes from recognizing that most problems are built around repeating patterns. Once you understand the pattern behind a problem, solving similar questions becomes significantly easier. A Practical Preparation Strategy- • Identify core DSA patterns • Focus on mastering one pattern at a time • Solve multiple problems that follow the same logic • Move to the next pattern only after gaining confidence Fundamental DSA Patterns Every Learner Should Know 1) Sliding Window 2) Two Pointers 3) Hashing & Frequency Map 4) Prefix Sum 5) Binary Search (on array & answer) 6) Recursion & Backtracking 7) Linked List Patterns 8) Stack & Monotonic Stack 9) Heap / Priority Queue 10) Greedy 11) Dynamic Programming 12) Graph Traversal (BFS / DFS) 13) Tree Traversal 14) Bit Manipulation When you prepare DSA pattern-wise: ✔ Problem recognition becomes faster. ✔ Solutions become more structured and confident. ✔ Learning shifts from memorization to understanding. Strong DSA skills are rarely about volume. They come from mastering foundational patterns. 📌 Save this as a structured DSA preparation roadmap. #DSA #CodingInterview #Python #PlacementPreparation #LeetCode #PatternBasedDSA #PythonDeveloper #SoftwareEngineering

One analogy completely rewired how I think about arrays. 🧠 Yesterday I talked about why I'm learning DSA through patterns, not topics. Today was the first real pattern: Two Pointers. Here's what clicked for me — The instructor explained it like this: imagine you're on the ground floor of a building and need to meet someone on the top floor. If only you move, you climb 4 floors. But if a second person starts from the top and walks down at the same time — you both only move 2 floors and meet in the middle. Same work. Half the time. That's Two Pointers. Instead of one index crawling through an array (O(n²)), you use two indices moving toward each other in coordination — cutting the time in half. The pattern applies when you see: → Sorted array or sorting would help → Merge, remove duplicates, or rearrange in the question → Find a pair/triplet with a target sum → "Do not use extra space" mentioned → Detect cycle in a linked list We also covered the Remove Duplicates problem today. The approach: one pointer (the "CM") scans the array checking for unique elements. Another pointer (the "Officer") marks the last confirmed unique position. When CM finds something new, it hands it to Officer — who places it in the next available spot. Two pointers. Zero extra space. O(n) time. The big lesson today wasn't just the algorithm — it was the flowchart mindset. Before jumping to code, ask: is this an array/linked list problem? Is it sorted? What are you looking for? That thinking process is what separates pattern-based learning from blind grinding. Tomorrow more Two Pointer problems. 💻 Following Pratyush Narain DSA Patterns in 2 Months series — highly recommend it if you're starting out. #DSA #TwoPointers #LeetCode #Java #CodingJourney #DSAPatterns #100DaysOfCode #PadhoWithPratyush

🚀 Day 17/50 – LeetCode Challenge 🧩 Problem: Longest Common Subsequence (LCS) Today I worked on the Longest Common Subsequence problem, which is a classic example of Dynamic Programming and appears frequently in coding interviews. 📌 Problem Summary: Given two strings, the goal is to find the length of the longest subsequence that appears in both strings in the same order (not necessarily contiguous). Example: String 1 → "abcde" String 2 → "ace" Output → 3, because "ace" is the longest common subsequence. 🔍 Approach Used ✔ Used Dynamic Programming (DP) ✔ Created a 2D table to store intermediate results ✔ Compared characters of both strings step by step ✔ If characters matched → increase the subsequence length ✔ Otherwise → take the maximum value from previous results ⏱ Time Complexity: O(m × n) 📦 Space Complexity: O(m × n) 💡 Key Learning ✔ Understanding dynamic programming patterns ✔ Solving problems with overlapping subproblems ✔ Improving logical thinking for sequence comparison problems Problems like LCS are important because they form the foundation for many advanced algorithms used in bioinformatics, text comparison, and version control systems. Consistency in problem solving is the key to improvement 🚀 #LeetCode #DSA #DynamicProgramming #ProblemSolving #CodingJourney #FutureAIEngineer #Consistency

No human is limited.🚀 I recently embarked on a self-paced journey into Python coding, specifically tackling matrices in lists. For a long time, this was a "complex section" that I struggled to understand whenever I tried to learn it on my own. However, by embracing the 5 AM challenge every morning, I’ve discovered a fundamental truth: consistency pays. Here are three insights I’ve gained from this experience: Flex Your Mental Muscles: As a speaker recently shared in a virtual meeting, "the more you flex your muscle, the stronger they become". When you apply consistency to a difficult skill like coding, you don't just learn—you gain excellence, perfection, and growth in stamina. The "Brain Upgrade": Since discovering this secret of self-discovery, I feel as though my brain’s memory speed has been upgraded. It is a level of mental performance I wish I had mastered back in my college days. Break Your Limits: We often set internal boundaries on what we can understand, but those limits are meant to be pushed through disciplined, daily effort. Whether you are learning a new language, a technical skill, or a new hobby, the secret isn't just talent it’s the discipline of showing up. What is one "complex" topic you've finally mastered through consistency? Let’s inspire each other in the comments! 👇 #Python #GrowthMindset #100DaysOfCode #Discipline #SelfDiscovery #5AMClub

Day 49 – Making a Slow Algorithm Faster 🚀 Yesterday (Day 48) I explored a problem that many beginners run into in programming. The task was simple: Given a list of numbers, find all pairs that add up to a target value. The first solution I learned used nested loops. This meant every number was compared with every other number. Example thinking process: Take the first number Compare it with every other number Move to the second number Compare it with every other number again This works… but there’s a problem. If the list has n numbers, the algorithm checks roughly n × n combinations. This makes the algorithm O(n²). That means as the data grows, the program slows down very quickly. So How Do We Make It Faster? Instead of comparing every number with every other number, we can remember numbers we’ve already seen. This is where a set (or dictionary) becomes very useful. The idea becomes: Go through the list once For each number, calculate the number needed to reach the target Check if that number already exists in our set If it does → we found a pair If it doesn’t → store the current number and continue Now instead of comparing every number with every other number, we only loop once through the list. This reduces the complexity from: O(n²) → O(n) Which is a huge performance improvement. Why This Matters in Real Systems Imagine this logic inside: A payment system A recommendation engine A social media feed A large API handling thousands of requests If the algorithm is inefficient, the system becomes slow, expensive, and hard to scale. Good engineers don't just solve problems. They solve them in the most efficient way possible. Today's Lesson The biggest lesson today was learning that: The right data structure can transform a slow algorithm into a fast one. And that’s exactly why data structures and algorithms are the foundation of software engineering. #Day49 #Algorithms #DataStructures #BigO #Python #SoftwareEngineering #BackendDevelopment #LearningInPublic