Solved Course Schedule Problem with Topological Sort

🚀 [Day 12/30] Coding Challenge Journey with @Educative.io 💻 💡 Problem: Count Subarrays With Fixed Bounds Today’s challenge really tested my understanding of subarray patterns and sliding window logic. The task was to count all subarrays where the minimum and maximum values are exactly equal to given bounds — minK and maxK. At first, my approach was brute force — I generated all possible subarrays, calculated the min and max for each, and increased the count if they matched. It worked, but with a painful O(n² + n) time complexity 😅 Then came the optimization breakthrough 💡 — I introduced three variables: badIndex → to mark positions where elements go out of range minIndex and maxIndex → to store the latest positions of valid min and max For each element, if it stayed within bounds, I could efficiently calculate how many valid subarrays ended at that index by using: count += Math.max(0, Math.min(minIndex, maxIndex) - badIndex) This reduced the complexity to O(n) and turned an expensive brute force into a clean, efficient linear pass ⚡ 🔍 Key Learnings: Identifying invalid states early (like badIndex) saves massive computation. Most subarray problems can be optimized using index tracking instead of recalculating repeatedly. Optimization isn’t about writing less code — it’s about thinking one step deeper 🧠 ✨ Small win — seeing how a few well-chosen variables can simplify a seemingly complex logic! #30DaysOfCode #Day12 #CodingChallenge #DSA #Educative #ProblemSolving #JavaScript #SlidingWindow #Optimization #KeepCoding #LearningJourney #Subarrays

🚀 [Day 10/30] Coding Challenge Journey with Educative 💡 Problem: Group Anagrams Today’s challenge was an interesting one — grouping words that are anagrams of each other. This problem pushed me to think deeply about string manipulation and hashing techniques. At first, I tried a frequency map approach — creating a character map for each string and comparing it with others. Though it worked, it wasn’t efficient (≈ O(n × k²) 😅). Then I optimized it by sorting each string and using the sorted value as a key in a hash map — grouping all strings with the same key together. This brought down the complexity to O(n × k log k) and made the logic much cleaner. Finally, I explored another variation — building a frequency-based signature for each string (like "a1b1c1") and using that as the key. This further improved the complexity to O(n × k) and avoided unnecessary sorting 🎯 🔍 Key Learnings: Choosing the right key representation is crucial for efficiency. Hash maps are powerful tools for grouping problems. Optimization is all about rethinking your data structure, not just your logic. ✨ Small win — seeing the same problem solved in 3 different ways reminded me that there’s always room to improve your first approach 💪 #30DaysOfCode #Day9 #CodingChallenge #DSA #Educative #ProblemSolving #JavaScript #HashMap #Anagrams #Optimization #KeepCoding #LearningJourney

🚀 [Day 15/30] Coding Challenge Journey with @Educative.io 💻 💡 Problem: Similar String Groups Today’s problem was all about identifying relationships between strings and grouping them based on their “similarity.” Two strings are considered similar if they differ in exactly two character positions — meaning you can swap those characters to transform one into the other. My intuition started with this core idea: 👉 If two strings differ by exactly two positions, they belong to the same group. To solve this, I approached the problem like a graph traversal challenge: 1️⃣ Consider each string as a node in a graph. 2️⃣ Create an edge between two nodes if the strings differ by exactly two characters. 3️⃣ Use DFS to explore all connected strings that form a similarity group. 4️⃣ Maintain a visited array to ensure each string is processed once. So for each unvisited string, I triggered a DFS call. That DFS marked all strings connected to it (all strings that were similar by 2-character difference). This naturally formed groups of similar strings — each connected component counted as one group. This problem beautifully reinforced how string similarity + graph connectivity can come together to form a clean and efficient solution 🧠✨ 🔍 Key Learnings: Many string problems hide an underlying graph structure — discovering it is half the solution. DFS is extremely powerful for grouping, clustering, and connectivity problems. A simple rule (differ by 2 characters) can create surprisingly complex group relationships. ✨ Small win — once I mapped the problem to graph traversal instead of brute-force comparisons, everything became much more intuitive! #30DaysOfCode #Day15 #CodingChallenge #Educative #DSA #GraphTheory #DFS #JavaScript #ProblemSolving #StringAlgorithms #LearningJourney #KeepCoding

🚀 [Day 11/30] Coding Challenge #30DaysOfCode 💡 Problem: Set Matrix Zeroes Today’s challenge tested my ability to balance time and space complexity efficiently — the task was to modify a matrix such that if any element is 0, its entire row and column should be set to zero. I explored multiple approaches before reaching an optimal one 👇 1️⃣ Brute Force Approach: I iterated through the entire matrix, and whenever I found a 0, I used a helper function to mark all elements in its row and column as -1. After completing this marking process, I did another pass to convert all -1 values to 0. ✅ Simple logic, but inefficient due to multiple passes and extra checks. 2️⃣ Using Extra Arrays: Next, I maintained two separate arrays — one for rows and one for columns — to keep track of which rows and columns should become zero. This improved clarity and avoided redundant marking. 🧠 Time Complexity: O(m × n) | Space Complexity: O(m + n) 3️⃣ Optimized In-Place Solution: Finally, I optimized further by using the first row and first column of the matrix itself as markers — eliminating the need for extra space. This reduced the space complexity to O(1) while maintaining O(m × n) time complexity. ✨ It was fascinating to see how a small shift in perspective (reusing the same matrix for storage) made the solution much more elegant and efficient. 🔍 Key Takeaways: Always aim to optimize space without compromising clarity. Sometimes, the best memory to use is the one already in use! 😄 Breaking a problem into stages (brute force → optimized) builds strong problem-solving intuition. eager for next day challenge with Educative. #Day11 #CodingChallenge #Educative #DSA #ProblemSolving #JavaScript #LearningJourney #KeepCoding #Matrix #Optimization #CleanCode

