Added tasks 2235, 2236, 2239, 2248.

Author: javadev

README.md

@@ -1332,8 +1332,12 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 2248 |[Intersection of Multiple Arrays](src/main/java/g2201_2300/s2248_intersection_of_multiple_arrays)| Easy || 2 | 99.46
 | 2246 |[Longest Path With Different Adjacent Characters](src/main/java/g2201_2300/s2246_longest_path_with_different_adjacent_characters)| Hard | Array, String, Depth_First_Search, Tree, Graph, Topological_Sort | 75 | 97.79
 | 2241 |[Design an ATM Machine](src/main/java/g2201_2300/s2241_design_an_atm_machine)| Medium | Array, Greedy, Design | 192 | 24.16
+| 2239 |[Find Closest Number to Zero](src/main/java/g2201_2300/s2239_find_closest_number_to_zero)| Easy | Array | 2 | 84.21
+| 2236 |[Root Equals Sum of Children](src/main/java/g2201_2300/s2236_root_equals_sum_of_children)| Easy | Tree, Binary_Tree | 0 | 100.00
+| 2235 |[Add Two Integers](src/main/java/g2201_2300/s2235_add_two_integers)| Easy | Math | 1 | 48.94
 | 2234 |[Maximum Total Beauty of the Gardens](src/main/java/g2201_2300/s2234_maximum_total_beauty_of_the_gardens)| Hard | Array, Sorting, Greedy, Binary_Search, Two_Pointers | 63 | 73.03
 | 2226 |[Maximum Candies Allocated to K Children](src/main/java/g2201_2300/s2226_maximum_candies_allocated_to_k_children)| Medium | Array, Binary_Search | 46 | 78.19
 | 2221 |[Find Triangular Sum of an Array](src/main/java/g2201_2300/s2221_find_triangular_sum_of_an_array)| Medium | Array, Math, Simulation, Combinatorics | 78 | 83.64

src/main/java/g2201_2300/s2235_add_two_integers/readme.md

@@ -0,0 +1,35 @@
+## 2235\. Add Two Integers
+
+Easy
+
+Given two integers `num1` and `num2`, return _the **sum** of the two integers_.
+
+**Example 1:**
+
+**Input:** num1 = 12, num2 = 5
+
+**Output:** 17
+
+**Explanation:** num1 is 12, num2 is 5, and their sum is 12 + 5 = 17, so 17 is returned.
+
+**Example 2:**
+
+**Input:** num1 = -10, num2 = 4
+
+**Output:** -6
+
+**Explanation:** num1 + num2 = -6, so -6 is returned.
+
+**Constraints:**
+
+* `-100 <= num1, num2 <= 100`
+
+## Solution
+
+```java
+public class Solution {
+    public int sum(int num1, int num2) {
+        return num1 + num2;
+    }
+}
+```

src/main/java/g2201_2300/s2236_root_equals_sum_of_children/readme.md

@@ -0,0 +1,48 @@
+## 2236\. Root Equals Sum of Children
+
+Easy
+
+You are given the `root` of a **binary tree** that consists of exactly `3` nodes: the root, its left child, and its right child.
+
+Return `true` _if the value of the root is equal to the **sum** of the values of its two children, or_ `false` _otherwise_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/04/08/graph3drawio.png)
+
+**Input:** root = [10,4,6]
+
+**Output:** true
+
+**Explanation:** The values of the root, its left child, and its right child are 10, 4, and 6, respectively. 
+
+10 is equal to 4 + 6, so we return true.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/04/08/graph3drawio-1.png)
+
+**Input:** root = [5,3,1]
+
+**Output:** false
+
+**Explanation:** The values of the root, its left child, and its right child are 5, 3, and 1, respectively. 
+
+5 is not equal to 3 + 1, so we return false.
+
+**Constraints:**
+
+* The tree consists only of the root, its left child, and its right child.
+* `-100 <= Node.val <= 100`
+
+## Solution
+
+```java
+import com_github_leetcode.TreeNode;
+
+public class Solution {
+    public boolean checkTree(TreeNode root) {
+        return root.left.val + root.right.val == root.val;
+    }
+}
+```

src/main/java/g2201_2300/s2239_find_closest_number_to_zero/readme.md

@@ -0,0 +1,56 @@
+## 2239\. Find Closest Number to Zero
+
+Easy
+
+Given an integer array `nums` of size `n`, return _the number with the value **closest** to_ `0` _in_ `nums`. If there are multiple answers, return _the number with the **largest** value_.
+
+**Example 1:**
+
+**Input:** nums = [-4,-2,1,4,8]
+
+**Output:** 1
+
+**Explanation:** 
+
+The distance from -4 to 0 is |-4| = 4. 
+
+The distance from -2 to 0 is |-2| = 2. 
+
+The distance from 1 to 0 is |1| = 1. The distance from 4 to 0 is |4| = 4. 
+
+The distance from 8 to 0 is |8| = 8. 
+
+Thus, the closest number to 0 in the array is 1. 
+
+**Example 2:**
+
+**Input:** nums = [2,-1,1]
+
+**Output:** 1
+
+**Explanation:** 1 and -1 are both the closest numbers to 0, so 1 being larger is returned. 
+
+**Constraints:**
+
+*   `1 <= n <= 1000`
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```java
+public class Solution {
+    public int findClosestNumber(int[] nums) {
+        int mini = Integer.MAX_VALUE;
+        int closestNum = 0;
+        for (int n : nums) {
+            if (mini > Math.abs(n)) {
+                mini = Math.abs(n);
+                closestNum = n;
+            } else if (mini == Math.abs(n) && closestNum < n) {
+                closestNum = n;
+            }
+        }
+        return closestNum;
+    }
+}
+```

src/main/java/g2201_2300/s2248_intersection_of_multiple_arrays/readme.md

@@ -0,0 +1,57 @@
+## 2248\. Intersection of Multiple Arrays
+
+Easy
+
+Given a 2D integer array `nums` where `nums[i]` is a non-empty array of **distinct** positive integers, return _the list of integers that are present in **each array** of_ `nums` _sorted in **ascending order**_.
+
+**Example 1:**
+
+**Input:** nums = \[\[**3**,1,2,**4**,5],[1,2,**3**,**4**],[**3**,**4**,5,6]]
+
+**Output:** [3,4]
+
+**Explanation:** 
+
+The only integers present in each of nums[0] = [**3**,1,2,**4**,5], nums[1] = [1,2,**3**,**4**], and nums[2] = [**3**,**4**,5,6] are 3 and 4, so we return [3,4].
+
+**Example 2:**
+
+**Input:** nums = \[\[1,2,3],[4,5,6]]
+
+**Output:** []
+
+**Explanation:** 
+
+There does not exist any integer present both in nums[0] and nums[1], so we return an empty list [].
+
+**Constraints:**
+
+* `1 <= nums.length <= 1000`
+* `1 <= sum(nums[i].length) <= 1000`
+* `1 <= nums[i][j] <= 1000`
+* All the values of `nums[i]` are **unique**.
+
+## Solution
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<Integer> intersection(int[][] nums) {
+        List<Integer> ans = new ArrayList<>();
+        int[] count = new int[1001];
+        for (int[] arr : nums) {
+            for (int i : arr) {
+                ++count[i];
+            }
+        }
+        for (int i = 0; i < count.length; i++) {
+            if (count[i] == nums.length) {
+                ans.add(i);
+            }
+        }
+        return ans;
+    }
+}
+```