Programming

2. Advanced Programming

3. Sample Input: Sample Output:
3 6 9
2 5 8
1 4 7
Question 1
Write a Java code to rotate the matrix 90 degrees anticlockwise.
3
3
1 2 3
4 5 6
7 8 9

4. import java.util.Scanner;
public class Main{
public static void main(String args[]){
Scanner in = new Scanner(System.in);
int r = in.nextInt();
int c = in.nextInt();
int matrix[][] = new int[r][c];
for(int i = 0; i < r; i++){
for(int j = 0; j < c; j++){
matrix[i][j] = in.nextInt();
}
}
for(int i = r - 1; i >= 0; i--){
for(int j = 0; j <= c-1; j++){
System.out.print(matrix[j][i] + " ");
}
System.out.println();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5. Sample Input: Sample Output:
1 5 9 2 6 3
Question 2
Write a Java code to print all the upper triangular matrix elements of the
given square matrix.
3
3
1 2 3
4 5 6
7 8 9

6. import java.util.Scanner;
class Main
{
public static void main(String args[])
{
int i, j;
Scanner sc = new Scanner(System.in);
int r = sc.nextInt();
int c = sc.nextInt();
int[][] matrix = new int[r][c];
for(i = 0; i < r; i++)
{
for(j = 0; j < c; j++)
{
matrix[i][j] = sc.nextInt();
}
}
upper_matrix(r, c, matrix);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

7. public static void upper_matrix(int r, int c, int[][] matrix)
{
int i, j, k;
for(k = 0; k < c; k++)
{
for(i = 0, j = k; j < c ; i++, j++)
System.out.print(matrix[i][j]+" ");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8. Sample Input: Sample Output:
No
Question 3
Write a Java code to check whether the given two matrices are identical or
not.
3 3
matrix1[][]
1 2 3
4 5 6
7 8 9
matrix2[][]
1 2 3
4 5 6
7 8 9

9. import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
Scanner in = new Scanner(System.in);
int flag = 0;
int r = in.nextInt();
int c = in.nextInt();
int a[][] = new int[r][c];
for(int i = 0; i < r; i++)
{
for(int j = 0; j < c; j++){
a[i][j] = in.nextInt();
}
}
int b[][] = new int[r][c];
for(int i = 0; i < r; i++){
for(int j = 0; j < c; j++){
b[i][j] = in.nextInt();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

10. for(int i = 0; i < r; i++)
{
for(int j = 0; j < c; j++)
{
if(a[i][j] != b[i][j])
{
flag = 1;
break;
}
}
}
if(flag == 0)
System.out.print("Yes");
else
System.out.print("No");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

11. Question 4
India has organized a blind folded ball passing game for two players.
They have a special kind of ground where player B can throw the ball in any
four directions (up, down, right, left).
The ground consists of some slant poles on which, when the ball strikes the
ball changes its direction by 90 degrees.
Consider the below field of 2 x 2 where the ball is at location 0,0 and being
thrown to its right. After hitting slant pole "", it will change direction and go
to 1,1.
B
- -

12. Question 4
If suppose you have thrown a ball in a direction in which there is no pole
then the ball goes out of the stadium in that direction.
Player B has the ball initially. The objective is to output the minimum steps
in which B can pass the ball to A and also the count of poles the ball has
struck.
If he can never pass the ball to A, then your output should be -1.
If you get multiple minimum steps then output those steps in which the ball
hits minimum no of barriers

13. Question 4
Input Format:
First line containing the integer K indicating the size of the field
Next two lines each having a pair of integers separated by space giving the
row and column numbers of
the positions of A and B respectively K lines of K integers each, separated
by space, giving the positions of
the barriers in the field - 0 indicating no barrier, 1 indicating a / barrier and 2
indicating a barrier.
Output Format:
Minimum number of steps required for the ball to reach A
Number of barriers ball on which the ball bounces

14. Sample Input: Sample Output:
4
3
Question 4
field_size = 4
A's position = 1 3
B's position = 3 3
Field[][]
0 0 0 0
1 1 1 0
2 2 2 2
1 1 1 0

15. import java.util.Scanner;
public class Main
{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
int K = sc.nextInt();
int a_pos_row = sc.nextInt();
int a_pos_col = sc.nextInt();
int b_pos_row = sc.nextInt();
int b_pos_col = sc.nextInt();
int play_field[][] = new int[K][K];
for(int i = 0; i < K; i++)
{
for(int j = 0; j < K; j++)
{
play_field[i][j] = sc.nextInt();
}
}
int min_step = -1;
int min_barriers = -1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

16. for(int i = 0; i <= 3; i++)
{
int direction = i;
int curr_row = b_pos_row, curr_col = b_pos_col;
int step = 0, barrier_count = 0;
while(true)
{
if(curr_col < 0 || curr_col >= K || curr_row < 0 ||
curr_row >= K)
{
break;
}
if(curr_row == a_pos_row && curr_col == a_pos_col)
{
if(min_step > step || min_step == -1)
{
min_step = step;
min_barriers = barrier_count;
}
else if (min_step == step && min_barriers >
barrier_count)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

17. for(int i = 0; i <= 3; i++)
{
min_barriers = barrier_count;
}
break;
}
step++;
if(play_field[curr_row][curr_col] == 1 ||
play_field[curr_row][curr_col] == 2)
{
barrier_count++;
}
switch(direction)
{
case 0:
if(play_field[curr_row][curr_col] == 1)
{
curr_col++;
direction = 2;
}
else if(play_field[curr_row][curr_col] == 2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

18. curr_col--;
direction = 3;
}
else
{
curr_row--;
}
break;
case 1:
if(play_field[curr_row][curr_col] == 1)
{
curr_col--;
direction = 3;
}
else if(play_field[curr_row][curr_col] == 2)
{
curr_col++;
direction = 2;
}
else
{
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

19. curr_row++;
}
break;
case 2:
if(play_field[curr_row][curr_col] == 1)
{
curr_row--;
direction = 0;
}
else if(play_field[curr_row][curr_col] == 2)
{
curr_row++;
direction = 1;
}
else
{
curr_col++;
}
break;
case 3:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

20. if(play_field[curr_row][curr_col] == 1){
curr_row++;
direction = 1;
}
else if(play_field[curr_row][curr_col] == 2){
curr_row--;
direction = 0;
}
else{
curr_col--;
}break;
}
}
}
if(min_step != -1) {
System.out.println(min_step);
System.out.print(min_barriers);
}
else{
System.out.print("-1");}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

21. THANK YOU