thảo luận Leetcode mỗi ngày

class Solution:
    def mergeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast = head.next
        slow = ListNode(0)
        while fast:
            if fast.val != 0:
                slow.val += fast.val
            elif  fast.val == 0 and fast.next:
                slow = slow.next
                
                slow.val = 0
            else:
                slow.next = None
            fast = fast.next
        return head

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode()
        k = dummy
        s = 0
        while head:
            if head.val == 0:
                dummy.next = ListNode(val=s)
                s = 0
                dummy = dummy.next
            else: s += head.val
            head = head.next
       
        while k:
            if k.val == 0:k=k.next
            else: break
        return k

class Solution {
    func mergeNodes(_ head: ListNode?) -> ListNode? {
        /*
        guard let head else { return nil }
        var result:ListNode?
        var resultNext:ListNode?

        var next:ListNode? = head
        var newNode = true
        while next != nil {
            if next!.val == 0 {
                newNode = true
            } else {
                if newNode {
                    newNode = false
                    if resultNext != nil {
                        resultNext!.next = ListNode()
                        resultNext = resultNext!.next
                    } else {
                        result = ListNode()
                        resultNext = result
                    }
                }
                resultNext!.val += next!.val
            }
            next = next!.next
        }

        return result
        */

        guard let head else { return nil }
        var result = ListNode()
        var resultNext:ListNode! = result
        var resultPre:ListNode! = result

        var next:ListNode? = head
        while next != nil {
            if next!.val == 0 {
                resultPre = resultNext
                resultNext.next = ListNode()
                resultNext = resultNext.next!
            } else {
                resultNext.val += next!.val
            }
            next = next!.next
        }

        result = result.next!
        if result.val == 0 {
            return nil
        }
        resultPre.next = nil

        return result
    }
}

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # Approach 1 : 2 pointers
        # pointer = head.next
        # ans = ListNode()
        # dummy = ans
        # while pointer:
        #     while pointer.val != 0:
        #         dummy.val += pointer.val
        #         pointer = pointer.next
        #     pointer = pointer.next
        #     if pointer:
        #         dummy.next = ListNode()
        #         dummy = dummy.next
        # return ans
        # Approach 2 : Recursion
        head = head.next
        if not head:
            return head
        temp = head
        curr_sum = 0
        while temp.val != 0:
            curr_sum += temp.val
            temp = temp.next
        
        head.val = curr_sum
        head.next = self.mergeNodes(temp)
        return head

public class Solution
{
    public ListNode MergeNodes(ListNode head)
    {
        ListNode result = new();
        ListNode pointer = result;

        bool open = false;
        while (head != null && head.next != null)
        {   
            if (head.val != 0)
            {
                pointer.val += head.val;
                head = head.next;
                continue;
            }

            if (!open)
            {
                open = true;
                pointer.next = new();
                pointer = pointer.next;
                head = head.next;
                continue;
            }

            open = false;
        }

        return result.next;
    }
}

class Solution {
    public ListNode mergeNodes(ListNode head) {
        ListNode pointer = head.next;
        int sum = 0;
        ListNode preZeroNode = head;
        while (pointer != null) {
            if (pointer.val == 0) {
                pointer.val = sum;
                preZeroNode.next = pointer;
                preZeroNode = pointer;
                sum = 0;
            } else {
                sum += pointer.val;
            }

            pointer = pointer.next;
        }
        return head.next;
    }
}

/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public $next = null;
 *     function __construct($val = 0, $next = null) {
 *         $this->val = $val;
 *         $this->next = $next;
 *     }
 * }
 */
class Solution {

    /**
     * @param ListNode $head
     * @return ListNode
     */
    function mergeNodes($head) {
        $next = $head->next; // traversal cursor
        $zeroNext = $head; // zero traversal cursor
        $sum = 0;

        while ($next) {
            if ($next->val !== 0) {
                $sum += $next->val;
                $next = $next->next;
                continue;
            }

            // case node val is 0
            $zeroNext->val = $sum;
            if ($next->next === null) {
                $zeroNext->next = null;
                return $head;
            }
            
            $sum = 0;
            $zeroNext->next = $next;
            $zeroNext = $next;
            $next = $next->next;
        }
    }
}

public ListNode mergeNodes(ListNode head) {
    int sum = 0;
    ListNode result = new ListNode(0);
    ListNode current = result;
    head = head.next;

    for (ListNode c = head; c != null; c = c.next) {
        if (c.val == 0) {
            current.next = new ListNode(sum);
            current = current.next;
            sum = 0;
        } else {
            sum += c.val;
        }
    }

    return result.next;
}

