added 104, 559, 1365, 1379, 3162

Author: rustykitty

0104-maximum-depth-of-binary-tree.cpp

@@ -0,0 +1,29 @@
+/*
+104. Maximum Depth of Binary Tree
+
+Submitted: December 6, 2024
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 19.09 MB (beats 6.14%)
+*/
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+        if (root == nullptr) return 0;
+        int left = maxDepth(root->left);
+        int right = maxDepth(root->right);
+        return left >= right ? left + 1 : right + 1;
+    }
+};

0559-maximum-depth-of-n-ary-tree.cpp

@@ -0,0 +1,41 @@
+/*
+559. Maximum Depth of N-ary Tree
+
+Submitted: December 6, 2024
+
+Runtime: 12 ms (beats 66.05%)
+Memory: 14.52 MB (beats 42.04%)
+*/
+
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> children;
+
+    Node() {}
+
+    Node(int _val) {
+        val = _val;
+    }
+
+    Node(int _val, vector<Node*> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+public:
+    int maxDepth(Node* root) {
+        if (root == nullptr) return 0;
+        int max = 0;
+        for (Node* child : root->children) {
+            int child_depth = maxDepth(child);
+            if (child_depth > max) max = child_depth;
+        }
+        return max + 1;
+    }
+};

1365-how-many-numbers-are-smaller-than-the-current-number.py

@@ -0,0 +1,12 @@
+"""
+1365. How Many Numbers Are Smaller Than the Current Number
+
+Submitted: December 6, 2024
+
+Runtime: 174 ms (beats 13.07%)
+Memory: 17.28 MB (beats 13.74%)
+"""
+
+class Solution:
+    def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
+        return [len(list(None for y in nums[:i] + nums[i + 1:] if y < nums[i])) for i in range(len(nums))]

1379-find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree.cpp

@@ -0,0 +1,36 @@
+/*
+1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree
+
+Submitted: December 6, 2024
+
+Runtime: 361 ms (beats 70.33%)
+Memory: 167.52 MB (beats 9.91%)
+*/
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+class Solution {
+public:
+    TreeNode* getTargetCopy(TreeNode* original, TreeNode* cloned, TreeNode* target) {
+        return binarySearch(cloned, target->val);
+    }
+    TreeNode* binarySearch(TreeNode* root, int val) {
+        if (root == nullptr) return nullptr;
+        if (root->val == val) return root;
+        TreeNode *left = binarySearch(root->left, val);
+        TreeNode *right = binarySearch(root->right, val);
+        if (left != nullptr && left->val == val) return left;
+        else if (right != nullptr && right->val == val) return right;
+        else {
+            return root->val == val ? root : nullptr;
+        }
+    }
+};

3162-find-the-number-of-good-pairs-i.py

@@ -0,0 +1,12 @@
+"""
+3162. Find the Number of Good Pairs I
+
+Submitted: December 6, 2024
+
+Runtime: 15 ms (beats 7.34%)
+Memory: 17.34 MB (beats 6.26%)
+"""
+
+class Solution:
+    def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:
+        return sum(sum((nums1[i] % (nums2[j] * k) == 0) for j in range(len(nums2))) for i in range(len(nums1)))