Focusing on DSA Logic with Intersection of Two Arrays

Day 82 of #100DaysOfCode Today I learned Hashing and Frequency Maps, a powerful concept in DSA. Covered: • Counting elements efficiently • Solving problems using key-value pairs • Optimizing time complexity #DSA #JavaScript #CodingInterview #LearningInPublic

Most developers don't know how their JavaScript code is executed.   V8 (Chrome's engine) compiles your code through 4 tiers -- bytecode interpreter, baseline JIT, mid-tier optimiser, and a top-tier compiler that generates near-C++ machine code. The engine watches how your code runs and recompiles hot paths with increasingly aggressive optimisations.   This is why consistent object shapes make code faster, why eval() kills performance, and why a function that runs 10,000 times is faster than one that runs 10 times -- the engine literally rewrites it.   Understanding this pipeline is one of the most-asked concepts in front end interviews -- and most candidates can't explain it beyond "V8 compiles JavaScript."   How deep does your understanding of JS engines go?   Practice JavaScript interview questions with detailed solutions: https://lnkd.in/gNxCH3e3 #JavaScript #V8 #FrontEnd #WebDevelopment #InterviewPrep #GreatFrontEnd

Unique Permutations using Backtracking Day 9👈 At first glance, permutations are straightforward — but handling duplicates efficiently is where the real challenge lies. Key idea: -- Sort the array first -- Skip duplicate elements during iteration to avoid redundant permutations -- Use backtracking to explore all possible combinations. #JavaScript #TypeScript #DSA #Algorithms #Backtracking #CodingInterview #FrontendDeveloper #LearnToCode #ProblemSolving #100DaysOfCode

DSA session update — Strings and Time & Space Complexity! ✅ Strings in JavaScript Strings are everywhere in development — but I never truly studied them from a DSA perspective before. This time I went deep: 🔹 String traversal 🔹 Reverse, palindrome problems 🔹 Character frequency & counting 🔹 Substring problems 🔹 String comparison techniques Time & Space Complexity This is what separates a working solution from a good one. Writing code that runs is not enough — understanding how it scales is what really matters. 🔹 Big O Notation — O(1), O(n), O(n²), O(log n) 🔹 Time Complexity — how algorithm scales with input size 🔹 Space Complexity — how much memory your solution uses 🔹 Best, average & worst case analysis 🔹 Choosing the right tradeoffs for each problem What clicked for me — every decision I make while coding now has a cost. Knowing that cost is what makes you think like a real engineer, not just a developer. Alhamdulillah for every concept that deepens the foundation. 🚀 #JavaScript #DSA #Strings #TimeComplexity #SpaceComplexity #BigO #FrontEndDevelopment #InterviewPrep #LearningInPublic #CareerGrowth

What is the difference between shallow copy and deep copy? Copying objects in JavaScript is not always what it seems. A `shallow copy` duplicates only the first level. Nested objects are still shared by reference. A `deep copy` duplicates everything recursively. Why did this happen? - The top-level object was copied - But `address` still points to the same reference To fully isolate data, a deep copy is required. Understanding this is critical when: - Managing state - Avoiding unintended mutations - Debugging shared data issues The behaviour is subtle — but the impact is everywhere. #Frontend #JavaScript #WebDevelopment #SoftwareEngineering

💡 Quick JS Trick: Group Anagrams Want to group words that are anagrams of each other? Use sorting & a Map — super clean and efficient: ✅ How it works: 🔹 Sort letters in each word → same letters = same key. 🔹 Use a Map to group words by this key. 🔹 Return all grouped values. ✨ Benefits: ✅ Simple ✅ Fast ✅ Works for any list of strings #JavaScript #CodingTips #Algorithms #DataStructures #CleanCode #WebDevelopment #JSChallenge

If you're only using Arrays and Objects in JavaScript, you're limiting yourself. Map and Set exist for a reason — and they solve problems cleaner. → Need unique values? Set does it instantly → Need proper key-value storage? Map beats Object Less workaround. More clarity. Wrote a quick breakdown with examples. Read here: 🔗 https://lnkd.in/drqhd7Vg #JavaScript #WebDevelopment #Coding

Most engineers draw system diagrams. I built them alive. 🔥 Load Balancers. Caching layers. CAP Theorem. Message Queues — concepts that took me weeks to grasp from textbooks, now rendered as live, animated flows you can actually watch in your browser. Just pure HTML, CSS, and JavaScript proving you don't need heavy dependencies to build something beautiful and blazing fast. 11 FAANG-level concepts. Zero jargon. One visual atlas. If you're a developer who learns by seeing, this was built for you #SystemDesign #SoftwareEngineering #WebDevelopment #LearningInPublic #JavaScript #BackendDevelopment #TechEducation #OpenSource #100DaysOfCode #CareerInTech

🚀 From Arrays to Efficiency: Mastering Set in JavaScript Today I solved the “Unique Rows in Boolean Matrix” problem using one simple yet powerful concept — Set. At first glance, the problem looks like a typical nested loop challenge. But instead of going brute force, I leveraged Set to achieve a clean and optimal solution. 💡 Key Idea: Convert each row into a string and store it in a Set to automatically handle duplicates. ✨ Why this is powerful: Eliminates duplicates in O(1) lookup time Avoids unnecessary nested loops Keeps the solution clean and readable 📊 Complexity: Time: O(n × m) Space: O(n × m) 🔥 Takeaway: Sometimes, the difference between an average solution and an optimal one is just knowing the right data structure. Today it was Set. Tomorrow, it could be something else. 💬 Curious: Where else have you used Set to simplify a problem? #JavaScript #DSA #CodingInterview #WebDevelopment #ProblemSolving #100DaysOfCode

If a function fires 1000 times, but you only want it to run every 100 calls, there's a neat technique for that. Today I learned about counter-based sampling in JavaScript. Use Cases • sampling analytics events to reduce load • limiting noisy logs or metrics • running expensive work periodically in high-frequency flows How it's different from throttling? Sampling is call-count based → run every N calls Throttling is time-based → run at most once every X ms So if 1000 events fire instantly: • sampling (every 100) → runs 10 times • throttling (200ms) → may run only once Different problems, different tools. #javascript #softwareengineering #frontend #webdevelopment #todayilearned