Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Mobina
|
f879c0c827 |
@@ -1,103 +1,190 @@
|
||||
public class MainExercises
|
||||
{
|
||||
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:
|
||||
* 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:
|
||||
*
|
||||
* example 2, input = 5:
|
||||
*
|
||||
**
|
||||
* *
|
||||
* *
|
||||
*****
|
||||
|
||||
the output has to be a two-dimensional array of characters, so don't just print the triangle!
|
||||
*
|
||||
* the output has to be a two-dimensional array of characters, so don't just
|
||||
* print the triangle!
|
||||
*/
|
||||
public char[][] generateTriangle(int n) {
|
||||
|
||||
// todo
|
||||
return null;
|
||||
char[][] triangle = new char[n][n];
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; 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)
|
||||
* 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
|
||||
return null;
|
||||
int rows = matrix.length;
|
||||
int cols = matrix[0].length;
|
||||
int[] arr = 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 i = left; i <= right; i++) {
|
||||
arr[index++] = matrix[top][i];
|
||||
}
|
||||
top++;
|
||||
|
||||
for (int i = top; i <= bottom; i++) {
|
||||
arr[index++] = matrix[i][right];
|
||||
}
|
||||
right--;
|
||||
|
||||
if (top <= bottom) {
|
||||
for (int i = right; i >= left; i--) {
|
||||
arr[index++] = matrix[bottom][i];
|
||||
}
|
||||
bottom--;
|
||||
}
|
||||
|
||||
if (left <= right) {
|
||||
for (int i = bottom; i >= top; i--) {
|
||||
arr[index++] = matrix[i][left];
|
||||
}
|
||||
left++;
|
||||
}
|
||||
}
|
||||
|
||||
return arr;
|
||||
}
|
||||
|
||||
/*
|
||||
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.
|
||||
* 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;
|
||||
if (n <= 0) {
|
||||
return new int[0][0];
|
||||
}
|
||||
|
||||
int[] current = new int[n];
|
||||
int[][] allPartitions = new int[1000][n];
|
||||
int[] counter = new int[1];
|
||||
|
||||
public static void main()
|
||||
{
|
||||
findPartitions(n, n, 0, current, allPartitions, counter);
|
||||
|
||||
int[][] result = new int[counter[0]][];
|
||||
for (int i = 0; i < counter[0]; i++) {
|
||||
int len = 0;
|
||||
while (len < n && allPartitions[i][len] != 0) {
|
||||
len++;
|
||||
}
|
||||
result[i] = new int[len];
|
||||
for (int j = 0; j < len; j++) {
|
||||
result[i][j] = allPartitions[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private void findPartitions(int remaining, int maxVal, int position,
|
||||
int[] current, int[][] allPartitions, int[] counter) {
|
||||
if (remaining == 0) {
|
||||
for (int i = 0; i < position; i++) {
|
||||
allPartitions[counter[0]][i] = current[i];
|
||||
}
|
||||
counter[0]++;
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i = maxVal; i >= 1; i--) {
|
||||
if (i <= remaining) {
|
||||
current[position] = i;
|
||||
findPartitions(remaining - i, i, position + 1,
|
||||
current, allPartitions, counter);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void main() {
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user