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

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    int get_size(ListNode* l){
        int n = 0;
        while (l != NULL){
            n++;
            l = l->next;
        }
        return n;
    }
    int rec(ListNode*& l1, ListNode*& l2){
        if (l1 == NULL){
            return 0;
        }
        l1->val += l2->val + rec(l1->next,l2->next); // cộng có nhớ
        if (l1->val >= 10){
            l1->val -= 10;
            return 1;
        }
        else return 0;
    }
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int n = get_size(l1), m = get_size(l2);
        if (n < m){
            swap(n,m);
            swap(l1,l2);
        }
        // làm cho len của 2 list bằng nhau
        while (n != m){
            m++;
            auto new_node = new ListNode(0,l2);
            l2 = new_node;
        }
        if (rec(l1,l2)) l1 = new ListNode(1,l1); // nếu như len(l1 + l2) > len(l1)
        return l1;
    }
};

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int val=0, ListNode next=null) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */
public class Solution {
    public ListNode AddTwoNumbers(ListNode l1, ListNode l2) {
        if(l1 == null)
            return l2;
        if(l2 == null)
            return l1;
       
        var length1 = findNodeLength(l1);
        var length2 = findNodeLength(l2);

        while(length1 != length2)
        {
            if(length1 > length2)
            {
                var temp = new ListNode(0);
                temp.next = l2;
                l2 = temp;
                length2 ++;
            }
            else
            {
                var temp = new ListNode(0);
                temp.next = l1;
                l1 = temp;
                length1 ++;
            }
        }

        var result = addTwoNumbers(l1, l2);
        if(result.number > 0)
        {
            return new ListNode(1, result.node);
        }

        return result.node;
    }

    private int findNodeLength(ListNode l)
    {
        var current = l;
        var length = 0;
        while(current != null)
        {
            length = length + 1;
            current = current.next;
        }

        return length;
    }

    private (int number, ListNode node) addTwoNumbers(ListNode l1, ListNode l2)
    {
        if(l1 == null && l2 == null)
            return (0, null);

        if(l1.next == null && l2.next == null)
        {
            var sum = l1.val + l2.val;
            return (sum/10, new ListNode( sum%10));
        }

        var nextNode = addTwoNumbers(l1.next, l2.next);
        var currentSum = l1.val + l2.val + nextNode.number;
        var result = (currentSum/10, new ListNode( currentSum%10, nextNode.node));
        return result;
    }
}

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
   
def reverse_list(head):
    if head is None:
        return None
    curr = head
    while curr.next:
        new_head = curr.next
        curr.next = curr.next.next
        new_head.next = head
        head = new_head
    return head


class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode(0)
       
        l1 = reverse_list(l1)
        l2 = reverse_list(l2)

        p1 = l1
        p2 = l2
        memory = 0

        while p1 or p2 or memory:
            curr_digit = memory

            if p1:
                curr_digit += p1.val
                p1 = p1.next
            if p2:
                curr_digit += p2.val
                p2 = p2.next
           
            memory = curr_digit // 10
            curr_digit %= 10
           
            new_node = ListNode(curr_digit)
            new_node.next = dummy.next
            dummy.next = new_node
       
        return dummy.next

class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        expression = ""
        pt = l1
        while pt:
            expression += str(pt.val)
            pt = pt.next
        expression += "+"
        pt = l2
        while pt:
            expression += str(pt.val)
            pt = pt.next
        total = str(eval(expression))
        ans = ListNode(int(total[0]))
        pt = ans
        for i in range(1, len(total)):
            pt.next = ListNode(int(total[i]))
            pt = pt.next
            
        return ans

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */

function addTwoNumbers(a: ListNode | null, b: ListNode | null): ListNode | null {
    const s1: number[] = [], s2: number[] = [];
    while(a) {
        s1.push(a.val);
        a = a.next;
    }
    while (b) {
        s2.push(b.val);
        b = b.next;
    }
    let carry = 0, ans = null;
    while(s1.length || s2.length || carry) {
        const sum = (s1.pop() ?? 0 ) + (s2.pop() ?? 0) + carry;
        const newNode = new ListNode(sum % 10);
        newNode.next = ans;
        ans = newNode;
        carry = Math.floor(sum / 10);
    }
    return ans;
};

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        return add(reverse(l1), reverse(l2));
    }

    ListNode* reverse(ListNode* l, ListNode* prev = nullptr) {
        auto next = l->next;
        l->next = prev;
        return next == nullptr ? l : reverse(next, l);
    }

    ListNode* add(ListNode* l1, ListNode* l2, int remain = 0, ListNode* prev = nullptr) {
        if (l1 == nullptr && l2 == nullptr && remain == 0) return prev;
        int val = remain + (l1 == nullptr ? 0 : l1->val) + (l2 == nullptr ? 0 : l2->val);
        return add((l1 == nullptr ? l1 : l1->next), (l2 == nullptr ? l2 : l2->next), val/10, new ListNode(val%10, prev));
    }
};

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
    return ListNode.fromBigInt(l1.toBigInt() + l2.toBigInt());
};
ListNode.fromBigInt = function (v) {
    let result = new ListNode(Number(v % 10n));
    v /= 10n;
    while (v > 0n) {
        result = new ListNode(Number(v % 10n), result);
        v /= 10n;
    }
    return result;
};
ListNode.prototype.toBigInt = function () {
    let head = this;
    let result = BigInt(head.val);
    while (head.next) {
        head = head.next;
        result = result * 10n + BigInt(head.val);
    }
    return result;
};