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, 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

    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