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

Python: 
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:
        def reverse(head):
            prev = None
            current = head
            while current != None:
                temp = current.next
                current.next = prev
                prev = current
                current = temp

            return prev

        head = reverse(head)
        current = head
        carry = 0
        while current != None:
            newVal = current.val * 2 + carry
            carry = newVal//10
            current.val = newVal%10
            if current.next == None and carry != 0:
                current.next = ListNode(carry)
                current = current.next

            current = current.next

        return reverse(head)
 
nchhnchh said:
Python: 
class Solution:
    def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:
       
        def next(node):
            if node is None:
                return 0
            node.val = node.val * 2 + next(node.next)
            node.val, mod = node.val % 10, node.val // 10

            return mod
       
        mod = next(head)

        if mod > 0:
            node = ListNode(1)
            node.next = head
            head = node
        return head
Click to expand...
Đệt thế mà ko nghĩ ra nhỉ, làm mình reverse lung tung lên haha
 
C++: 
class Solution {
public:
    ListNode* doubleIt(ListNode* head) {
        ListNode *dmp = new ListNode(0);
        dmp->next = head;
        ListNode *pre =  dmp;
        while(head)
        {
            head->val = head->val*2;
            if(head->val >= 10)
            {
                head->val -= 10;
                pre->val = pre->val + 1;
            }
            pre = head;
            head = head->next;
        }
        if(dmp->val == 0) return dmp->next;
        else return dmp;
    }
};
 
Hơi nhiều thao tác, để đây tối ưu sau!

C++: 
    ListNode* doubleIt(ListNode* head) {
        head = reverse(head);
        ListNode* curr = head, *prev = nullptr;
        int val = 0, mem = 0;
        while(curr) {
            val = curr->val * 2 + mem;
            mem = val / 10;
            curr->val = val % 10;;
            prev = curr;
            curr = curr->next;
        }
        if (mem)
            prev->next = new ListNode(mem);
        return reverse(head);
    }
    ListNode* reverse(ListNode* head) {
        ListNode* prev = nullptr, *curr = head, *next = head;
        while(curr) {
            next = next->next;
            curr->next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}
 
Last edited:
Xài lại bài reverse hôm trước
Java: 
public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode current = head;
    while (current != null) {
        ListNode nextNode = current.next;
        current.next = prev;
        prev = current;
        current = nextNode;
    }
    return prev;
}

public ListNode doubleIt(ListNode head) {
    ListNode reversed = reverseList(head);
    int rem = 0;
    for (ListNode current = reversed; current != null; current = current.next) {
        int newValue = current.val * 2 + rem;
        current.val = newValue % 10;
        rem = newValue / 10;
        if (rem > 0 && current.next == null) {
            current.next = new ListNode(rem);
            break;
        }
    }
    return reverseList(reversed);
}
 
stack đơn giản
JavaScript: 
function doubleIt(head: ListNode | null): ListNode | null {
    if (!head) return null;
    const stack: ListNode[] = [];
    while(head) {
        stack.push(head);
        head = head.next;
    }
    let mod = 0, prev = null;
    while(stack.length) {
        const item = stack.pop();
        let next = item.val * 2 + mod;
        if (next > 9) mod = 1, next-= 10;
        else mod = 0;
        item.val = next;
        item.next = prev;
        prev = item;
    }
    if (mod === 1) {
        let ans = new ListNode(1);
        ans.next = prev;
        return ans;
    }
    return prev;
};
 
Python: 
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:
        curr = head
        res = []
        while curr:
            res.append(curr.val)
            curr = curr.next
        n = len(res)
        tmp = 0
        ans = None
        for i in range(n - 1, -1, -1):
            a = res[i] * 2 + tmp
            res[i] = int(a % 10)
            tmp = int( a / 10)
            # create new Node
            currNode = ListNode(res[i])
            currNode.next = ans
            ans = currNode
            
        if tmp > 0:
            currNode = ListNode(tmp)
            currNode.next = ans
            ans = currNode
      
        return ans
 
07/05/2024:
Bài hôm nay cách đơn giản nhất là đảo ngược cái list, double rồi đảo ngược lại lần nữa là xong.
Python: 
class Solution:
    def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:
        def reverse(head, prev = None):
            if not head.next:
                head.next = prev
                return head
            next_node = head.next
            head.next = prev
            return reverse(next_node, head)
        
        def double(head, remain = 0):
            if not head:
                return ListNode(remain) if remain > 0 else None
            val = head.val*2 + remain
            head.val = val%10
            remain = val//10
            head.next = double(head.next, remain)
            return head
        
        head = reverse(head)
        head = double(head)
        return reverse(head)

