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

var insertGreatestCommonDivisors = function(head) {
    const gcd = (a, b) => {
        while (b !== 0) {
            let temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    let cur = head;
    while (cur && cur.next) {
        let next = cur.next;
        cur.next = new ListNode(gcd(cur.val, cur.next.val), next);
        cur = next;
    }

    return head;
};

class Solution {
    public ListNode insertGreatestCommonDivisors(ListNode head) {
        ListNode curr = head;       
        while (curr.next != null) {
            int gcd = findGCD(curr.val, curr.next.val);
            ListNode newNode = new ListNode(gcd, curr.next);
            curr.next = newNode;
            curr = newNode.next;
        }
        return head;
    }

    private int findGCD(int a, int b) {
        if (b == 0) {
            return a;
        }
        return findGCD(b, a % b);
    }
}

function gcd(a, b) {
    if (b === 0) {
        return a;
    }
    return gcd(b, a % b);
}

function insertGreatestCommonDivisors(head: ListNode | null): ListNode | null {
    let cur = head;
    while (cur && cur.next) {
        const c = gcd(cur.val, cur.next.val);
        const next = new ListNode(c, cur.next);
        cur.next = next;
        cur = cur.next.next;
    }
    return head;
};

class Solution {
public:
    int greastCommonDivisor(int a, int b){
        while (a!=b){
            if(a>b) a -= b;
            else b-=a;
        }
        return a;
    }
    ListNode* insertGreatestCommonDivisors(ListNode* head){
        ListNode* temp = head;

        while (temp->next){
            ListNode* add = new ListNode(greastCommonDivisor(temp->val, temp->next->val), temp->next);
            temp->next = add;
            temp = temp->next->next;
        }
        return head;
    }
};

/**
 * 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:
    ListNode* insertGreatestCommonDivisors(ListNode* head) {
        ListNode* current = head;
        while (current->next != nullptr)
        {
            int gcdValue = gcd(current->val, current->next->val);
            ListNode* node = new ListNode(gcdValue, current->next);
            current->next = node;
            current = node->next;
        }

        return head;
    }
};

class Solution {
    public ListNode insertGreatestCommonDivisors(ListNode head) {
        ListNode pointer = head;

        while (pointer != null && pointer.next != null) {
            ListNode next = new ListNode(gcd(pointer.val, pointer.next.val), pointer.next);
            pointer.next = next;
            pointer = next.next;
        }

        return head;
    }

    private int gcd(int x, int y) {
        if (y == 0) return x;
        return gcd(y, x % y);
    }
}

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def insertGreatestCommonDivisors(self, head: Optional[ListNode]) -> Optional[ListNode]:
        def gcd(a,b):
            if b == 0:
                return a
            return gcd(b, a % b)
        
        slow = head
        if head.next:
            fast = head.next
            while fast:
                g = gcd(slow.val, fast.val)
                slow.next = ListNode(g, fast)
                slow = fast
                fast = fast.next
            return head
        else:
            return head

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode insertGreatestCommonDivisors(ListNode head) {
        ListNode root = new ListNode();
        ListNode temp = root;
        while (head != null) {
            if (head.next == null) {
                temp.next = new ListNode(head.val);
                break;
            }
            temp.next = new ListNode(head.val);
            temp.next.next = new ListNode(greatCommonDivisor(head.val, head.next.val));
            temp = temp.next.next;
            head = head.next;
        }
        return root.next;
    }
    private int greatCommonDivisor(int num1, int num2) {
        if (num1 == 1 || num2 == 1) return 1;
        while (num2 != 0) {
            int tmp = num1 % num2;
            num1 = num2;
            num2 = tmp;
        }
        return num1;
    }
}

public class Solution {
    public int LastStoneWeightII(int[] stones) {
        var possibility = new List<int>{ 0 };
        foreach (var t in stones)
        {
            var length = possibility.Count;
            var casePlus = possibility.Select(x => x + t).ToList();
            possibility = possibility.Select(x => Math.Abs(x - t)).Union(casePlus).ToList();
        }

        return possibility.Min();
    }
}

class Solution {
    public ListNode insertGreatestCommonDivisors(ListNode head) {
        ListNode curNode = head.next;
        ListNode preNode = head;
        while(curNode!=null){
            int gcd = gcd(curNode.val, preNode.val);
            ListNode inserted = new ListNode(gcd, curNode);
            preNode.next = inserted;
            preNode= curNode;
            curNode = curNode.next;
        }
        return head;
    }
    public int gcd(int a, int b){
        if(b==0) return a;
        return gcd(b,a%b);
    }
}

class Solution {

    /**
     * @param ListNode $head
     * @return ListNode
     */
    function insertGreatestCommonDivisors($head) {
        $cur = $head;
        $next = $cur->next;

        while ($cur && $next) {
            $common = $this->getGreatedDivisor($cur->val, $next->val);
            $node = new ListNode($common);
            $node->next = $next;
            $cur->next = $node;

            $cur = $next;
            $next = $cur->next;
        }
        
        return $head;
    }

    /**
     * @param int $a
     * @param int $b
     * @return int
     */
    function getGreatedDivisor($a, $b) {
        // a should always be greater than b
        list($a,$b) = ($a < $b) ? [$b, $a] : [$a, $b];

        if ($a % $b === 0) return $b;

        $common = floor($b / 2);
        while ($common > 0) {
            if ($a % $common === 0 && $b % $common === 0) break;
            $common--;
        }

        return $common;
    }
}

class Solution {
    func insertGreatestCommonDivisors(_ head: ListNode?) -> ListNode? {
        guard let head else { return head }

        var cur = head
        while let next = cur.next {
            //let num = findCommonDivior(num1: cur.val, num2: next.val)
            let num = gcd(cur.val, next.val)
            cur.next = ListNode(num, next)
            cur = next
        }
        return head
    }
// Tự viết
    func findCommonDivior(num1: Int, num2: Int) -> Int {
        var num1 = num1
        var num2 = num2
        while num1 != num2 {
            if num1 > num2 {
                num1 -= num2
            } else {
                num2 -= num1
            }
        }
        return num1
    }
// Chôm về hiệu năng cao hơn
    private func gcd(_ a: Int, _ b: Int) -> Int {
        var (a, b) = (max(a, b), min(a, b))

        while b > 0 {
            (a, b) = (b, a % b)
        }

        return a
    }
}