Add 4 problems

Author: ex01tus

README.md

@@ -2,18 +2,18 @@
 
 ![DSA Learning](https://img.shields.io/badge/DSA-Learning-blue?style=for-the-badge&logo=leetcode)
 
-This repository contains solutions for 593 DSA problems from the [LeetCode](https://leetcode.com/)
+This repository contains solutions for 597 DSA problems from the [LeetCode](https://leetcode.com/)
 website.
 
 Problems are separated into 20 topics:
 
 |    | Topic               | Package                                        | Problems |
 |---:|:--------------------|:-----------------------------------------------|---------:|
-|  1 | Array               | [array](src/array)                             |       84 |
+|  1 | Array               | [array](src/array)                             |       85 |
 |  2 | Binary              | [binary](src/binary)                           |       13 |
 |  3 | Binary Search       | [binary_search](src/binary_search)             |       19 |
 |  4 | Binary Search Tree  | [binary_search_tree](src/binary_search_tree)   |       16 |
-|  5 | Binary Tree         | [binary_tree](src/binary_tree)                 |       47 |
+|  5 | Binary Tree         | [binary_tree](src/binary_tree)                 |       50 |
 |  6 | Design              | [design](src/design)                           |       18 |
 |  7 | Dynamic Programming | [dynamic_programming](src/dynamic_programming) |       49 |
 |  8 | Graph               | [graph](src/graph)                             |       68 |

src/array/GroupPeopleGivenGroupSizeTheyBelongTo.java

@@ -0,0 +1,34 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/group-the-people-given-the-group-size-they-belong-to
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class GroupPeopleGivenGroupSizeTheyBelongTo {
+
+    public List<List<Integer>> groupThePeople(int[] groupSizes) {
+        Map<Integer, List<Integer>> groupToPeople = new HashMap<>();
+
+        List<List<Integer>> groups = new ArrayList<>();
+        for (int person = 0; person < groupSizes.length; person++) {
+            int groupSize = groupSizes[person];
+            List<Integer> group = groupToPeople.computeIfAbsent(groupSize, __ -> new ArrayList<>());
+            group.add(person);
+
+            if (group.size() == groupSize) {
+                groups.add(group);
+                groupToPeople.remove(groupSize);
+            }
+
+        }
+
+        return groups;
+    }
+}

src/array/RearrangeArrayElementsBySign.java

@@ -3,7 +3,7 @@
 /**
  * Description: https://leetcode.com/problems/rearrange-array-elements-by-sign
  * Difficulty: Medium
- * Time complexity: O(n(
+ * Time complexity: O(n)
  * Space complexity: O(n)
  */
 public class RearrangeArrayElementsBySign {

src/binary_tree/NaryTreeLevelOrderTraversal.java

@@ -0,0 +1,45 @@
+package binary_tree;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/n-ary-tree-level-order-traversal
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class NaryTreeLevelOrderTraversal {
+
+    public List<List<Integer>> levelOrder(Node root) {
+        List<List<Integer>> traversal = new ArrayList<>();
+        if (root == null) return traversal;
+
+        Queue<Node> planned = new LinkedList<>();
+        planned.offer(root);
+
+        while (!planned.isEmpty()) {
+            int levelSize = planned.size();
+            List<Integer> level = new ArrayList<>();
+            traversal.add(level);
+
+            for (int i = 0; i < levelSize; i++) {
+                Node current = planned.poll();
+                level.add(current.val);
+
+                for (Node child : current.children) {
+                    planned.offer(child);
+                }
+            }
+        }
+
+        return traversal;
+    }
+
+    private static class Node {
+        int val;
+        List<Node> children;
+    }
+}

src/binary_tree/ReverseOddLevelsOfBinaryTree.java

@@ -0,0 +1,61 @@
+package binary_tree;
+
+import java.util.LinkedList;
+
+/**
+ * Description: https://leetcode.com/problems/reverse-odd-levels-of-binary-tree
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class ReverseOddLevelsOfBinaryTree {
+
+    public TreeNode reverseOddLevels(TreeNode root) {
+        LinkedList<TreeNode> planned = new LinkedList<>();
+        planned.offer(root);
+
+        int level = 0;
+        while (!planned.isEmpty()) {
+            int levelSize = planned.size();
+
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode current = planned.poll();
+
+                if (current.left != null) planned.offer(current.left);
+                if (current.right != null) planned.offer(current.right);
+            }
+
+            level++;
+
+            if (level % 2 != 0) {
+                reverseLevel(planned);
+            }
+        }
+
+        return root;
+    }
+
+    private void reverseLevel(LinkedList<TreeNode> planned) {
+        int left = 0;
+        int right = planned.size() - 1;
+
+        while (left < right) {
+            swap(planned.get(left), planned.get(right));
+
+            left++;
+            right--;
+        }
+    }
+
+    private void swap(TreeNode first, TreeNode second) {
+        int tmp = first.val;
+        first.val = second.val;
+        second.val = tmp;
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}

src/binary_tree/SumOfNodesWithEvenValuedGrandparent.java

@@ -0,0 +1,29 @@
+package binary_tree;
+
+/**
+ * Description: https://leetcode.com/problems/sum-of-nodes-with-even-valued-grandparent
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(h)
+ */
+public class SumOfNodesWithEvenValuedGrandparent {
+
+    public int sumEvenGrandparent(TreeNode root) {
+        return sum(null, null, root);
+    }
+
+    private int sum(TreeNode grandParent, TreeNode parent, TreeNode current) {
+        if (current == null) return 0;
+
+        int sum = (grandParent != null && grandParent.val % 2 == 0) ? current.val : 0;
+        return sum
+                + sum(parent, current, current.left)
+                + sum(parent, current, current.right);
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}