138 lines
4.0 KiB
Java
138 lines
4.0 KiB
Java
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(j == 0 || i == n - 1 || i == j)
|
|
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 rows = matrix.length;
|
|
int cols = matrix[0].length;
|
|
int[] result = new int[rows * cols];
|
|
int index = 0;
|
|
int top = 0, bottom = rows - 1;
|
|
int left = 0, right = cols - 1;
|
|
while (top <= bottom && left <= right) {
|
|
for (int j = left; j <= right; j++) {
|
|
result[index++] = matrix[top][j];
|
|
}
|
|
top++;
|
|
for (int i = top; i <= bottom; i++) {
|
|
result[index++] = matrix[i][right];
|
|
}
|
|
right--;
|
|
if (top <= bottom) {
|
|
for (int j = right; j >= left; j--) {
|
|
result[index++] = matrix[bottom][j];
|
|
}
|
|
bottom--;
|
|
}
|
|
if (left <= right) {
|
|
for (int i = bottom; i >= top; i--) {
|
|
result[index++] = matrix[i][left];
|
|
}
|
|
left++;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/*
|
|
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;
|
|
}
|
|
|
|
|
|
public static void main()
|
|
{
|
|
|
|
}
|
|
} |