How to Flatten Nested Arrays with Recursion in JavaScript

🔽 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

🔥 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗖𝗼𝗱𝗶𝗻𝗴 — 𝗙𝗶𝗹𝗲 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 Got inspired after watching Akshay Saini 🚀’s Machine coding series — and decided to take on a fun machine coding challenge: Building a file explorer from scratch. 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 👇 ✅ Render a tree-structure from JSON (folders/files with expand-collapse) ✅ Add new files or folders dynamically at any level ✅ Keep everything sorted alphabetically — folders first, then files 𝗧𝗲𝗰𝗵𝗻𝗶𝗾𝘂𝗲𝘀 𝗜 𝘂𝘀𝗲𝗱:  1. Recursive function to render nested structures.  2. React Context API to manage shared states (active folder, add mode, etc).  3. Pure immutable state updates using structured cloning for clean re-renders.  4. Smart sorting logic — folders and files handled separately and merged elegantly. 💻 𝗟𝗶𝘃𝗲 𝗱𝗲𝗺𝗼 : https://lnkd.in/gJapscTm 🔗 𝗚𝗶𝘁𝗛𝘂𝗯 (𝗰𝗼𝗱𝗲): https://lnkd.in/gCnpu39P 🎥 𝗔𝗸𝘀𝗵𝗮𝘆'𝘀 𝗬𝗧 𝘃𝗶𝗱𝗲𝗼: https://lnkd.in/gXch9JKE 𝗗𝗿𝗼𝗽 𝘆𝗼𝘂𝗿 𝘁𝗵𝗼𝘂𝗴𝗵𝘁𝘀 👇 — 𝘄𝗼𝘂𝗹𝗱 𝗹𝗼𝘃𝗲 𝘁𝗼 𝗱𝗶𝘀𝗰𝘂𝘀𝘀 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵𝗲𝘀! #ReactJS #MachineCoding #FrontendDevelopment #JavaScript #CleanCode #WebDevelopment #SoftwareEngineering #CodingInterview #Learning

Day 113: Deep Dive into Core JavaScript & DSA Fundamentals! I spent today drilling into fundamental programming concepts, using multiple approaches for each problem to maximize my understanding and coding flexibility. This is the crucial prep work before jumping back into advanced Data Structures and Algorithms. 🎯 Today's Focus Areas: String Manipulation: Implemented String Reversal using four distinct methods: Built-in methods (.split(), .reverse(), .join()) Iterative for loop Recursion with substring() Recursion with slice() (and noted the difference between slice and substring on negative indices!) Mathematical Logic: Factorial Finder: Solved iteratively and recursively. Sum of Digits: Solved using string conversion, iterative while loop, and recursion. Power Calculation and Simple Interest Calculation. Conditional & Array Logic: Created a precise function to check for a Leap Year (year % 4 == 0 && year % 100 !== 0 || year % 400 == 0). Found the Biggest Number in an array without using the .sort() method, then compared it with Math.max(). Implemented robust Palindrome Checkers (for individual words and for finding all palindromic substrings). Wrote functions for Vowel/Consonant Counting, Finding Factors, and Calculating Average. Determined the Smallest of Three Numbers using conditional operators and Math.min(). It's been a great exercise in code efficiency and algorithmic thinking. Feeling much more confident and ready to accelerate into my DSA curriculum soon! #JavaScript #DSA #CodingChallenge #ProblemSolving #FullStack #Day113 #LearningInPublic

Euclidean Algorithm: 2300 years old, still the most elegant solution I've seen. This morning's Codewars problem: Find the Greatest Common Divisor of two numbers. My first instinct? Write a loop. Seven lines of code. It worked, but felt clunky. Then I thought: "This feels recursive." Spent 10 minutes staring at the screen. "What's the base case?" "How do I reduce the problem?" Then it clicked. The insight: GCD(a, b) is just GCD(b, remainder). Keep calling until the remainder is zero. That's your answer. Four lines instead of seven. Elegant instead of clunky. Recursive instead of iterative. What makes it beautiful: → Each step is simpler than the last → The solution emerges naturally → Base case is obvious (when b = 0) Traced through an example: GCD(48, 18) becomes GCD(18, 12) which becomes GCD(12, 6) which becomes GCD(6, 0) Answer: 6 Euclid figured this out in 300 BC. I figured it out this morning. Better late than never. This is why I solve algorithms daily. Not for interviews. For the mindset. Learning to see problems recursively changes how you code. #Algorithms #Recursion #Codewars #JavaScript #LearningInPublic

📚 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

I'm building something unique for #computervision developers. It's called #AgentUI. A visual workflow builder for computer vision that works both in your browser and/or directly in Python. So I built this:  - Drag and drop CV tools on a canvas. Design your pipeline visually  - Switch between models with a dropdown. That's it. No config/dependency hell.  - Export as JSON, load it in Python, process 1000s images with 3 lines of code. Everything runs 100% locally (or cloud if you prefer). It's MIT licensed and built on top of our other libraries (#PixelFlow for detection formats, #Mozo for model serving). Let me know what you think or if you'd actually use something like this.

