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

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

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[][] triangle = new char[n][];
        for(int i = 0; i < n; i++)
        {
            triangle[i] = new char[i+1];
            for(int j = 0; j <= i; j++)
            {
                if(i == 0 || j == 0 || i == j || i == n-1)
                    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)
    {

        int m = matrix.length;
        int n = matrix[0].length;
        int x = 0;
        int y = 0;
        int idx = 0;

        int[] numbers = new int[m * n];
        boolean[][] visitedCell = new boolean[m][n];
        int[][] dir = {{0,1},{1,0},{0,-1},{-1,0}};

        for(int i = 0; i < (m * n); i++)
        {
            numbers[i] = matrix[x][y];
            visitedCell[x][y] = true;

            int nextX = x + dir[idx][0];
            int nextY = y + dir[idx][1];

            if (nextX < 0 || nextX >= m || nextY < 0 || nextY >= n || visitedCell[nextX][nextY] == true)
            {
                idx = (idx + 1) % 4;

                nextX = x + dir[idx][0];
                nextY = y + dir[idx][1];
            }
            x = nextX;
            y = nextY;
        }
        return numbers;
    }

    /*
        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)
    {
        List<int[]> result = new ArrayList<>();
        findPartitions(n, n, new ArrayList<>(), result);
        return result.toArray(new int[result.size()][]);
    }

    private void findPartitions(int r, int max, List<Integer> list, List<int[]> finalList)
    {
        if (r == 0)
        {
            int[] partition = new int[list.size()];
            for (int i = 0; i < list.size(); i++)
            {
                partition[i] = list.get(i);
            }
            finalList.add(partition);
            return;
        }

        if (r >= max)
        {
            list.add(max);
            findPartitions(r - max, max, list, finalList);
            list.remove(list.size() - 1);
        }

        if (max > 1)
        {
            findPartitions(r, max - 1, list, finalList);
        }
    }

    public static void main()
    {

    }
}