39 Problems Solved with LeetCode

Day 18/100 of #100DaysOfCode 💻 Short query. Clear logic. Clean result. 🎯 Customer Placing the Largest Number of Orders:- Find the customer who placed the most orders from the Orders table. GROUP BY to count orders per customer → ORDER BY COUNT DESC to rank them → LIMIT 1 to grab the top one. Done. ✅ 💡 The real insight here - LIMIT 1 is one of those small but powerful tools. Instead of writing a subquery or CTE to find the max, just sort and slice. Cleaner and faster. Sometimes the best query is the shortest one. 🧩 Not every day is a Hard problem grind, some days you just stay consistent, show up, and keep the streak alive. That matters too. 😄 #SQL #100DaysOfCode #LearningInPublic #DataAnalytics #Consistency #DevJourney #LeetCode

Day 16/100 of #100DaysOfCode 💻 Solved a Hard-level SQL problem today, but it didn't come easy. 🎯 Q. Trips & Users: Calculate the daily cancellation rate of taxi trips only for unbanned clients and drivers, within a specific date range. Honestly? I stared at this one for a while😅. I wrote the query, ran it, wrong output. Checked the logic, looked fine to me. Ran it again, still wrong. That frustrating loop where you know something's off but can't see what. Took a hint. And that's when it hit me🤦. I was only joining the Users table once. But you need a double JOIN, one for the client, one for the driver, because both must be unbanned for the trip to count. I was filtering one side and completely missing the other. One missing JOIN = entirely wrong cancellation rates across all three days. 💡 That's what makes this problem Hard, not the syntax, but the logic you almost overlook. Fixed it. Query ran clean. Used CASE WHEN inside ROUND(SUM(...)) to count cancellations per day and it finally made sense. Some days you need a hint. That's not failure, that's how you actually learn. 🧩 #SQL #100DaysOfCode #LearningInPublic #DataAnalytics #Consistency #DevJourney #LeetCode

Day 21/100 of #100DaysOfCode 💻 Today's problem made me think in trees. 🌳 Tree Node:- Given a tree structure in a table, classify each node as Root, Inner, or Leaf. The logic: Root → has no parent (p_id IS NULL) Inner → appears as a parent of someone else Leaf → everything else I didn't get it right on the first try. 😅 My first attempt used "WHERE p_id = 1" inside the subquery, which hardcodes the root and breaks for any other tree structure. Wrong logic, wrong output. Then I stepped back and thought about it properly (Code is given in the image) 💡 The fix is instead of hardcoding, ask "does this node appear as a parent of anyone?" If yes → Inner. That's the real tree logic. Never hardcode what SQL can figure out dynamically. 🧩 Trial and error is part of the process. The wrong attempt taught me more than the right one. 😄 #SQL #100DaysOfCode #LearningInPublic #DataAnalytics #Consistency #DevJourney #LeetCode

🚀 Day 26 – 30 Days SQL LeetCode Challenge Today’s problem was simple but highlights an important real-world scenario 👀 📌 Today's Problem: Article Views I (LeetCode #1148) 🧠 Problem Statement: Find all authors who viewed at least one of their own articles. 💡 Key SQL Concepts Used: • DISTINCT • Filtering with conditions • Comparing columns within the same row 📚 What I Practiced Today: ✔ Comparing values within the same table ✔ Removing duplicates using DISTINCT ✔ Writing clean filtering queries 🔥 This pattern is useful in: • Detecting self-actions (self-purchases, self-views) • Fraud detection • User behavior analysis 🔗 GitHub Repository: https://lnkd.in/e8aV37dA #SQL #LeetCode #DataAnalytics #30DaysOfSQL #LearningInPublic

🚀 Day 34/50 – #LeetCode Challenge Today’s problem: Product Price at a Given Date 📊 This one really tested my understanding of handling time-based data in SQL. 💡 Key Learning: When dealing with historical data, it's important to focus on the latest valid record before a given date — not just any record. 🔍 Approach I used: Consider all products Find the most recent price change on or before the target date (2019-08-16) If no change exists → use default price = 10 Used concepts like MAX(date), GROUP BY, and JOIN 🧠 What I improved today: Writing cleaner SQL queries Handling edge cases (no previous data) Thinking in terms of real-world data scenarios 🔥 Consistency is building confidence step by step. #Day34 #LeetCode #SQL #DataStructures #CodingJourney #Consistency #PlacementPreparation