Cách ngắn gọn hơn nữa là k cần đảo ngược chuỗi.

Python: 
class Solution:
    def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:
        def double(head):
            if not head:
                return 0
            r = double(head.next)
            val = head.val*2 + r
            head.val = val%10
            return val//10
        head = ListNode(0, head)
        double(head)
        return head if head.val != 0 else head.next
 
Thấy bọn làm 1 loop thôi mà lười làm lại quá :censored: đề nói sao làm vậy cho khỏe.
C#: 
public class Solution
{
    public ListNode DoubleIt(ListNode head)
    {
        Stack<int> st = new();
        while (head != null)
        {
            st.Push(head.val);
            head = head.next;
        }

        int mem = 0;
        ListNode next = null;
        while (st.Count > 0)
        {
            int digit = st.Pop() * 2;
            ListNode prevNode = new(digit % 10 + mem);
            prevNode.next = next;
            next = prevNode;

            mem = digit / 10;
        }

        if (mem == 1)
        {
            ListNode memNode = new(1, next);
            next = memNode;
        }
        return next;       
    }
}
 
Mấy bác cho em hỏi, đó giờ làm LC em đa phần toàn tryhard tự làm , nào mà khó quá bí idea thì em mới xem solution, nên thường thường thì mất 1 ngày - 2 ngày để làm LC nếu bí problem đó, thì có nên không nhỉ?
 
DoanhDepTrai said:
Mấy bác cho em hỏi, đó giờ làm LC em đa phần toàn tryhard tự làm , nào mà khó quá bí idea thì em mới xem solution, nên thường thường thì mất 1 ngày - 2 ngày để làm LC nếu bí problem đó, thì có nên không nhỉ?
Click to expand...
Nên, ko phải ai cũng kiên trì được lâu để ngồi giải
 
DoanhDepTrai said:
Mấy bác cho em hỏi, đó giờ làm LC em đa phần toàn tryhard tự làm , nào mà khó quá bí idea thì em mới xem solution, nên thường thường thì mất 1 ngày - 2 ngày để làm LC nếu bí problem đó, thì có nên không nhỉ?
Click to expand...
Nên học về cấu trúc dữ liệu và giải thuật cơ bản trước
Cố giải bài easy trong 15p, medium trong 1h, hard thì hên xui.
Tùy vào thời gian mình có chứ cũng k nên đắm chìm quá.

via theNEXTvoz for iPhone
 
Python: 
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:
        res = []
        while head:
            res.append(head.val)
            head = head.next

        mod = 0
        while res:
            val = res.pop()
            val = val * 2 + mod
            mod = val // 10
            node = ListNode(val % 10)
            node.next = head
            head = node
        
        if mod != 0:
            node = ListNode(mod)
            node.next = head
            head = node
            
        return head
Q8sGcLO.png
 
DoanhDepTrai said:
Mấy bác cho em hỏi, đó giờ làm LC em đa phần toàn tryhard tự làm , nào mà khó quá bí idea thì em mới xem solution, nên thường thường thì mất 1 ngày - 2 ngày để làm LC nếu bí problem đó, thì có nên không nhỉ?
Click to expand...
Ko nên, ngồi 30ph ko ra thì xem luôn solution rồi code lại, ngồi nghiền ngẫm tại sao tụi nó code như thế.
Ngồi lâu quá 1 vấn đề sẽ ko học được gì, vì học theo pattern chứ ko phải học theo từng bài 1

via theNEXTvoz for iPhone
 
Java: 
  public static ListNode doubleIt(ListNode head) {
    ListNode res;
    ListNode runNode = head;
    if (head.val >= 5) {
      res = new ListNode(1, head);
    } else {
      res = head;
    }
    while (runNode.next != null) {
      runNode.val = (runNode.val * 2) % 10 + (runNode.next.val >= 5 ? 1 : 0);
//      System.out.println(runNode.val);
      runNode = runNode.next;
    }
    runNode.val = (runNode.val * 2) % 10;
    return res;
  }
 
