Learn Merge Sort: Divide, Conquer, Combine

🔽 Day 166 of #200DaysOfCode Today, I continued sharpening my fundamentals by implementing Bubble Sort in descending order — without using JavaScript’s built-in .sort() method. 💡 While sorting might look simple on the surface, it is one of the most essential concepts in programming — powering search algorithms, intelligent ordering systems, real-time data processing, and more. By writing this logic manually, I reinforced: ✅ How comparisons work inside loops ✅ Value swapping and index manipulation ✅ Time complexity analysis (O(n²) for Bubble Sort) ✅ Why optimized sorting algorithms matter in bigger datasets 🌱 Every advanced concept in Data Structures & Algorithms is built on these fundamentals — and revisiting them helps improve clarity, confidence, and coding discipline. 🔁 Progress in programming isn’t linear — it’s iterative. Master the basics, and everything else becomes easier. #JavaScript #166DaysOfCode #BubbleSort #Algorithms #WebDevelopment #DSA #CodingChallenge #ProblemSolving #LearnInPublic #DeveloperMindset

🔼 Day 165 of #200DaysOfCode Today, I revisited a fundamental concept that plays a major role in data structures and algorithm design — sorting an array in ascending order using Bubble Sort (without built-in sort methods). 💡 Modern JavaScript gives us shortcuts like Array.sort(), but when we build the logic manually, we develop a much deeper understanding of: • Pairwise comparison • Value swapping in arrays • Nested looping structure • Time complexity (Bubble Sort → O(n²)) Sorting isn’t just a beginner concept — it’s the backbone of efficient searching, optimization, and real-world computational logic. 🔁 Going back to basics reminds me that advanced problem-solving ability is built on strong fundamentals, not shortcuts. 🌱 Every step forward in coding is supported by the basics we choose to master — and revisit. #JavaScript #200DaysOfCode #CodingChallenge #Sorting #Algorithms #WebDevelopment #DeveloperMindset #LearnInPublic #DSA #ProblemSolving

🧠 Day 7: Exploring Stack & Queue — The Building Blocks of Logic As I continue my #DSA journey, today I explored Stack and Queue, two foundational data structures that power many real-world algorithms — from undo/redo actions to task scheduling. Let’s go 🚀 #JavaScript #DSA #LearnInPublic #Developers 1️⃣ Problem Statement: Given a string containing only parentheses ()[]{}, determine if the input string is valid. A string is valid if every opening bracket has a corresponding closing bracket in the correct order. Approach (Using Stack): Use a stack to keep track of opening brackets. For each character: Push if it’s an opening bracket. If it’s a closing bracket, check if it matches the top of the stack. If the stack is empty at the end → it’s valid ✅ 💡 Why Stack? Stack follows LIFO (Last In, First Out) — perfect for problems that require matching or reversing order, like parsing expressions or syntax validation. 2️⃣ Problem Statement: Implement a Queue using two stacks. Approach: Use one stack for enqueue (adding elements). For dequeue, pop all elements from the first stack into the second stack, pop the top element (oldest), and then move others back. This mimics FIFO (First In, First Out) behavior. 💡 Why Queue? Queues are ideal for handling tasks in order — like background jobs, print queues, or API request processing.

At which level do you write your tests? 🤔 (Assuming you have three levels: low-level Domain, mid-level Service, high-level API) There's no perfect solution:  - Low-level tests give you fine-grained feedback about your code. But when it's time to update the code design, these tests need to be replaced as they're tightly coupled to one implementation. - High-level tests give high coverage with few tests. But they tell us nothing about the fine-grained design of the code. The authors of Architecture Patterns with Python recommend writing most tests at the service layer. This gives a healthy balance between coupling and design feedback. 🎉 I admittedly over-test at the domain level, which means I have to rewrite many unit tests if I make a low-level change. 🥹 How do you choose the target level of your tests? #softwaredesign #softwarearchitecture #testing

🧠 Day 8: Starting My Sorting Series — Bubble Sort As I continue my #DSA journey, I’m starting a new chapter: Sorting Algorithms. Sorting is the foundation of optimization — it improves searching, comparison, and data organization across real-world systems. Let’s go 🚀 #JavaScript #DSA #LearnInPublic #Developers 1️⃣ Problem Statement: Given an array of integers, sort them in ascending order using Bubble Sort. Approach: Compare adjacent elements in the array. Swap them if they’re in the wrong order. Repeat this process until no swaps are needed — meaning the array is sorted. 💡 Intuition: Each pass “bubbles up” the largest element to the end — just like bubbles rising to the surface 🫧 Time Complexity: Best Case: O(n) (already sorted) Average/Worst Case: O(n²) Space Complexity: O(1)