Code doesn’t just work — it evolves. Every time I look back at code I wrote months ago, I realize how much I’ve grown — not because the code was bad, but because I’ve learned to write smarter, cleaner, and more efficient logic. That’s the beauty of programming — it’s not about writing perfect code, it’s about constant refinement. Whether it’s learning new syntax, debugging smarter, or mastering version control — every line teaches something new. What’s one coding lesson you’ve learned recently that changed how you write? Put it down in the comment section. #code #Techxcellence #Elevate #SpentAcademy

🚀 Day 3 of my 30-Day Coding Challenge with Educative.io Today’s problem looked simple but had some fun twists. The task: given a binary string, find the number of steps to reduce it to 1 by repeatedly 1)dividing by 2 if even 2)adding 1 if odd. At first, I tried converting the binary to a number and then looping. Lesson learned — in JavaScript, large binary strings (length > 53 bits) overflow the Number limit. My approach worked for small inputs but failed for long ones. After debugging, I discovered a smarter pattern: 1)Work directly on the binary string from right to left. 2)Use a carry variable to simulate “add 1” operations. 3)Count operations based on whether the current bit + carry is odd or even. This avoids conversion and runs in O(n) time for strings up to 500 characters! Here’s what I took away from this challenge: Always think about data type limits (JS Number ≠ unlimited integer). Sometimes the best solution is bit-level simulation instead of numeric math. Debugging is just as valuable as solving. #JavaScript #CodingChallenge #Educative #LearningInPublic #DSA #ProblemSolving #SoftwareEngineering

Why Practical Coding Matters More Than Theory One thing I’ve learned in my journey as a coding mentor is this: 👉 Most students don’t struggle with coding… they struggle with applying it. Anyone can memorize syntax. Anyone can watch tutorials for hours. But when it’s time to build something real, most learners freeze — not because they lack talent, but because they were never taught the practical side of coding. This is exactly why I started focusing on: 🔹 hands-on coding 🔹 real-world projects 🔹 debugging together 🔹 building small but meaningful applications Because coding becomes easier the moment you start creating, not consuming. I’ve seen students who couldn’t understand loops build full working apps within weeks — just because they shifted from “learning theory” to learning by doing. If you’re starting your coding journey, remember this: 💭 Your first project won’t be perfect. But it will be the most important step you take. Keep building. Keep breaking things. Keep improving. That’s how real programmers grow. 🚀 #CodingBlockHisar #Coding #Python #FullStack #Java #DataAnalytics #ProgrammingJourney #LearnToCode #Hisar

The Power of Small, Daily Progress in Coding When I first started learning to code, I believed that in order to get better, I would need to work for hours every day. To be honest, though, that strategy never succeeded. On some days, I felt exhausted, disoriented, or just angry. Then I decided to do something easy: Just code a little bit every day. 20 to 30 minutes, or even an hour is fine. And it changed everything. Some days I corrected a lot of mistakes. Some days I just watched tutorials. Some days I just practiced, built a lot of programs, and failed at many of them. But by learning to code daily, things started getting easier. I began to understand logic better, remember syntax naturally, and actually started enjoying the process. The truth is, small steps every day may not seem exciting, but over time they can become something exciting. Don't worry about being flawless if you're learning to code. Simply keep going, one line of code at a time. You'll be shocked at how far you can go with this consistency. #CodingJourney #Consistency #DeveloperLife #Python #WebDevelopment #KeepLearning

Cheat sheets for TONS of coding languages 😎 When you first start learning a new language, it can be extremely useful to have a cheat sheet. It can remind you of the basic commands/functions that you’ll be using most of the time! Best part is it’s free! Follow along for more free coding resources ✅ #code #coding #tech #learntocode

Day 115/250 🚀 Most beginners fail to solve this simple-looking problem efficiently! Today I solved “Remove Duplicates from Sorted Array” — one of the most popular LeetCode problems that tests your logical thinking and pointer manipulation skills. 💻 🧩 Problem Statement: Given a sorted array, remove all duplicate elements in-place, so that each element appears only once and return the new length of the array. 👉 No extra space allowed. 👉 Must modify the array in O(1) space. At first, it seems tricky — but the trick lies in using two pointers: 🔹 One pointer (x) to track the position of the last unique element. 🔹 Another pointer (i) to scan through the array. Every time we find a new unique element, we move the slow pointer forward and copy that element. In the end, x + 1 gives us the count of unique elements! ✅ Time Complexity: O(n) ✅ Space Complexity: O(1) ✅ Language Used: C++ 🔥 Hashtags #Coding #LeetCode #DSA #ProblemSolving #CPlusPlus #Programming #SoftwareEngineering #CodeNewbie #100DaysOfCode #InterviewPreparation #LearnToCode #TechCommunity #DeveloperJourney #LinkedInCoding #DSAChallenge #StudentsWhoCode #LeetCodeChallenge #ProgrammersLife #CodingJourney #ViralPost