Suy nghĩ đơn giản thì cứ reverse thôi :)
C-like: 
/**
 * Example:
 * var li = ListNode(5)
 * var v = li.`val`
 * Definition for singly-linked list.
 * class ListNode(var `val`: Int) {
 *     var next: ListNode? = null
 * }
 */
class Solution {
    fun doubleIt(head: ListNode?): ListNode? {
        val reversedNodes = reversedLinkedList(head)
        var carry = 0
        var newHead = head
        for (i in 0 until reversedNodes.size) {
            val curNode = reversedNodes[i]
            val doubleCurVal = curNode.`val` * 2 + carry
            val newVal = doubleCurVal % 10
            carry = doubleCurVal / 10
            curNode.`val` = newVal
        }
        if (carry > 0) {
            val carryNode = ListNode(carry)
            carryNode.next = head
            newHead = carryNode
        }
        return newHead
    }

    private fun reversedLinkedList(head: ListNode?): List<ListNode> {
        val nodes = mutableListOf<ListNode>()
        var ptr = head
        while (ptr != null) {
            nodes.add(ptr!!)
            ptr = ptr?.next
        }
        return nodes.asReversed()
    }
}
 
JavaScript: 
var doubleIt = function(head) {
    let reversed = reverseList(head);
    let carry = 0;
    let cur = reversed;

    while (cur) {
        let val = cur.val * 2 + carry;
        cur.val = val % 10;
        carry = Math.floor(val / 10);

        if (!cur.next && carry > 0) {
            cur.next = new ListNode(carry);
            break;
        }

        cur = cur.next;
    }

    return reverseList(reversed);
};

var reverseList = function(head) {
    if (!head) return head;
    let cur = head;
    let prev = null;
    while (cur.next) {
        let next = cur.next;
        cur.next = prev;
        prev = cur;
        cur = next;
    }

    cur.next = prev;

    return cur;
};
 
Ruby: 
# Definition for singly-linked list.
# class ListNode
#     attr_accessor :val, :next
#     def initialize(val = 0, _next = nil)
#         @val = val
#         @next = _next
#     end
# end
# @param {ListNode} head
# @return {ListNode}
def double_it(head)
    carry = recurse(head)

    head = ListNode.new(carry, head) if carry == 1

    head
end

def recurse(node)
    return 0 if node.nil?

    carry = 0
    carry = recurse(node.next) if node.next

    val = node.val * 2 + carry
    carry = val / 10
    node.val = val % 10

    carry
end
 
C++: 
  ListNode *doubleIt(ListNode *head) {
    ListNode *temp = head;
    ListNode *prev = NULL;
    while (temp != NULL) {
      int currVal = temp->val * 2;
      if (currVal > 9) {
        temp->val = currVal - 10;
        if (temp == head) {
          ListNode *newHead = new ListNode(1);
          newHead->next = head;
          head = newHead;
        } else
          prev->val += 1;
      } else
        temp->val = currVal;
      prev = temp;
      temp = temp->next;
    }
    return head;
  }
 
Java: 
class Solution {
    private int doubleNode(ListNode node){
        if(node==null) return 0;
        int mem = doubleNode(node.next);
        int val = node.val*2 + mem;
        node.val =val %10;
        return val/10;
    }
    public ListNode doubleIt(ListNode head) {
        int mem = doubleNode(head);
        if(mem>0){
            ListNode newHead = new ListNode(mem,head);
            return newHead;
        }
        return head;
    }
}
 

Similar threads

Duy1122
kiến thức Phân biệt Encrypt và Hashing
2
Replies
29
Views
2K
Machiko
Machiko
Xuan Ha Thu Dong
thảo luận [Review] Cuộc sống và công việc Dev ở Hà Lan. Làm thế nào để tìm việc ở HL và châu Âu nói chung?
9 10 11
Replies
208
Views
17K
Willas
Willas
hatayquelua
thắc mắc Cần kiến thức gì để được nhận thực tập Dev
3 4 5
Replies
88
Views
6K
thovotri
T
freezer0604
  • Locked
Động lực để 'phượt' mỗi ngày gần 30, 40 km đến công ty làm việc
13 14 15
Replies
288
Views
21K
yb123123
yb123123
MasterchiefsReborn
Tác dụng bất ngờ của việc đi chân trần mỗi ngày
Replies
18
Views
1K
Nacuto
Nacuto

Share this page

Back
Top