src/main/java/MainExercises.java

@@ -20,36 +20,6 @@ public class MainExercises
 
 
 
-    /*
-       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) {
         ArrayList<Integer> result = new ArrayList<>();
 
@@ -86,8 +56,9 @@ public class MainExercises
             }
         }
 
+        //for returning an int[] array:
         int n = (matrix.length)*(matrix[0].length);
-        int[] finalResult = new int[n];    //for returning an int[] array
+        int[] finalResult = new int[n];
         for (int i=0; i<n; i++) {
             finalResult[i] = result.get(i);
         }
@@ -96,42 +67,42 @@ public class MainExercises
 
 
 
-    /*
-        integer partitioning is a combinatorics problem in discreet maths
-        the problem is to generate sum numbers which their summation is the input number
-
-        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) {
-        // todo
-        return null;
+        ArrayList<ArrayList<Integer>> partitions = new ArrayList<>();
+
+        class partitionRecursive {
+            void solve(int remaining, int max, ArrayList<Integer> current) {
+                //End condition
+                if (remaining == 0) {
+                    partitions.add(new ArrayList<>(current));
+                    return;
+                }
+
+                //The main part of the algorithm
+                for (int i = Math.min(max, remaining); i>0; i--) {
+                    current.add(i);
+                    solve(remaining - i, i, current);
+                    current.remove(current.size() - 1);
+                }
+            }
+        }
+
+        new partitionRecursive().solve(n, n, new ArrayList<>());
+
+        //Making the result
+        int[][] result = new int[partitions.size()][];
+        for (int i = 0; i < partitions.size(); i++) {
+            ArrayList<Integer> partition = partitions.get(i);
+            result[i] = new int[partition.size()];
+            for (int j = 0; j < partition.size(); j++) {
+                result[i][j] = partition.get(j);
+            }
+        }
+
+        return result;
     }
 
 
     public static void main()
-    {
-
-    }
+    {}
 }