🚀 Day 28/50 #LeetCodeChallenge Today’s problem: Biggest Single Number This problem was a brilliant exercise in combining Aggregation with Subqueries to filter out duplicates effectively. 🔥 💡 Problem Insight: The task was to find the largest number that appears only once in the table. If no unique number exists, the result should be null. 🧠 Key Learning: Identify Uniqueness: Used GROUP BY combined with HAVING COUNT(*) = 1 to isolate numbers that don't repeat. The Power of MAX(): Applied MAX() on the filtered subset to grab the highest value. Handling Nulls: Using MAX() on a subquery is a clean way to ensure a null output if the criteria aren't met, instead of getting an empty result set. ⚡ Big Realization: The real trick isn't just finding the maximum—it's knowing how to exclude data that doesn't fit your constraints (duplicates) before you look for the top value. 📈 Takeaway: SQL logic is often about "layers." Filtering the noise first makes finding the answer straightforward. Consistency > Difficulty 💯 #Day28 #LeetCode #SQL #DataAnalytics #LearningJourney #CodingChallenge #50DaysOfChallenge

Solving the SQL 50 challenge on LeetCode has been an exciting and confidence-boosting journey. Each problem pushed me to think deeper, optimize queries, and strengthen my understanding of SQL concepts. From basic queries to advanced topics like joins, aggregations, subqueries, and window functions — this journey was truly enriching 💡 📘 What’s in my notes/document? A structured study guide covering: All 50 problems with solutions Clear explanations for each query Key SQL concepts like SELECT, JOINs, Aggregations, Window Functions, and more Practical patterns and best practices for real-world scenarios Once you get a solid grip on fundamentals, problems labeled medium or even hard start feeling like easy. It’s all about consistency and practice. #SQL #LeetCode #DataEngineering #LearningJourney #sql50

🚀 Day 21/30 Days of MY SQL Problem Solving Challenge 💡 Problem Find the fraction of players who logged in again the day after their first login. 🧠 Approach -Get each player’s first login using MIN() -Check if they logged in on the next day -Count such players and divide by total players -Use ROUND() for formatting 🔑 Key Learnings -Using subqueries + joins for comparison -Handling date logic with DATEDIFF() -Importance of COUNT(DISTINCT ...) -Writing ratio-based queries ⚡ Takeaway A great example of user retention analysis, very common in real-world data problems. #SQL #LearningInPublic #DataAnalytics #LeetCode #30DaysChallenge #SDE #DailyPractice #ProblemSolving

🚀 Tackling SQL challenges one query at a time! Today I solved #LeetCode #1280: Students and Examinations — a problem that tests how well you can combine tables and count relationships. 📌 The challenge: Find the number of times each student attended each exam. 💡 The solution: Use a CROSS JOIN to pair every student with every subject. Apply a LEFT JOIN with the Examinations table to capture attendance. Finally, group and count to get the number of exams attended per student per subject. #sql #SQL #Leetcode #dataanalysis

Day 87 of #100DaysOfCode Today I solved "Convert Sorted List to Binary Search Tree" on LeetCode using Two Pointers + Recursion. Key Idea: A sorted linked list can be converted into a height-balanced BST by always choosing the middle element as root. Approach: • Use slow & fast pointers to find the middle node • Middle node becomes the root • Left part → build left subtree • Right part → build right subtree Repeat this process recursively to construct the entire BST. Concepts Used: • Linked List • Binary Search Tree (BST) • Two Pointers (Slow & Fast) • Recursion Time Complexity: O(n log n) Space Complexity: O(log n) This problem helped me understand how to transform one data structure into another efficiently From lists → to trees… leveling up data structure mastery #Day87 #100DaysOfCode #LeetCode #BST #LinkedList #Recursion #Cpp #CodingJourney