DEV Community: Aaysha

Merge 2 Sorted LinkedLists!

Aaysha — Fri, 25 Jul 2025 20:36:28 +0000

Hey fellow devs! 👋
Today I was doing a revision of linkedList basics and encountered this leetcode problem. I actually forgot how to do it and had to solve it again and found the problem quite satisfying with a simple elegant solution. I thought I would share it here

The problem is Merge Two Sorted LinkedLists

You are given the heads of two sorted linked lists list1 and list2.

Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists.

Return the head of the merged linked list.
So I started thinking — “Hey, this is basically merging two sorted arrays, right?” So I just tried to replicate that logic but with linked lists.

And boom 💥 — it worked.

Here's the version I first wrote:

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if l1 is None: return l2
        if l2 is None: return l1

        i, j = l1, l2
        head, k = None, None

        while i and j:
            if i.val <= j.val:
                newNode = ListNode(i.val)
                i = i.next
            else:
                newNode = ListNode(j.val)
                j = j.next

            if head is None:
                head = newNode
                k = head
            else:
                k.next = newNode
                k = k.next

        while i:
            k.next = ListNode(i.val)
            k = k.next
            i = i.next
        while j:
            k.next = ListNode(j.val)
            k = k.next
            j = j.next

        return head

This version creates a new list by copying values — clean and readable. But then something hit me...

Wait — in most linked list problems, they care about actual node identity too. What if they checked if I used the same node instances from the input lists?

So I sat with it for sometime then realised the issue is with head initialization. Then it hit me what if I just initialize a dummy head and just reference the original nodes instead of duplicating them. Then while returning just return the next node to the dummy next. That led to this version:

A cleaner, simpler approach:

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        if not list1:
            return list2
        if not list2:
            return list1

        i, j = list1, list2
        head = ListNode(0)
        res = head

        while i and j:
            if i.val <= j.val:
                res.next = i
                i = i.next
            else:
                res.next = j
                j = j.next
            res = res.next

        res.next = i if i else j
        return head.next

This version feels a lot more elegant — fewer allocations, reuses existing nodes, and it’s just simpler to reason about. Just adding a dummy head node made the solution much easier and robust.

Sometimes, taking a step back and asking “how can I improve this?” leads to those little "aha!" moments that make problem-solving so satisfying. And next time I face a similar problem, I’ll definitely think of this approach — not because I saw it in a video, but because I discovered it myself by playing around.

Have you had any moments like this — where something just clicks while you’re coding or debugging? Would love to hear your stories!

Day 1(long after day 0 )

Aaysha — Tue, 22 Jul 2025 18:52:38 +0000

Hey fellow devs! 👋
I dipped after bragging about becoming a 10x engineer and making a public announcement of how I will be consistent(embarrassing!!). Well I am back and ready to give this another hand. The roadmap for the last post was created with the help of my mentor, Senpai chatGPT. From this post onwards, I have decided I will freestyle the content while trying to stick to Senpai's advice. I got laid off too (out of the blue), So I am struggling to decide whether I should practice DSA and system Design or focus on building fundamentals( Any advice is welcome).

I built a CRUD API server in the mean time as part of a company interview assessment. And learnt some DSA topics solved some leetcode questions. Today to break the long winter of my disappearance I will warm-up with solving a leet-code problem.

Leetcode 875. Koko Eating Bananas

Problem statement

Koko loves to eat bananas. There are n piles of bananas, the ith pile has piles[i] bananas. The guards have gone and will come back in h hours.

Koko can decide her bananas-per-hour eating speed of k. Each hour, she chooses some pile of bananas and eats k bananas from that pile. If the pile has less than k bananas, she eats all of them instead and will not eat any more bananas during this hour.

Koko likes to eat slowly but still wants to finish eating all the bananas before the guards return.

Return the minimum integer k such that she can eat all the bananas within h hours.

Example 1:
Input: piles = [3,6,7,11], h = 8
Output: 4

Example 2:
Input: piles = [30,11,23,4,20], h = 5
Output: 30

Example 3:
Input: piles = [30,11,23,4,20], h = 6
Output: 23

