Revert "fix: remove redundant comment"

This reverts commit 959c579550.

src/main/java/MainExercises.java

@@ -1,122 +1,98 @@
-import java.util.ArrayList;
-
 public class MainExercises
 {
+    /*
+    you should create a triangle with "*" and return a two-dimensional array of characters based on that
+    the triangle's area is empty, which means some characters should be " "
+
+    example 1, input = 3:
+    *
+    **
+    ***
+
+    example 2, input = 5:
+    *
+    **
+    * *
+    *  *
+    *****
+
+    the output has to be a two-dimensional array of characters, so don't just print the triangle!
+ */
     public char[][] generateTriangle(int n) {
 
-        char[][] result = new char[n][];
+        // todo
+        return null;
 
-        for (int i = 0; i < n; i++)
-        {
-            result[i] = new char[i+1];
-            if (i == n-1)
-            {
-                for (int j = 0; j <= i; j++)
-                {
-                    result[i][j] = '*';
-                }
-            }
-            else 
-            {
-                result[i][0] = '*';
-                result[i][i] = '*';
-
-                for (int j = 1; j < i; j++) result[i][j] = ' ';
-            }
     }
 
-        return result;
-    }
 
+
+    /*
+       SPIRAL TRAVERSAL OF A RECTANGULAR MATRIX
+
+       Given a rectangular matrix (2D array) of integers, this method traverses
+       it in a spiral order (clockwise from outside to inside) and returns
+       the elements as a 1D array.
+
+       EXAMPLE:
+       Input matrix:
+           1  2  3
+           4  5  6
+           7  8  9
+
+       Spiral order: start at top-left (1), go right →, then down ↓,
+       then left ←, then up ↑, then repeat inward.
+
+       Result: {1, 2, 3, 6, 9, 8, 7, 4, 5}
+
+       so you should walk in that matrix in a curl and then add the numbers in order you've seen them in a 1D array
+
+       RECTANGULAR MATRIX ASSUMPTION:
+       This method assumes the input matrix is RECTANGULAR (all rows have
+       the same number of columns). In Java, we can verify this because
+       2D arrays might be jagged (rows of different lengths).
+
+       IMPORTANT: In Java, we do NOT need to pass rows and cols!
+       The 2D array 'matrix' knows its own dimensions:
+           - Number of rows:    matrix.length
+           - Number of columns: matrix[0].length (if rectangular)
+   */
     public int[] spiralTraversal(int[][] matrix) {
-        int rows = matrix.length, cols = matrix[0].length;
+        // todo
-        int elementCount = rows * cols, curElement = 0;
+        return null;
-        int[] result = new int[elementCount];
-
-        for (int leyer = 0; curElement < elementCount; leyer++) {
-            int curi = leyer, maxi = rows - 1 - leyer;
-            int curj = leyer, maxj = cols - 1 - leyer;
-
-            for (;curj < maxj && curElement < elementCount; curj++, curElement++)
-            {
-                result[curElement] = matrix[curi][curj];
-            }
-            for (;curi < maxi && curElement < elementCount; curi++, curElement++)
-            {
-                result[curElement] = matrix[curi][curj];
-            }
-            for (;curj > leyer && curElement < elementCount; curj--, curElement++)
-            {
-                result[curElement] = matrix[curi][curj];
-            }
-            for (;curi > leyer && curElement < elementCount; curi--, curElement++)
-            {
-                result[curElement] = matrix[curi][curj];
     }
 
-            if (curi == maxi || curj == maxj) {
+    /*
-                if (curi == maxi && curj == maxj) result[curElement] = matrix[curi][curj];
+        integer partitioning is a combinatorics problem in discreet maths
-                break;
+        the problem is to generate sum numbers which their summation is the input number
-            }
-        }
 
-        return result;
+        e.g. 1 -> all partitions of integer 3 are:
-    }
+        3
+        2, 1
+        1, 1, 1
+
+        e.g. 2 -> for number 4 goes as:
+        4
+        3, 1
+        2, 2
+        2, 1, 1
+        1, 1, 1, 1
+
+        Note: As you can see in the examples, we want to generate distinct partitions,
+        which means 1,2 and 2,1 are not different — they count as the same combination.
+
+        You should generate all partitions of the input number.
+
+        Hint: You can determine the size and order of the arrays by finding the pattern
+        of partitions and their count. Trust me, this one's fun and easy :)
+
+        If you're familiar with Lists and ArrayLists, you can also edit the method's
+        body to use them instead of arrays.
+    */
 
     public int[][] intPartitions(int n) {
-        int[][] result;
+        // todo
-        ArrayList<ArrayList<Integer>> mainArray = new ArrayList<>();
+        return null;
-
-        ArrayList<Integer> start = new ArrayList<>();
-        start.add(n);
-        mainArray.add(start);
-        
-        while (true) { 
-            ArrayList<Integer> latestArray = mainArray.get(mainArray.size() - 1);
-
-            Integer numberOfInterest = 0;
-            for (Integer number : latestArray)
-            {
-                if (number > 1) {
-                    numberOfInterest = number;
-                    break;
-                }
-            }   
-
-            if (numberOfInterest == 0) break;
-
-            numberOfInterest--;
-            Integer remain = n - numberOfInterest;
-            ArrayList<Integer> newArray = new ArrayList<>();
-            newArray.add(numberOfInterest);
-
-            for (Integer number = numberOfInterest;;) {
-                if (number >= remain) {
-                    newArray.add(remain);
-                    break;
-                }
-                else {
-                    newArray.add(number);
-                    remain -= number;
-                }
-            }
-
-            mainArray.add(newArray);
-        }
-
-        result = new int[mainArray.size()][];
-
-        for (int i = 0; i < mainArray.size(); i++) {
-            ArrayList<Integer> array = mainArray.get(i);
-
-            result[i] = new int[array.size()];
-
-            for (int j = 0; j < array.size(); j++) {
-                result[i][j] = array.get(j);
-            }
-        }
-
-        return result;
     }