puperfused
diff --git a/‎src/main/java/com/fishercoder/solutions/_554.java
Lines changed: 34 additions & 32 deletions b/‎src/main/java/com/fishercoder/solutions/_554.java
Lines changed: 34 additions & 32 deletions
diff --git a/‎src/test/java/com/fishercoder/_554Test.java
Lines changed: 2 additions & 2 deletions b/‎src/test/java/com/fishercoder/_554Test.java
Lines changed: 2 additions & 2 deletions
@@ -34,41 +34,43 @@
  The number of bricks in each row is in range [1,10,000]. The height of wall is in range [1,10,000]. Total number of bricks of the wall won't exceed 20,000.
  */
 public class _554 {
-    //credit to: https://leetcode.com/articles/brick-wall/
+    public static class Solution1 {
+        /**
+         * credit: https://leetcode.com/articles/brick-wall/
+         *
+         * we make use of a HashMap
+         * map which is used to store entries in the form:
+         * (sum,count). Here,
+         * sum refers to the cumulative sum of the bricks' widths encountered in the current row, and
+         * count refers to the number of times the corresponding sum is obtained. Thus,
+         * sum in a way, represents the positions of the bricks's boundaries relative to the leftmost boundary.
+         *
+         * This is done based on the following observation:
+         * We will never obtain the same value of sum twice while traversing over a particular row.
+         * Thus, if the sum value is repeated while traversing over the rows, it means some row's brick boundary coincides with some previous row's brick boundary.
+         * This fact is accounted for by incrementing the corresponding count value.
+         * But, for every row, we consider the sum only upto the second last brick, since the last boundary isn't a valid boundary for the solution.
+         */
 
-    /**we make use of a HashMap
-     map which is used to store entries in the form:
-     (sum,count). Here,
-     sum refers to the cumulative sum of the bricks' widths encountered in the current row, and
-     count refers to the number of times the corresponding sum is obtained. Thus,
-     sum in a way, represents the positions of the bricks's boundaries relative to the leftmost boundary.
-
-     This is done based on the following observation:
-     We will never obtain the same value of sum twice while traversing over a particular row.
-     Thus, if the sum value is repeated while traversing over the rows, it means some row's brick boundary coincides with some previous row's brick boundary.
-     This fact is accounted for by incrementing the corresponding count value.
-
-     But, for every row, we consider the sum only upto the second last brick, since the last boundary isn't a valid boundary for the solution.*/
-
-    public int leastBricks(List<List<Integer>> wall) {
-        Map<Integer, Integer> map = new HashMap();
-        for (List<Integer> row : wall) {
-            int sum = 0;
-            for (int i = 0; i < row.size() - 1; i++) {
-                //NOTE: i < row.size()-1
-                sum += row.get(i);
-                if (map.containsKey(sum)) {
-                    map.put(sum, map.get(sum) + 1);
-                } else {
-                    map.put(sum, 1);
+        public int leastBricks(List<List<Integer>> wall) {
8000 +            Map<Integer, Integer> map = new HashMap();
+            for (List<Integer> row : wall) {
+                int sum = 0;
+                for (int i = 0; i < row.size() - 1; i++) {
+                    //NOTE: i < row.size()-1
+                    sum += row.get(i);
+                    if (map.containsKey(sum)) {
+                        map.put(sum, map.get(sum) + 1);
+                    } else {
+                        map.put(sum, 1);
+                    }
                 }
             }
+            int result = wall.size();
+            for (int key : map.keySet()) {
+                result = Math.min(result, wall.size() - map.get(key));
+            }
+            return result;
         }
-        int result = wall.size();
-        for (int key : map.keySet()) {
-            result = Math.min(result, wall.size() - map.get(key));
-        }
-        return result;
     }
-
 }
@@ -12,14 +12,14 @@
 import static junit.framework.Assert.assertEquals;
 
 public class _554Test {
-    private static _554 test;
+    private static _554.Solution1 test;
     private static int expected;
     private static int actual;
     private static List<List<Integer>> wall;
 
     @BeforeClass
     public static void setup() {
-        test = new _554();
+        test = new _554.Solution1();
     }
 
     @Before