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

def goodNodes(self, root: TreeNode, prev = -1e5) -> int:
        return 0 if not root else 1 + self.goodNodes(root.left, root.val) + self.goodNodes(root.right, root.val) if root.val >= prev else self.goodNodes(root.left, prev) + self.goodNodes(root.right, prev)

class Solution {
public:
    int goodNodes(TreeNode* root, int prev = -1e5) {
        if (root == NULL) return 0;
        if (root->val < prev) return goodNodes(root->left, prev) + goodNodes(root->right, prev);
        return 1 + goodNodes(root->left, root->val) + goodNodes(root->right, root->val);
    }
};

var goodNodes = function(root, prev) {
    if (root === null) {
        return 0
    }
    if (prev===undefined || root.val >= prev) {
        return 1 + goodNodes(root.left, root.val) + goodNodes(root.right, root.val)
    }
    return goodNodes(root.left, prev) + goodNodes(root.right, prev)
};

func goodNodes(root *TreeNode) int {
    return goodNodesRecursive(root, -1e5)
}
func goodNodesRecursive(root *TreeNode, prev int) int {
    if root == nil {
        return 0
    }
    if root.Val < prev {
        return goodNodesRecursive(root.Left, prev) + goodNodesRecursive(root.Right, prev)
    }
    return 1 + goodNodesRecursive(root.Left, root.Val) + goodNodesRecursive(root.Right, root.Val)
}

int goodNodes(TreeNode* p, int mx = INT_MIN) {
    return p ? mx = max(mx, p->val), (p->val >= mx) + goodNodes(p->left, mx) + goodNodes(p->right, mx) : 0;
}

class Solution {
    public int goodNodes(TreeNode root) {
        if(root == null)
        {
            throw new NullPointerException("NullRootArgument");
        }
        int ans = 0;
        Stack<TreeNode> s = new Stack<>();
        HashMap<TreeNode, Integer> hash = new HashMap<>();
        s.push(root);
        hash.put(root, root.val);
        while(!s.isEmpty())
        {
            TreeNode current = s.pop();
            int maxVal = hash.get(current);
            if(current.val >= maxVal)
            {
                ans++;
            }
            maxVal = Math.max(current.val, maxVal);
            if(current.right != null)
            {
                s.push(current.right);
                hash.put(current.right, maxVal);
            }
            if(current.left != null)
            {
                s.push(current.left);
                hash.put(current.left, maxVal);
            }
        }
        return ans;
    }
}

def average_of_levels(root)
  queue = [root]
  res = []
  until queue.empty?
    level_len = queue.length
    sum = 0.0
    level_len.times do
      curr = queue.shift
      queue << curr.left if curr.left
      queue << curr.right if curr.right
      sum += curr.val
    end
    res << sum / level_len
  end
  res
end

class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        d = defaultdict(list)

        def dfs(node, i):
            d[i].append(node.val)
            if node.left:
                dfs(node.left, i+1)
            if node.right:
                dfs(node.right, i+1)

        dfs(root, 0)
        return [sum(d[i])/len(d[i]) for i in d]

    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        queue = [root]
        res = []
      
        while queue:
            level_len = len(queue)
            level_sum = 0
          
            for i in range(level_len):
                node = queue.pop(0)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                level_sum += node.val
              
            res.append(level_sum/level_len)
      
        return res

def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
    bfs=[root]
    while len(bfs)>0:
        length=len(bfs)
        res=0
        for i in range(0,length):
            iteam=bfs.pop(0)
            res+=iteam.val
            if iteam.left is not None: bfs.append(iteam.left)
            if iteam.right is not None: bfs.append(iteam.right)
        yield res/length

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        // level-order traversal
        if(root == null)
        {
            throw new NullPointerException("NullArgument");
        }
        List<Double> ans = new ArrayList<>();
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        while(!q.isEmpty())
        {
            int size = q.size();
            double sum = 0;
            for(int i = 0; i < size; i++)
            {
                TreeNode current = q.poll();
                sum += current.val;
                if(current.left != null)
                {
                    q.offer(current.left);
                }
                if(current.right != null)
                {
                    q.offer(current.right);
                }
            }
            ans.add(sum / size);
        }
        return ans;
    }
}

class Solution:
    def numsSameConsecDiff(self, n: int, k: int) -> List[int]:
        res = set()
    
        def gen_num(val, index, arr):
        
            if index == n:
                res.add(arr)
                return
        
            if val < 0 or val > 9:
                return
        
            arr = arr*10 + val
            
            gen_num(val - k, index + 1, arr)
            gen_num(val + k, index + 1, arr)
        
            arr = arr//10
        
        for i in range(1, 10):
            gen_num(i, 0, 0)

        return list(res)

class Solution:
    def numsSameConsecDiff(self, n: int, k: int) -> List[int]:
        res=set()
        def help(ind: int,number: int):
            if ind == n:
                res.add(number)
            else:
                lst_num = number%10
                if lst_num + k < 10:
                    help(ind+1,number*10+lst_num+k)
                if lst_num - k >=0:
                    help(ind+1,number*10+lst_num-k)
        for i in range(1,10):
            help(1,i)
        return list(res)