implement intPartitions method in MainExercises

src/main/java/MainExercises.java

@@ -1,98 +1,122 @@
+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) {
 
-        // todo
+        char[][] result = new char[n][];
-        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) {
-        // todo
+        int rows = matrix.length, cols = matrix[0].length;
-        return null;
+        int elementCount = rows * cols, curElement = 0;
+        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) {
-        integer partitioning is a combinatorics problem in discreet maths
+                if (curi == maxi && curj == maxj) result[curElement] = matrix[curi][curj];
-        the problem is to generate sum numbers which their summation is the input number
+                break;
+            }
+        }
         
-        e.g. 1 -> all partitions of integer 3 are:
+        return result;
-        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) {
-        // todo
+        int[][] result;
-        return null;
+        ArrayList<ArrayList<Integer>> mainArray = new ArrayList<>();
+
+        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;
     }