🔍 Day 171 of #200DaysOfCode Today, I implemented a function to check whether a specific value exists in an array — without using built-in methods like .includes(). This challenge helped strengthen my understanding of: • Array traversal using loops • Conditional comparisons • Manual search logic • Returning Boolean results effectively 🌍 Though simple, this concept plays a big role in real-world applications like: ✅ Searching records in a dataset ✅ Validating user inputs ✅ Checking access permissions ✅ Matching values in dynamic arrays 💡 Every “basic” problem hides a core principle that drives advanced algorithms. Mastering small steps leads to giant leaps in logic building! #JavaScript #171DaysOfCode #ProblemSolving #LearnInPublic #BackToBasics #WebDevelopment #CodingChallenge #DeveloperMindset #LogicBuilding

📚 Understanding Time & Space Complexities (The “Big O” Basics) When we write code, we care about two things: 1️⃣ How much time our program takes. 2️⃣ How much memory (space) it uses. Here’s a quick, no-jargon guide to the different types of complexities: ⚡ O(1) – Constant: No matter how big your input is, the time stays the same. Example: Accessing array[0] or checking if a number is even. 📈 O(log n) – Logarithmic: Time increases slowly as inputs grow. Example: Binary Search (it keeps cutting the problem in half). 🚶 O(n) – Linear: Time grows directly with your data size. Example: Looping through an array once to find the largest number. 🧩 O(n log n) – Linearithmic: A bit slower than linear, but still efficient. Example: Merge Sort or Quick Sort. 💥 O(n²) – Quadratic: Gets slower quickly, often due to nested loops. Example: Bubble Sort or Insertion Sort. 🧮 O(n³) – Cubic: Even slower — usually three nested loops. 🧠 O(2ⁿ) – Exponential: Doubles in time with each extra input. Example: Recursive Fibonacci. 😰 O(n!) – Factorial: The slowest! Used in complex tasks like checking all permutations (e.g., Traveling Salesman Problem). The smaller your “Big O,” the faster and more efficient your code is. 🚀 Learning this helps you think like a problem solver — not just a coder! #DSA #BigO #LearningInPublic #Coding #Education #ProblemSolving #FrontendDevelopment #JavaScript #WebDev

Start free on CSX and practice as you read: https://lnkd.in/eFtB-g27 In JavaScript, data types tell your code how to treat a value. Primitives are single values like text, numbers, and true/false. Composites group values together as labeled objects or ordered lists. Knowing the difference helps your conditions, loops, and functions behave predictably. Practice the data types lesson on CSX. Get instant feedback and beginner-friendly exercises. Follow for more tips.💻 ✨ #javascript #coding #webdevelopment #csx #datatypes #objects #arrays

🎯 Day 172 of #200DaysOfCode Today’s challenge was all about finding all pairs in an array whose sum equals a given target number — a classic logic-building problem that strengthens both your thinking pattern and problem-solving flow. 💡 While most developers would jump to use built-in methods or advanced structures, I implemented it manually using nested loops — because fundamentals matter the most. 📘 Concepts reinforced today: • Nested loop logic • Pair combination generation • Conditional validation • Edge case handling (no valid pairs found) 🌍 Real-world use cases: ✅ Matching data pairs (like prices or scores) ✅ Detecting patterns in datasets ✅ Implementing basic algorithmic logic for interviews 🔥 The beauty of coding lies in building clarity — not just functionality. Every problem solved sharpens your analytical edge! #JavaScript #172DaysOfCode #ProblemSolving #LearnInPublic #WebDevelopment #CodingChallenge #LogicBuilding #BackToBasics #DeveloperMindset

💡 Brute Force vs. Mathematical Logic — Which One Wins? ⚔️ Tried a small coding challenge today: 👉 Find two numbers in an array whose sum equals a target (classic 2-sum problem 😎). code: https://lnkd.in/gtRVzcZY 🧠 Observation: Both give the same result — but the mathematical approach is cleaner, faster, and more efficient 💪 Sometimes, it’s not just about solving the problem… It’s about solving it smartly. 🚀 #JavaScript #CodingFun #LogicBuilding #ProblemSolving #WebDevelopment #LearnToCode #Efficiency #DeveloperLife