Question:
The result of a quiz competition is to be prepared as follows:
The quiz has five questions with four multiple choices (A, B, C, D), with each question carrying 1 mark for the correct answer. Design a program to accept the number of participants N such that N must be greater than 3 and less than 11. Create a double dimensional array of size (Nx5) to store the answers of each participant row-wise.
Calculate the marks for each participant by matching the correct answer stored in a single dimensional array of size 5. Display the scores for each participant and also the participant(s) having the highest score.
Example: If the value of N = 4, then the array would be:
Note: Array entries are line fed (i.e. one entry per line)
Test your program with the sample data and some random data:
Example 1
INPUT : N = 5
Participant 1 D A B C C
Participant 2 A A D C B
Participant 3 B A C D B
Participant 4 D A D C B
Participant 5 B C A D D
Key: B C D A A
OUTPUT : Scores :
Participant 1 D A B C C
Participant 1 = 0
Participant 2 = 1
Participant 3 = 1
Participant 4 = 1
Participant 5 = 2
Highest score: Participant 5
Example 2
INPUT : N = 4
Participant 1 A C C B D
Participant 2 B C A A C
Participant 3 B C B A A
Participant 4 C C D D B
Key: A C D B B
OUTPUT : Scores :
Participant 1 = 3
Participant 2 = 1
Participant 3 = 1
Participant 4 = 3
Highest score:
Participant 1
Participant 4
Example 3
INPUT : N = 12
OUTPUT : INPUT SIZE OUT OF RANGE.
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
* The class QuizResult_ISC2017 inputs the answers of each participant row-wise
* and calculates the marks for each participant
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2017 Question 2
*/
import java.util.*;
class QuizResult_ISC2017
{
char A[][],K[];
int S[],n;
void input()
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter number of participants : ");
n = sc.nextInt();
if(n<4 || n>10)
{
System.out.println("INPUT SIZE OUT OF RANGE");
System.exit(0);
}
A = new char[n][5]; // Array to store the answers of every participants
K = new char[5]; // Array to store answer key
S = new int[n]; // Array to store score of every participant
System.out.println("\n* Enter answer of each participant row-wise in a single line *\n");
for(int i = 0; i<n; i++)
{
System.out.print("Participant "+(i+1)+" : ");
for(int j=0; j<5; j++)
{
A[i][j] = sc.next().charAt(0);
}
}
System.out.print("\nEnter Answer Key : ");
for(int i = 0; i<5; i++)
{
K[i] = sc.next().charAt(0);
}
}
void CalcScore() // Function to calculate score of every participant
{
for(int i = 0; i<n; i++)
{
S[i] = 0;
for(int j=0; j<5; j++)
{
if(A[i][j] == K[j]) // Checking if Answer of the participants match with the key or not
{
S[i]++;
}
}
}
}
void printScore()
{
int max = 0;
System.out.println("\nSCORES : ");
for(int i = 0; i<n; i++)
{
System.out.println("\tParticipant "+(i+1)+" = "+S[i]);
if(S[i]>max)
{
max = S[i]; // Storing the Highest Score
}
}
System.out.println();
System.out.println("\tHighest Score : "+max);
System.out.println("\tHighest Scorers : ");
for(int i = 0; i<n; i++) //Printing all those participant number who got highest score
{
if(S[i] == max)
{
System.out.println("\t\t\tParticipant "+(i+1));
}
}
}
public static void main(String args[])
{
QuizResult_ISC2017 ob = new QuizResult_ISC2017();
ob.input();
ob.CalcScore();
ob.printScore();
}
}
Output:
Enter number of participants : 4
* Enter answer of each participant row-wise in a single line *
Participant 1 : A C C B D
Participant 2 : B C A A C
Participant 3 : B C B A A
Participant 4 : C C D D B
Enter Answer Key : A C D B B
SCORES :
Participant 1 = 3
Participant 2 = 1
Participant 3 = 1
Participant 4 = 3
Highest Score : 3
Highest Scorers :
Participant 1
Participant 4
Question:
A company manufactures packing cartons in four sizes, i.e. cartons to accommodate 6 boxes, 12 boxes, 24 boxes and 48 boxes. Design a program to accept the number of boxes to be packed (N) by the user (maximum up to 1000 boxes) and display the break-up of the cartons used in descending order of capacity (i.e. preference should be given to the highest capacity available, and if boxes left are less than 6, an extra carton of capacity 6 should be used.)
Test your program with the sample data and some random data:
Example 1
INPUT : N = 726
OUTPUT :
48 x 15 = 720
6 x 1 = 6
Remaining boxes = 0
Total number of boxes = 726
Total number of cartons = 16
Example 2
INPUT : N = 140
OUTPUT :
48 X 2 = 96
24 x 1 = 24
12 x 1 = 12
6 x 1 = 6
Remaining boxes 2 x 1 = 2
Total number of boxes = 140
Total number of cartons = 6
Example 3
INPUT : N = 4296
OUTPUT : INVALID LENGTH
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
* The class BoxPacking_ISC2017 inputs number of boxes to be packed
* and display the break-up of the cartons used in descending order of capacity
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2017 Question 1
*/
import java.util.*;
class BoxPacking_ISC2017
{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter number of boxes to be packed : ");
int N = sc.nextInt();
if(N<1 || N > 1000)
{
System.out.println("INVALID INPUT");
}
else
{
int cart[] = {48, 24, 12, 6};
int copy = N;
int totalCart = 0,count = 0;
System.out.println("OUTPUT :");
for(int i=0; i<4; i++)
{
count = N / cart[i];
if(count!=0)
{
System.out.println("\t"+cart[i]+"\tx\t"+count+"\t= "+cart[i]*count);
}
totalCart = totalCart + count;
N = N % cart[i];
}
if(N>0)
{
System.out.println("\tRemaining Boxes "+N+" x 1 = "+N);
totalCart = totalCart + 1;
}
else
{
System.out.println("\tRemaining Boxes\t\t= 0");
}
System.out.println("\tTotal number of boxes = "+copy);
System.out.println("\tTotal number of cartons = "+totalCart);
}
}
}
Output:
Enter number of boxes to be packed : 815
OUTPUT :
48 x 16 = 768
24 x 1 = 24
12 x 1 = 12
6 x 1 = 6
Remaining Boxes 5 x 1 = 5
Total number of boxes = 815
Total number of cartons = 20
Question:
Caesar Cipher is an encryption technique which is implemented as ROT13 (rotate by 13 places). It is a simple letter substitution cipher that replaces a letter with the letter 13 places after it in the alphabets, with the other characters remaining unchanged.
Write a program to accept a plain text of length L, where L must be greater than 3 and less than 100.
Encrypt the text if valid as per the Caesar Cipher.
Test your program with the sample data and some random data:
Example 1
INPUT : Hello! How are you?
OUTPUT : The cipher text is:
Uryyb? Ubj ner lbh?
Example 2
INPUT : Encryption helps to secure data.
OUTPUT : The cipher text is:
Rapelcgvba urycf gb frpher qngn.
Example 3
INPUT : You
OUTPUT : INVALID LENGTH
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/**
* The class CaesarCipher_ISC2017 inputs a sentence and encrypts it by shifting
* every alphabet 13 places ahead in a circular fashion
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2017 Question 3
*/
import java.util.*;
class CaesarCipher_ISC2017
{
void rot13(String w)
{
char ch;
int a = 0;
String ans = "";
for(int i = 0; i<w.length(); i++)
{
ch = w.charAt(i);
if(Character.isLetter(ch))
{
a = ch + 13;
if((Character.isUpperCase(ch) && a>90) || (Character.isLowerCase(ch) && a>122))
{
a = a - 26;
}
ch = (char)a;
}
ans = ans + ch;
}
System.out.println("OUTPUT : The cipher text is :\n"+ans);
}
public static void main(String args[])
{
CaesarCipher_ISC2017 ob = new CaesarCipher_ISC2017();
Scanner sc = new Scanner(System.in);
System.out.print("Enter a sentence : ");
String s = sc.nextLine();
int L = s.length();
if(L<4 || L>99)
{
System.out.println("INVALID LENGTH");
}
else
{
ob.rot13(s);
}
}
}
Output:
Enter a sentence : Encryption helps to secure data.
OUTPUT : The cipher text is :
Rapelcgvba urycf gb frpher qngn.
Question:
Write a program to declare a square matrix A[][] of order (M x M) where M must be greater than 3 and less than 10. Allow the user to input positive integers into this matrix. Perform the following tasks on the matrix:
(a) Sort the boundary elements in descending order using any standard sorting technique and rearrange them in the matrix.
(b) Calculate the sum of the boundary elements.
(c) Display the original matrix, rearranged matrix and sum of the boundary elements.
Test your program with the sample data and some random data:
Example 1
INPUT :M = 4
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
OUTPUT:
ORIGINAL MATRIX
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
REARRANGED MATRIX
23 15 12 11
1 13 8 9
2 6 3 8
4 5 7 8
The sum of boundary elements is = 105
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/**The class SortBoundary, sorts the boundary elements of a 2-D square matrix in descending order.
* It also finds the sum of the boundary elements
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
*/
import java.util.*;
class SortBoundary
{
int A[][], B[], m, n;
static int sum=0;
void input() //Function for taking all the necessary inputs
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter the size of the square matrix : ");
m=sc.nextInt();
if(m<4 || m>10)
{
System.out.println("Invalid Range");
System.exit(0);
}
else
{
A = new int[m][m];
n = m*m;
B = new int[n]; // 1-D Array to store Boundary Elements
System.out.println("Enter the elements of the Matrix : ");
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
System.out.print("Enter a value : ");
A[i][j]=sc.nextInt();
}
}
}
}
/* The below function is used to store Boundary elements
* from array A[][] to array B[]
*/
void convert()
{
int x=0;
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
if(i == 0 || j == 0 || i == m-1 || j == m-1) // Condition for boundary elements
{
B[x] = A[i][j];
x++;
sum = sum + A[i][j]; // Finding sum of boundary elements
}
}
}
}
void sortArray() //Function for sorting Boundary elements stored in array B[]
{
int c = 0;
for(int i=0; i<n-1; i++)
{
for(int j=i+1; j<n; j++)
{
if(B[i]<B[j]) // for ascending use B[i]>B[j]
{
c = B[i];
B[i] = B[j];
B[j] = c;
}
}
}
}
/* Function fillSpiral is filling the boundary of 2-D array in spiral
* way from the elements of 1-D array
*/
void fillSpiral()
{
int R1=0, R2=m-1, C1=0, C2=m-1, x=0;
for(int i=C1;i<=C2;i++) // accessing the top row
{
A[R1][i]=B[x++];
}
for(int i =R1+1;i<=R2;i++) // accessing the right column
{
A[i][C2]=B[x++];
}
for(int i =C2-1;i>=C1;i--) // accessing the bottom row
{
A[R2][i]=B[x++];
}
for(int i =R2-1;i>=R1+1;i--) // accessing the left column
{
A[i][C1]=B[x++];
}
}
void printArray() //Function for printing the array A[][]
{
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
System.out.print(A[i][j]+"\t");
}
System.out.println();
}
}
public static void main(String args[])
{
SortBoundary ob = new SortBoundary();
ob.input();
System.out.println("*********************");
System.out.println("The original matrix:");
System.out.println("*********************");
ob.printArray(); //Printing the original array
ob.convert(); //Storing Boundary elements to a 1-D array
ob.sortArray(); //Sorting the 1-D array (i.e. Boundary Elements)
ob.fillSpiral(); //Storing the sorted Boundary elements back to original 2-D array
System.out.println("*********************");
System.out.println("The Rearranged matrix:");
System.out.println("*********************");
ob.printArray(); //Printing the rearranged array
System.out.println("*********************");
System.out.println("The sum of boundary elements is = "+sum); //Printing the sum of boundary elements
}
}
See:
How to access Boundary Elements.
How to fill in a spiral format.
Output:
Enter the size of the square matrix : 4
Enter the elements of the Matrix :
Enter a value : 9
Enter a value : 2
Enter a value : 1
Enter a value : 5
Enter a value : 8
Enter a value : 13
Enter a value : 8
Enter a value : 4
Enter a value : 15
Enter a value : 6
Enter a value : 3
Enter a value : 11
Enter a value : 7
Enter a value : 12
Enter a value : 23
Enter a value : 8
*********************
The original matrix:
*********************
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
*********************
The Rearranged matrix:
*********************
23 15 12 11
1 13 8 9
2 6 3 8
4 5 7 8
*********************
The sum of boundary elements is = 105
Question:
Write a program to accept a sentence which may be terminated by either., ?or! only. The words may be separated by more than one blank space and are in UPPER CASE.
Perform the following tasks:
(a) Find the number of words beginning and ending with a vowel.
(b) Place the words which begin and end with a vowel at the beginning, followed by the remaining words as they occur in the sentence.
Test your program with the sample data and some random data:
Example 1
INPUT: ANAMIKA AND SUSAN ARE NEVER GOING TO QUARREL ANYMORE.
OUTPUT: NUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL= 3
ANAMIKA ARE ANYMORE AND SUSAN NEVER GOING TO QUARREL
Example 2
INPUT: YOU MUST AIM TO BE A BETTER PERSON TOMORROW THAN YOU ARE TODAY.
OUTPUT: NUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL= 2
A ARE YOU MUST AIM TO BE BETTER PERSON TOMORROW THAN YOU TODAY
Example 3
INPUT: LOOK BEFORE YOU LEAP.
OUTPUT: NUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL= 0
LOOK BEFORE YOU LEAP
Example 4
INPUT: HOW ARE YOU@
OUTPUT: INVALID INPUT
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/**
* The class ISC2016_Q3 inputs a sentence, and prints and counts the words
* beginning and ending with a vowel, before other words
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2016 Question 3
*/
import java.util.*;
class ISC2016_Q3
{
boolean isVowel(String w) // Function to check if a word begins and ends with a vowel or not
{
int l = w.length();
char ch1 = w.charAt(0); // Storing the first character
char ch2 = w.charAt(l-1); // Storing the last character
if((ch1=='A' || ch1=='E' || ch1=='I' || ch1=='O' || ch1=='U') &&
(ch2=='A' || ch2=='E' || ch2=='I' || ch2=='O' || ch2=='U'))
{
return true;
}
else
{
return false;
}
}
public static void main(String args[])
{
ISC2016_Q3 ob = new ISC2016_Q3();
Scanner sc = new Scanner(System.in);
System.out.print("Enter a sentence : ");
String s = sc.nextLine();
s = s.toUpperCase();
int l = s.length();
char last = s.charAt(l-1); // Extracting the last character
/* Checking whether the sentence ends with '.' or '?' or not */
if(last != '.' && last != '?' && last != '!')
{
System.out.println("Invalid Input. End a sentence with either '.', '?' or '!' only");
}
else
{
StringTokenizer str = new StringTokenizer(s," .?!");
int x = str.countTokens();
int c = 0;
String w = "", a = "", b = "";
for(int i=1; i<=x; i++)
{
w = str.nextToken(); // Extracting words and saving them in w
if(ob.isVowel(w))
{
c++; // Counting all words beginning and ending with a vowel
a = a + w + " "; // Saving all words beginning and ending with a vowel in variable 'a'
}
else
b = b + w + " "; // Saving all other words in variable 'b'
}
System.out.println("OUTPUT : \nNUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL = " + c);
System.out.println(a+b);
}
}
}
Output:
Enter a sentence : ANAMIKA AND SUSAN ARE NEVER GOING TO QUARREL ANYMORE.
OUTPUT :
NUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL = 3
ANAMIKA ARE ANYMORE AND SUSAN NEVER GOING TO QUARREL
Question:
Write a program to declare a square matrix A[][] of order (M x M) where M must be greater than 3 and less than 10. Allow the user to input positive integers into this matrix. Perform the following tasks on the matrix:
(a) Sort the non-boundary elements in ascending order using any standard sorting technique and rearrange them in the matrix.
(b) Calculate the sum of both the diagonals.
(c) Display the original matrix, rearranged matrix and only the diagonal elements of the rearranged matrix with their sum.
<
p style=text-align: justify;>Test your program with the sample data and some random data:
Example 1
INPUT :M = 4
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
OUTPUT:
ORIGINAL MATRIX
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
REARRANGED MATRIX
9 2 1 5
8 3 6 4
15 8 13 11
7 12 23 8
DIAGONAL ELEMENTS
9 5
3 6
8 13
7 8
SUM OF THE DIAGONAL ELEMENTS = 59
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/**
* The class SortNonBoundary_ISC2016 inputs a square matrix and
* sorts the non-boundary elements in ascending order
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2016 Question 2
*/
import java.util.*;
class SortNonBoundary_ISC2016
{
int A[][],B[],m,n;
void input() //Function for taking all the necessary inputs
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter the size of the square matrix : ");
m=sc.nextInt();
if(m<4 || m>10)
{
System.out.println("Invalid Range");
System.exit(0);
}
else
{
A = new int[m][m];
n = (m-2)*(m-2);
B = new int[n]; //Array to store Non-Boundary Elements
System.out.println("Enter the elements of the Matrix : ");
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
System.out.print("Enter a value : ");
A[i][j]=sc.nextInt();
}
}
}
}
/* The below function stores Non-Boundary elements
* from array A[][] to array B[] if s = 1
* else stores the Non-Boundary elements in array A[][] from array B[]
*/
void convert(int s)
{
int x=0;
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
if(i != 0 && j != 0 && i != m-1 && j != m-1)
{
if(s==1)
B[x] = A[i][j];
else
A[i][j] = B[x];
x++;
}
}
}
}
void sortArray() //Function for sorting Non-Boundary elements stored in array B[]
{
int c = 0;
for(int i=0; i<n-1; i++)
{
for(int j=i+1; j<n; j++)
{
if(B[i]>B[j])
{
c = B[i];
B[i] = B[j];
B[j] = c;
}
}
}
}
void printArray() //Function for printing the array A[][]
{
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
System.out.print(A[i][j]+"\t");
}
System.out.println();
}
}
void printDiagonal() //Function for printing the diagonal elements and their sum
{
int sum = 0;
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
if(i==j || (i+j)==m-1)
{
System.out.print(A[i][j]+"\t");
sum = sum + A[i][j];
}
else
System.out.print("\t");
}
System.out.println();
}
System.out.println("Sum of the Diagonal Elements : "+sum);
}
public static void main(String args[])
{
SortNonBoundary_ISC2016 ob = new SortNonBoundary_ISC2016();
ob.input();
System.out.println("*********************");
System.out.println("The original matrix:");
System.out.println("*********************");
ob.printArray(); //Printing the original array
ob.convert(1); //Storing Non-Boundary elements to a 1-D array
ob.sortArray(); //Sorting the 1-D array (i.e. Non-Diagonal Elements)
ob.convert(2); //Storing the sorted Non-Boundary elements back to original 2-D array
System.out.println("*********************");
System.out.println("The Rearranged matrix:");
System.out.println("*********************");
ob.printArray(); //Printing the rearranged array
System.out.println("*********************");
System.out.println("The Diagonal Elements:");
System.out.println("*********************");
ob.printDiagonal(); //Printing the diagonal elements and their sum
}
}
Output:
Enter the size of the square matrix : 4
Enter the elements of the Matrix :
Enter a value : 9
Enter a value : 2
Enter a value : 1
Enter a value : 5
Enter a value : 8
Enter a value : 13
Enter a value : 8
Enter a value : 4
Enter a value : 15
Enter a value : 6
Enter a value : 3
Enter a value : 11
Enter a value : 7
Enter a value : 12
Enter a value : 23
Enter a value : 8
*********************
The original matrix:
*********************
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
*********************
The Rearranged matrix:
*********************
9 2 1 5
8 3 6 4
15 8 13 11
7 12 23 8
*********************
The Diagonal Elements:
*********************
9 5
3 6
8 13
7 8
Sum of the Diagonal Elements : 59
Question:
A Circular Prime is a prime number that remains prime under cyclic shifts of its digits. When the leftmost digit is removed and replaced at the end of the remaining string of digits, the generated number is still prime. The process is repeated until the original number is reached again.
A number is said to be prime if it has only two factors I and itself.
Example:
131
311
113
Hence, 131 is a circular prime.
Test your program with the sample data and some random data:
Example 1
INPUT :N = 197
OUTPUT:
197
971
719
197 IS A CIRCULAR PRIME
Example 2
INPUT :N = 1193
OUTPUT:
1193
1931
9311
3119
1193 IS A CIRCULAR PRIME
Example 3
INPUT :N = 29
OUTPUT:
29
92
29 IS NOT A CIRCULAR PRIME
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/**
* The class CircularPrime_Q1_ISC2016 inputs a number and
* checks whether it is a Circular Prime or not
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2016 Question 1
*/
import java.util.*;
class CircularPrime_Q1_ISC2016
{
boolean isPrime(int n) // Function for checking whether a number is prime or not
{
int c = 0;
for(int i = 1; i<=n; i++)
{
if(n%i == 0)
c++;
}
if(c == 2)
return true;
else
return false;
}
int circulate(int n) //Function for circulating the digits to form new number
{
String s = Integer.toString(n);
String p = s.substring(1)+s.charAt(0);
int a = Integer.parseInt(p);
return a;
}
void isCircularPrime(int n) //Function to check for circular prime
{
int f = 0,a = n;
do
{
System.out.println(a);
if(isPrime(a)==false)
{
f = 1;
break;
}
a = circulate(a);
}while(a!=n);
if(f==1)
System.out.println(n+" IS NOT A CIRCULAR PRIME");
else
System.out.println(n+" IS A CIRCULAR PRIME");
}
public static void main(String args[])
{
CircularPrime_Q1_ISC2016 ob = new CircularPrime_Q1_ISC2016();
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number : ");
int n = sc.nextInt();
ob.isCircularPrime(n);
}
}
Output:
Enter a number : 87
87
87 IS NOT A CIRCULAR PRIME
Enter a number : 1193
1193
1931
9311
3119
1193 IS A CIRCULAR PRIME
Enter a number : 123
123
231
312
123 IS NOT A CIRCULAR PRIME
The result of a quiz competition is to be prepared as follows:
The quiz has five questions with four multiple choices (A, B, C, D), with each question carrying 1 mark for the correct answer. Design a program to accept the number of participants N such that N must be greater than 3 and less than 11. Create a double dimensional array of size (Nx5) to store the answers of each participant row-wise.
Calculate the marks for each participant by matching the correct answer stored in a single dimensional array of size 5. Display the scores for each participant and also the participant(s) having the highest score.
Example: If the value of N = 4, then the array would be:
Note: Array entries are line fed (i.e. one entry per line)
Test your program with the sample data and some random data:
Example 1
INPUT : N = 5
Participant 1 D A B C C
Participant 2 A A D C B
Participant 3 B A C D B
Participant 4 D A D C B
Participant 5 B C A D D
Key: B C D A A
OUTPUT : Scores :
Participant 1 D A B C C
Participant 1 = 0
Participant 2 = 1
Participant 3 = 1
Participant 4 = 1
Participant 5 = 2
Highest score: Participant 5
Example 2
INPUT : N = 4
Participant 1 A C C B D
Participant 2 B C A A C
Participant 3 B C B A A
Participant 4 C C D D B
Key: A C D B B
OUTPUT : Scores :
Participant 1 = 3
Participant 2 = 1
Participant 3 = 1
Participant 4 = 3
Highest score:
Participant 1
Participant 4
Example 3
INPUT : N = 12
OUTPUT : INPUT SIZE OUT OF RANGE.
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
* The class QuizResult_ISC2017 inputs the answers of each participant row-wise
* and calculates the marks for each participant
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2017 Question 2
*/
import java.util.*;
class QuizResult_ISC2017
{
char A[][],K[];
int S[],n;
void input()
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter number of participants : ");
n = sc.nextInt();
if(n<4 || n>10)
{
System.out.println("INPUT SIZE OUT OF RANGE");
System.exit(0);
}
A = new char[n][5]; // Array to store the answers of every participants
K = new char[5]; // Array to store answer key
S = new int[n]; // Array to store score of every participant
System.out.println("\n* Enter answer of each participant row-wise in a single line *\n");
for(int i = 0; i<n; i++)
{
System.out.print("Participant "+(i+1)+" : ");
for(int j=0; j<5; j++)
{
A[i][j] = sc.next().charAt(0);
}
}
System.out.print("\nEnter Answer Key : ");
for(int i = 0; i<5; i++)
{
K[i] = sc.next().charAt(0);
}
}
void CalcScore() // Function to calculate score of every participant
{
for(int i = 0; i<n; i++)
{
S[i] = 0;
for(int j=0; j<5; j++)
{
if(A[i][j] == K[j]) // Checking if Answer of the participants match with the key or not
{
S[i]++;
}
}
}
}
void printScore()
{
int max = 0;
System.out.println("\nSCORES : ");
for(int i = 0; i<n; i++)
{
System.out.println("\tParticipant "+(i+1)+" = "+S[i]);
if(S[i]>max)
{
max = S[i]; // Storing the Highest Score
}
}
System.out.println();
System.out.println("\tHighest Score : "+max);
System.out.println("\tHighest Scorers : ");
for(int i = 0; i<n; i++) //Printing all those participant number who got highest score
{
if(S[i] == max)
{
System.out.println("\t\t\tParticipant "+(i+1));
}
}
}
public static void main(String args[])
{
QuizResult_ISC2017 ob = new QuizResult_ISC2017();
ob.input();
ob.CalcScore();
ob.printScore();
}
}
Output:
Enter number of participants : 4
* Enter answer of each participant row-wise in a single line *
Participant 1 : A C C B D
Participant 2 : B C A A C
Participant 3 : B C B A A
Participant 4 : C C D D B
Enter Answer Key : A C D B B
SCORES :
Participant 1 = 3
Participant 2 = 1
Participant 3 = 1
Participant 4 = 3
Highest Score : 3
Highest Scorers :
Participant 1
Participant 4
Question:
A company manufactures packing cartons in four sizes, i.e. cartons to accommodate 6 boxes, 12 boxes, 24 boxes and 48 boxes. Design a program to accept the number of boxes to be packed (N) by the user (maximum up to 1000 boxes) and display the break-up of the cartons used in descending order of capacity (i.e. preference should be given to the highest capacity available, and if boxes left are less than 6, an extra carton of capacity 6 should be used.)
Test your program with the sample data and some random data:
Example 1
INPUT : N = 726
OUTPUT :
48 x 15 = 720
6 x 1 = 6
Remaining boxes = 0
Total number of boxes = 726
Total number of cartons = 16
Example 2
INPUT : N = 140
OUTPUT :
48 X 2 = 96
24 x 1 = 24
12 x 1 = 12
6 x 1 = 6
Remaining boxes 2 x 1 = 2
Total number of boxes = 140
Total number of cartons = 6
Example 3
INPUT : N = 4296
OUTPUT : INVALID LENGTH
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
* The class BoxPacking_ISC2017 inputs number of boxes to be packed
* and display the break-up of the cartons used in descending order of capacity
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2017 Question 1
*/
import java.util.*;
class BoxPacking_ISC2017
{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter number of boxes to be packed : ");
int N = sc.nextInt();
if(N<1 || N > 1000)
{
System.out.println("INVALID INPUT");
}
else
{
int cart[] = {48, 24, 12, 6};
int copy = N;
int totalCart = 0,count = 0;
System.out.println("OUTPUT :");
for(int i=0; i<4; i++)
{
count = N / cart[i];
if(count!=0)
{
System.out.println("\t"+cart[i]+"\tx\t"+count+"\t= "+cart[i]*count);
}
totalCart = totalCart + count;
N = N % cart[i];
}
if(N>0)
{
System.out.println("\tRemaining Boxes "+N+" x 1 = "+N);
totalCart = totalCart + 1;
}
else
{
System.out.println("\tRemaining Boxes\t\t= 0");
}
System.out.println("\tTotal number of boxes = "+copy);
System.out.println("\tTotal number of cartons = "+totalCart);
}
}
}
Output:
Enter number of boxes to be packed : 815
OUTPUT :
48 x 16 = 768
24 x 1 = 24
12 x 1 = 12
6 x 1 = 6
Remaining Boxes 5 x 1 = 5
Total number of boxes = 815
Total number of cartons = 20
Question:
Caesar Cipher is an encryption technique which is implemented as ROT13 (rotate by 13 places). It is a simple letter substitution cipher that replaces a letter with the letter 13 places after it in the alphabets, with the other characters remaining unchanged.
Write a program to accept a plain text of length L, where L must be greater than 3 and less than 100.
Encrypt the text if valid as per the Caesar Cipher.
Test your program with the sample data and some random data:
Example 1
INPUT : Hello! How are you?
OUTPUT : The cipher text is:
Uryyb? Ubj ner lbh?
Example 2
INPUT : Encryption helps to secure data.
OUTPUT : The cipher text is:
Rapelcgvba urycf gb frpher qngn.
Example 3
INPUT : You
OUTPUT : INVALID LENGTH
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/**
* The class CaesarCipher_ISC2017 inputs a sentence and encrypts it by shifting
* every alphabet 13 places ahead in a circular fashion
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2017 Question 3
*/
import java.util.*;
class CaesarCipher_ISC2017
{
void rot13(String w)
{
char ch;
int a = 0;
String ans = "";
for(int i = 0; i<w.length(); i++)
{
ch = w.charAt(i);
if(Character.isLetter(ch))
{
a = ch + 13;
if((Character.isUpperCase(ch) && a>90) || (Character.isLowerCase(ch) && a>122))
{
a = a - 26;
}
ch = (char)a;
}
ans = ans + ch;
}
System.out.println("OUTPUT : The cipher text is :\n"+ans);
}
public static void main(String args[])
{
CaesarCipher_ISC2017 ob = new CaesarCipher_ISC2017();
Scanner sc = new Scanner(System.in);
System.out.print("Enter a sentence : ");
String s = sc.nextLine();
int L = s.length();
if(L<4 || L>99)
{
System.out.println("INVALID LENGTH");
}
else
{
ob.rot13(s);
}
}
}
Output:
Enter a sentence : Encryption helps to secure data.
OUTPUT : The cipher text is :
Rapelcgvba urycf gb frpher qngn.
Question:
Write a program to declare a square matrix A[][] of order (M x M) where M must be greater than 3 and less than 10. Allow the user to input positive integers into this matrix. Perform the following tasks on the matrix:
(a) Sort the boundary elements in descending order using any standard sorting technique and rearrange them in the matrix.
(b) Calculate the sum of the boundary elements.
(c) Display the original matrix, rearranged matrix and sum of the boundary elements.
Test your program with the sample data and some random data:
Example 1
INPUT :M = 4
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
OUTPUT:
ORIGINAL MATRIX
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
REARRANGED MATRIX
23 15 12 11
1 13 8 9
2 6 3 8
4 5 7 8
The sum of boundary elements is = 105
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/**The class SortBoundary, sorts the boundary elements of a 2-D square matrix in descending order.
* It also finds the sum of the boundary elements
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
*/
import java.util.*;
class SortBoundary
{
int A[][], B[], m, n;
static int sum=0;
void input() //Function for taking all the necessary inputs
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter the size of the square matrix : ");
m=sc.nextInt();
if(m<4 || m>10)
{
System.out.println("Invalid Range");
System.exit(0);
}
else
{
A = new int[m][m];
n = m*m;
B = new int[n]; // 1-D Array to store Boundary Elements
System.out.println("Enter the elements of the Matrix : ");
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
System.out.print("Enter a value : ");
A[i][j]=sc.nextInt();
}
}
}
}
/* The below function is used to store Boundary elements
* from array A[][] to array B[]
*/
void convert()
{
int x=0;
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
if(i == 0 || j == 0 || i == m-1 || j == m-1) // Condition for boundary elements
{
B[x] = A[i][j];
x++;
sum = sum + A[i][j]; // Finding sum of boundary elements
}
}
}
}
void sortArray() //Function for sorting Boundary elements stored in array B[]
{
int c = 0;
for(int i=0; i<n-1; i++)
{
for(int j=i+1; j<n; j++)
{
if(B[i]<B[j]) // for ascending use B[i]>B[j]
{
c = B[i];
B[i] = B[j];
B[j] = c;
}
}
}
}
/* Function fillSpiral is filling the boundary of 2-D array in spiral
* way from the elements of 1-D array
*/
void fillSpiral()
{
int R1=0, R2=m-1, C1=0, C2=m-1, x=0;
for(int i=C1;i<=C2;i++) // accessing the top row
{
A[R1][i]=B[x++];
}
for(int i =R1+1;i<=R2;i++) // accessing the right column
{
A[i][C2]=B[x++];
}
for(int i =C2-1;i>=C1;i--) // accessing the bottom row
{
A[R2][i]=B[x++];
}
for(int i =R2-1;i>=R1+1;i--) // accessing the left column
{
A[i][C1]=B[x++];
}
}
void printArray() //Function for printing the array A[][]
{
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
System.out.print(A[i][j]+"\t");
}
System.out.println();
}
}
public static void main(String args[])
{
SortBoundary ob = new SortBoundary();
ob.input();
System.out.println("*********************");
System.out.println("The original matrix:");
System.out.println("*********************");
ob.printArray(); //Printing the original array
ob.convert(); //Storing Boundary elements to a 1-D array
ob.sortArray(); //Sorting the 1-D array (i.e. Boundary Elements)
ob.fillSpiral(); //Storing the sorted Boundary elements back to original 2-D array
System.out.println("*********************");
System.out.println("The Rearranged matrix:");
System.out.println("*********************");
ob.printArray(); //Printing the rearranged array
System.out.println("*********************");
System.out.println("The sum of boundary elements is = "+sum); //Printing the sum of boundary elements
}
}
See:
How to access Boundary Elements.
How to fill in a spiral format.
Output:
Enter the size of the square matrix : 4
Enter the elements of the Matrix :
Enter a value : 9
Enter a value : 2
Enter a value : 1
Enter a value : 5
Enter a value : 8
Enter a value : 13
Enter a value : 8
Enter a value : 4
Enter a value : 15
Enter a value : 6
Enter a value : 3
Enter a value : 11
Enter a value : 7
Enter a value : 12
Enter a value : 23
Enter a value : 8
*********************
The original matrix:
*********************
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
*********************
The Rearranged matrix:
*********************
23 15 12 11
1 13 8 9
2 6 3 8
4 5 7 8
*********************
The sum of boundary elements is = 105
Question:
Write a program to accept a sentence which may be terminated by either., ?or! only. The words may be separated by more than one blank space and are in UPPER CASE.
Perform the following tasks:
(a) Find the number of words beginning and ending with a vowel.
(b) Place the words which begin and end with a vowel at the beginning, followed by the remaining words as they occur in the sentence.
Test your program with the sample data and some random data:
Example 1
INPUT: ANAMIKA AND SUSAN ARE NEVER GOING TO QUARREL ANYMORE.
OUTPUT: NUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL= 3
ANAMIKA ARE ANYMORE AND SUSAN NEVER GOING TO QUARREL
Example 2
INPUT: YOU MUST AIM TO BE A BETTER PERSON TOMORROW THAN YOU ARE TODAY.
OUTPUT: NUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL= 2
A ARE YOU MUST AIM TO BE BETTER PERSON TOMORROW THAN YOU TODAY
Example 3
INPUT: LOOK BEFORE YOU LEAP.
OUTPUT: NUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL= 0
LOOK BEFORE YOU LEAP
Example 4
INPUT: HOW ARE YOU@
OUTPUT: INVALID INPUT
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/**
* The class ISC2016_Q3 inputs a sentence, and prints and counts the words
* beginning and ending with a vowel, before other words
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2016 Question 3
*/
import java.util.*;
class ISC2016_Q3
{
boolean isVowel(String w) // Function to check if a word begins and ends with a vowel or not
{
int l = w.length();
char ch1 = w.charAt(0); // Storing the first character
char ch2 = w.charAt(l-1); // Storing the last character
if((ch1=='A' || ch1=='E' || ch1=='I' || ch1=='O' || ch1=='U') &&
(ch2=='A' || ch2=='E' || ch2=='I' || ch2=='O' || ch2=='U'))
{
return true;
}
else
{
return false;
}
}
public static void main(String args[])
{
ISC2016_Q3 ob = new ISC2016_Q3();
Scanner sc = new Scanner(System.in);
System.out.print("Enter a sentence : ");
String s = sc.nextLine();
s = s.toUpperCase();
int l = s.length();
char last = s.charAt(l-1); // Extracting the last character
/* Checking whether the sentence ends with '.' or '?' or not */
if(last != '.' && last != '?' && last != '!')
{
System.out.println("Invalid Input. End a sentence with either '.', '?' or '!' only");
}
else
{
StringTokenizer str = new StringTokenizer(s," .?!");
int x = str.countTokens();
int c = 0;
String w = "", a = "", b = "";
for(int i=1; i<=x; i++)
{
w = str.nextToken(); // Extracting words and saving them in w
if(ob.isVowel(w))
{
c++; // Counting all words beginning and ending with a vowel
a = a + w + " "; // Saving all words beginning and ending with a vowel in variable 'a'
}
else
b = b + w + " "; // Saving all other words in variable 'b'
}
System.out.println("OUTPUT : \nNUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL = " + c);
System.out.println(a+b);
}
}
}
Output:
Enter a sentence : ANAMIKA AND SUSAN ARE NEVER GOING TO QUARREL ANYMORE.
OUTPUT :
NUMBER OF WORDS BEGINNING AND ENDING WITH A VOWEL = 3
ANAMIKA ARE ANYMORE AND SUSAN NEVER GOING TO QUARREL
Question:
Write a program to declare a square matrix A[][] of order (M x M) where M must be greater than 3 and less than 10. Allow the user to input positive integers into this matrix. Perform the following tasks on the matrix:
(a) Sort the non-boundary elements in ascending order using any standard sorting technique and rearrange them in the matrix.
(b) Calculate the sum of both the diagonals.
(c) Display the original matrix, rearranged matrix and only the diagonal elements of the rearranged matrix with their sum.
<
p style=text-align: justify;>Test your program with the sample data and some random data:
Example 1
INPUT :M = 4
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
OUTPUT:
ORIGINAL MATRIX
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
REARRANGED MATRIX
9 2 1 5
8 3 6 4
15 8 13 11
7 12 23 8
DIAGONAL ELEMENTS
9 5
3 6
8 13
7 8
SUM OF THE DIAGONAL ELEMENTS = 59
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/**
* The class SortNonBoundary_ISC2016 inputs a square matrix and
* sorts the non-boundary elements in ascending order
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2016 Question 2
*/
import java.util.*;
class SortNonBoundary_ISC2016
{
int A[][],B[],m,n;
void input() //Function for taking all the necessary inputs
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter the size of the square matrix : ");
m=sc.nextInt();
if(m<4 || m>10)
{
System.out.println("Invalid Range");
System.exit(0);
}
else
{
A = new int[m][m];
n = (m-2)*(m-2);
B = new int[n]; //Array to store Non-Boundary Elements
System.out.println("Enter the elements of the Matrix : ");
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
System.out.print("Enter a value : ");
A[i][j]=sc.nextInt();
}
}
}
}
/* The below function stores Non-Boundary elements
* from array A[][] to array B[] if s = 1
* else stores the Non-Boundary elements in array A[][] from array B[]
*/
void convert(int s)
{
int x=0;
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
if(i != 0 && j != 0 && i != m-1 && j != m-1)
{
if(s==1)
B[x] = A[i][j];
else
A[i][j] = B[x];
x++;
}
}
}
}
void sortArray() //Function for sorting Non-Boundary elements stored in array B[]
{
int c = 0;
for(int i=0; i<n-1; i++)
{
for(int j=i+1; j<n; j++)
{
if(B[i]>B[j])
{
c = B[i];
B[i] = B[j];
B[j] = c;
}
}
}
}
void printArray() //Function for printing the array A[][]
{
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
System.out.print(A[i][j]+"\t");
}
System.out.println();
}
}
void printDiagonal() //Function for printing the diagonal elements and their sum
{
int sum = 0;
for(int i=0;i<m;i++)
{
for(int j=0;j<m;j++)
{
if(i==j || (i+j)==m-1)
{
System.out.print(A[i][j]+"\t");
sum = sum + A[i][j];
}
else
System.out.print("\t");
}
System.out.println();
}
System.out.println("Sum of the Diagonal Elements : "+sum);
}
public static void main(String args[])
{
SortNonBoundary_ISC2016 ob = new SortNonBoundary_ISC2016();
ob.input();
System.out.println("*********************");
System.out.println("The original matrix:");
System.out.println("*********************");
ob.printArray(); //Printing the original array
ob.convert(1); //Storing Non-Boundary elements to a 1-D array
ob.sortArray(); //Sorting the 1-D array (i.e. Non-Diagonal Elements)
ob.convert(2); //Storing the sorted Non-Boundary elements back to original 2-D array
System.out.println("*********************");
System.out.println("The Rearranged matrix:");
System.out.println("*********************");
ob.printArray(); //Printing the rearranged array
System.out.println("*********************");
System.out.println("The Diagonal Elements:");
System.out.println("*********************");
ob.printDiagonal(); //Printing the diagonal elements and their sum
}
}
Output:
Enter the size of the square matrix : 4
Enter the elements of the Matrix :
Enter a value : 9
Enter a value : 2
Enter a value : 1
Enter a value : 5
Enter a value : 8
Enter a value : 13
Enter a value : 8
Enter a value : 4
Enter a value : 15
Enter a value : 6
Enter a value : 3
Enter a value : 11
Enter a value : 7
Enter a value : 12
Enter a value : 23
Enter a value : 8
*********************
The original matrix:
*********************
9 2 1 5
8 13 8 4
15 6 3 11
7 12 23 8
*********************
The Rearranged matrix:
*********************
9 2 1 5
8 3 6 4
15 8 13 11
7 12 23 8
*********************
The Diagonal Elements:
*********************
9 5
3 6
8 13
7 8
Sum of the Diagonal Elements : 59
Question:
A Circular Prime is a prime number that remains prime under cyclic shifts of its digits. When the leftmost digit is removed and replaced at the end of the remaining string of digits, the generated number is still prime. The process is repeated until the original number is reached again.
A number is said to be prime if it has only two factors I and itself.
Example:
131
311
113
Hence, 131 is a circular prime.
Test your program with the sample data and some random data:
Example 1
INPUT :N = 197
OUTPUT:
197
971
719
197 IS A CIRCULAR PRIME
Example 2
INPUT :N = 1193
OUTPUT:
1193
1931
9311
3119
1193 IS A CIRCULAR PRIME
Example 3
INPUT :N = 29
OUTPUT:
29
92
29 IS NOT A CIRCULAR PRIME
Programming Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/**
* The class CircularPrime_Q1_ISC2016 inputs a number and
* checks whether it is a Circular Prime or not
* @author : agarwalrajhans@gmail.com
* @Program Type : BlueJ Program - Java
* @Question Year : ISC Practical 2016 Question 1
*/
import java.util.*;
class CircularPrime_Q1_ISC2016
{
boolean isPrime(int n) // Function for checking whether a number is prime or not
{
int c = 0;
for(int i = 1; i<=n; i++)
{
if(n%i == 0)
c++;
}
if(c == 2)
return true;
else
return false;
}
int circulate(int n) //Function for circulating the digits to form new number
{
String s = Integer.toString(n);
String p = s.substring(1)+s.charAt(0);
int a = Integer.parseInt(p);
return a;
}
void isCircularPrime(int n) //Function to check for circular prime
{
int f = 0,a = n;
do
{
System.out.println(a);
if(isPrime(a)==false)
{
f = 1;
break;
}
a = circulate(a);
}while(a!=n);
if(f==1)
System.out.println(n+" IS NOT A CIRCULAR PRIME");
else
System.out.println(n+" IS A CIRCULAR PRIME");
}
public static void main(String args[])
{
CircularPrime_Q1_ISC2016 ob = new CircularPrime_Q1_ISC2016();
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number : ");
int n = sc.nextInt();
ob.isCircularPrime(n);
}
}
Output:
Enter a number : 87
87
87 IS NOT A CIRCULAR PRIME
Enter a number : 1193
1193
1931
9311
3119
1193 IS A CIRCULAR PRIME
Enter a number : 123
123
231
312
123 IS NOT A CIRCULAR PRIME
No comments:
Post a Comment
any problem in any program comment:-