# Solving Leetcode Interviews in Seconds with AI: Merge Nodes in Between Zeros


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2181" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given the head of a linked list, which contains a series of integers separated by 0's. The beginning and end of the linked list will have Node.val == 0. For every two consecutive 0's, merge all the nodes lying in between them into a single node whose value is the sum of all the merged nodes. The modified list should not contain any 0's. Return the head of the modified linked list.   Example 1:   Input: head = [0,3,1,0,4,5,2,0] Output: [4,11] Explanation:  The above figure represents the given linked list. The modified list contains - The sum of the nodes marked in green: 3 + 1 = 4. - The sum of the nodes marked in red: 4 + 5 + 2 = 11.  Example 2:   Input: head = [0,1,0,3,0,2,2,0] Output: [1,3,4] Explanation:  The above figure represents the given linked list. The modified list contains - The sum of the nodes marked in green: 1 = 1. - The sum of the nodes marked in red: 3 = 3. - The sum of the nodes marked in yellow: 2 + 2 = 4.    Constraints:  The number of nodes in the list is in the range [3, 2 * 105]. 0 <= Node.val <= 1000 There are no two consecutive nodes with Node.val == 0. The beginning and end of the linked list have Node.val == 0.  

	# Explanation
	Here's the breakdown of the problem and the solution:

*   **High-Level Approach:**
    *   Iterate through the linked list.
    *   Accumulate the sum of node values between consecutive 0's.
    *   Replace the first 0 of each pair with the accumulated sum and remove the intermediate nodes and the second 0.

*   **Complexity:**
    *   Runtime: O(n), where n is the number of nodes in the linked list.
    *   Space: O(1), as we modify the list in-place.

	
	# Code
	```python
	class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def mergeNodes(head: ListNode) -> ListNode:
    curr = head
    while curr:
        if curr.val == 0:
            sum_val = 0
            temp = curr.next
            while temp and temp.val != 0:
                sum_val += temp.val
                temp = temp.next

            curr.val = sum_val
            curr.next = temp.next if temp else None

            temp_del = curr.next
            curr_del = curr
            while temp_del != temp and curr_del.next != temp:
                curr_del = curr_del.next

            if curr_del.next == temp:
                del_node = curr_del.next
                curr_del.next = temp.next

            curr = curr.next
        else:
            curr = curr.next

    return head

def mergeNodes_optimal(head: ListNode) -> ListNode:
    curr = head
    tail = head
    sum_val = 0

    while curr:
        if curr.val == 0:
            if sum_val != 0:
                tail.next = ListNode(sum_val)
                tail = tail.next
                sum_val = 0
        else:
            sum_val += curr.val
        curr = curr.next

    return head.next
	```