Learn JavaScript data types on CSX with interactive exercises

DSA Practice — Day 10 Solved the “Merge Sorted Array” problem on LeetCode 🧩 At first glance, it looked simple — just merge and sort. But when I started optimizing, it turned into an interesting challenge. 🧠 My Approaches: 1️⃣ Brute Force: Directly add all elements into one array and sort. (Simple, but inefficient ) 2️⃣ Two Pointer + Extra Space: Created a copy of nums1 and merged both arrays efficiently. ➤ Time Complexity: O(m + n) ➤ Space Complexity: O(n) 3️⃣ Optimized In-Place Approach: Used two pointers starting from the end of both arrays — merging in reverse order without extra space. ➤ Time Complexity: O(m + n) ➤ Space Complexity: O(1) 💡 Lesson: The best solution often hides behind simple logic — you just have to look from the right direction. #DSA #LeetCode #ProblemSolving #JavaScript #LearningInPublic #CodingJourney #BackendDeveloper #100DaysOfCode

Day 23/90 – 90 Days DSA Challenge Today I practiced another classic recursion problem — Sum of first N natural numbers using recursion 💡 🧠 Concept Recap: Recursion is when a function calls itself with a smaller input until it reaches a base condition. It’s like peeling an onion layer by layer — until you reach the core 🧅 ⚙️ Problem Statement: 👉 Write a function sum(n) that calculates the sum of the first n natural numbers. 🧩 Example: Input: 5 Process: 5 + 4 + 3 + 2 + 1 = 15 Output: 15 Time Complexity: O(n) 💾 Space Complexity: O(n) (due to call stack) ✨ Key takeaway: Recursion helps break down complex problems into smaller, simpler ones — it’s elegant, powerful, and mind-opening once you get the hang of it! #Day23 #DSA #Recursion #JavaScript #CodingChallenge #MechCode #LearningInPublic #FrontendDeveloper #CodeEveryday

🔍 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

