DEV Community: kevinrawal

Daily Dev Challenges - Day 01 🚀

kevinrawal — Sat, 01 Nov 2025 12:36:02 +0000

Day 1 — In-Memory Cache with TTL

I’ve started a daily challenge to improve my skills as a developer.

Today marks Day 1 of the challenge, where I worked on implementing an In-Memory Cache with TTL.

You can check out my solution here:

🔗 GitHub Repository

🧠 What I Learned

Singleton classes
Thread-safe execution
LRU cache design
Using OrderedDict in Python

A solid start to this learning journey — excited for what’s next! 💪

Master Git with Interactive Learning Platforms! 🚀

kevinrawal — Sat, 06 Jan 2024 04:29:58 +0000

Hey folks,

Are you looking to level up your Git version control skills? We've got you covered! Here are two awesome online platforms that offer interactive and engaging ways to enhance your Git proficiency:

LearnGitBranching:
LearnGitBranching is an interactive and visually appealing tool that allows you to practice Git branching, merging, rebasing, and more. Whether you're a beginner or looking to refine your skills, this platform provides an intuitive way to understand and experiment with Git commands. It's a great resource to solidify your understanding of Git workflows.

Git Exercises:
Git Exercises is another excellent platform to enhance your Git proficiency. With various exercises and challenges, it covers a wide range of Git concepts and scenarios. The hands-on nature of these exercises makes it a valuable resource for individual learners and teams aiming to improve their version control practices.

By actively engaging with these platforms, you can gain practical experience and boost your confidence in using Git effectively. Whether you're a developer, student, or simply curious about version control, these resources cater to various skill levels.

do share other helpful resources in the comments.
Happy coding! 🚀

TLE Tales: When Unordered_map Bites You

kevinrawal — Fri, 29 Dec 2023 14:58:05 +0000

Hey, fellow devs👋!

I just tackled a problem that taught me a valuable lesson about time complexity: always consider the worst-case scenario, even when average-case performance seems good ⚠️.

Here's the gist:

Problem: Find a subarray with a sum of zero.
Constraints
- Array size: 1 to 2*10^5
- Element range: 1 to 10^9
- Total sum of elements: ≤ 2*10^5

My initial approach:

Used unordered_map to store sums for efficient lookup.
Average-case time complexity: O(1) ✨
Worst-case time complexity of entire code: O(n) (this led to the TLE)

The TLE surprise:

Got a Time Limit Exceeded (TLE) verdict, specifically during lookup operations in the unordered_map.
Why? The worst-case lookup time in unordered_map can be linear O(n), so with the given constraint worst-case complexity of the program becomes O(n^2).

The solution:

Switched to map (ordered_map with worst-case complexity O(log n)):
- Now Worst-case time complexity of my code become: O(nlogn), O(n) to traverse the array and O(long) for lookup.
- Accepted solution!

Key takeaways:

just look at the complexity of ordered and unordered_map

This complexity tells you a lot about when to use which data structure, map stores the data in a sorted manner while unordered will not, here we do not need sorted data which's why in the first attempt I went with unordered_map but later I realized my mistake and correct it.

instead of 10^5 if the number of elements is 10^9 then our ordered_map will not work so,

Always analyze worst-case time complexity, especially when dealing with large inputs.
Don't rely solely on average-case performance.
Choose data structures wisely based on problem constraints and potential worst-case scenarios.

Happy coding!!

Quick Sort vs. Merge Sort: A Developer's Dilemma 🤔

kevinrawal — Sat, 23 Dec 2023 09:51:11 +0000

Let's delve into the intriguing realm of sorting algorithms and zoom in on the dynamic duo—Quick Sort and Merge Sort. 🚀✨

Quick Sort: The Swift Pathfinder 🏎️

Quick Sort is the speed demon of sorting algorithms. Its divide-and-conquer strategy, coupled with clever pivot selection, makes it incredibly efficient.

Use Cases:

Real-Time Processing: In scenarios like financial trading, where split-second decisions matter, Quick Sort's speed is a game-changer.
Large Datasets: When dealing with massive datasets, Quick Sort's average time complexity of O(n log n) shines, ensuring rapid data organization.

Worst Case Consideration:

Caveat Emptor: However, it's important to note the worst-case scenario. If the pivot selection consistently results in unbalanced partitions, Quick Sort can degrade to a quadratic time complexity (O(n^2)), making it less favorable for certain cases.

Merge Sort: The Consistent Performer 🔄

Merge Sort, on the other hand, takes a more laid-back approach. It's stable, reliable, and maintains a consistent performance.

Use Cases:

Stability Matters: When stability is crucial, as in applications where the relative order of equal elements must be preserved, Merge Sort comes to the forefront.
Predictable Performance: In scenarios where a consistent and predictable time complexity of O(n log n) is preferred over the fastest possible speed.

Choosing Wisely: Balancing Speed and Consistency ⚖️

As developers, the choice between Quick Sort and Merge Sort often boils down to the specific needs of the task at hand. Need blazing speed and can handle a bit of unpredictability? Quick Sort is your ally. Craving stability and a consistent performance profile? Merge Sort has your back. 🤝

Your Experiences?💬

Have you encountered situations where the choice between Quick Sort and Merge Sort made a significant impact on your project? Share your thoughts, experiences, and let's keep the conversation alive! 🚀✨

2023 Leetcode Rewind

kevinrawal — Thu, 21 Dec 2023 04:46:13 +0000

"2023 was a great year for my coding skills! Thanks to LeetCode
for helping me level up 🚀.