impl Solution {
    pub fn merge_nodes(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        let mut current = None;
        current = head.as_mut().and_then(|node| node.next.take());
        let mut tail = head.as_mut();

        while let Some(mut node) = current {
            current = node.next.take();

            tail =
                tail.and_then(|tail_node| {
                    if tail_node.val == 0 {
                        if node.val != 0 {
                            tail_node.val += node.val;
                        }

                        Some(tail_node)
                    } else {
                        if node.val == 0 {
                            if current.is_some() {
                                tail_node.next = Some(node);
                                tail_node.next.as_mut()
                            } else {
                                Some(tail_node)
                            }
                        } else {
                            tail_node.val += node.val;
                            Some(tail_node)
                        }
                    }
                });
        }
        head
    }
}

impl Solution {
    pub fn merge_nodes(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        let mut current = head.as_mut().and_then(|node| node.next.take());
        let mut tail = head.as_mut();

        while let Some(mut node) = current {
            current = node.next.take();

            tail =
                tail.and_then(|tail_node| {
                    if node.val == 0 {
                        if current.is_none() {
                            Some(tail_node)
                        } else {
                            tail_node.next = Some(node);
                            tail_node.next.as_mut()
                        }
                    } else {
                        tail_node.val += node.val;

                        Some(tail_node)
                    }
                });
        }

        head
    }
}

class Solution {
public:
    ListNode* mergeNodes(ListNode* head) {
        if (!head->next) return nullptr;
        ListNode* root = head; head = head->next;
        while (head->val)
            root->val += head->val, head = head->next;
        root->next = mergeNodes(head);
        return root;
    }
};

impl Solution {
    pub fn merge_nodes(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        match head {
            None => None,
            Some(head) => {
                let mut node = head.as_ref();

                let mut head_out = None;
                let mut prev_out = &mut head_out;

                while let Some(next) = &node.next {
                    node = next;

                    let mut new_val = 0;
                    while node.val != 0 {
                        new_val += node.val;

                        match node.next {
                            None => break,
                            Some(ref next_node) => node = next_node,
                        }
                    }

                    let new_out = Box::new(ListNode::new(new_val));
                    match prev_out {
                        None => *prev_out = Some(new_out),

                        Some(prev) => {
                            prev.next = Some(new_out);
                            prev_out = &mut prev.next;
                        }
                    }
                }

                head_out
            }
        }
    }
}

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var mergeNodes = function(head) {
    const dump = new ListNode();
    let curDump = dump;
    let cur = head;
    let curSum = 0;
    let zeroCounter = 0;

    while (cur) {
        if (cur.val === 0) {
            zeroCounter++;
        }

        if (zeroCounter === 2) {
            curDump.next = new ListNode(curSum);
            curDump = curDump.next;
            zeroCounter = 1;
            curSum = 0;
        } else {
            curSum += cur.val;
        }

        cur = cur.next;
    }

    return dump.next;
};

class Solution {
    public ListNode mergeNodes(ListNode head) {
        while(head.val==0 && head!=null){
            head=head.next;
        }
        if(head==null) return head;
        ListNode newHead = head;
        ListNode temp = head.next;
        Boolean isNext = false;
        while(temp!= null){
            if(temp.val!=0 && isNext==false) newHead.val+=temp.val;
            else if(temp.val!=0 && isNext==true){
                newHead.next = temp;
                newHead = newHead.next;
                isNext = false;
            }
            else isNext = true;
            temp = temp.next;
        }
        newHead.next = null;
        return head;
    }
}

var mergeNodes = function (head) {
  let list = new ListNode(), clone = list, sum = 0
  while (head) {
    if (head.val == 0) {
      if (sum != 0) {
        clone.val = sum
        if (head.next) {
          clone.next = new ListNode()
          clone = clone.next
          sum = 0
        }
      }
    } else {
      sum += head.val
    }
    head = head.next
  }
  return list
};

class Solution:
    def mergeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
        curMergedNode = head.next
        rightNode = head.next
        curSum = 0
        while rightNode:
            if rightNode.val != 0:
                curSum += rightNode.val
            else:
                curMergedNode.val = curSum
                curMergedNode.next = rightNode.next
                curMergedNode = curMergedNode.next
                curSum = 0
            rightNode = rightNode.next
        return head.next

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]:
        def dfs(head, p):
            if p is None or p.next is None:
                return head
            
            p_next = p.next
            p.val += p_next.val
            p.next = p_next.next
            if p_next.val == 0:
                p = p.next
            return dfs(head, p)
        return dfs(head.next, head.next)

public class Solution {
    public ListNode MergeNodes(ListNode head) {
        head = head.next;
        ListNode temp = head;
        while(temp != null)
        {
            if(temp.next.val == 0)
            {
                temp.next = temp.next.next;
                temp = temp.next;
            }
            else
            {
                temp.val += temp.next.val;
                temp.next = temp.next.next;
            }
        }
        return head;
    }
}