KEYPAD KEYSTROKE
Start
Input the word:
Prompt the user to enter a word.
Convert the word to uppercase.
Validate the input:
Iterate through each character in the word:
o Check if the character is a letter:
If any character is not a letter, display "INVALID ENTRY" and terminate
the program.
Initialize variables:
Set count = 0 (to keep track of the total keystrokes).
Iterate through each character in the word:
For each character ch in the word:
o If ch belongs to "ADGJMPTW":
Add 1 to count.
o Else if ch belongs to "BEHKNQUX":
Add 2 to count.
o Else if ch belongs to "CFILORVY":
Add 3 to count.
o Else (remaining letters such as "SZ"):
Add 4 to count.
Output the total keystrokes:
Display "Number of keystrokes = <count>".
End
import java.util.Scanner;
class Keypad{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print("Enter the word: ");
String word = in.next().toUpperCase();
int count = 0;
for(int i = 0; i < word.length(); i++){
char ch = word.charAt(i);
if(!Character.isLetter(ch)){
System.out.println("INVALID ENTRY");
return;
if("ADGJMPTW".indexOf(ch) >= 0)
count++;
else if("BEHKNQUX".indexOf(ch) >= 0)
count += 2;
else if("CFILORVY".indexOf(ch) >= 0)
count += 3;
else
count += 4;
System.out.println("Number of keystrokes = " + count);
}
DATE PROGRAM
1. Start
2. Input the day number, year, and value of N:
o Prompt the user to enter:
dayNum (an integer representing the day of the year).
year (an integer representing the year).
n (an integer representing the number of days to add).
3. Validate the input values:
o Initialize validDayNum = true and validN = true.
o Check the validity of dayNum:
If dayNum < 1 or:
dayNum > 365 for a non-leap year.
dayNum > 366 for a leap year.
Set validDayNum = false and display "INCORRECT DAY
NUMBER".
o Check the validity of n:
If n < 1 or n > 100:
Set validN = false and display "INCORRECT VALUE OF
'N'".
o If either validDayNum or validN is false, terminate the program.
4. Set up month and day arrays:
o Initialize an array day with the number of days in each month for a non-leap
year:
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}.
o Initialize an array month with the names of the months:
{"JANUARY", "FEBRUARY", ..., "DECEMBER"}.
5. Adjust for leap year:
o If the year is a leap year (isLeap(year) returns true):
Set day[1] = 29.
6. Calculate the entered date:
o Initialize index = 0 (to track the current month).
o While dayNum > day[index]:
Subtract day[index] from dayNum.
Increment index.
If index reaches 12 (end of the year):
Reset index = 0.
Increment year.
Adjust day[1] for the new year if it's a leap year.
7. Display the entered date:
o Print "ENTERED DATE: <month[index]> <dayNum>, <year>".
8. Calculate the date N days later:
o While n > 0:
Increment dayNum.
Decrement n.
If dayNum > day[index]:
Reset dayNum = 1.
Increment index.
If index reaches 12 (end of the year):
Reset index = 0.
Increment year.
Adjust day[1] for the new year if it's a leap year.
9. Display the resulting date:
o Print "<n> DAYS LATER: <month[index]> <dayNum>, <year>".
10. Define the helper function isLeap(year) to determine if a year is a leap year:
o Return true if:
(year % 4 == 0) and (year % 100 != 0), or (year % 400 == 0).
o Otherwise, return false.
11. End
import java.util.Scanner;
class LaterDate{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
boolean validDayNum = true;
boolean validN = true;
System.out.print("DAY NUMBER: ");
int dayNum = Integer.parseInt(in.nextLine());
System.out.print("YEAR: ");
int year = Integer.parseInt(in.nextLine());
System.out.print("N: ");
int n = Integer.parseInt(in.nextLine());
if(dayNum < 1 || (dayNum > 365 && !isLeap(year))){
validDayNum = false;
System.out.println("INCORRECT DAY NUMBER");
else if(dayNum > 366 && isLeap(year)){
validDayNum = false;
System.out.println("INCORRECT DAY NUMBER");
if(n < 1 || n > 100){
validN = false;
System.out.println("INCORRECT VALUE OF 'N'");
if(!validDayNum || !validN)
return;
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
String month[] = {"JANUARY", "FEBRUARY", "MARCH", "APRIL",
"MAY", "JUNE", "JULY", "AUGUST", "SEPTEMBER", "OCTOBER",
"NOVEMBER", "DECEMBER"};
if(isLeap(year))
day[1] = 29;
int index = 0;
while(dayNum > day[index]){
dayNum -= day[index++];
if(index == 12){
index = 0;
year++;
if(isLeap(year))
day[1] = 29;
else
day[1] = 28;
System.out.println("ENTERED DATE: " + month[index] + " " + dayNum + ", "
+ year);
System.out.print(n + " DAYS LATER: ");
while(n > 0){
dayNum++;
n--;
if(dayNum > day[index]){
dayNum = 1;
index++;
if(index == 12){
index = 0;
year++;
if(isLeap(year))
day[1] = 29;
else
day[1] = 28;
System.out.println(month[index] + " " + dayNum + ", " + year);
public static boolean isLeap(int y){
if((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)
return true;
return false;
}
GOLDBACH
Start
Input the even integer N:
Prompt the user to enter an integer N.
Convert the input to an integer.
Validate the input:
Check if N is greater than 50 or if N is odd:
o If true, display "INVALID INPUT" and terminate the program.
Initialize variables:
Set i = 3 (starting from the smallest odd prime number).
Iterate to find prime pairs:
While i is less than or equal to (N - i):
o Check if both i and (N - i) are prime using the isPrime method.
o If both numbers are prime:
Print the pair (i, N - i).
o Increment i by 1.
Prime-checking method (isPrime):
Input: An integer n.
Initialize a counter f = 0.
Loop through integers from 1 to n:
o If n is divisible by the current integer, increment f.
If f equals 2 (indicating only two divisors: 1 and itself):
o Return true (the number is prime).
Else:
o Return false (the number is not prime).
End
import java.util.Scanner;
class Goldbach{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print("N = ");
int n = Integer.parseInt(in.nextLine());
if(n > 50 || n % 2 != 0){
System.out.println("INVALID INPUT");
return;
}
int i = 3;
while(i <= (n - i)){
if(isPrime(i) && isPrime(n - i))
System.out.println(i + ", " + (n - i));
i++;
}
}
public static boolean isPrime(int n){
int f = 0;
for(int i = 1; i <= n; i++){
if(n % i == 0)
f++;
}
return f == 2;
}
}
ANAGRAM
Start
Input two strings:
Prompt the user to enter the first string a.
Convert the string a to uppercase.
Prompt the user to enter the second string b.
Convert the string b to uppercase.
Validate both strings using the valid method:
For each string, iterate through its characters:
o If any character is neither a letter nor a whitespace, the input is invalid.
If either string is invalid:
o Print "INVALID CHARACTERS IN STRING. INVALID INPUT".
o Terminate the program.
Remove spaces from both strings using the removeSpaces method:
For each string:
o Create an empty result string.
o Iterate through each character:
Append the character to the result if it is not a whitespace.
Update a and b to their space-free versions.
Check if the strings are anagrams:
Initialize status = true (to track if they are anagrams).
While the length of a is greater than 0:
o Extract the first character x from a.
o Remove all occurrences of x from both a and b:
Use the replace method.
o If the lengths of a and b differ at any point:
Set status = false.
Break the loop.
Output the result:
If status is true:
o Print "THEY ARE ANAGRAMS!".
Otherwise:
o Print "THEY ARE NOT ANAGRAMS.".
End
class Anagrams{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print("Enter first string: ");
String a = in.nextLine().toUpperCase();
System.out.print("Enter second string: ");
String b = in.nextLine().toUpperCase();
if(!valid(a) || !valid(b)){
System.out.println("INVALID CHARACTERS IN STRING. INVALID
INPUT");
return;
a = removeSpaces(a);
b = removeSpaces(b);
boolean status = true;
while(a.length() > 0){
String x = String.valueOf(a.charAt(0));
a = a.replace(x, "");
b = b.replace(x, "");
if(a.length() != b.length()){
status = false;
break;
if(status)
System.out.println("THEY ARE ANAGRAMS!");
else
System.out.println("THEY ARE NOT ANAGRAMS.");
public static boolean valid(String s){
for(int i = 0; i < s.length(); i++){
char ch = s.charAt(i);
if(!Character.isWhitespace(ch) && !Character.isLetter(ch))
return false;
return true;
public static String removeSpaces(String s){
String str = new String();
for(int i = 0; i < s.length(); i++){
char ch = s.charAt(i);
if(Character.isWhitespace(ch))
continue;
str += ch;
return str;
}
PANGRAM PROGRAM
Start
Input the sentence:
Prompt the user to enter a sentence s.
Validate the input:
Check if the length of s is zero:
o If true, print "INVALID INPUT" and terminate the program.
Check if the last character of s is one of ., ?, or !:
o If not, print "INVALID INPUT" and terminate the program.
Initialize variables:
shortest = s (to store the shortest word, initialize to the input sentence).
longest = "" (to store the longest word).
isPangram = true (to track if the sentence is a pangram).
Check if the sentence is a pangram:
Iterate through each character ch from 'a' to 'z':
o Initialize match = false.
o For each character in the sentence s:
If ch matches any character in s (case-insensitive), set match = true
and break.
o If match = false for any letter, set isPangram = false and break the loop.
If isPangram is true, print "IT IS A PANGRAM".
Otherwise, print "IT IS NOT A PANGRAM".
Find the shortest and longest words:
Initialize word = "" (to accumulate characters of the current word).
Iterate through each character ch in the sentence s:
o If ch is a letter or digit, append it to word.
o Otherwise (punctuation or space):
If the length of word is greater than the length of longest, update
longest = word.
If the length of word is less than the length of shortest, update
shortest = word.
Reset word = "" to start a new word.
After the loop, check if word (last word in the sentence) needs updating:
o Compare its length with shortest and longest.
Output the longest and shortest words:
Print "LONGEST WORD: <longest>".
Print "SHORTEST WORD: <shortest>".
End
import java.util.Scanner;
class Pangram{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print("Enter the sentence: ");
String s = in.nextLine();
if(s.length() == 0){
System.out.println("INVALID INPUT");
return;
char last = s.charAt(s.length() - 1);
if(".?!".indexOf(last) == -1){
System.out.println("INVALID INPUT");
return;
String shortest = new String(s);
String longest = new String();
boolean isPangram = true;
for(char ch = 'a'; ch <= 'z'; ch++){
boolean match = false;
for(int i = 0; i < s.length(); i++){
if(ch == Character.toLowerCase(s.charAt(i))){
match = true;
break;
}
}
if(!match){
isPangram = false;
break;
if(isPangram)
System.out.println("IT IS A PANGRAM");
else
System.out.println("IT IS NOT A PANGRAM");
String word = new String();
for(int i = 0; i < s.length(); i++){
char ch = s.charAt(i);
if(Character.isLetterOrDigit(ch))
word += ch;
else{
if(word.length() > longest.length())
longest = new String(word);
if(word.length() < shortest.length())
shortest = new String(word);
word = new String();
System.out.println("LONGEST WORD: " + longest);
System.out.println("SHORTEST WORD: " + shortest);
}
}
ROWS PROGRAM
Start
Input matrix dimensions M and N:
Prompt the user to input:
o M (number of rows in the matrix).
o N (number of columns in the matrix).
Validate the dimensions:
Check if M and N are in the range [3, 9]:
o If not, print "SIZE IS OUT OF RANGE. INVALID ENTRY." and terminate the
program.
Input matrix elements:
Initialize a 2D array mat[M][N].
Prompt the user to enter M × N elements:
o Store these elements in the matrix mat.
Display the original matrix:
Call the display method to print the matrix in tabular form.
Rotate the matrix rows upward:
Store the first row of the matrix in a temporary array a[N].
For each row starting from the second:
o Copy the elements of the row into the previous row.
Replace the last row of the matrix with the elements of a.
Display the rotated matrix:
Call the display method to print the matrix after rotation.
Find the highest element in the matrix:
Initialize r = 0 and c = 0 to store the row and column indices of the highest
element.
Iterate through all elements of the matrix:
o If the current element is greater than the element at mat[r][c]:
Update r and c with the indices of the current element.
Display the highest element:
Print the value of the highest element along with its row and column indices.
End
import java.util.Scanner;
class ShiftRows{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print("M = ");
int m = Integer.parseInt(in.nextLine());
System.out.print("N = ");
int n = Integer.parseInt(in.nextLine());
if(m < 3 || m > 9 || n < 3 || n > 9){
System.out.println("SIZE IS OUT OF RANGE. INVALID ENTRY.");
return;
int mat[][] = new int[m][n];
int r = 0;
int c = 0;
System.out.println("ENTER ELEMENTS IN THE MATRIX:");
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
mat[i][j] = Integer.parseInt(in.nextLine());
System.out.println("ORIGINAL MATRIX:");
display(mat);
int a[] = new int[n];
for(int i = 0; i < n; i++)
a[i] = mat[0][i];
for(int i = 1; i < m; i++){
for(int j = 0; j < n; j++){
mat[i - 1][j] = mat[i][j];
for(int i = 0; i < n; i++)
mat[m - 1][i] = a[i];
System.out.println("FORMED MATRIX AFTER ROTATING:");
display(mat);
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
if(mat[i][j] > mat[r][c]){
r = i;
c = j;
System.out.print("HIGHEST ELEMENT: " + mat[r][c]);
System.out.println(" (Row: " + r + " and Column: " + c + ")");
public static void display(int mat[][]){
for(int i = 0; i < mat.length; i++){
for(int j = 0; j < mat[0].length; j++){
System.out.print(mat[i][j] + "\t");
System.out.println();