Ever wondered how searching in a sorted array can go from slow to lightning fast? ⚡🔍 Hey everyone! Day 290 of my 365-day coding journey, and today I focused on a fundamental algorithm: LeetCode's "Binary Search." Understanding search algorithms is crucial for efficient data retrieval, and this problem is a perfect way to strengthen that skill. Let’s dive in! 🛠️ The Problem Given a sorted array of integers nums and a target value, the task is to search for the target in nums. If the target exists, return its index; otherwise, return -1. The array is guaranteed to be sorted in ascending order. 🎯 The Approach Solution 1: Linear Search - Iterate through each element from start to end. - Compare each element with the target; return the index if matched. - Simple, but O(n) time complexity makes it inefficient for large datasets. Solution 2: Binary Search - Much more efficient for sorted arrays. - Use two pointers, left and right, to track search boundaries. - Calculate mid, compare nums[mid] with target, and adjust pointers accordingly. - Repeat until target is found or pointers cross. - O(log n) time complexity makes it ideal for large datasets. ⚡ 🧠 Key Takeaways - For sorted data, always consider Binary Search first due to its logarithmic efficiency.   - Understanding midpoint calculation and pointer adjustments is critical for correct implementation.   - Linear search is simple but quickly becomes inefficient as input size grows.  💡 Challenge for you! Can you think of scenarios where linear search might still be better than binary search, even though the latter is faster? Share your thoughts! 💬 📺 Check out my video walkthrough I demonstrate both methods and discuss their nuances in detail: https://lnkd.in/dk89dtnJ 🔥 Join the Conversation If you’re sharpening your algorithms skills or tackling daily coding challenges, let’s connect! Always great to learn and share with fellow developers. 🚀 #CodingJourney #DSA #Algorithms #BinarySearch #LeetCode #JavaScript #ProblemSolving #DataStructures #Programming #DeveloperLife #LearningEveryDay #CodeNewbies

Still juggling loops and swaps to reverse strings? Try the push–pop stack trick instead 🔄 Using a stack to reverse a string? Pure genius! Here's the breakdown that'll blow your mind 💪 Think of it like this - you're literally flipping the script with LIFO (Last In, First Out). Push every character onto your stack, then pop them back out. Boom! Reversed string without breaking a sweat. Check out this Python magic: def reverse_string(s): stack = [] # Push all characters for char in s: stack.append(char) # Pop to create reversed string reversed_str = "" while stack: reversed_str += stack.pop() return reversed_str Sure, it's O(n) time and O(n) space - but here's why this approach is absolutely worth knowing: 🎯 Handling nested structures becomes a breeze 🎯 Perfect for complex parsing where order matters 🎯 Builds that rock-solid algorithmic foundation Now, I know what you're thinking - "But string[::-1] is faster!" And you're right! But understanding the stack method? That's what separates good developers from great ones. It's about building that problem-solving muscle 🧠 Trust me, once you master this pattern, you'll start seeing stack solutions everywhere. Your future self will thank you when you're tackling those tricky interview questions! Drop a 🔥 if this just clicked for you! #DataStructures #Programming #Frontend

Can a tree stay balanced no matter how deep it grows? 🌳 Let’s find out. Hey everyone! Day 299 of my 365-day coding journey was all about trees — LeetCode’s “Balanced Binary Tree.” This is one of those classic problems that truly tests your grasp of recursion and optimization. Let’s dive in! ⚡ 🛠️ The Problem Given a binary tree, the goal is to determine if it’s height-balanced. A tree is height-balanced if, for every node, the height difference between its left and right subtrees is at most 1. 🎯 The Approach I explored two different ways to solve it — one simple but inefficient, and another optimized and elegant. 1️⃣ Brute Force Approach (Top-Down) - For each node, check if both subtrees are balanced. - Compute heights of left and right subtrees separately. - Simple but inefficient — recalculates heights multiple times. - Time Complexity: O(N²) in the worst case. 2️⃣ Optimized Approach (Bottom-Up using DFS) - A smarter way using Depth-First Search. - Calculate height and balance simultaneously in one traversal. - If any subtree is unbalanced, propagate a signal (like -1) upward to stop further computation. - Time Complexity: O(N) 🧠 Key Takeaways - Optimization often comes from rethinking recursion flow — switching from top-down to bottom-up can save massive computation. - The “return height + status” pattern is powerful for many tree problems. - Always analyze if a recursive function can return multiple useful values to avoid redundant work. 💡 Challenge for You! The optimized solution uses a special return value (like -1) to indicate unbalance. How else could you design this logic? Maybe with a helper class or a tuple? Drop your ideas below! 💬 📺 Watch My Walkthrough I’ve explained both approaches (brute force and optimized DFS) in detail here: https://lnkd.in/gyMuFivt 🔥 Join the Conversation If you’re diving deep into recursion and tree problems, let’s connect! Sharing ideas and patterns like these makes the learning journey even better. 🚀 #CodingJourney #365DaysOfCode #LeetCode #DSA #BinaryTree #TreeTraversal #Recursion #DepthFirstSearch #ProblemSolving #Programming #SoftwareEngineering #CodeNewbies #DeveloperLife #TechLearning #LearningEveryDay