HW-02-git-and-java-practice/src/main/java/MainExercises.java

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

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
        if (n <= 0)
            return new char[0][0];

       char[][] triangle = new char[n][n];
        for (int i = 0 ; i< n ; i++)
        {
            if (i == n-1)
            {
                for (int j = 0 ; j < n ; j++)
                {
                    triangle[i][j] ='*';
                }
            }

            else
            {
                for (int j = 0 ; j <= i ; j++) {
                    if (j == 0 || j== i)
                        triangle[i][j] = '*';

                    else
                        triangle[i][j] = ' ';
                }
            }
        }

        return triangle;

    }



    /*
       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
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return new int[0];
        }

        int rows = matrix.length;
        int cols = matrix[0].length;
        int[] spiral = new int[rows * cols];

        int top = 0;
        int bottom = rows - 1;
        int left = 0;
        int right = cols - 1;
        int index = 0;

        while (top <= bottom && left <= right) {
            for (int j = left; j <= right; j++) {
                spiral[index++] = matrix[top][j];
            }
            top++;

            for (int i = top; i <= bottom; i++) {
                spiral[index++] = matrix[i][right];
            }
            right--;

            if (top <= bottom) {
                for (int j = right; j >= left; j--) {
                    spiral[index++] = matrix[bottom][j];
                }
                bottom--;
            }

            if (left <= right) {
                for (int i = bottom; i >= top; i--) {
                    spiral[index++] = matrix[i][left];
                }
                left++;
            }
        }
        return spiral;
    }

    /*
        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
        if (n <= 0) {
            return new int[0][0];
        }

        List<int[]> partitionsList = new ArrayList<>();
        generatePartitions(n, n, new ArrayList<>(), partitionsList);

        int[][] result = new int[partitionsList.size()][];
        for (int i = 0; i < partitionsList.size(); i++) {
            result[i] = partitionsList.get(i);
        }

        return result;
    }

    private void generatePartitions(int remaining, int maxValue, List<Integer> current, List<int[]> result) {
        if (remaining == 0) {
            int[] partition = new int[current.size()];
            for (int i = 0; i < current.size(); i++) {
                partition[i] = current.get(i);
            }
            result.add(partition);
            return;
        }

        for (int i = Math.min(maxValue, remaining); i >= 1; i--) {
            current.add(i);
            generatePartitions(remaining - i, i, current, result);
            current.remove(current.size() - 1);
        }
    }


    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        MainExercises me = new MainExercises();

        System.out.print("Enter a number: ");
        int n = in.nextInt();


        char[][] triangle = me.generateTriangle(n);
        for (char[] row : triangle) {
            for (char c : row) {
                System.out.print(c);
            }
            System.out.println();
        }

        int[][] matrix = {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}
        };
        int[] spiral = me.spiralTraversal(matrix);
        for (int num : spiral) {
            System.out.print(num + " ");
        }
        System.out.println();

        int[][] partitions = me.intPartitions(n);
        for (int[] p : partitions) {
            for (int i = 0; i < p.length; i++) {
                System.out.print(p[i]);
                if (i < p.length - 1) System.out.print(", ");
            }
            System.out.println();
        }

        in.close();
    }
}