"Optimizing Anagram Grouping with Hash Maps"

🚀 [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 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

🚀 Day 30 of My COHORT 2.0 Development Journey Sheryians Coding School Topic: Operators in JS Today’s class focused on one of the most important foundations of JavaScript: Operators. Operators help us perform calculations, assign values, compare data, and write logical conditions - basically the backbone of any program. Here’s what we covered: 🔢 1️⃣ Arithmetic Operators Used for basic mathematical operations: + , - , * , / , % , ** These help us calculate values and perform number-based logic. 📝 2️⃣ Assignment Operators Used to assign or update variable values: = , += , -= , *= , /= , %= They make updating values shorter and cleaner. ⚖️ 3️⃣ Comparison Operators Used to compare two values: == , === , != , !== , > , < , >= , <= These return true/false and are essential for conditions, loops, and decision-making. 🔐 4️⃣ Logical Operators Used to combine multiple conditions: && (AND) || (OR) ! (NOT) These help in creating complex logical checks in real-world applications. 🧠 Key Takeaway: Operators may look simple, but they form the base of every function, condition, calculation, and logic flow in JavaScript. Today’s class helped me understand how they work behind the scenes and how to use them effectively while building real projects. #JavaScript #Cohort2 #WebDevelopment #FrontendDevelopment #CodingJourney #OperatorsInJS #LearnByDoing #SheriyansCodingSchool

🚀 [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

The Art of Efficient Problem-Solving. “Programs must be written for people to read, and only incidentally for machines to execute.” — Harold Abelson Efficiency in JavaScript isn’t just about speed—it’s about clarity and logic. Explore the beauty of efficient coding with LearnMing. https://www.rfr.bz/lb52f75 #CodingQuotes #JSWisdom #ProblemSolving #LearnMing

🚀 [Day 13/30] Coding Challenge Journey with @Educative.io 💻 💡 Problem: Course Schedule Today’s challenge was all about dependency management — figuring out whether it’s possible to finish all courses given their prerequisites. Essentially, it’s a graph problem disguised as a real-world scheduling issue 🎓 At first, my intuition was to use DFS (Depth First Search) to detect cycles — because if there’s a cycle, you can’t complete all courses. But as I explored further, I realized there’s a more intuitive approach: Topological Sorting using BFS (Kahn’s Algorithm). Here’s how I approached it step by step: 1️⃣ Built a graph representation from the prerequisites list. 2️⃣ Calculated the in-degree (number of incoming edges) for each course. 3️⃣ Used a queue to process all nodes (courses) with zero in-degree — meaning no dependencies. 4️⃣ Repeatedly removed nodes from the queue, reducing the in-degree of dependent nodes. 5️⃣ If all nodes were processed successfully, it meant the course order was possible ✅ This method helped identify cycles efficiently and made the logic easy to reason about — truly a satisfying example of graph traversal in action 🧠 🔍 Key Learnings: Many real-world problems (like task scheduling or project dependencies) can be modeled as graphs. Topological Sort is a must-know technique for problems involving order and precedence. Sometimes, the cleanest logic comes from thinking in terms of relationships, not just data. ✨ Small win — once I saw the connection between course dependencies and graph theory, the problem instantly clicked! #30DaysOfCode #Day13 #CodingChallenge #Educative #DSA #JavaScript #GraphAlgorithms #TopologicalSort #ProblemSolving #LearningJourney #KeepCoding #ProgrammersLife

Day 31 of #100DaysOfCode – Building Logic with Conditions and Loops in JavaScript Today’s session focused on strengthening core programming logic using conditional statements and loops. Key Learnings: Understood how if, else if, and else conditions control program flow. Explored looping structures to execute repetitive tasks efficiently. Learned how combining these concepts helps in building real-world logic and problem-solving patterns. Takeaway: Mastering loops and conditions is the foundation for writing efficient, dynamic, and logical code in JavaScript. Grateful to Harsh Vandana Sharma from Sheryians Coding School and Sheryians Coding School Community for guiding us through today’s session with clear explanations and practical logic-building examples. #100DaysOfCode #JavaScript #WebDevelopment #CodingJourney #Frontend #ProgrammingLogic

Day 6 of Learning JavaScript  from Sheryians Coding School Today, I have learned about Conditionals and Loops.  Conditionals:   if: Inside this block, a condition is tested that returns true or false.   Falsy values: 0, "", NaN, null, false, undefined, document.all   Truthy values: Everything other than falsy values.   else: Executes when the if condition is false.   else if: Executes when the if condition fails, but another specific condition needs to be checked.  Ternary Operator:   condition? true: false  Switch:   Used to check multiple conditions.   You can create multiple cases inside a switch.   Each case runs when the passed condition matches the case value.   Always write a break after each case to stop further execution.  Loops:   There are two main types of use cases:   1. Straightforward loop: The value and printed result do not change.   2. Dynamic loop: Both the value and printed output can change.  For Loop:   for (start; end; change) { }   Used to repeat a block of code multiple times.   You can start the loop from any value, for example, 100, 1999, or 6778 in a straightforward loop.  #JavaScript #WebDevelopment #CodingJourney #LearningWithSheryians #ProgrammingBasics

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

Day 30 of Cohort 2.0 🚀 Today’s wrap-up was all about diving deeper into JavaScript fundamentals and understanding how the language handles operations and logic. 💻 Here’s what I learned today: 🔹 Arithmetic Operators → Perform basic mathematical operations 🔹 Assignment Operators → Assign and update variable values 🔹 Comparison Operators → Compare values and return true/false 🔹 Logical Operators → Combine multiple conditions 🔹 Ternary Operator → Write shorter conditional statements 🔹 Type Checking (typeof) → Identify data types in JavaScript 🔹 String Operations → Work with and manipulate text 🔹 Nullish Coalescing (??) → Provide default values when dealing with null or undefined 🔹 Optional Chaining (?.) → Safely access nested object properties 🔹 Hoisting → Understand how variable and function declarations are processed before execution ✨ Key takeaway: Learning these core concepts builds a strong foundation for writing clean, efficient, and bug-free JavaScript code. Sheryians Coding School #sheryianscodingschool #cohort2 #learningjourney #dailyupdates #JavaScript #WebDevelopment #Frontend