update 560

fishercoder1534 · fishercoder1534 · commit c8e1297892b3 · 2024-06-07T16:33:20.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_560.java b/src/main/java/com/fishercoder/solutions/_560.java
@@ -14,47 +14,51 @@ public static class Solution1 {
          * To achieve this, we just need to go through the array,
          * calculate the current sum and save number of all seen PreSum to a HashMap.
          * <p>
-         * Time complexity O(n), Space complexity O(n).
+         * Time complexity: O(n);
+         * Space complexity: O(n).
          */
         public int subarraySum(int[] nums, int k) {
-            Map<Integer, Integer> preSum = new HashMap();
+            Map<Integer, Integer> preSumFrequencyMap = new HashMap();
             int sum = 0;
-            int result = 0;
-            preSum.put(0, 1);
+            int count = 0;
+            preSumFrequencyMap.put(0, 1);
             for (int i = 0; i < nums.length; i++) {
                 sum += nums[i];
-                if (preSum.containsKey(sum - k)) {
-                    result += preSum.get(sum - k);
+                if (preSumFrequencyMap.containsKey(sum - k)) {
+                    count += preSumFrequencyMap.get(sum - k);
                 }
-                preSum.put(sum, preSum.getOrDefault(sum, 0) + 1);
+                preSumFrequencyMap.put(sum, preSumFrequencyMap.getOrDefault(sum, 0) + 1);
             }
-            return result;
+            return count;
         }
     }
 
     public static class Solution2 {
         /**
          * My completely original solution on 10/14/2021.
          * Again, using a pen and paper to visualize your thought process just clears out all ambiguities.
+         * <p>
+         * Time: O(n^2)
+         * Space: O(n)
          */
         public int subarraySum(int[] nums, int k) {
-            int ans = 0;
+            int count = 0;
             int[] prefixSum = new int[nums.length];
             prefixSum[0] = nums[0];
             for (int i = 1; i < nums.length; i++) {
                 prefixSum[i] = prefixSum[i - 1] + nums[i];
             }
             for (int i = 0; i < nums.length; i++) {
                 if (prefixSum[i] == k) {
-                    ans++;
+                    count++;
                 }
                 for (int j = 0; j < i; j++) {
                     if (prefixSum[i] - prefixSum[j] == k) {
-                        ans++;
+                        count++;
                     }
                 }
             }
-            return ans;
+            return count;
         }
     }
 
diff --git a/src/test/java/com/fishercoder/_560Test.java b/src/test/java/com/fishercoder/_560Test.java
@@ -1,10 +1,10 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._560;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class _560Test {
     private static _560.Solution1 solution1;
@@ -14,8 +14,8 @@ public class _560Test {
     private static int[] nums;
     private static int k;
 
-    @BeforeClass
-    public static void setup() {
+    @BeforeEach
+    public void setup() {
         solution1 = new _560.Solution1();
         solution2 = new _560.Solution2();
     }