Today, I solved an interesting LeetCode problem called “Max Sum of a Pair With Equal Sum of Digits(https://lnkd.in/gfE37qjM)". It looks simple — until you realize it’s actually two problems cleverly disguised as one. Let’s break it down: Problem 1 — Compute the Digit Sum For each number, we first need its digit sum — a classic number manipulation subproblem. 51 → 5 + 1 = 6   42 → 4 + 2 = 6   This step groups numbers by a common mathematical property — their digit sum. Problem 2 — Find the Maximum Pair Sum in Each Group Once we group numbers by their digit sum, the next challenge is to find two numbers with the same sum of digits that produce the largest total. This now becomes a hash map optimization problem: Use a map to store the largest number seen for each digit sum. For every new number, check if we already have one with the same digit sum. If yes → compute the potential pair sum → update the maximum. Approach Summary Digit Sum Calculation: O(logn) per number Hash Map Lookup: O(1) per operation Overall Time: O(n), efficient and clean Here is the solution Below #LeetCode #JavaScript #Coding

🧠 Day 20 of #100DaysOfDSA Today I practiced two classic problems from LeetCode — FizzBuzz and Reverse String. 📘 What I learned: These might look like simple problems, but they help sharpen logic building, loops, and condition handling — essential building blocks for bigger challenges. 💻 Problems Solved: 1️⃣ FizzBuzz – A fun way to practice modular arithmetic and condition prioritization. 2️⃣ Reverse String – Implemented using the two-pointer approach for an in-place reversal. 💡 Key Takeaways: FizzBuzz reinforces thinking through branching logic. The two-pointer method is efficient for array and string manipulation. Small problems like these build the foundation for complex algorithms. 🔗 Check out my implementations here: https://lnkd.in/gxs9yaen #100DaysOfCode #DSA #LeetCode #JavaScript #CodingJourney #ProblemSolving #LearningInPublic

DSA Practice — Day 13 Solved the “Missing Number” problem on LeetCode 🔢 🧠 Problem: You’re given an array of n distinct numbers from the range [0…n], and exactly one number is missing. The task: return the missing number. This problem felt very straightforward, but I still didn’t jump into the final code immediately. I first tried a brute-force mindset, explored edge cases, and then moved to a clean mathematical approach without using any built-in JS shortcuts. Approach: • Sum all numbers from 0 to n • Subtract the sum of the array • The difference = missing number → Time Complexity: O(n) → Space Complexity: O(1) “Simple problems become powerful when solved with the right fundamentals.” #DSA #LeetCode #ProblemSolving #JavaScript #LearningInPublic #CodingJourney #BackendDeveloper #100DaysOfCode

📘 DSA Practice – Day 16: Recursion Clicked Even Deeper Today Today I solved a classic problem: finding the sum of the first N numbers using recursion. To understand it better, I walked through the entire recursion tree — call by call — and observed how each function waits on the next one, and how the values return back up the stack. function sumToN(n) {  if (n === 0) {   return 0;  }  return n + sumToN(n - 1); } While tracing it manually, I followed this flow: sumToN(5) → 5 + sumToN(4) sumToN(4) → 4 + sumToN(3) sumToN(3) → 3 + sumToN(2) sumToN(2) → 2 + sumToN(1) sumToN(1) → 1 + sumToN(0) sumToN(0) → base case → returns 0 Then everything unwinds back up with the final result: 15 Today’s takeaway: Recursion becomes simple when you clearly see two things — the base case and the flow of return values in the call stack. #Recursion #JavaScript #DSA #100DaysOfCode #LearningInPublic

📘 Day 175 of #200DaysOfCode Today, I explored how to count the number of properties in a JavaScript object — a small but meaningful step toward understanding how objects truly work under the hood. 🧠 Key Concepts Practiced • Working with objects • Looping through keys using for...in • Using hasOwnProperty() to avoid inherited keys • Returning calculated output 🌍 Real-World Uses ✅ Validating form inputs ✅ Checking JSON response structures ✅ Data integrity checks ✅ Object analysis in APIs 🔎 Learning takeaway: Even the simplest operations help you develop a deeper understanding of core JavaScript behavior. Mastering the fundamentals builds confidence for tackling complex problems later. #JavaScript #Day175 #175DaysOfCode #ProblemSolving #CodingChallenge #WebDevelopment #LogicBuilding #BackToBasics #LearnInPublic #DeveloperJourney #CodingMindset

For anyone that didn't already know this, but #JSON is your friend, especially when doing development testing on Postman... JSON is preferred because it optimizes readability, interoperability, and parsing speed. Key points: 1. Human-readable: Simple key–value structure with minimal syntax. Easy to debug and edit manually. 2. Language-independent: Supported natively or via libraries in nearly all programming languages, including C#, Python, and JavaScript. 3. Lightweight: No markup overhead like XML. Compact and efficient to transmit over networks. 4. Native web compatibility: Directly compatible with JavaScript objects, ideal for APIs and web applications. 5. Parsing efficiency: Modern parsers (e.g., System.Text.Json in .NET) handle JSON faster than XML or YAML. 6. Hierarchical structure: Supports nested objects and arrays naturally, fitting most data models. #architecture #designinnovation #computationaldesign #AECindustry

🌟 Day 22 of #100DaysOfDSA Today, I solved two interesting problems: 1️⃣ Reverse a Linked List Reversed a singly linked list by iteratively changing the node pointers. Time Complexity: O(n) Space Complexity: O(1) 2️⃣ Move Zeroes Rearranged all zeroes in an array to the end while maintaining the order of non-zero elements — done in-place with linear time. Time Complexity: O(n) Space Complexity: O(1) Both problems were great practice for improving logical thinking and working efficiently with pointers and arrays. https://lnkd.in/gt7VYQ_E #100DaysOfCode #DSA #JavaScript #CodingJourney #LearningInPublic #LeetCode