Update

Author: ex01tus

README.md

@@ -2,14 +2,14 @@
 
 ![DSA Learning](https://img.shields.io/badge/DSA-Learning-blue?style=for-the-badge&logo=leetcode)
 
-This repository contains solutions for 541 DSA problems from the [LeetCode](https://leetcode.com/)
+This repository contains solutions for 544 DSA problems from the [LeetCode](https://leetcode.com/)
 website.
 
 Problems are separated into 19 topics:
 
 |    | Topic               | Package                                        | Problems |
 |---:|:--------------------|:-----------------------------------------------|---------:|
-|  1 | Array               | [array](src/array)                             |       76 |
+|  1 | Array               | [array](src/array)                             |       79 |
 |  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 |

src/array/AddToArrayFormOfInteger.java

@@ -0,0 +1,33 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Description: https://leetcode.com/problems/add-to-array-form-of-integer
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class AddToArrayFormOfInteger {
+
+    public List<Integer> addToArrayForm(int[] num, int k) {
+        List<Integer> result = new ArrayList<>();
+        int carry = k;
+
+        for (int i = num.length - 1; i >= 0; i--) {
+            int sum = num[i] + carry;
+            result.add(sum % 10);
+            carry = sum / 10;
+        }
+
+        while (carry != 0) {
+            result.add(carry % 10);
+            carry = carry / 10;
+        }
+
+        Collections.reverse(result);
+        return result;
+    }
+}

src/array/DegreeOfArray.java

@@ -0,0 +1,36 @@
+package array;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/degree-of-an-array
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class DegreeOfArray {
+
+    public int findShortestSubArray(int[] nums) {
+        Map<Integer, Integer> first = new HashMap<>();
+        Map<Integer, Integer> last = new HashMap<>();
+        Map<Integer, Integer> freqMap = new HashMap<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            first.putIfAbsent(nums[i], i);
+            last.put(nums[i], i);
+            freqMap.merge(nums[i], 1, Integer::sum);
+        }
+
+        int arrayDegree = Collections.max(freqMap.values());
+        int shortest = Integer.MAX_VALUE;
+        for (int num : freqMap.keySet()) {
+            if (freqMap.get(num) == arrayDegree) {
+                shortest = Math.min(shortest, last.get(num) - first.get(num) + 1);
+            }
+        }
+
+        return shortest;
+    }
+}

src/array/RichestCustomerWealth.java

@@ -0,0 +1,24 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/richest-customer-wealth
+ * Difficulty: Easy
+ * Time complexity: O(n * m)
+ * Space complexity: O(1)
+ */
+public class RichestCustomerWealth {
+
+    public int maximumWealth(int[][] accounts) {
+        int max = 0;
+        for (int[] customer : accounts) {
+            int wealth = 0;
+            for (int account : customer) {
+                wealth += account;
+            }
+
+            max = Math.max(max, wealth);
+        }
+
+        return max;
+    }
+}

src/linked_list/PlusOneLinkedList.java

@@ -4,7 +4,7 @@
 import java.util.LinkedList;
 
 /**
- * Description: https://leetcode.com/problems/plus-one-linked-list
+ * Description: https://leetcode.com/problems/plus-one-lignked-list
  * Difficulty: Medium
  */
 public class PlusOneLinkedList {
@@ -42,7 +42,7 @@ public ListNode plusOneViaStack(ListNode head) {
 
         Deque<ListNode> stack = buildStack(dummy);
 
-        int carry = 0;
+        int carry = 1;
         while (!stack.isEmpty()) {
             ListNode current = stack.pop();
             int sum = current.val + carry;
@@ -59,7 +59,6 @@ private Deque<ListNode> buildStack(ListNode dummy) {
         ListNode current = dummy;
         while (current != null) {
             stack.push(current);
-            if (current.next == null) current.val += 1;
             current = current.next;
         }