Constraints:

1 <= piles.length <= 10^4
piles.length <= h <= 10^9
1 <= piles[i] <= 10^9

Thought process
So what is upper limit of rate k at which koko can eat bananas? it will be the max of array(max of pile) if she ate at that rate she can always finish before h hours(because piles.length<=h). But koko would love to eat as slow as possible which is 1 banana per hour. So our desired k lies within the range (1,max(piles)). How to calculate how much time it will take koko to finish eating all the piles: Iterate through each pile, divide by k and round to the next integer if not completely divisible.

def timeRequired(m):
 t=0
 for i in piles:
    t+=math.ceil(i/k)
 return t

this should be calculated for each k in range(1,max(piles)) then the time complexity become O(n*maxK)

maxK=max(piles)
for k in range(1,maxK):
 t=timeRequired(k)
 if t==h:
   return k
 if t>h:
   return k-1

Optimization

Since we're searching for the smallest k in the range [1, max(piles)] such that Koko finishes eating all bananas within h hours, and the total time needed decreases as k increases, we can use binary search.

We define:

left = 1: slowest possible speed

right = max(piles): fastest needed (eat whole pile in one hour)

At each step, we:

**1. Pick mid = (left + right) // 2 as our current candidate eating speed.

Calculate time t = sum(ceil(pile / mid) for pile in piles).
If time t<= h, it means mid is fast enough, but we want the minimum such speed → try smaller → right = mid.
If total time t > h, it means mid is too slow → try faster → left = mid + 1.

We repeat this until left == right. At that point, left holds the minimum eating speed k that allows Koko to finish in time.**

The improved time complexity is O(n*log(maxK))

l, r := 1, maxK
for l < r {
    m := (l + r) / 2
    if timeRequired(m) <= h {
        r = m
    } else {
        l = m + 1
    }
}
return l

My Journey to Becoming a 10x Developer: Day 0

Aaysha — Tue, 22 Apr 2025 19:22:49 +0000

Hey fellow devs! 👋

I'm a software engineer looking to level up my skills and share my learning journey. After reading some great advice on becoming a more impactful developer, I've decided to document my progress daily here on dev.to to stay accountable and hopefully help others along the way.

The Plan

I'm focusing on building fundamentals and solving practical problems that showcase multiple skills at once. Here's what I'll be working on:

Core Projects

Implement a Trie in Go
- While relatively straightforward, tries are versatile data structures used in autocomplete, spell-checkers, and IP routing
- Will help me practice Go and efficient memory usage
Design and Build a URL Shortener Service
- Complete with a REST API, database persistence, and basic analytics
- Will cover web development, database design, and system architecture
Implementing Advanced Data Structures
- B-trees for database indexing
- Concurrent hash maps with lock striping
- Bloom filters for efficient set membership testing
- Skip lists for fast search within ordered data
Distributed Systems Mini-Projects
- Build a simple distributed key-value store with consistency guarantees
- Implement a leader election algorithm (Raft consensus)
- Create a basic load balancer with different strategies
Performance Engineering
- Benchmark different data structures and algorithms
- Profile and optimize Go code using pprof
- Implement various concurrency patterns (worker pools, fan-out/fan-in)
Full-Stack Application
- Build a real-time collaborative editor using WebSockets
- Implement JWT authentication and authorization
- Deploy using Docker and Kubernetes

Why This Approach?

I believe becoming a "10x developer" isn't about typing faster—it's about making better decisions, understanding fundamentals deeply, and building systems that scale. These projects cover:

Data structures and algorithms
System design and architecture
Performance optimization
Testing and reliability
DevOps and deployment

How I'll Track Progress

For each project, I'll:

Post daily updates with code snippets and learnings
Share benchmarks and performance metrics
Discuss design decisions and trade-offs
Include diagrams for system architecture

Let's Connect!

I'd love to hear your thoughts:

Are there other projects you'd recommend for becoming a more effective developer?
Have you implemented any of these data structures or systems in Go?
Any particular resources you've found helpful for advanced Go development?

Follow along as I document this journey, and let's learn together!

#programming #datastructures #systemdesign #learneveryday