ISC COMPUTER

THEORY QUESTION
PAPER
PROGRAMMING
QUESTIONS
WITH SOLUTION
2019-2010

By KeepKoding
Question 7 2019
DESIGN A CLASS ARMNUM TO CHECK IF A GIVEN NUMBER IS AN ARMSTRONG NUMBER OR NOT.
[A NUMBER IS SAID TO BE ARMSTRONG IF SUM OF ITS DIGITS RAISED TO THE POWER OF
LENGTH OF THE NUMBER IS EQUAL TO THE NUMBER]
EXAMPLE : 371 = 33 + 73 + 13
1634 = 14 + 64 + 34 + 44
54748 = 55 + 45 + 75 + 45 + 85
THUS 371, 1634 AND 54748 ARE ALL EXAMPLES OF ARMSTRONG NUMBERS.
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASS NAME:ARMNUM
DATA MEMBERS/INSTANCE VARIABLES:
N:TO STORE THE NUMBER
L:TO STORE THE LENGTH OF THE NUMBER
METHODS/MEMBER FUNCTIONS:
ARMNUM (INT NN):PARAMETERIZED CONSTRUCTOR TO INITIALIZE THE DATA MEMBER N=NN
INT SUM_POW(INT I):RETURNS THE SUM OF EACH DIGIT RAISED TO THE POWER OF THE LENGTH
OF THE NUMBER USING RECURSIVE TECHNIQUE
EG. 34 WILL RETURN 32 + 42 (AS THE LENGTH OF THE NUMBER IS 2)
VOID ISARMSTRONG( ):CHECKS WHETHER THE GIVEN NUMBER IS AN ARMSTRONG NUMBER BY
INVOKING THE FUNCTION SUM_POW() AND DISPLAYS THE RESULT WITH AN APPROPRIATE
MESSAGE
SPECIFY THE CLASS ARMNUM GIVING DETAILS OF THE CONSTRUCTOR( ), INT SUM_POW(INT)
AND VOID ISARMSTRONG( ). DEFINE A MAIN( ) FUNCTION TO CREATE AN OBJECT AND CALL THE
FUNCTIONS ACCORDINGLY TO ENABLE THE TASK
Answer 2019

import java.util.Scanner;
public class ArmNum
{
int n,l;

ArmNum(int nn)
{
n=nn;
l=Integer.toString(n).length();
}

int sum_pow(int i)
{
if(i==0)
{
return 0;
}
else
{
return (int)Math.pow(i%10,l) + sum_pow(i/10);
}
}

void isArmstrong()
{
if(sum_pow(n)==n)
{
System.out.println(n + " is an Armstrong number");
}
else
{
System.out.println(n + "is not an Armstrong number");
}
}
 2019

public static void main()

{
Scanner sc=new Scanner(System.in);
System.out.println("ENTER THE NUMBER");
int num=sc.nextInt();
ArmNum ob1=new ArmNum(num);
ob1.isArmstrong();
}
}
Question 8 2019
DESIGN A CLASS MATREV TO REVERSE EACH ELEMENT OF A MATRIX.

72 371 5
12 6 426
5 123 94

BECOMES

27 173 5
21 6 624
5 321 49

SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:

CLASS NAME:MATREV
DATA MEMBERS/INSTANCE VARIABLES:
ARR[ ][ ]:TO STORE INTEGER ELEMENTS
M:TO STORE THE NUMBER OF ROWS
N:TO STORE THE NUMBER OF COLUMNS
MEMBER FUNCTIONS/METHODS:
MATREV(INT MM, INT NN):PARAMETERISED CONSTRUCTOR TO INITIALISE THE DATA MEMBERS
M = MM AND N = NN
VOID FILLARRAY( ):TO ENTER ELEMENTS IN THE ARRAY
INT REVERSE(INT X): RETURNS THE REVERSE OF THE NUMBER X
VOID REVMAT( MATREV P):REVERSES EACH ELEMENT OF THE ARRAY OF THE PARAMETERIZED
OBJECT AND STORES IT IN THE ARRAY OF THE CURRENT OBJECT
VOID SHOW( ):DISPLAYS THE ARRAY ELEMENTS IN MATRIX FORM
DEFINE THE CLASS MATREV GIVING DETAILS OF THE CONSTRUCTOR( ), VOID FILLARRAY( ), INT
REVERSE(INT), VOID REVMAT(MATREV) AND VOID SHOW( ). DEFINE THE MAIN( ) FUNCTION TO
CREATE OBJECTS AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2019

import java.util.Scanner;
public class MatRev
{
int arr[][],m,n;
Scanner sc=new Scanner(System.in);

MatRev(int mm,int nn)

{
m=mm;
n=nn;
arr=new int[m][n];
}

void fillarray()
{
System.out.println("ENTER ELEMENTS IN ARRAY");
for(int i=0;i< m;i++)
{
for(int j=0 ;j< n;j++)
{
arr[i][j]=sc.nextInt();
}
}
}

int reverse(int x)
{
int rev=0, rem=0;
while(x!=0)
{
rem=x% 10;
rev=rev*10 + rem;
x=x/ 10;
}
return rev;
}
 2019

void revMat(MatRev P)
{
for(int i=0;i< m;i++)
{
for(int j=0 ;j< n;j++)
{
arr[i][j]=reverse(P.arr[i][j]);
}
}
}

void show()
{
for(int i=0;i< m;i++)
{
for(int j=0 ;j< n;j++)
{
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}

public static void main()

{
Scanner sc1=new Scanner(System.in);
System.out.println("ENTER NUMBER OF ROWS OF MATRIX");
int row=sc1.nextInt();
System.out.println("ENTER NUMBER OF COLUMNS OF MATRIX");
int col=sc1.nextInt();
MatRev ob1 = new MatRev(row,col);
MatRev ob2=new MatRev(row,col);
ob1.fillarray();
System.out.println("Original Array");
ob1.show();
ob2.revMat(ob1);
System.out.println(" Reverse array");
 2019

ob2.show();
}
}
Question 9 2019
A CLASS REARRANGE HAS BEEN DEFINED TO MODIFY A WORD BY BRINGING ALL THE VOWELS IN
THE
WORD AT THE BEGINNING FOLLOWED BY THE CONSONANTS.
EXAMPLE: ORIGINAL BECOMES OIIARGNL
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASS NAME:REARRANGE
DATA MEMBER/INSTANCE VARIABLE:
WRD:TO STORE A WORD
NEWWRD:TO STORE THE REARRANGED WORD
MEMBER FUNCTIONS/METHODS:
REARRANGE( ):DEFAULT CONSTRUCTOR
VOID READWORD( ):TO ACCEPT THE WORD IN UPPER CASE
VOID FREQ_VOW_CON( ):FINDS THE FREQUENCY OF VOWELS AND CONSONANTS IN THE WORD
AND DISPLAYS THEM WITH AN APPROPRIATE MESSAGE
VOID ARRANGE( ):REARRANGES THE WORD BY BRINGING THE VOWELS AT THE BEGINNING
FOLLOWED BY CONSONANTS
VOID DISPLAY( ):DISPLAYS THE ORIGINAL WORD ALONG WITH THE REARRANGED WORD
SPECIFY THE CLASS REARRANGE, GIVING THE DETAILS OF THE CONSTRUCTOR( ), VOID
READWORD( ), VOID FREQ_VOW_CON( ), VOID ARRANGE( ) AND VOID DISPLAY( ). DEFINE THE
MAIN( ) FUNCTION TO CREATE AN OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE
THE TASK.
Answer 2019

import java.util.Scanner;
public class Rearrange
{
String wrd,newwrd;
Scanner sc=new Scanner(System.in);
Rearrange()
{
wrd="";
newwrd="";
}

void readword()
{
System.out.println("Enter a word" );
wrd=sc.next();
wrd=wrd.toUpperCase();
}

void freq_vow_con()
{
int vowelFrequency=0,consonantFrequency=0;
char ch=' ';
for(int i=0;i< wrd.length();i++)
{
ch=wrd.charAt(i);
if(ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U')
{
vowelFrequency++;
}
}
consonantFrequency= wrd.length()- vowelFrequency ;
System.out.println("vowels = "+ vowelFrequency);
System.out.println("consonants = " + consonantFrequency);
}
 2019

void arrange()
{
char ch=' ';
String vowel="",consonants="";
for(int i=0;i< wrd.length();i++)
{
ch=wrd.charAt(i);
if(ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U')
{
vowel=vowel+ch;
}
else
{
consonants =consonants+ch;
}
}
newwrd= vowel+consonants;
}

void display()
{
System.out.println("Original word = "+ wrd);
System.out.println("Rearranged word = "+ newwrd);
}

public static void main()

{
Rearrange ob1=new Rearrange();
ob1.readword();
ob1.freq_vow_con();
ob1.arrange();
ob1.display();
}
}
Question 10 2019
A SUPER CLASS RECORD CONTAINS NAMES AND MARKS OF THE STUDENTS IN TWO DIFFERENT
SINGLE DIMENSIONAL ARRAYS. DEFINE A SUB CLASS HIGHEST TO DISPLAY THE NAMES OF THE
STUDENTS OBTAINING THE HIGHEST MARKS.
THE DETAILS OF THE MEMBERS OF BOTH THE CLASSES ARE GIVEN BELOW:
CLASS NAME:RECORD
DATA MEMBER/INSTANCE VARIABLE:
N[ ]:ARRAY TO STORE NAMES
M[ ] : ARRAY TO STORE MARKS
SIZE:TO STORE THE NUMBER OF STUDENTS
MEMBER FUNCTIONS/METHODS:
RECORD(INT CAP):PARAMETERIZED CONSTRUCTOR TO INITIALIZE THE DATA MEMBER SIZE =
CAP
VOID READARRAY():TO ENTER ELEMENTS IN BOTH THE ARRAYS
VOID DISPLAY( ): DISPLAYS THE ARRAY ELEMENTS
CLASS NAME:HIGHEST
DATA MEMBER/INSTANCE VARIABLE:
IND:TO STORE THE INDEX
MEMBER FUNCTIONS/METHODS:
HIGHEST(...) :PARAMETERIZED CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS OF BOTH THE
CLASSES
VOID FIND( ):FINDS THE INDEX OF THE STUDENT OBTAINING THE HIGHEST MARK AND ASSIGN
IT TO ' IND'
VOID DISPLAY( ):DISPLAYS THE ARRAY ELEMENTS ALONG WITH THE NAMES AND MARKS OF THE
STUDENTS WHO HAVE OBTAINED THE HIGHEST MARK
ASSUME THAT THE SUPER CLASS RECORD HAS BEEN DEFINED. USING THE CONCEPT OF
INHERITANCE, SPECIFY THE CLASS HIGHEST GIVING THE DETAILS OF THE
CONSTRUCTOR(...),VOID FIND( ) AND VOID DISPLAY( ).
THE SUPER CLASS, MAIN FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2019

import java.util.Scanner;
public class Highest extends Record
{
int ind;
Highest(int cap)
{
super(cap);
ind=-1;
}

void find()
{
readarray();
int hm=m[0];
for (int i=0;i< size;i++)
{
if (m[i]>hm)
{
hm=m[i];
ind=i;
}
}
}

void display()
{
super.display();
for(int i=0;i< size;i++)
{
if(m[i]==m[ind])
{
System.out.println("Highest obtained by "+n[i]+" marks "+m[i]);
}
}
}
}
Question 11 2019
A LINEAR DATA STRUCTURE ENABLES THE USER TO ADD ADDRESS FROM REAR END AND REMOVE
ADDRESS FROM FRONT. DEFINE A CLASS DIARY WITH THE FOLLOWING DETAILS:
CLASS NAME:DIARY
DATA MEMBERS / INSTANCE VARIABLES:
Q[ ]:ARRAY TO STORE THE ADDRESSES
SIZE:STORES THE MAXIMUM CAPACITY OF THE ARRAY
START: TO POINT THE INDEX OF THE FRONT END
END:TO POINT THE INDEX OF THE REAR END
MEMBER FUNCTIONS:
DIARY (INT MAX):CONSTRUCTOR TO INITIALIZE THE DATA MEMBER SIZE=MAX, START=0 AND
END=0
VOID PUSHADD(STRING N):TO ADD ADDRESS IN THE DIARY FROM THE REAR END IF POSSIBLE,
OTHERWISE DISPLAY THE MESSAGE "NO
SPACE"
STRING POPADD( ):REMOVES AND RETURNS THE ADDRESS FROM THE FRONT END OF THE DIARY
IF ANY, ELSE RETURNS "?????"
VOID SHOW( ):DISPLAYS ALL THE ADDRESSES IN THE DIARY
(A)SPECIFY THE CLASS DIARY GIVING DETAILS OF THE FUNCTIONS VOID PUSHADD(STRING)
AND STRING POPADD( ).ASSUME THAT THE OTHER FUNCTIONS HAVE BEEN DEFINED.
THE MAIN FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2019

class Diary
{
String Q[];
int size, start, end;

void pushadd(String n)
{
if(end< size)
{
Q[end]=n;
end=end+1;
}
else
{
System.out.println(" NO SPACE");
}
}

String popadd()
{
if(start!=end)
{
return Q[start++];

}
else
{
return "?????";
}
}
}
Question 12 2019
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS NODE. THE CLASS STRUCTURE OF
THE
NODE IS GIVEN BELOW:

CLASS NODE

INT NUM;

NODE NEXT;

}
WRITE AN ALGORITHM OR A METHOD TO FIND AND DISPLAY THE SUM OF EVEN INTEGERS FROM
AN EXISTING LINKED LIST.
THE METHOD DECLARATION IS AS FOLLOWS:

VOID SUMEVENNODE( NODE STR )

Answer 2019

void SumEvenNode(Node str)

{
Node temp=str;
int s=0;
while(temp!=null )
{
if (temp.num%2==0)
{
s=s+temp.num;
}
temp=temp.next;
}
System.out.println("sum of even integers="+s);
}
Question 7 2018
DESIGN A CLASS PERFECT TO CHECK IF A GIVEN NUMBER IS A PERFECT NUMBER OR NOT. [ A
NUMBER IS SAID TO BE PERFECT IF SUM OF THE FACTORS OF THE NUMBER EXCLUDING ITSELF
IS EQUAL TO THE ORIGINAL NUMBER]
EXAMPLE : 6 = 1 + 2 + 3 (WHERE 1, 2 AND 3 ARE FACTORS OF 6, EXCLUDING ITSELF)
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASS NAME PERFECT
DATA MEMBERS/INSTANCE VARIABLES:
NUM:TO STORE THE NUMBER
METHODS/MEMBER FUNCTIONS:
PERFECT (INT NN):PARAMETERIZED CONSTRUCTOR TO INITIALIZE THE DATA MEMBER NUM=NN
INT SUM_OF_FACTORS(INT I):RETURNS THE SUM OF THE FACTORS OF THE NUMBER(NUM),
EXCLUDING ITSELF, USING RECURSIVE TECHNIQUE
VOID CHECK():CHECKS WHETHER THE GIVEN NUMBER IS PERFECT BY INVOKING THE FUNCTION
SUM_OF_FACTORS() AND DISPLAYS THE RESULT WITH AN APPROPRIATE MESSAGE
SPECIFY THE CLASS PERFECT GIVING DETAILS OF THE CONSTRUCTOR (), INT
SUM_OF_FACTORS(INT) AND VOID CHECK (). DEFINE A MAIN () FUNCTION TO CREATE AN
OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2018

import java.util.Scanner;
public class Perfect
{
int num;
Perfect(int nn)
{
num=nn;
}

int sum_of_factors(int i)
{
if (i == num)
{
return 0;
}
else if(num%i==0)
{
return i + sum_of_factors((i+ 1));
}
else
{
return sum_of_factors((i+ 1));
}
}

void check()
{
int s=sum_of_factors(1);
if (s==num)
{
System.out.println(num+"is a perfect number");
}
else
{
System. out.println(num+"is not a perfect number");
}
}
 2018

public static void main()

{
Scanner sc=new Scanner(System.in);
System.out.println("Enter a number");
int num=sc.nextInt() ;
Perfect ob1=new Perfect(num);
ob1.check();
}
}
Question 8 2018
TWO MATRICES ARE SAID TO BE EQUAL IF THEY HAVE THE SAME DIMENSION AND THEIR
CORRESPONDING
ELEMENTS ARE EQUAL.
FOR EXAMPLE, THE TWO MATRICES A AND B GIVEN BELOW ARE EQUAL:
MATRIX A
1 2 3

2 4 5

3 5 6

MATRIX B

27 173 5

21 6 624

5 321 49

DESIGN A CLASS EQMAT TO CHECK IF TWO MATRICES ARE EQUAL OR NOT. ASSUME THAT THE
TWO MATRICES HAVE THE SAME DIMENSION.
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASS NAME:EQMAT
DATA MEMBERS/INSTANCE VARIABLES:
A[ ][ ]:TO STORE INTEGER ELEMENTS
M:TO STORE THE NUMBER OF ROWS
N:TO STORE THE NUMBER OF COLUMNS
MEMBER FUNCTIONS/METHODS:
EQMAT(INT MM, INT NN): PARAMETERISED CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS M
= MM AND N = NN
VOID READARRAY( ):TO ENTER ELEMENTS IN THE ARRAY
INT CHECK(EQMAT P, EQMAT Q):CHECKS IF THE PARAMETERIZED OBJECTS P AND Q ARE EQUAL
AND RETURNS 1 IF TRUE, OTHERWISE RETURNS 0
VOID PRINT( ):DISPLAYS THE ARRAY ELEMENTS
DEFINE THE CLASS EQMAT GIVING DETAILS OF THE CONSTRUCTOR( ), VOID READARRAY( ), INT
CHECK(EQMAT, EQMAT) AND VOID PRINT( ). DEFINE THE MAIN( ) FUNCTION TO CREATE
OBJECTS AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2018

import java.util.Scanner;
public class EqMat
{
int a[][];
int m;
int n;
Scanner sc=new Scanner(System.in) ;
EqMat(int mm,int nn)
{
m=mm ;
n=nn;
a=new int[m][n];
}

void readarray()
{
System.out.println("enter" + (m*n) + "elements" );
for (int i=0;i< m;i++)
{
for (int j=0 ;j< n ;j++)
{
a[i][j]=sc.nextInt();
}
}
}

int check(EqMat P,EqMat Q)

{
for (int i=0;i< P.m;i++)
{
for (int j=0 ;j < P.n ;j++)
{
if (P.a[i][j]!=Q. a[i][j])
{
return 0;
}
}
 2018

}
return 1;
}

void print()
{
for (int i=0;i< m;i++)
{
for (int j=0 ;j < n ;j++)
{
System.out.print(a[i][j]+" ");
}
System.out.println();

}
}

public static void main()

{
Scanner sc1=new Scanner(System.in);
System.out.println("ENTER NUMBER OF ROWS OF MATRIX");
int row=sc1.nextInt();
System.out.println("ENTER NUMBER OF COLUMNS OF MATRIX");
int col=sc1.nextInt();
EqMat ob1=new EqMat(row,col) ;
EqMat ob2=new EqMat(row,col) ;
System.out.println("enter nos for the 1st Matrix");
ob1.readarray();
System.out.println("enter nos for the 2nd Matrix");
ob2.readarray();
if(ob1.check(ob1,ob2)==1)
{
System.out.println("Equal Matrix") ;
ob1.print();
ob2.print();
}
 2018

else
{
System.out.println("not equal");
}
}
}
Question 9 2018
A CLASS CAPITAL HAS BEEN DEFINED TO CHECK WHETHER A SENTENCE HAS WORDS
BEGINNING WITH A CAPITAL LETTER OR NOT.
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASS NAME:CAPITAL
DATA MEMBER/INSTANCE VARIABLE:
SENT:TO STORE A SENTENCE
FREQ :STORES THE FREQUENCY OF WORDS BEGINNING WITH A CAPITAL LETTER
MEMBER FUNCTIONS/METHODS:
CAPITAL( ):DEFAULT CONSTRUCTOR
VOID INPUT():TO ACCEPT THE SENTENCE
BOOLEAN ISCAP(STRING W):CHECKS AND RETURNS TRUE IF WORD BEGINS WITH A CAPITAL
LETTER, OTHERWISE RETURNS FALSE
VOID DISPLAY ():DISPLAYS THE SENTENCE ALONG WITH THE FREQUENCY OF THE WORDS
BEGINNING WITH A CAPITAL LETTER
SPECIFY THE CLASS CAPITAL, GIVING THE DETAILS OF THE CONSTRUCTOR( ), VOID INPUT( ),
BOOLEAN ISCAP(STRING) AND VOID DISPLAY( ). DEFINE THE MAIN( ) FUNCTION TO CREATE AN
OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2018

import java.util.Scanner;
public class Capital
{
String sent;
int freq;
Capital()
{
sent="";
freq=0;
}

void input()
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter the sentence");
sent=sc.nextLine();
sent=sent+" ";
}

boolean isCap(String w)
{
char ch=w.charAt(0) ;
if (Character.isUpperCase(ch)==true)
{
return true;
}
else
{
return false;
}
}

void display()
{
System.out.println("Original sentence="+sent);
String wd="";
char ch=' ';
 2018

for (int i=0;i< sent.length();i++)

{
ch=sent.charAt(i);
if(ch==' ')
{
if(isCap(wd)==true)
{
freq=freq+1;
}
wd="";
}
else
{
wd=wd+ch;
}
}

System.out.println("Freqency ofword with first letter a Capital letter ="+freq) ;

}

public static void main()

{
Capital ob1=new Capital();
ob1.input();
ob1.display() ;
}
}
Question 10 2018
A SUPER CLASS NUMBER IS DEFINED TO CALCULATE THE FACTORIAL OF A NUMBER. DEFINE A
SUB CLASS SERIES TO FIND THE SUM OF THE SERIES S = 1! + 2! + 3 ! + 4!+ . . . . . . . . . ... . ..+N!
THE DETAILS OF THE MEMBERS OF BOTH THE CLASSES ARE GIVEN BELOW:
CLASS NAME:NUMBER
DATA MEMBER/INSTANCE VARIABLE:
N:TO STORE AN INTEGER NUMBER
MEMBER FUNCTIONS/METHODS:
NUMBER(INT NN):PARAMETERIZED CONSTRUCTOR TO INITIALIZE THE DATA MEMBER N=NN
INT FACTORIAL (INT A):RETURNS THE FACTORIAL OF A NUMBER (FACTORIAL OF N = 1X 2X 3 X . .
. . . . . . . X N)
VOID DISPLAY():DISPLAYS THE DATA MEMBERS
CLASS NAME:SERIES
DATA MEMBER/INSTANCE VARIABLE:
SUM:TO STORE THE SUM OF THE SERIES
MEMBER FUNCTIONS/METHODS:
SERIES( . . .):PARAMETERIZED CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS OF BOTH THE
CLASSES
VOID CALSUM( ):CALCULATES THE SUM OF THE GIVEN SERIES
VOID DISPLAY( ):DISPLAYS THE DATA MEMBERS OF BOTH THE CLASSES
ASSUME THAT THE SUPER CLASS NUMBER HAS BEEN DEFINED. USING THE CONCEPT OF
INHERITANCE, SPECIFY THE CLASS SERIES GIVING THE DETAILS OF THE CONSTRUCTOR( . . .),
VOID CALSUM( ) AND VOID DISPLAY( ).
THE SUPER CLASS, MAIN FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2018

class Series extends Number

{
long sum;
Series(int nn)
{
super(nn);
sum=0;
}

void calsum()
{
for (int i= l ;i<=n;i++)
{
/*Factorial() already defined in class Number*/
sum=sum+factorial(i);
}
}

void display()
{
super.display() ;
System.out.println("sum of the series="+sum) ;
}
}
Question 11 2018
REGISTER IS AN ENTITY WHICH CAN HOLD A MAXIMUM OF 100 NAMES. THE REGISTER ENABLES
THE USER TO ADD AND REMOVE NAMES FROM THE TOP MOST END ONLY.
DEFINE A CLASS REGISTER WITH THE FOLLOWING DETAILS:
CLASS NAME:REGISTER
DATA MEMBERS / INSTANCE VARIABLES:
STUD[ ]:ARRAY TO STORE THE NAMES OF THE STUDENTS
CAP:STORES THE MAXIMUM CAPACITY OF THE ARRAY
TOP: TO POINT THE INDEX OF THE TOP END
MEMBER FUNCTIONS:
REGISTER (INT MAX):CONSTRUCTOR TO INITIALIZE THE DATA MEMBER CAP = MAX, TOP = -1
AND CREATE THE STRING ARRAY
VOID PUSH(STRING N):TO ADD NAMES IN THE REGISTER AT THE TOP LOCATION IF POSSIBLE,
OTHERWISE DISPLAY THE MESSAGE "OVERFLOW"
STRING POP():REMOVES AND RETURNS THE NAMES FROM THE TOP MOST LOCATION OF THE
REGISTER IF ANY, ELSE RETURNS "$"
VOID DISPLAY():DISPLAYS ALL THE NAMES IN THE REGISTER
(A)SPECIFY THE CLASS REGISTER GIVING DETAILS OF THE FUNCTIONS VOID PUSH(STRING)
AND STRING POP( ). ASSUME THAT THE OTHER FUNCTIONS HAVE BEEN DEFINED .
THE MAIN FUNCTION AND ALGORITHM NEED NOT BE WRITTEN .
Answer 2018

public class Register

{
void push(String n)
{
if (top< cap-1)
{
top=top+1;
stud[top]=n;

}
else
{
System.out.println("OVERFLOW");
}
}

String pop()
{
if (top>=0)
{
return stud[top--];
}
else
{
return " $$";
}
}
}
Question 12 2018
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS NODE. THE CLASS STRUCTURE OF
THE NODE IS GIVEN BELOW:
CLASS NODE
{
INT N;
NODE LINK;
}
WRITE AN ALGORITHM OR A METHOD TO SEARCH FOR A NUMBER FROM AN EXISTING LINKED
LIST. THE METHOD DECLARATION IS AS FOLLOWS:
VOID FINDNODE( NODE STR, INT B )
Answer 2018

void FindNode(Node str, int b)

{
Node temp=str;
while(temp!=null)
{
if (temp.n == b)
{
System.out.prinln(b+" is found ");
break;
}
temp=temp.link;
}
}
Question 7 2017
CLASS PALIN HAS BEEN DEFINED TO CHECK WHETHER A POSITIVE NUMBER IS A PALINDROME
NUMBER OR NOT.
THE NUMBER 'N ' IS PALINDROME IF THE ORIGINAL NUMBER AND ITS REVERSE ARE SAME.
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASS NAME:PALIN
DATA MEMBERS/INSTANCE VARIABLES:
NUM: INTEGER TO STORE THE NUMBER
REVNUM:INTEGER TO STORE THE REVERSE OF THE NUMBER
METHODS/MEMBER FUNCTIONS:
PALIN( ):CONSTRUCTOR TO INITIALIZE DATA MEMBERS WITH LEGAL INITIAL VALUES
VOID ACCEPT( ):TO ACCEPT THE NUMBER
INT REVERSE(INT Y):REVERSES THE PARAMETERIZED ARGUMENT 'Y' AND STORES IT IN
'REVNUM' USING RECURSIVE TECHNIQUE
VOID CHECK( ):CHECKS WHETHER THE NUMBER IS A PALINDROME BY INVOKING THE FUNCTION
REVERSE( ) AND DISPLAY THE RESULT WITH AN APPROPRIATE MESSAGE
SPECIFY THE CLASS PALIN GIVING THE DETAILS OF THE CONSTRUCTOR ( ), VOID ACCEPT( ),INT
REVERSE( INT ) AND VOID CHECK( ). DEFINE THE MAIN( ) FUNCTION TO CREATE AN OBJECT AND
CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2017

import java. util.Scanner;

public class Palin
{
int num,revnum;
Scanner sc=new Scanner(System.in);
Palin()
{
num=0;
revnum=0;
}

void accept()
{
System.out.println( "Enter a number") ;
num=sc.nextInt();
}

int reverse( int y)

{
if(y>0)
{
revnum =revnum * 10 + (y%10);
return reverse(y/10);
}
else
{
return revnum;
}
}

void check()
{

if( num==reverse(num))
{
System.out.println(num+" is palindrome number") ;
}
 2017

else
{
System.out.println(num +" is not a palindrome number") ;
}
}

public static void main()

{
Palin ob1=new Palin();
ob1.accept() ;
ob1.check() ;
}
}
Question 8 2017
A CLASS ADDER HAS BEEN DEFINED TO ADD ANY TWO ACCEPTED TIME.
EXAMPLE: TIME A - 6 HOURS 35 MINUTES
TIME B - 7 HOURS 45 MINUTES
THEIR SUM IS - 14 HOURS 20 MINUTES ( WHERE 60 MINUTES = 1 HOUR)
THE DETAILS OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASS NAME:ADDER
DATA MEMBER/INSTANCE VARIABLE:
A[ ]:INTEGER ARRAY TO HOLD TWO ELEMENTS (HOURS AND MINUTES)
MEMBER FUNCTIONS/METHODS:
ADDER( ):CONSTRUCTOR TO ASSIGN 0 TO THE ARRAY ELEMENTS
VOID READTIME():TO ENTER THE ELEMENTS OF THE ARRAY
VOID ADDTIME( ADDER X, ADDER Y):ADDS THE TIME OF THE TWO PARAMETERIZED OBJECTS X
AND Y AND STORES THE SUM IN THE CURRENT CALLING OBJECT
VOID DISPTIME( ):DISPLAYS THE ARRAY ELEMENTS WITH AN APPROPRIATE MESSAGE (I.E.
HOURS = AND MINUTES = )
SPECIFY THE CLASS ADDER GIVING DETAILS OF THE CONSTRUCTOR( ), VOID READTIME( ), VOID
ADDTIME(ADDER, ADDER) AND VOID DISPTIME( ). DEFINE THE MAIN( ) FUNCTION TO CREATE
OBJECTS AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2017

import java. util.Scanner;

public class Adder
{
int a[]=new int[2];
Scanner sc=new Scanner( System.in);
Adder()
{
a[0]=0;
a[1]=0;
}

void readtime()
{
System.out.println("Enter hours and minutes");
a[0]=sc. nextInt();
a[1]=sc. nextInt();
}

void disptime()
{
System. out.println("Hours=" + a[0]);
System.out.println("Minutes="+ a[ 1]);
}

void addtime(Adder X,Adder Y)

{
/* adds minutes */
a[1]=X.a[1] + Y.a[1];
/*if minutes is greater than 60 than add hours(a[1]/60) to a[0] position*/
if(a[1]>=60)
{
a[0]=a[1]/60;
a[1]=a[1]%60;
}
a[0] += X.a[0] + Y.a[0];
}
 2017

public static void main()

{
Adder ob1=new Adder();
Adder ob2=new Adder();
Adder ob3=new Adder();
ob1.readtime();
ob2.readtime() ;
ob3.addtime(ob1,ob2);
ob3.disptime();
}

}
Question 9 2017
A CLASS SWAPSORT HAS BEEN DEFINED TO PERFORM STRING RELATED OPERATIONS ON A
WORD INPUT. SOME OF THE MEMBERS OF THE CLASS ARE AS FOLLOWS:
CLASS NAME SWAPSORT
DATA MEMBERS/INSTANCE VARIABLES:
WRD:TO STORE A WORD
LEN:INTEGER TO STORE LENGTH OF THE WORD
SWAPWRD: TO STORE THE SWAPPED WORD
SORTWRD:TO STORE THE SORTED WORD
MEMBER FUNCTIONS/METHODS:
SWAPSORT( ):DEFAULT CONSTRUCTOR TO INITIALIZE DATA MEMBERS WITH LEGAL INITIAL
VALUES
VOID READWORD( ):TO ACCEPT A WORD IN UPPER CASE
VOID SWAPCHAR( ):TO INTERCHANGE/SWAP THE FIRST AND LAST CHARACTERS OF THE WORD
IN 'WRD' AND STORES THE NEW WORD IN 'SWAPWRD'
VOID SORTWORD( ):SORTS THE CHARACTERS OF THE ORIGINAL WORD IN ALPHABETICAL ORDER
AND STORES IT IN 'SORTWRD'
VOID DISPLAY( )DISPLAYS THE ORIGINAL WORD, SWAPPED WORD AND THE SORTED WORD
SPECIFY THE CLASS SWAPSORT, GIVING THE DETAILS OF THE CONSTRUCTOR( ), VOID
READWORD( ), VOID SWAPCHAR( ), VOID SORTWORD( ) AND VOID DISPLAY( ). DEFINE THE MAIN(
) FUNCTION TO CREATE AN OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE
TASK.
Answer 2017

import java .util.Scanner;

public class SwapSort
{
String wrd,swapwrd,sortwrd;
int len;
Scanner sc=new Scanner(System.in) ;
SwapSort()
{
swapwrd="" ;
sortwrd=" ";
len=0;
wrd="";
}

void readword()
{
System.out.println("Enterword in Upper case");
wrd=sc.next() ;
len=wrd.length();
wrd=wrd.toUpperCase();
}

void swapchar()
{
/*add last character of word to swapwrd*/
swapwrd=swapwrd+wrd.charAt(len-1);
/*add characters between first and last character of word to swapwrd*/
swapwrd=swapwrd+ wrd.substring(1,len-1);
/*add first character to swapwrd*/
swapwrd=swapwrd + wrd.charAt(0);
}
 2017

void sortword()
{
char ch1;
for(char ch='A' ;ch<='Z';ch++)
{
for(int i=0 ;i < len;i++)
{
ch1=wrd.charAt(i);
if(ch1==ch)
{
sortwrd += ch1;
}
}
}
}

void display()
{
System.out.println("Originalword = " + wrd);
System.out.println("Swappedword = " + swapwrd);
System.out.println("Sortedword = " + sortwrd);
}

public static void main()

{
SwapSort ob1=new SwapSort();
ob1.readword() ;
ob1.swapchar();
ob1.sortword();
ob1.display();
}
}
Question 10 2017
A SUPER CLASS PRODUCT HAS BEEN DEFINED TO STORE THE DETAILS OF A PRODUCT SOLD BY A
WHOLESALER TO A RETAILER. DEFINE A SUB CLASS SALES TO COMPUTE THE TOTAL AMOUNT
PAID BY THE RETAILER WITH OR WITHOUT FINE ALONG WITH SERVICE TAX.
SOME OF THE MEMBERS OF BOTH THE CLASSES ARE GIVEN BELOW:
CLASS NAME:PRODUCT
DATA MEMBER/INSTANCE VARIABLE:
NAME:STORES THE NAME OF THE PRODUCT INTEGER
CODE: TO STORE THE PRODUCT CODE
AMOUNT:STORES THE TOTAL SALE AMOUNT OF THE PRODUCT (IN DECIMALS)
MEMBER FUNCTIONS/METHODS:
PRODUCT(STRING N, INT C, DOUBLE P):PARAMETERIZED CONSTRUCTOR TO ASSIGN DATA
MEMBERS NAME=N, CODE=C AND AMOUNT = P
VOID SHOW( ) :DISPLAYS THE DETAILS OF THE DATA MEMBERS SALES
CLASS NAME:SALES
DATA MEMBER/INSTANCE VARIABLE:
DAY:STORES NUMBER OF DAYS TAKEN TO PAY THE SALE AMOUNT
TAX:TO STORE THE SERVICE TAX (IN DECIMALS)
TOTAMT: TO STORE THE TOTAL AMOUNT (IN DECIMALS)
MEMBER FUNCTIONS/METHODS:
SALES(...):PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUES TO DATA MEMBERS OF BOTH THE
CLASSES
VOID COMPUTE( ):CALCULATES THE SERVICE TAX @ 12.4% OF THE ACTUAL SALE AMOUNT
CALCULATES THE FINE @ 2.5% OF THE ACTUAL SALE AMOUNT ONLY IF THE AMOUNT PAID BY
THE RETAILER TO THE WHOLESALER EXCEEDS 30 DAYS
CALCULATES THE TOTAL AMOUNT PAID BY THE RETAILER AS (ACTUAL SALE AMOUNT + SERVICE
TAX + FINE)
VOID SHOW( ):DISPLAYS THE DATA MEMBERS OF SUPER CLASS AND THE TOTAL AMOUNT
ASSUME THAT THE SUPER CLASS PRODUCT HAS BEEN DEFINED. USING THE CONCEPT OF
INHERITANCE, SPECIFY THE CLASS SALES GIVING THE DETAILS OF THE CONSTRUCTOR( ...),
VOID COMPUTE( ) AND VOID SHOW( ).
THE SUPER CLASS, MAIN FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2017

public class Sales extends Product

{
int day;
double tax,totamt;
Sales( String n,int a, double b, int d)
{
super(n,a,b);
day=d;
}

void compute()
{
double f=0.0;
tax= (12.4 / 100) * amount;
if(day>30)
{
f=(2.5/ 100)* amount;
}
totamt= amount+tax+f ;
}

void show()
{
super.show();
System.out.println("No of days=" + day);
System.out.println("SalesTax=" + tax);
System.out.println("Total Amount=" + totamt );
}
}
Question 11 2017
QUEUE IS AN ENTITY WHICH CAN HOLD A MAXIMUM OF 100 INTEGERS . THE QUEUE ENABLES
THE USER TO ADD INTEGERS FROM THE REAR AND REMOVE INTEGERS FROM THE FRONT.
DEFINE A CLASS QUEUE WITH THE FOLLOWING DETAILS:
CLASS NAME QUEUE
DATA MEMBERS / INSTANCE VARIABLES:
QUE[ ] :ARRAY TO HOLD THE INTEGER ELEMENTS
SIZE : STORES THE SIZE OF THE ARRAY
FRONT:TO POINT THE INDEX OF THE FRONT
REAR:TO POINT THE INDEX OF THE REAR
MEMBER FUNCTIONS:
QUEUE (INT MM):CONSTRUCTOR TO INITIALIZE THE DATA SIZE = MM, FRONT = 0, REAR = 0
VOID ADDELE(INT V ):TO ADD INTEGER FROM THE REAR IF POSSIBLE ELSE DISPLAY THE
MESSAGE "OVERFLOW"
INT DELELE( ):RETURNS ELEMENTS FROM FRONT IF PRESENT, OTHERWISE DISPLAYS THE
MESSAGE "UNDERFLOW " AND RETURN -9999
VOID DISPLAY ( ):DISPLAYS THE ARRAY ELEMENTS
SPECIFY THE CLASS QUEUE GIVING DETAILS OF ONLY THE FUNCTIONS VOID ADDELE(INT) AND
INT DELELE( ). ASSUME THAT THE OTHER FUNCTIONS HAVE BEEN DEFINED.
THE MAIN FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2017

public class Queue

{

void addele(int v)
{
if(r< size)
{
Que[r]=v;
r=r+1;
}
else
{
System.out.println(" Overflow");
}
}

int delele()
{
if(f==r)
{
System.out.println("UnderFlow");
return -9999;

}
else
{
return Que[f++];
}
}
}
Question 12 2017
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS NODE. THE CLASS STRUCTURE OF
THE NODE IS GIVEN BELOW:
CLASS NODE
{
INT NUM;
NODE NEXT;
}
WRITE AN ALGORITHM OR A METHOD TO COUNT THE NODES THAT CONTAIN ONLY ODD
INTEGERS FROM AN EXISTING LINKED LIST AND RETURNS THE COUNT.
THE METHOD DECLARATION IS AS FOLLOWS:
INT COUNTODD( NODE STARTPTR )
Answer 2017

int CountOdd(Node startPtr)

{
int c=0;
Node temp=startPtr;
while(temp != null)
{
if (temp.num % 2 != 0)
{
c++;
}
temp=temp.next;
}
return c;
}
Question 7 2016
A DISARIUM NUMBER IS A NUMBER IN WHICH THE SUM OF THE DIGITS TO THE POWER OF THEIR
RESPECTIVE POSITION IS EQUAL TO THE NUMBER ITSELF.
EXAMPLE:135=11+32+53
HENCE,135 IS A DISARIUM NUMBER.
DESIGN A CLASS DISARIUM TO CHECK IF A GIVEN NUMBER IS A DISARIUM NUMBER OR NOT.
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASSNAME:DISARIUM
DATA MEMBERS/ INSTANCE VARIABLES:
INT NUM:STORES THE NUMBER
INT SIZE:STORES THE SIZE OF THE NUMBER
METHODS/MEMBER FUNCTIONS:
DISARIUM(INT NN):PARAMETERIZED CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS
NUM=NN AND SIZE=0
VOID COUNTDIGIT():COUNTS THE TOTAL NUMBER OF DIGITS AND ASSIGNS IT TO SIZE
INT SUMOFDIGITS(INT N,INT P):RETURNS THE SUM OF DIGITS OF THE NUMBER(N) TO THE
POWER OF THEIR RESPECTIVE POSITIONS(P) USING RECURSIVE TECHNIQUE
VOIDCHECK():CHECKS WHETHER THE NUMBER IS A DISARIUIM NUMBER AND DISPLAYS THE
RESULT WITH AN APPROPRIATE MESSAGE
SPECIFY THE CLASS DISARIUM GIVING THE DETAILS OF THE CONSTRUCTOR(),VOID
COUNTDIGIT(),INT SUMOFDIGITS(INT,INT) AND VOID CHECK().DEFINE THE MAIN() FUNCTION
TO CREATE AN OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2016

import java.util.Scanner;
public class Disarium
{
int num,size;

Disarium(int nn)
{
num=nn;
size=0;
}

void countDigits()
{
int temp=num;
while(temp>0)
{
temp=temp/10;
size++;
}
}

int sumofDigits(int n,int p)

{
if(n==0)
{
return 0;
}
else
{
return (int)Math.pow((n%10),p) +sumofDigits((n/10),(p-1));
}
}
 2016

void check()
{
if(sumofDigits(num,size)==num)
{
System.out.println(num+" is a Disarium number");
}
else
{
System.out.println(num+" is not a Disarium number");
}
}

public static void main()

{
Scanner sc=new Scanner(System.in);
System.out.println("Input a Number");
int number=sc.nextInt();
Disarium ob1=new Disarium(number);
ob1.countDigits();
ob1.check();
}
}
Question 8 2016
DESIGN THE CLASS SHIFT TO SHUFFLE THE MATRIX ( I.E. THE FIRST ROW BECOMES THE LAST ,
THE SECOND ROW BECOMES THE FIRST AND SO ON). THE DETAILS OF THE MEMBERS OF THE
CLASS IS GIVEN BELOW:
CLASSNAME:SHIFT
DATA MEMBER/INSTANCE VARIABLE:
MAT[ ][ ]:STORES THE ARRAY ELEMENT
M:INTEGER TO STORE THE NUMBER OF ROWS
N:INTEGER TO STORE THE NUMBER OF COLUMNS
MEMBER FUNCTIONS/METHODS:
SHIFT(INT MM,INT NN):PARAMETERIZED CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS
M=MM AND N=NN
VOID INPUT():ENTER THE ELEMENT OF THE ARRAY
VOID CYCLIC(SHIFT P):ENABLES THE MATRIX OF THE OBJECT(P) TO SHIFT EACH ROW UPWARDS
IN A CYCLIC MANNER AND STORE THE RESULTANT MATRIX IN THE CURRENT OBJECT
VOID DISPLAY():DISPLAYS THE MATRIX ELEMENTS
SPECIFY THE CLASS SHIFT GIVING DETAILS OF THE CONSTRUCTOR(),VOID INPUT(),VOID
CYCLIC(SHIFT) AND VOID DISPLAY(). DEFINE THE MAIN() FUNCTION TO CREATE AN OBJECT AND
CALL THE METHODS ACCORDINGLY TO ENABLE THE TASK OF SHIFTING THE ARRAY ELEMENTS.
Answer 2016

import java.util.Scanner;
public class Shift
{
Scanner sc=new Scanner(System.in);
int mat[][];
int m,n;
Shift(int mm,int nn)
{
m=mm;
n=nn;
mat=new int[m][n];
}

void input()
{
System.out.println("Enter elements of array");
for(int i=0;i< m;i++)
{
for(int j=0;j< n;j++)
{
mat[i][j]=sc.nextInt();
}
}
}

void display()
{
for(int i=0;i< m;i++)
{
for(int j=0;j< n;j++)
{
System.out.print(mat[i][j]+" ");
}
System.out.println();
}
}
 2016

void cyclic(Shift P)
{
for(int i=0;i< m;i++)
{
for(int j=0;j< n;j++)
{
if(i==0)
{
mat[m-1][j]=P.mat[0][j];
}
else
{
mat[i-1][j]=P.mat[i][j];
}
}
}
}

public static void main()

{
Scanner sc1=new Scanner(System.in);
System.out.println("ENTER THE NUMBER OF ROWS");
int r=sc1.nextInt();
System.out.println("ENTER THE NUMBER OF COLUMNS");
int c=sc1.nextInt();
Shift ob1=new Shift(r,c);
Shift ob2=new Shift(r,c);
ob1.input();
ob2.cyclic(ob1);
ob1.display();
ob2.display();
}
}
Question 9 2016
A CLASS CONSCHANGE HAS BEEN DEFINED WITH THE FOLLOWING DETAILS:
CLASS NAME:CONSCHANGE
DATA MEMBERS/ INSTANCE VARIABLES:
WORD:STORES THE WORD
LEN:STORES THE LENGTH OF THE WORD
MEMBER FUNCTIONS/METHODS:
CONSCHANGE():DEFAULT CONSTRUCTOR
VOID READWORD():ACCEPTS THE WORD IN LOWER CASE
VOID SHIFTCONS():SHIFTS ALL THE CONSONANTS OF THE WORD AT THE BEGINNING FOLLOWED
BY THE VOWELS(E.G.SPOON BECOMES SPNOO)
VOID CHANGEWORD():CHANGES THE CASE OF ALL OCCURING CONSONANTS OF THE SHIFTED
WORD TO UPPER CASE, FOR E.G.(SPNOO BECOMES SPNOO)
VOID SHOW():DISPLAYS THE ORIGINAL WORD,SHIFTED WORD AND THE CHANGED WORD
SPECIFY THE CLASS CONSCHANGE GIVING THE DETAILS OF THE CONSTRUCTOR( ), VOID
READWORD(), VOID SHIFTCONS(), VOID CHANGEWORD() AND VOID SHOW(). DEFINE THE MAIN()
FUNCTION TO CREATE AN OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE
TASK.
Answer 2016

import java.util.Scanner;
public class ConsChange
{
String word;
int len;
Scanner sc=new Scanner(System.in);

ConsChange()
{
len=0;
word="";
}

void readword()
{
System.out.println("Enter word in Lowercase");
word=sc.next();
len=word.length();
}

void shiftcons()
{
String consonants="",vowels="",sortedWord="";
char ch=' ';
for(int i=0;i< len;i++)
{
ch=word.charAt(i);
if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')
{
vowels+=ch;
}
else
{
consonants+=ch;
}
}
 2016

sortedWord=consonants+vowels;
System.out.println("Sorted Word="+sortedWord);
word=sortedWord;
}

void changeword()
{
char ch=' ';
String newWd="";
for(int i=0;i< len;i++)
{
ch=word.charAt(i);
if(ch!='a'&&ch!='e'&&ch!='i'&&ch!='o'&&ch!='u')
{
newWd+=Character.toUpperCase(ch);
}
else
{
newWd+=ch;
}
}
System.out.println("Changed word="+newWd);

void show()
{
System.out.println("Originalword="+word);
shiftcons();

changeword();
}
 2016

public static void main()

{
ConsChange ob1=new ConsChange();
ob1.readword();
ob1.show();
}
}
Question 10 2016
A SUPER CLASS BANK HAS BEEN DEFINED TO STORE THE DETAILS OF A CUSTOMER. DEFINE A
SUB-CLASS ACCOUNT THAT ENABLES TRANSACTIONS FOR THE CUSTOMER WITH THE BANK.
THE DETAILS OF BOTH THE CLASSES ARE GIVEN BELOW:
CLASSNAME:BANK
DATA MEMBER/INSTANCE VARIABLE:
NAME:STORES THE NAME OF THE CUSTOMER
ACCNO:STORES THE ACCOUNT NUMBER
P:STORES THE PRINCIPAL AMOUNT IN DECIMALS
MEMBERFUNCTIONS/METHODS:
BANK(...) :PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUES TO THE INSTANCE VARIABLES
VOID DISPLAY():DISPLAYS THE DETAILS OF THE CUSTOMER
CLASSNAME:ACCOUNT
DATA MEMBER/INSTANCE VARIABLE:
AMT:STORES THE TRANSACTION AMOUNT IN DECIMALS
MEMBER FUNCTIONS/METHODS:
ACCOUNT(...):PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUES TO THE INSTANCE
VARIABLES OF BOTH THE CLASSES
VOID DEPOSIT():ACCEPTS THE AMOUNT AND UPDATES THE PRINCIPAL AS P=P+AMT
VOID WITHDRAW( ):ACCEPTS THE AMOUNT AND UPDATES THE PRINCIPAL AS P=P-AMT
IF THE WITHDRAWAL AMOUNT IS MORE THAN THE PRINCIPAL AMOUNT , THEN DISPLAY THE
MESSAGE "INSUFFICIENT BALANCE". IF THE PRINCIPAL AMOUNT AFTER WITHDRAWAL IS LESS
THAN 500, THEN A PENALTY IS IMPOSED BY USING THE FORMULA
P=P-(500-P)/10
VOID DISPLAY():DISPLAYS THE DETAILS OF THE CUSTOMER
ASSUME THAT THE SUPER CLASS BANK HAS BEEN DEFINED. USING THE CONCEPT OF
INHERITANCE, SPECIFY THE CLASS ACCOUNT GIVING DETAILS OF THE CONSTRUCTOR(...), VOID
DEPOSIT( ),VOID WITHDRAW() AND VOID DISPLAY().
THE SUPER CLASS AND THE MAIN FUNCTION NEED NOT BE WRITTEN.
Answer 2016

import java.util.Scanner;
public class Account extends Bank
{
Scanner sc=new Scanner(System.in);
double amt;
Account(String n,String a,double pp)
{
super(n,a,pp);
amt=0.0;
}

void deposit()
{
System.out.println("Enter amount to deposit");
amt=sc.nextDouble();
p=p+amt;
}

void withdraw()
{
System.out.println("Enter amount to withdrawal");
amt=sc.nextDouble();
if(amt>p)
{
System.out.println("INSUFFICIENT BALANCE");
}
else
{
p=p-amt;
if(p< 500)
{
p=p-(500-p)/1O;
}
}
}
 2016

void display()
{
super.display();

}
Question 11 2016
A BOOKSHELF IS DESIGNED TO STORE THE BOOKS IN A STACK WITH LIFO(LASTINFIRSTOUT)
OPERATION. DEFINE A CLASS BOOK WITH THE FOLLOWING SPECIFICATIONS:
CLASSNAME:BOOK
DATA MEMBERS/INSTANCE VARIABLES:
NAME[ ]:STORES THE NAMES OF THE BOOKS
POINT:STORES THE INDEX OF THE TOP MOST BOOK
MAX:STORES THE MAXIMUM CAPACITY OF THE BOOKSHELF
METHODS/MEMBER FUNCTIONS:
BOOK(INT CAP):CONSTRUCTOR TO INITIALISE THE DATA MEMBERS MAX=CAP AND POINT=-1
VOID TELL():DISPLAYS THE NAME OF THE BOOK WHICH WAS LAST ENTERED IN THE SHELF.IF
THERE IS NO BOOK LEFT IN THE SHELF,DISPLAYS THE MESSAGE"SHELF EMPTY"
VOID ADD(STRING V):ADDS THE NAME OF THE BOOK TO THE SHELF IF POSSIBLE,OTHERWISE
DISPLAYS THE MESSAGE"SHELF FULL"
VOID DISPLAY():DISPLAYS ALL THE NAMES OF THE BOOKS AVAILABLE IN THE SHELF
SPECIFY THE CLASS BOOK GIVING THE DETAILS OF ONLY THE FUNCTIONS VOID TELL( ) AND
VOID ADD(STRING). ASSUME THAT THE OTHER FUNCTIONS HAVE BEEN DEFINED.
THE MAIN FUNCTION NEED NOT BE WRITTEN.
Answer 2016

public class Book

{
String name[];
int point,max;
Book(int cap)
{
max=cap;
point=-1;
name=new String[max];
}

void tell()
{
if(point< 0)
{
System.out.println("SHELF EMPTY");
}
else
{
System.out.println(name[point]);
}
}

void add(String v)
{
if(point< max-1)
{
name[++point]=v;
}
else
{
System.out.println("SHELF FULL");
}
}
 2016

void display()
{
for(int i=point;i>=0;i--)
{
System.out.println(name[i]);
}
}
}
Question 12 2016
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS ,
CLASS NODE
{
STRING NAME;
NODE NEXT;
}
WRITE A METHOD OR AN ALGORITHM TO SEARCH FOR A GIVEN NAME IN THE LINKED LIST .THE
METHOD DECLARATION IS SPECIFIED BELOW:
BOOLEAN SEARCHNAME(NODE START,STRING V);
Answer 2016

boolean searchName(Node start,String v)

{
Node temp=new Node(start);
while(temp!=null)
{
if(temp.name.equals(v)==true)
{
return true;
}
temp=temp.next;
}
return false;
}
Question 8 2015
A CLASS ADMISSION CONTAINS THE ADMISSION NUMBERS OF 100 STUDENTS. SOME OF THE
DATA MEMBERS / MEMBER FUNCTIONS ARE GIVEN BELOW:
CLASSNAME:ADMISSION
DATA MEMBER/ INSTANCE VARIABLE:
ADNO[ ]:INTEGER ARRAY TO STORE ADMISSION NUMBERS
MEMBER FUNCTIONS / METHODS:
ADMISSION():CONSTRUCTOR TO INITIALIZE THE ARRAY ELEMENTS
VOID FILLARRAY():TO ACCEPT THE ELEMENTS OF THE ARRAY IN ASCENDING ORDER
INT BINSEARCH:(INT L,INT U,INT V):TO SEARCH FOR A PARTICULAR ADMISSION NUMBER(V)
USING BINARY SEARCH AND RECURSIVE TECHNIQUE AND RETURNS 1 IF FOUND OTHERWISE
RETURNS -1
SPECIFY THE CLASS ADMISSION GIVING DETAILS OF THE CONSTRUCTOR, VOID FILLARRAY()
AND INT BINSEARCH(INT,INT, INT). DEFINE THE MAIN() FUNCTION TO CREATE AN OBJECT AND
CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2015

import java.util.Scanner;
public class Admission
{
Scanner sc=new Scanner(System.in);
int Adno[];
Admission()
{
Adno=new int[100];
}

void fillArray()
{
System.out.println("Enter 100 elements in ascending order");
for(int i=0;i< 100;i++)
{
Adno[i]=sc.nextInt();
}
}

int binSearch(int l,int u,int v)

{
int m=(l+u)/2;
if(Adno[m]==v)
{
return 1;
}
else if(l> u)
{
return -1;
}
else if(v>Adno[m])
{
return binSearch(m+1,u,v);

}
 2015

else
{
return binSearch(l,m-1,v);
}
}

public static void main()

{
Scanner sc1=new Scanner(System.in);
Admission ob1=new Admission();
ob1.fillArray();
System.out.println("Enter value to be searched");
int v=sc1.nextInt();
int p=ob1.binSearch(0,ob1.Adno.length-1,v);

if(p==-1)
{
System.out.println(v+" not found in the array");
}
else
{
System.out.println(v+" is found in the array");
}
}
}
Question 9 2015
A CLASS MERGER CONCATENATES TWO POSITIVE INTEGERS THAT ARE GREATER THAN 0 AND
PRODUCES A NEW MERGED INTEGER.
EXAMPLE:IF THE FIRST NUMBER IS 23 AND THE SECOND IS 764,THEN THE CONCATENATED
NUMBER WILL BE 23764.
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASSNAME:MERGER
DATA MEMBERS/INSTANCE VARIABLES:
N1:LONG INTEGER TO STORE FIRST NUMBER
N2:LONG INTEGER TO STORE SECOND NUMBER
MERGNUM:LONG INTEGER TO STORE MERGEDNUMBER
MEMBER FUNCTIONS:
MERGER():CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS
VOID READNUM():TO ACCEPT THE VALUES OF THE DATA MEMBERS N1 AND N2
VOID JOINNUM():TO CONCATENATE THE NUMBERS N1 AND N2 AND STORE IT IN MERGNUM
VOID SHOW():TO DISPLAY THE ORIGINAL NUMBERS AND THE MERGED NUMBER WITH
APPROPRIATE MESSAGES
SPECIFY THE CLASS MERGER,GIVING THE DETAILS OF THE CONSTRUCTOR,VOID
READNUM(),VOID JOINNUM() AND VOID SHOW( ) . DEFINE THE MAIN() FUNCTION TO CREATE AN
OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2015

import java.util.Scanner;
public class Merger
{
long nl,n2,mergNum;
Merger()
{
nl=n2=mergNum=0;
}

void readNum()
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter two numbers");
nl=sc.nextLong();
n2=sc.nextLong();
}

void JoinNum()
{
String s1=Long.toString(nl);
String s2=Long.toString(n2);
String s3=s1+s2;
mergNum=Long.valueOf(s3);
}

void show()
{
System.out.println("First Number="+nl);
System.out.println("Second Number="+n2);
System.out.println("Merged Number="+mergNum);
}
 2015

public static void main()

{
Merger ob1=new Merger();
ob1.readNum();
ob1.JoinNum();
ob1.show();
}
}
Question 10 2015
A CLASS THESTRING ACCEPTS A STRING OF A MAXIMUM OF 100 CHARACTERS WITH ONLY ONE
BLANK SPACE BETWEEN THE WORDS.
SOME OF THE MEMBERS OF THE CLASS ARE AS FOLLOWS:
CLASSNAME:THESTRING
DATA MEMBERS /INSTANCE VARIABLES:
STR:TO STORE A STRING
LEN: INTEGER TO STORE THE LENGTH OF THE STRING
WORDCOUNT:INTEGER TO STORE NUMBER OF WORDS
CONS:INTEGER TO STORE NUMBER OF CONSONANTS
MEMBER FUNCTIONS/METHODS:
THESTRING():DEFAULT CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS
THESTRING(STRING DS):PARAMETERIZED CONSTRUCTOR TO ASSIGN STR=DS
VOID COUNTFREQ():TO COUNT THE NUMBER OF WORDS AND THE NUMBER OF CONSONANTS AND
STORE THEM IN WORDCOUNT AND CONS RESPECTIVELY
VOIDDISPLAY(): TO DISPLAY THE ORIGINAL STRING,ALONG WITH THE NUMBER OF WORDS AND
THE NUMBER OF CONSONANTS
SPECIFY THE CLASS THESTRING GIVING THE DETAILS OF THE CONSTRUCTORS, VOID
COUNTFREQ() AND VOID DISPLAY(). DEFINE THE MAIN() FUNCTION TO CREATE AN OBJECT AND
CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK
Answer 2015

import java.util.Scanner;
public class TheString
{
String str;
int len,wordcount,cons;
TheString()
{
str="";
wordcount=0;
cons=0;
}

TheString(String ds)
{
str=ds+" ";
len=str.length();
cons=0;
wordcount=0;

void countFreq()
{
char ch=' ';
str=str.toLowerCase();
for(int i=0;i< len;i++)
{
ch=str.charAt(i);
if(ch==' ')
{
wordcount++;
}
 2015

else
{
if(ch!='a'&&ch!='e'&&ch!='i'&&ch!='o'&&ch!='u')
{
cons++;
}
}

}
}

void Display()
{
System.out.println("Number of words="+wordcount);
System.out.println("Number of consonants="+cons);
}

public static void main()

{
Scanner sc=new Scanner(System.in);
System.out.println("ENTER A SENTENCE WITH CHARACTER NOT MORE THAN
100");
String sen=sc.nextLine();
TheString ob1=new TheString(sen);
ob1.countFreq();
ob1.Display();
}
}
Question 11 2015
WORDPILE IS AN ENTITY WHICH CAN HOLD MAXIMUM OF 20 CHARACTERS .THE RESTRICTION IS
THAT A CHARACTER CAN BE ADDED OR REMOVED FROM ONE END ONLY.SOME OF THE MEMBERS
OF CLASSES ARE GIVEN BELOW:
CLASSNAME:WORDPILE
DATA MEMBERS/INSTANCE VARIABLES:
CH[ ]:CHARACTER ARRAY TO HOLD THE CHARACTER ELEMENTS
CAPACITY:INTEGER VARIABLE TO STORE THE MAXIMUM CAPACITY
TOP:TO POINT TO THE INDEX OF THE TOP MOST ELEMENT
METHODS / MEMBER FUNCTIONS:
WORDPILE( INT CAP):CONSTRUCTOR TO INITIALISE THE DATA MEMBER CAPACITY=CAP ,
TOP=-1 AND CREATE THE WORDPILE
VOID PUSHCHAR(CHAR V):ADDS THE CHARACTER TO THE TOP OF WORDPILE IF
POSSIBLE,OTHERWISE OUTPUT A MESSAGE ''WORDPILE
IS FULL"
CHAR POPCHAR():RETURNS THE DELETED CHARACTER FROM THE TOP OF THE WORDPILE IF
POSSIBLE,OTHERWISE IT RETURNS '\\'
(A)SPECIFY THE CLASS WORDPILE GIVING THE DETAILS OF THE CONSTRUCTOR, VOID
PUSHCHAR(CHAR) AND CHAR POPCHAR().
THE MAIN() FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2015

public class WordPile

{
char ch[]=new char[20];
int capacity,top;
WordPile(int cap)
{
capacity=cap;
top=-1;
ch=new char[capacity];
}

void pushChar(char v)
{
if(top< capacity-1)
{
top=top+1;
ch[top]=v;
}
else
{
System.out.println("WordPile is full");
}
}

char popChar()
{
if(top>=0)
{
return ch[top--];
}
else
{
return'\\';
}
}
}
Question 12 2015
A LINE ON A PLANE CAN BE REPRESENTED BY COORDINATES OF THE TWO-END POINTS P1 AND
P2 AS P1(X1,Y1) AND P2(X2,Y2).
A SUPER CLASS PLANE IS DEFINED TO REPRESENT A LINE AND A SUBCLASS CIRCLE TO FIND THE
LENGTH OF THE RADIUS AND THE AREA OF CIRCLE BY USING THE REQUIRED DATA MEMBERS OF
SUPER CLASS.
SOME OF THE MEMBERS OF BOTH THE CLASSES ARE GIVEN BELOW:
CLASSNAME:PLANE
DATA MEMBERS/INSTANCE VARIABLES:
X1:TO STORE THE X-COORDINATE OF THE FIRST END POINT
Y1:TO STORE THE Y-COORDINATE OF THE FIRST END POINT
MEMBER FUNCTIONS/METHODS:
PLANE(INT NX,INT NY):PARAMETERIZED CONSTRUCTOR TO ASSIGN THE DATA MEMBERS X1=NX
AND Y1=NY
VOID SHOW():TO DISPLAY THE COORDINATES
CLASSNAME:CIRCLE
DATA MEMBERS/INSTANCE VARIABLES:
X2:TO STORE THE X-COORDINATE OF THE SECOND END POINT
Y2:TO STORE THE Y-COORDINATE OF THE SECOND END POINT
RADIUS:DOUBLE VARIABLE TO STORE THE RADIUS OF THE CIRCLE
AREA:DOUBLE VARIABLE TO STORE THE AREA OF THE CIRCLE
MEMBER FUNCTIONS / METHODS:
CIRCLE(...):PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUES TO DATA MEMBERS OF BOTH
THE CLASSES
VOID FINDRADIUS():TO CALCULATE THE LENGTH OF RADIUS USING THE FORMULA:
(√(X2-X1)2+(Y2-Y1)2 )/2
ASSUMING THAT X1, X2, Y1, Y2 ARE THE COORDINATES OF THE TWO ENDS OF THE DIAMETER OF
A CIRCLE
VOID FINDAREA():TO FIND THE AREA OF CIRCLE USING FORMULA: ΠR2.
THE VALUE OF Π IS 22/7 OR 3.14
VOID SHOW():TO DISPLAY BOTH THE COORDINATES ALONG WITH THE LENGTH OF THE RADIUS
AND AREA OF THE CIRCLE
SPECIFY THE CLASS PLANE GIVING DETAILS OF THE CONSTRUCTOR AND VOID SHOW(). USING
THE CONCEPT OF INHERITANCE, SPECIFY THE CLASS CIRCLE GIVING DETAILS OF THE
CONSTRUCTOR,VOID FINDRADIUS(),VOID FINDAREA() AND VOID SHOW().
THE MAIN FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2015

public class Plane

{
double xl,yl;
Plane(double nx,double ny)
{
xl=nx;
yl=ny;
}

void Show()
{
System.out.println("x-coordinate="+xl);
System.out.println("y-coordinate="+yl);
}
}

public class Circle extends Plane

{
double x2,y2,radius,area;
Circle(double nx,double ny,double a,double b)
{
super(nx,ny);
x2=a;
y2=b;
}

void findRadius()
{
radius=(Math.sqrt(Math.pow((x2-xl),2)+Math.pow((y2-yl),2)))/2;
}

void findArea()
{
area=3.14*radius*radius;
}
 2015

void Show()
{
super.Show();
System.out.println("Second x-coordinate="+x2);
System.out.println("Second y-coordinate="+y2);
System.out.println("Length of radius="+radius);
System.out.println("Area ="+area);
}
}
Question 13 2015
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS ,
CLASS NODE
{
INT NUM;
NODE NEXT;
}
WRITE A METHOD OR AN ALGORITHM TO PRINT SUM OF NODES THAT CONTAINS ONLY ODD
INTEGERS OF AN EXISTING LINKED LIST .THE METHOD DECLARATION IS SPECIFIED BELOW:
VOID NODESCOUNT(NODE STARTPTR);
Answer 2015

void NodeCount(Node startPtr)

{
Nodes temp=new Nodes(startPtr);
int c=0;
while(temp!=null)
{
if(temp.num%2!=0)
{
c+=temp.num;

}
temp=temp.next;

}
System.out.println(c);

}
Question 8 2014
A CLASS MIXER HAS BEEN DEFINED TO MERGE TWO SORTED INTEGER ARRAYS IN ASCENDING
ORDER.
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASSNAME:MIXER
DATA MEMBERS/INSTANCE VARIABLES:
INT ARR[ ]:TO STORE THE ELEMENTS OF AN ARRAY
INT N:TO STORE THE SIZE OF THE ARRAY
MEMBER FUNCTIONS:
MIXER(INT NN):CONSTRUCTOR TO ASSIGN N=NN
VOID ACCEPT():TO ACCEPT THE ELEMENTS OF THE ARRAY IN ASCENDING ORDER WITHOUT ANY
DUPLICATES
MIXER MIX(MIXER A) : TO MERGE THE CURRENT OBJECT ARRAY ELEMENTS WITH THE
PARAMETERIZED ARRAY ELEMENTS AND RETURN THE RESULTANT OBJECT
VOID DISPLAY():TO DISPLAY THE ELEMENTS OF THE ARRAY
SPECIFY THE CLASS MIXER, GIVING DETAILS OF THE CONSTRUCTOR(INT), VOID ACCEPT( ),
MIXER MIX(MIXER) AND VOID DISPLAY() . DEFINE THE MAIN() FUNCTION TO CREATE AN OBJECT
AND CALL THE FUNCTION ACCORDINGLY TO ENABLE THE TASK.
Answer 2014

import java.util.Scanner;
public class Mixer
{
int arr[];
int n;
Scanner sc=new Scanner(System.in);

Mixer(int nn)
{
n=nn;
arr=new int[n];
}

void accept()
{
System.out.println("Enter "+n+" elements in ascending order");
for(int i=0;i< n;i++)
{
arr[i]=sc.nextInt();
}
}

Mixer mix(Mixer A)
{
Mixer B=new Mixer(n+A.n);
int x=0;
for(int i=0;i< n;i++)
{
B.arr[x++]=arr[i];
}
for(int j=0;j< A.n;j++)
{
B.arr[x++]=A.arr[j];
}
return B;
}
 2014

void display()
{
for(int i=0;i< n;i++)
{
System.out.print(arr[i]+" ");
}
}

public static void main()

{
Scanner sc1=new Scanner(System.in);
System.out.println("ENTER SIZE OF FIRST ARRAY");
int sizeOfFirstArray=sc1.nextInt();
Mixer P=new Mixer(sizeOfFirstArray);
P.accept();
System.out.println("ENTER SIZE OF SECOND ARRAY");
int sizeOfSecondArray=sc1.nextInt();
Mixer Q=new Mixer(sizeOfSecondArray);
Q.accept();

Mixer R=P.mix(Q);
R.display();
}
}
Question 9 2014
A CLASS SERIESSUM IS DESIGNED TO CALCULATE THE SUM OF THE FOLLOWING SERIES:
SUM=(X2 / 1!)+(X4 / 3!)+(X6 / 5!)+....(XN /(N- 1)!)
SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASSNAME:SERIESSUM
DATA MEMBERS / INSTANCE VARIABLES:
X:TO STORE AN INTEGER NUMBER
N:TO STORE NUMBER OF TERMS
SUM:TO STORE THE SUM OF THE SERIES
MEMBER FUNCTIONS:
SERIESSUM(INT XX,INT NN):CONSTRUCTOR TO ASSIGN X=XX AND N=NN
DOUBLE FINDFACT(INT M):TO RETURN THE FACTORIAL OF M USING RECURSIVE TECHNIQUE.
DOUBLE FINDPOWER(INT X,INT Y):TO RETURN X RAISED TO THE POWER OF Y USING RECURSIVE
TECHNIQUE.
VOID CALCULATE():TO CALCULATE THE SUM OF THE SERIES BY INVOKING THE RECURSIVE
FUNCTIONS RESPECTIVELY
VOID DISPLAY():TO DISPLAY THE SUM OF THE SERIES
SPECIFY THE CLASS SERIESSUM, GIVING DETAILS OF THE CONSTRUCTOR(INT, INT),DOUBLE
FINDFACT(INT), DOUBLE FINDPOWER(INT , INT), VOID CALCULATE( ) AND VOID DISPLAY().
DEFINE THE MAIN() FUNCTION TO CREATE AN OBJECT AND CALL THE FUNCTIONS ACCORDINGLY
TO ENABLE THE TASK.
Answer 2014

import java.util.Scanner;
public class SeriesSum
{
int x,n;
double sum;
SeriesSum(int xx,int nn)
{
x=xx;
n=nn;
sum=0.0;
}

double findfact(int a)
{
if(a==1)
{
return 1;
}
else
{
return a* findfact(a-1);
}

double findpower(int a,int b)

{
if(b==0)
{
return 1;
}
else
{
return a* findpower(a,b-1);
}

}
 2014

void calculate()
{
int k=2;
for(int i=1;i<=n;i++)
{
sum+=findpower(x,k)/findfact(k-1);
k=k+2;
}
}

void display()
{
System.out.println("sum="+sum);
}

public static void main()

{
Scanner sc=new Scanner(System.in);
System.out.println("ENTER A NUMBER");
int a=sc.nextInt();
System.out.println("ENTERNUMBER OF TERMS");
int b=sc.nextInt();
SeriesSum obj1=new SeriesSum(a,b);
obj1.calculate();
obj1.display();
}
}
Question 10 2014
A SEQUENCE OF FIBONACCI STRINGS IS GENERATED AS FOLLOWS:
S0="A' ' , S1="B" , SN=S(N-I)+S(N-2)) WHERE '+' DENOTES CONCATENATION . THUS THE
SEQUENCE IS : A, B, BA, BAB, BABBA, BABBABAB, ......... N TERMS.
DESIGN A CLASS FIBOSTRING TO GENERATE FIBONACCI STRINGS. SOME OF THE MEMBERS OF
THE CLASS ARE GIVEN BELOW:
CLASSNAME:FIBOSTRING
DATA MEMBERS/INSTANCE VARIABLES:
X:TO STORE THE FIRST STRING
Y:TO STORE THE SECOND STRING
Z:TO STORE THE CONCATENATION OF THE PREVIOUS TWO STRINGS
N:TO STORE THE NUMBER OF TERMS
MEMBER FUNCTIONS/METHODS:
FIBOSTRING():CONSTRUCTOR TO ASSIGN X="A",Y=''B" AND Z=''BA"
VOID ACCEPT():TO ACCEPT THE NUMBER OF TERMS 'N'
VOID GENERATE():TO GENERATE AND PRINT THE FIBONACCI STRINGS.THE SUM OF('+ 'IE
CONCATENATION) FIRST TWO STRINGS IS THE THIRD STRING.EG."A" IS FIRST STRING,"B" IS
SECOND STRING THEN THE THIRD WILL BE "BA" , AND FOURTH WILL BE"BAB" AND SO ON.
SPECIFY THE CLASS FIBOSTRING, GIVING DETAILS OF THE CONSTRUCTOR(), VOID ACCEPT()
AND VOID GENERATE() . DEFINE THE MAIN() FUNCTION TO CREATE AN OBJECT AND CALL THE
FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2014

import java.util.Scanner;
public class FiboString
{
String x,y,z;
int n;
FiboString()
{
x="a";
y="b";
z="ba";
}

void accept()
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter number of terms");
n=sc.nextInt();
}

void generate()
{
System.out.print(x+","+y+","+z);
for(int i=1;i<=n-3;i++)
{

x=y;
y=z;
z=y+x;
System.out.print(","+z);
}
}
 2014

public static void main()

{
FiboString obj1=new FiboString();
obj1.accept();
obj1.generate();
}
}
Question 11 2014
A SUPER CLASS STOCK HAS BEEN DEFINED TO STORE THE DETAILS OF THE STOCK OF A RETAIL
STORE.DEFINE A SUBCLASS PURCHASE TO STORE THE DETAILS OF THE ITEMS PURCHASED
WITH THE NEW RATE AND UPDATES THE STOCK. SOME OF THE MEMBERS OF THE CLASSES ARE
GIVEN BELOW:
CLASSNAME:STOCK
DATA MEMBERS/INSTANCE VARIABLES:
ITEM:TO STORE THE NAME OF THE ITEM
QTY:TO STORE THE QUANTITY OF AN ITEM IN STOCK
RATE:TO STORE THE UNIT PRICE OF AN ITEM
AMT:TO STORE THE NET VALUE OF THE ITEM IN STOCK
MEMBER FUNCTIONS:
STOCK(...):PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUES TO THE DATA MEMBERS
VOID DISPLAY():TO DISPLAY THE STOCK DETAILS
CLASSNAME:PURCHASE
DATA MEMBERS/INSTANCE VARIABLES:
PQTY: TO STORE THE PURCHASED QUANTITY
PRATE: TO STORE THE UNIT PRICE OF THE PURCHASED ITEM
MEMBER FUNCTIONS / METHODS:
PURCHASE(...):PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUES TO THE DATA MEMBERS OF
BOTH CLASSES
VOID UPDATE():TO UPDATE STOCK BY ADDING THE PREVIOUS QUANTITY BY THE PURCHASED
QUANTITY AND REPLACE THE RATE OF THE ITEM IF THERE IS A DIFFERENCE IN THE PURCHASE
RATE . ALSO UPDATE THE CURRENT STOCK VALUE AS:
(QUANTITY*UNIT PRICE)
VOID DISPLAY():TO DISPLAY THE STOCK DETAILS BEFORE AND AFTER UPDATION
SPECIFY THE CLASS STOCK,GIVING DETAILS OF THE CONSTRUCTOR() AND VOID
DISPLAY().USING CONCEPT OF INHERITANCE,SPECIFY THE CLASS PURCHASE,GIVING DETAILS
OF THE CONSTRUCTOR(),VOID UPDATE() AND VOID DISPLAY().
THE MAIN() FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2014

public class Stock

{
String item;
double qty,rate,amt;
Stock(String a,double b,double c)
{
item=a;
qty=b;
rate=c;
amt=qty*rate;
}

void display()
{
System.out.println("Name of the item:"+item);
System.out.println("Quantity:"+qty);
System.out.println("Rate per unit: "+rate);
System.out.println("Net value:"+amt);
}
}

public class Purchase extends Stock

{
int pqty;
double prate;
Purchase(String a,double b,double c,int d,double e)
{
super(a,b,c);
pqty=d;
prate=e;
}
 2014

void update()
{
qty=qty+pqty;
rate=prate;
amt=qty*rate;

void display()
{
super.display();
update();
super.display();
}
}
Question 12 2014
A STACK IS A LINEAR DATA STRUCTURE WHICH ENABLES THE USER TO ADD AND REMOVE
INTEGERS FROM ONE END ONLY,USING THE CONCEPT OF LIFO(LASTINFIRSTOUT).AN ARRAY
CONTAINING THE MARKS OF 50 STUDENTS IN ASCENDING ORDER IS TO BE PUSHED INTO THE
STACK.
DEFINE A CLASS ARRAY_TO_STACK WITH THE FOLLOWING DETAILS:
CLASSNAME:ARRAY_TO_STACK
DATA MEMBERS / INSTANCE VARIABLES:
M[ ]:TO STORE THE MARKS
ST[]:TO STORE THE STACK ELEMENTS
CAP:MAXIMUM CAPACITY OF THE ARRAY AND STACK
TOP:TO POINT THE INDEX OF THE TOP MOST ELEMENT OF THE STACK
METHODS/MEMBER FUNCTIONS:
ARRAY_TO_STACK(INT N):PARAMETERIZED CONSTRUCTOR TO INITIALIZE CAP=N AND TOP=-1
VOID INPUT_MARKS():TO INPUT THE MARKS FROM USER AND STORE IT IN THE ARRAY M[ ] IN
ASCENDING ORDER AND
SIMULTANEOUSLY PUSH THE MARKS INTO THE STACK ST[ ] BY INVOKING THE FUNCTION
PUSHMARKS()
VOID PUSHMARKS(INT V):TO PUSH THE MARKS INTO THE STACK AT TOP LOCATION
IF POSSIBLE,OTHERWISE,DISPLAY "NOT POSSIBLE"
INT POPMARKS():TO RETURN MARKS FROM THE STACK IF POSSIBLE,OTHERWISE, RETURN -999
VOID DISPLAY():TO DISPLAY THE STACK ELEMENTS
SPECIFY THE CLASS ARRAY_TO_STACK, GIVING THE DETAILS OF THE CONSTRUCTOR(INT), VOID
INPUT_MARKS( ), VOID PUSHMARKS(INT), INT POPMARKS() AND VOID DISPLAY().
THE MAIN FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2014

import java.util.Scanner;
public class Array_to_Stack
{
int m[],st[];
int cap,top;
Scanner sc=new Scanner(System.in);
Array_to_Stack(int n)
{
cap=n;
top=-1;
st=new int[cap];
m=new int[cap];
}

void input_marks()
{
System.out.println("Enter "+cap+" elements in ascending order");
for(int i=0;i< cap;i++)
{
m[i]=sc.nextInt();
pushmarks(m[i]);

void pushmarks(int v)
{
if(top< cap-1)
{
top=top+1;
st[top]=v;
}
else
{
System.out.println("stack is full");
}
 2014

int popmarks()
{
if(top>=0)
{
return st[top--];
}
else
{
return -999;
}
}

void display()
{
for(int i=top;i>=0;i--)
{
System.out.println(st[i]);
}
}
}
Question 13 2014
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS ,
CLASS NODE
{
INT NUMBER;
NODE NEXTNODE;
}
WRITE A METHOD OR AN ALGORITHM TO ADD A NODE AT THE END OF EXISTING THE LINKED LIST
.THE METHOD DECLARATION IS SPECIFIED BELOW:
VOID ADDNODE(NODE START,INT NUM);
Answer 2014

void addnode(Node start,int num)

{
Node temp=new Node(start);

while(temp.nextNode!=null)
{
temp=temp.nextNode;
}
Node C=new Node();
C.number=num;
C.nextNode=null;
temp.nextNode=C;
}
Question 8 2013
AN EMIRP NUMBER IS A NUMBER WHICH IS PRIME BACKWARDS AND FORWARDS.
EXAMPLE: 13 AND 31 ARE BOTH PRIME NUMBERS. THUS,13 IS AN EMIRP NUMBER.
DESIGN A CLASS EMIRP TO CHECK IF A GIVEN NUMBER IS EMIRP NUMBER OR NOT. SOME OF THE
MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASSNAME:EMIRP
DATA MEMBERS / INSTANCE VARIABLES:
N:STORES THE NUMBER
REV:STORES THE REVERSE OF THE NUMBER
F:STORES THE DIVISOR
MEMBER FUNCTIONS:
EMIRP (INT NN):TO ASSIGN N= NN, REV=0 AND F=2
INT ISPRIME(INT X):CHECK IF THE NUMBER IS PRIME USING THE RECURSIVE TECHNIQUE AND
RETURN 1 IF PRIME OTHERWISE RETURN 0
VOID ISEMIRP(): REVERSE THE GIVEN NUMBER AND CHECK IF BOTH THE ORIGINAL NUMBER AND
THE REVERSE NUMBER ARE PRIME , BY INVOKING THE FUNCTION ISPRIME(INT) AND DISPLAY
THE RESULT WITH AN APPROPRIATE MESSAGE
SPECIFY THE CLASS EMIRP GIVING DETAILS OF THE CONSTRUCTOR(INT) , INT ISPRIME(INT)
AND VOID ISEMIRP(). DEFINE THE MAIN() FUNCTION TO CREATE AN OBJECT AND CALL THE
METHODS TO CHECK FOR EMIRP NUMBER
Answer 2013

import java.util.Scanner;
public class Emirp
{
int n,rev,f;
Emirp(int nn)
{
n=nn;
rev=0;
f=2;
}

int isprime(int x)
{
if(n==x)
{
return 1;
}
else if(n % x==0 || n==1)
{
return 0;
}
else
{
return isprime(x+1);
}
}
void isEmirp()
{
int x=n;
while(x!=0)
{
rev=(rev*10)+x%10;
x=x/10;
}
int ansl=isprime(f);
x=n;
n=rev;
 2013

f=2;
int ans2=isprime(f);
if(ansl==1 && ans2==1)
{
System.out.println(x+" is an Emirp number");
}
else
{
System.out.println(x+" is not an Emirp number");
}
}
public static void main()
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter a number");
int x=sc.nextInt();
Emirp obj1=new Emirp(x);
obj1.isEmirp();
}
}
Question 9 2013
DESIGN A CLASS EXCHANGE TO ACCEPT A SENTENCE AND INTERCHANGE THE FIRST ALPHABET
WITH THE LAST
ALPHABET FOR EACH WORD IN THE SENTENCE,WITH SINGLE LETTER WORD REMAINING
UNCHANGED. THE WORDS IN THE INPUT SENTENCE ARE SEPARATED BY A SINGLE BLANK SPACE
AND TERMINATED BY A FULL STOP.
EXAMPLE: INPUT: IT IS A WARM DAY.
OUTPUT: TI SI A MARW YAD
SOME OF THE DATA MEMBERS AND MEMBER FUNCTIONS ARE GIVEN BELOW:
CLASSNAME:EXCHANGE
DATA MEMBERS / INSTANCE VARIABLES:
SENT:STORES THE SENTENCE
REV:TO STORE THE NEW SENTENCE
SIZE: STORES THE LENGTH OF THE SENTENCE
MEMBER FUNCTIONS:
EXCHANGE(): DEFAULT CONSTRUCTOR
VOID READSENTENCE():TO ACCEPT THE SENTENCE
VOID EXFIRSTLAST():EXTRACT EACH WORD AND INTERCHANGE THE FIRST AND LAST ALPHABET
OF THE WORD AND FORM A NEW SENTENCE REV USING THE CHANGED WORDS
VOID DISPLAY():DISPLAY THE ORIGINAL SENTENCE ALONG WITH THE NEW CHANGED SENTENCE.
SPECIFY THE CLASS EXCHANGE GIVING DETAILS OF THE CONSTRUCTOR(), VOID
READSENTENCE() , VOID EXFIRSTLAST() AND VOID DISPLAY(). DEFINE THE MAIN() FUNCTION TO
CREATE AN OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2013

import java.util.Scanner;
public class Exchange
{
String sent,rev;
int size;
Exchange()
{
sent="";
rev="";
size=0;
}

void readsentence()
{
Scanner sc=new Scanner(System.in);
System.out.print("Enter a sentence");
sent=sc.nextLine();
size=sent.length();
}

void exfirstlast()
{
char ch=' ';
String wd="";
for(int i=0;i< size;i++)
{
ch=sent.charAt(i);
if(ch==' '||ch=='.')
{
if(wd.length()>1)
{
/*last character*/
rev=rev + wd.charAt(wd.length()-1);
/*middle characters*/
rev=rev + wd.substring(1,wd.length()-1);
/*first character*/
rev=rev + wd.charAt(0);
 2013

/*space or full stop*/

rev=rev+ch;
}
else
{
rev=rev+wd+ch;
}

wd="";
}
else
{
wd=wd+ch;
}
}
}

void display()
{
System.out.println("Input:"+sent);
System.out.println("Output: "+rev);
}

public static void main()

{
Exchange obj1=new Exchange();
obj1.readsentence();
obj1.exfirstlast();
obj1.display();
}
}
Question 10 2013
A CLASS MATRIX CONTAINS A TWO DIMENSIONAL INTEGER ARRAY OF ORDER [M X N].THE
MAXIMUM VALUE POSSIBLE FOR BOTH 'M' AND 'N' IS 25 . DESIGN A CLASS MATRIX TO FIND THE
DIFFERENCE OF THE TWO MATRICES . THE DETAILS OF THE MEMBERS OF THE CLASS ARE GIVEN
BELOW:
CLASSNAME:MATRIX
DATA MEMBERS/ INSTANCE VARIABLES:
ARR[ ][ ]:STORES THE MATRIX ELEMENT
M:INTEGER TO STORE THE NUMBER OF ROWS
N:INTEGER TO STORE THE NUMBER OF COLUMNS
MEMBER FUNCTIONS:
MATRIX(INT MM,INT NN): TO INITIALIZE THE SIZE OF THE MATRIX M=MM AND N=NN
VOID FILLARRAY():TO ENTER THE ELEMENTS OF THE MATRIX
MATRIX SUBMAT(MATRIX A):SUBTRACT THE CURRENT OBJECT FROM THE MATRIX OF
PARAMETERIZED OBJECT AND RETURN THE RESULTING OBJECT
VOID DISPLAY():DISPLAY THE MATRIX ELEMENTS
SPECIFY THE CLASS MATRIX GIVING DETAILS OF THE CONSTRUCTOR(INT,INT ). VOID
FILLARRAY() ,MATRIX SUBMAT(MATRIX) AND VOID DISPLAY() . ALSO DEFINE A MAIN()
FUNCTION TO CREATE AN OBJECT AND CALL THE METHODS ACCORDINGLY TO ENABLE THE
TASK.
Answer 2013

import java.util.Scanner;
public class Matrix
{
Scanner sc=new Scanner(System.in);
int arr[][];
int m,n;
Matrix(int mm,int nn)
{
m=mm;
n=nn;
arr=new int[m][n];
}

void fillarray()
{

for(int i=0;i< m;i++)

{
for(int j=0;j< n;j++)
{
arr[i][j]=sc.nextInt();
}
}
}

Matrix SubMat(Matrix A)
{
Matrix B=new Matrix(m,n);
for(int i=0;i< m;i++)
{
for(int j=0;j< n;j++)
{
B.arr[i][j]=A.arr[i][j]-arr[i][j] ;
}
}
return B;
}
 2013

void display()
{
for(int i=0;i< m;i++)
{
System.out.println();

for(int j=0;j< n;j++)

{
System.out.print(arr[i][j]+"\t");
}
}
}

public static void main()

{
Scanner sc1=new Scanner(System.in);
System.out.println("Size of array:");
int x=sc1.nextInt();

int y=sc1.nextInt();
if(x>25 ||y>25)
{
System.out.println("Invalid Size" );
}
else
{
Matrix P=new Matrix(x,y);
Matrix Q=new Matrix(x,y);
Matrix R=new Matrix(x,y);
System.out.println("ENTER ELEMENTS IN MATRIX P");
P.fillarray();
System.out.println("ENTER ELEMENTS IN MATRIX Q");
Q.fillarray();
System.out.println("MATRIX P - MATRIX Q");
R=Q.SubMat(P);
R.display();
}
 2013

}
}
Question 11 2013
A SUPER CLASS PERIMETER HAS BEEN DEFINED TO CALCULATE THE PERIMETER OF A
PARALLELOGRAM. DEFINE A SUBCLASS AREA TO COMPUTE THE AREA OF THE PARALLELOGRAM
BY USING THE REQUIRED DATA MEMBERS OF THE SUPER CLASS. THE DETAILS ARE GIVEN
BELOW:
CLASSNAME:PERIMETER
DATA MEMBERS / INSTANCE VARIABLES:
A:TO STORE THE LENGTH IN DECIMAL
B:TO STORE THE BREADTH IN DECIMAL
MEMBER FUNCTIONS:
PERIMETER(...):PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUES TO DATA MEMBERS
DOUBLE CALCULATE():CALCULATE AND RETURN THE PERIMETER OF A PARALLELOGRAM AS 2*
(LENGTH+BREADTH)
VOID SHOW():TO DISPLAY THE DATA MEMBERS ALONG WITH THE PERIMETER OF THE
PARALLELOGRAM
CLASSNAME:AREA
DATA MEMBERS / INSTANCE VARIABLES:
H:TO STORE THE HEIGHT IN DECIMAL
AREA:TO STORE THE AREA OF THE PARALLELOGRAM
MEMBER FUNCTIONS:
AREA(...): PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUES TO DATA MEMBERS OF BOTH THE
CLASSES
VOID DOAREA():COMPUTE THE AREA AS (BREADTH*HEIGHT)
VOID SHOW():DISPLAY THE DATA MEMBERS OF BOTH CLASSES ALONG WITH THE AREA AND
PERIMETER OF THE PARALLELOGRAM.
SPECIFY THE CLASS PERIMETER GIVING DETAILS OF THE CONSTRUCTOR(...) , DOUBLE
CALCULATE() AND VOID SHOW(). USING THE CONCEPT OF INHERITANCE, SPECIFY THE CLASS
AREA GIVING DETAILS OF THE CONSTRUCTOR(...) , VOID DOAREA() AND VOID SHOW().
THE MAIN() FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2013

public class Perimeter

{
double a,b;
Perimeter(double aa,double bb)
{
a=aa;b=bb;
}
double Calculate()
{
return (2*(a+b));
}
void show()
{
System.out.println("Length="+a);
System.out.println("Breadth= "+b);
System.out.println("Perimeter="+Calculate());
}
}

public class Area extends Perimeter

{
double h;
double area;
Area(double aa,double bb,double cc)
{
super(aa,bb);
h=cc;
}
void doarea()
{
area=b*h;
}
 2013

void show()
{
super.show();
System.out.println("Height= "+h);
System.out.println("Area= "+area);
}
}
Question 12 2013
A DOUBLY QUEUE IS A LINEAR DATA STRUCTURE WHICH ENABLES THE USER TO ADD AND
REMOVE INTEGERS FROM EITHER ENDS , I.E FROM FRONT OR REAR. DEFINE A CLASS DEQUEUE
WITH THE FOLLOWING DETAILS:
CLASSNAME:DEQUEUE
DATA MEMBERS / INSTANCE VARIABLES:
ARR[]:ARRAY TO HOLD UPTO 100 INTEGER ELEMENTS
LIM: STORES THE LIMIT OF THE DEQUEUE
FRONT:TO POINT TO THE INDEX OF FRONT END
REAR:TO POINT TO THE INDEX OF REAR END
MEMBERFUNCTIONS:
DEQUEUE(INT L):CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS LIM=L,FRONT=REAR=0
VOID ADDFRONT(INT VAL):TO ADD INTEGER FROM THE FRONT IF POSSIBLE ELSE DISPLAY THE
MESSAGE("OVERFLOW FROM FRONT")
VOID ADDREAR(INT VAL):TO ADD INTEGER FROM THE REAR IF POSSIBLE ELSE DISPLAY THE
MESSAGE("OVERFLOW FROM REAR")
INT POPFRONT():RETURNS ELEMENT FROM FRONT, IF POSSIBLE OTHERWISE RETURNS -9999
INT POPREAR():RETURNS ELEMENT FROM REAR, IF POSSIBLE OTHERWISE RETURNS -9999
SPECIFY THE CLASS DEQUEUE GIVING DETAILS OF THE CONSTRUCTOR(INT), VOID
ADDFRONT(INT) , VOID ADDREAR(INT) , INT POPFRONT() AND INT POPREAR().
THE MAIN FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2013

public class Dequeue

{
int arr[]=new int[100];
int lim,front,rear;
Dequeue(int l)
{
lim=l;
front=0;
rear=0;
arr=new int[lim];

void addrear(int val)

{
if(rear< lim)
{

arr[rear++]=val;
}
else
{
System.out.println("OVERFLOW");
}

}
int poprear()
{

//if front and rear are at zero which means nothing is entered
if(front==0&&rear==0 )
{

return -9999;
}
 2013

else
{
rear=rear-1;
return arr[rear];
}

int popfront()
{

//If front is equal to rear that means that either all elements of array are deleted
// or no elements are added
if(front==rear)
{
front=0;
rear=0;
return -9999;
}

else
{

return arr[front++];
}

void addfront(int val)

{
if(front>0)
{
front=front-1;
arr[front]=val;

}
 2013

else
{
System.out.println("Overflow from front");
}
}
void display()
{
for (int i=front;i< rear;i++)
{
System.out.println(arr[i]);
}
}
}
Question 13 2013
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS ,
CLASS NODE
{
INT ITEM;
NODE NEXT;
}
WRITE A METHOD OR AN ALGORITHM TO COUNT THE NUMBER OF NODES IN THE LINKED LIST
.THE METHOD DECLARATION IS SPECIFIED BELOW:
INT COUNT(NODE PTR_START);
Answer 2013

int count(Node ptr_start)

{
Node temp=new Node(ptr_start);
int c=0;
while(temp!=null)
{
c++;
temp=temp.next;
}
return c;
}
Question 8 2012
A CLASS COMBINE CONTAINS AN ARRAY OF INTEGERS WHICH COMBINES TWO ARRAYS INTO A
SINGLE ARRAY INCLUDING THE DUPLICATE ELEMENTS IF ANY AND SORTS THE COMBINED
ARRAY .SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASSNAME:COMBINE
DATA MEMBERS / INSTANCE VARIABLES:
COM[ ]:INTEGER ARRAY
SIZE: SIZE OF THE ARRAY
MEMBER FUNCTIONS/METHODS:
COMBINE(INT NN): PARAMETERIZED CONSTRUCTOR TO ASSIGN SIZE= NN
VOID INPUTARRAY():TO ACCEPT THE ARRAY ELEMENTS
VOID SORT():SORTS THE ELEMENTS OF COMBINED ARRAY IN ASCENDING ORDER USING THE
SELECTION SORT TECHNIQUE
VOID MIX(COMBINE A,COMBINE B):COMBINES THE PARAMETERIZED OBJECT ARRAYS AND
STORES THE RESULT IN THE CURRENT OBJECT ARRAY ALONG WITH DUPLICATE ELEMENTS IF
ANY
VOID DISPLAY():DISPLAYS THE ARRAY ELEMENTS
SPECIFY THE CLASS COMBINE GIVING DETAILS OF THE CONSTRUCTOR( INT),VOID
INPUTARRAY(),VOID SORT() , VOID MIX(COMBINE,COMBINE) AND VOID DISPLAY(). ALSO DEFINE
THE MAIN() FUNCTION TO CREATE AN OBJECT AND CALL THE METHODS ACCORDINGLY TO
ENABLE THE TASK.
Answer 2012

import java.util.Scanner;

public class Combine

{

int com[]=new int[100];

int size;
Scanner sc=new Scanner(System.in);

Combine(int nn)
{
size=nn;
com=new int[size];
}

void inputarray()
{
System.out.println("\nEnter "+size+" elements");
for(int i=0;i< size;i++)
{
com[i]=sc.nextInt();
}
}

void sort()
{
int t;
for(int i=0;i< size;i++)
{

for(int j=i;j< size;j++)

{
if(com[j]< com[i])
{
t=com[j];
com[j]=com[i];
com[i]=t;
 2012

}
}

}
}

void mix(Combine A,Combine B)

{
int x=0,y=0,z=0;
while(x< A.size)
{
com[z++]=A.com[x++];
}
while(y< B.size)
{
com[z++]=B.com[y++];
}
}

void display()
{

for(int i=0;i< size;i++)

{
System.out.print(com[i]+" ");
}
}

public static void main()

{
Scanner sc1=new Scanner(System.in);
System.out.println("\n enter size of first array");
int a=sc1.nextInt();
Combine P=new Combine(a);
P.inputarray();
System.out.println("\n Enter size of Second array");
int b=sc1.nextInt();
 2012

Combine Q=new Combine(b);

Q.inputarray();

Combine R=new Combine(a+b);

R.mix(P,Q);
R.sort();
System.out.println("Array 1:");
P.display();
System.out.println();
System.out.println("Array 2:");
Q.display();
System.out.println();
System.out.println("Combined Array:");
R.display();
}
}
Question 9 2012
DESIGN A CLASS VOWELWORD TO ACCEPT A SENTENCE AND CALCULATE THE FREQUENCY OF
WORDS THAT BEGIN WITH A VOWEL . THE WORDS IN THE INPUT STRING ARE SEPARATED BY A
SINGLE BLANK SPACE AND IS TERMINATED BY A FULL STOP. THE DESCRIPTION OF THE CLASS IS
GIVEN BELOW:
CLASSNAME:VOWELWORD
DATA MEMBERS / INSTANCE VARIABLES:
STR : TO STORE A SENTENCE
FREQ : STORE THE FREQUENCY OF THE WORDS BEGINNING WITH A VOWEL
MEMBER FUNCTIONS:
VOWELWORD( ): DEFAULT CONSTRUCTOR TO INITIALIZE DATA MEMBER TO LEGAL INITIAL
VALUE
VOID READSTR(): TO ACCEPT A SENTENCE
VOID FREQ_VOWEL(): COUNTS THE FREQUENCY OF THE WORDS THAT BEGIN WITH A VOWEL
VOID DISPLAY(): TO DISPLAY THE ORIGINAL STRING AND THE FREQUENCY OF THE WORD THAT
BEGIN WITH A VOWEL
SPECIFY THE CLASS VOWELWORD GIVING DETAILS OF THE CONSTRUCTOR( ), VOID READSTR( ) ,
VOID FREQ_VOWEL() AND VOID DISPLAY() . ALSO DEFINE THE MAIN() FUNCTION TO CREATE AN
OBJECT AND CALL THE METHODS ACCORDINGLY TO ENABLE THE TASK.
Answer 2012

import java.util.Scanner;
public class VowelWord
{
String str;
int freq;
public VowelWord()
{
str="";
freq=0;
}
public void readstr()
{
Scanner sc=new Scanner(System.in);
System.out.println("enter a string");
str=sc.nextLine();
}
public void freq_vowel()
{
char ch,ch1=' ';
for(int i=0;i< str.length();i++)
{
ch=str.charAt(i);
if(i==0)
{
if(ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u'||ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U')
{
freq++;
}
}
else if(ch==' ')
{
ch1=str.charAt(i+1);
 2012

if(ch1=='a'||ch1=='e'||ch1=='i'||ch1=='o'||ch1=='u'||ch1=='A'||ch1=='E'||
ch1=='I'||ch1=='O'||ch1=='U')
{
freq++;
}
}
}
}

void display()
{
System.out.println("ORIGINALSENTENCE: "+str);
System.out.println("FREQUECY OF WORD BEGINNING WITH A VOWEL "+freq);
}
public static void main()
{
VowelWord ob1=new VowelWord();
ob1.readstr();
ob1.freq_vowel();
ob1.display();
}
}
Question 10 2012
A HAPPY NUMBER IS A NUMBER IN WHICH THE EVENTUAL SUM OF THE SQUARE OF THE DIGITS
OF THE NUMBER IS EQUAL TO 1.
EXAMPLE:28=2^2+8^2=4+64=68
68=6^2+8^2=36+64=100
100=1^2+0^2+0^2=1 +0+0=1
HENCE,28 IS A HAPPY NUMBER.
EXAMPLE:12 =1^2+2^2=1+4=5
HENCE, 12 IS NOT A HAPPY NUMBER.
DESIGN A CLASS HAPPY TO CHECK IF A GIVEN NUMBER IS A HAPPY NUMBER.SOME OF THE
MEMBER OF THE CLASS ARE GIVEN BELOW:
CLASSNAME:HAPPY
DATA MEMBERS/ INSTANCE VARIABLES:
N: STORES THE NUMBER
MEMBER FUNCTIONS:
HAPPY(): CONSTRUCTOR TO ASSIGN 0 TO N
VOID GETNUM(INT NN): TO ASSIGN THE PARAMETER VALUE TO THE NUMBER N=NN
INT SUM_SQ_DIGITS(INT X): RETURNS THE SUM OF THE SQUARE OF THE DIGIT OF THE NUMBER
X. USING THE RECURSIVE TECHNIQUE
VOID ISHAPPY(): CHECKS IF THE GIVEN NUMBER IS A HAPPY NUMBER BY CALLING THE
FUNCTION SUM_SQ_DIGITS (INT) AND DISPLAYS AN APPROPRIATE MESSAGE
SPECIFY THE CLASS HAPPY GIVING DETAILS OF THE CONSTRUCTOR( ). VOID GETNUM(INT) , INT
SUM_SQ_DIGITS(INT) AND VOID ISHAPPY() . ALSO DEFINE A MAIN() FUNCTIONC TO CREATE AN
OBJECT AND CALL THE METHODS TO CHECK FOR HAPPY NUMBER.
Answer 2012

import java.util.Scanner;
public class Happy
{
int n;

Happy()
{
n=0;
}
void getnum(int nn)
{
n=nn;
}

int sum_sq_digits(int x)
{
if(x==0)
{
return 0;
}

else
{
int rem=x%10;
return (rem * rem)+sum_sq_digits(x/10);
}
}
void ishappy()
{
int x=n;
while(x!=1 && x!=4)
{
x=sum_sq_digits(x);
}
if(x==1)
{
System.out.println(n+" IS A HAPPY NUMBER");
 2012

}
else
{
System.out.println(n+" IS NOT A HAPPY NUMBER");
}
}

public static void main()

{
Scanner sc=new Scanner(System.in);
System.out.println("Enter a number");
int a=sc.nextInt();
Happy ob1=new Happy( );
ob1.getnum(a);
ob1.ishappy();
}
}
Question 11 2012
LINK IS AN ENTITY WHICH CAN HOLD A MAXIMUM OF 100 INTEGERS . LINK ENABLES THE USER
TO ADD ELEMENTS FROM THE REAR END AND REMOVE INTEGERS FROM THE FRONT END OF THE
ENTITY. DEFINE A CLASS LINK WITH THE FOLLOWING DETAILS:
CLASSNAME:LINK
DATA MEMBERS / INSTANCE VARIABLES:
LNK[ ]: ENTITY TO HOLD THE INTEGER ELEMENTS
MAX:STORES THE MAXIMUM CAPACITY OF THE ENTITY
BEGIN: TO POINT TO THE INDEX OF THE FRONT END
END: TO POINT TO THE INDEX OF THE REAR END
MEMBER FUNCTIONS:
LINK(INT MM):CONSTRUCTOR TO INITIALIZE,MAX=MM,BEGIN=0,END=0
VOID ADDLINK(INT V):TO ADD AN ELEMENT FROM THE REAR INDEX IF POSSIBLE OTHERWISE
DISPLAY THE MESSAGE "OUT OF SIZE..."
INT DELLINK():TO REMOVE AND RETURN AN ELEMENT FROM THE FRONT INDEX , IF POSSIBLE
OTHERWISE DISPLAY THE MESSAGE "EMPTY..." AND RETURN -99
VOID DISPLAY():DISPLAYS THE ELEMENTS OF THE ENTITY
(A) SPECIFY THE CLASS LINK GIVING DETAILS OF THE CONSTRUCTOR(INT) VOID ADDLINK(INT),
INT DELLINK() AND VOID DISPLAY().
THE MAIN() FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2012

public class Link

{
int lnk[]=new int[100];
int max,begin,end;
Link(int mm)
{
max=mm;begin=0;end=0;
lnk=new int[max];
}

void addlink(int v)
{
if(end< max)
{
lnk[end]=v;
end=end+1;
}
else
{
System.out.println("OUT OF SIZE...");
}
}

int dellink( )
{
int v;
if(begin!=end)
{
v=lnk[begin];
begin=begin+1;
return v;
}
 2012

else
{
System.out.println("EMPTY...");
return -99;
}
}

void display()
{
for(int i=begin;i< end;i++)
{
System.out.println(lnk[i]);
}
}
}
Question 12 2012
A SUPER CLASS DETAIL HAS BEEN DEFINED TO STORE THE DETAILS OF A CUSTOMER.DEFINE A
SUB CLASS BILL TO COMPUTE THE MONTHLY TELEPHONE CHARGE OF THE CUSTOMER AS PER
THE CHART GIVEN BELOW:

NUMBER OF CALLS RATE

1-100 ONLY RENTAL CHARGE
101-200 60 PAISA PER CALL +RENTAL CHARGE
201-300 80 PAISA PER CALL+RENTAL CHARGE
ABOVE 300 1 RUPEE PER CALL + RENTAL CHARGE

THE DETAILS OF BOTH THE CLASSES ARE GIVEN BELOW:

CLASSNAME:DETAIL
DATA MEMBER / INSTANCE VARIABLES:
NAME: TO STORE THE NAME OF THE CUSTOMER
ADDRESS:TO STORE THE ADDRESS OF THE CUSTOMER
TELNO:TO STORE THE PHONE NUMBER OF THE CUSTOMER
RENT:TO STORE THE MONTHLY RENTAL CHARGE
MEMBER FUNCTIONS:
DETAIL(...): PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUES TO DATA MEMBERS
VOID SHOW(): TO DISPLAY THE DETAIL OF THE CUSTOMER
CLASSNAME:BILL
DATA MEMBERS / INSTANCE VARIABLES:
N: TO STORE THE NUMBER OF CALLS
AMT:TO STORE THE AMOUNT TO BE PAID BY THE CUSTOMER
MEMBER FUNCTION:
BILL(...):PARAMETERIZED CONSTRUCTOR TO ASSIGN VALUE TO DATA MEMBER OF BOTH
CLASSES AND TO INITIALIZE AMT=0.0
VOID CAL():CALCULATES THE MONTHLY TEL PHONE CHARGE AS PER THE CHART GIVEN ABOVE
VOID SHOW( ):DISPLAY THE DETAILS OF THE CUSTOMER AND AMOUNT TO BE PAID
SPECIFY THE CLASS DETAIL GIVING DETAILS OF THE CONSTRUCTOR() AND VOID SHOW(). USING
THE CONCEPT OF INHERITANCE , SPECIFY THE CLASS BILL GIVING DETAILS OF THE
CONSTRUCTOR( ) , VOID CAL() AND VOID SHOW().
THE MAIN() FUNCTION AND ALGORITHM NEED NOT BE WRITTEN
Answer 2012

public class Detail

{
String name,address;
long telno;
double rent;
Detail(String n,String a,long t,double r)
{
name=n;
address=a;
telno=t;
rent=r;
}
void show()
{
System.out.println("Name:"+name);
System.out.println("Address:"+address);
System.out.println("Telephone Number:"+telno);
System.out.println("MonthlyRent:"+rent);
}
}

public class Bill extends Detail

{
int n;
double amt;
Bill(String a,String b,long c,double d,int e)
{
super(a,b,c,d);
n=e;
amt=0.0;
}
void cal()
{
if(n>=1 && n<=100)
{
amt=rent;
 2012

}
else if(n>=101 && n<=200)
{
amt=n*0.6+rent;
}
else if(n>=201 && n<=300)
{
amt=n*0.8+rent;
}
else if(n>300)
{
amt=n+rent;
}
}
void show()
{
super.show();
System.out.println("Number of calls="+n);
System.out.println("Amount to pay="+amt);
}
}
Question 13 2012
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS ,
CLASS NODE
{
INT P;
STRING N;
NODE NEXT;
}
WRITE A METHOD OR AN ALGORITHM TO SEARCH FOR A NAME AND DISPLAY THE CONTENTS OF
THAT NODE .THE METHOD DECLARATION IS SPECIFIED BELOW:
VOID SEARCH(NODE START,STRING B);
Answer 2012

void search(node start,String b)

{
node temp=new node(start);
int f=-1;
while(temp!=null)
{
if(temp.n.equals(b)==true)
{
f=1;
break;
}
temp=temp.next;

if(f==1)
{
System.out.println(temp.n+" found");
System.out.prinlnt("Content:"+temp.p);

}
else
{
System.out.println("Node not found");
}
}
Question 8 2011
INPUT A SENTENCE FROM THE USER AND COUNT THE NUMBER OF TIMES,THE WORDS "AN" AND
"AND" ARE PRESENT IN
THE SENTENCE. DESIGN A CLASS FREQUENCY USING THE DESCRIPTION GIVEN BELOW:
CLASS NAME:FREQUENCY
DATA MEMBERS/ VARIABLES :
TEXT:STORES THE SENTENCE
COUNTAND: TO STORE THE FREQUENCY OF THE WORD "AND"
COUNTAN: TO STORE THE FREQUENCY OF THE WORD "AN"
LEN: STORES THE LENGTH OF THE STRING
MEMBER FUNCTIONS / METHODS:
FREQUENCY( ) :CONSTRUCTOR TO INITIALIZE THE INSTANCE VARIABLES
VOID ACCEPT(STRING N):TO ASSIGN N TO TEXT,WHERE THE VALUE OF THE PARAMETER N
SHOULD BE IN LOWER CASE.
VOID CHECKANDFREQ( ):TO COUNT THE FREQUENCY OF "AND"
VOID CHECKANFREQ( ):TO COUNT THE FREQUENCY OF "AN"
VOID DISPLAY( ):TO DISPLAY THE NUMBER OF"AND" AND "AN" WITH APPROPRIATE MESSAGES.
SPECIFY THE CLASS FREQUENCY GIVING DETAILS OF THE CONSTRUCTOR( ), VOID
ACCEPT(STRING),VOID CHECKANDFREQ( ),VOID CHECKANFREQ( ) AND VOID DISPLAY( ).ALSO
DEFINE THE MAIN( ) FUNCTION TO CREATE AN OBJECT AND CALL METHODS ACCORDINGLY TO
ENABLE THE TASK.
Answer 2011

import java.util.Scanner;

public class Frequency

{
String text;
int countand,countan,len;
public Frequency()
{
text="";
countand=0;
countan=0;
}

public void accept(String n)

{
text=n;
if(text.charAt(text.length()-1)!='.')
{
text=text+'.';
}

len=text.length();
}

public void checkandfreq()

{
int pos=0,i=0;
char ch=' ';
String b="";
for(i=0;i< len;i++)
{
ch=text.charAt(i);
if(ch==' '||ch=='.')
{
b=text.substring(pos,i);
if(b.equals("and")==true)
{
 2011

countand++;
}
pos=i+1;
}
}
}
public void checkanfreq()
{
int pos=0,i=0;
char ch=' ';
String b="";
for(i=0;i< len;i++)
{
ch=text.charAt(i);
if(ch==' '||ch=='.')
{
b=text.substring(pos,i);
if(b.equals("an")==true)
{
countan++;
}
pos=i+1;
}
}
}
public void display()
{
System.out.println("Number of and's="+countand);
System.out.println("Number of an's="+countan);
}

public static void main()

{
Scanner sc=new Scanner(System.in);
System.out.println("Enter a sentence in Lowercase");
String n=sc.nextLine();
Frequency ob1=new Frequency();
 2011

ob1.accept(n);
ob1.checkandfreq();
ob1.checkanfreq();
ob1.display();

}
}
Question 9 2011
A CLASS DECIOCT HAS BEEN DEFINED TO CONVERT A DECIMAL NUMBER INTO ITS EQUIVALENT
OCTAL NUMBER . SOME OF THE MEMBERS OF THE CLASS ARE GIVEN BELOW:
CLASSNAME:DECIOCT
DATA MEMBERS / INSTANCE VARIABLES:
N:STORES THE DECIMAL NUMBER
OCT:STORES THE OCTAL EQUIVALENT NUMBER
MEMBER FUNCTIONS:
DECIOCT():CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS , N=0, OCT=0.
VOID GETNUM(INT NN):ASSIGN NN TO N
VOID DECI_OCT():CALCULATES THE OCTAL EQUIVALENT OF 'N' AND STORES IT IN OCT USING
THE RECURSIVE TECHNIQUE
VOID SHOW():DISPLAYS THE DECIMAL NUMBER 'N', CALLS THE FUNCTION DECI_OCT() AND
DISPLAYS ITS OCTAL EQUIVALENT.
SPECIFY THE CLASS DECIOCT, GIVING DETAILS OF THE CONSTRUCTOR( ), VOID
GETNUM(INT),VOID DECI_OCT() AND VOID SHOW().ALSO DEFINE A MAIN() FUNCTION TO
CREATE AN OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO ENABLE THE TASK
Answer 2011

import java.util.Scanner;
public class DeciOct
{
int n,oct,i=0;
Scanner sc=new Scanner(System.in);
public DeciOct()
{
n=0;
oct=0;
i=0;
}
public void getnum(int nn)
{
n=nn;
}
public void deci_oct()
{
int c;

if(n!=0)
{
c=n%8;
n=n/8;
oct=oct+c*(int)Math.pow(10,i);
i=i+1;
deci_oct();

}
 2011

public void show()

{
System.out.println("Decimal number="+n);
deci_oct();
System.out.println("Octalequivalent="+oct);
}
public static void main()
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter a decimal num:");
int num=sc.nextInt();
DeciOct ob1=new DeciOct();
ob1.getnum(num);
ob1.show();
}
}
Question 10 2011
YOU ARE GIVEN A SEQUENCE OF N INTEGERS,WHICH ARE CALLED AS PSEUDO ARITHMETIC
SEQUENCES(SEQUENCES THAT
ARE IN ARITHMETIC PROGRESSION).
SEQUENCE OF N INTEGERS:2,5,6, 9,12
WE OBSERVE THAT 2+12=5+ 9=6+8=14.
THE SUM OF THE ABOVE SEQUENCE CAN BE CALCULATED AS 14 X 3 = 42.
FOR SEQUENCE CONTAINING AN ODD NUMBER OF ELEMENTS THE RULE IS TO DOUBLE THE
MIDDLE ELEMENT,FOR EXAMPLE
2,5,7,9,1
=2+12=5+9=7+7=14
14 X 3=42 [MIDDLE ELEMENT= 7]
A CLASS PSEUDOARITHMETIC DETERMINES WHETHER A GIVEN SEQUENCE IS A PSEUDO-
ARITHMETIC SEQUENCE . THE DETAILS OF THE CLASS ARE GIVEN BELOW:
CLASSNAME:PSEUDOARITHMETIC
DATA MEMBERS / INSTANCE VARIABLES:
N:TO STORE THE SIZE OF THE SEQUENCE
A[ ]:INTEGER ARRAY TO STORE THE SEQUENCE OF NUMBERS
ANS,FLAG:STORE THE STATUS
SUM:STORE THE SUM OF SEQUENCE OF NUMBERS
R:STORE THE SUM OF THE TWO NUMBERS
MEMBER FUNCTIONS:
PSEUDARITHMETIC():DEFAULT CONSTRUCTOR
VOID ACCEPT(INT NN): TO ASSIGN NN TO N AND TO CREATE AN INTEGER ARRAY.
FILL IN THE ELEMENTS OF THE ARRAY.
BOOLEAN CHECK():RETURN TRUE IF THE SEQUENCE IS A PSEUDO-ARITHMETIC SEQUENCE
OTHERWISE RETURNS FALSE

SPECIFY THE CLASS PSEUDOARITHMETLC , GIVING THE DETAILS OF THE CONSTRUCTOR() , VOID
ACCEPT(INT) AND BOOLEAN CHECK(). ALSO DEFINE MAIN() FUNCTION TO CREATE AN OBJECT
AND CALL THE MEMBER FUNCTIONS ACCORDINGLY TO ENABLE THE TASK.
Answer 2011

import java.util.Scanner;

public class Pseudoarithmetic

{
int n,sum,r;
boolean ans,flag;
int a[];
public Pseudoarithmetic()
{
ans=true;
flag=true;
}
public void accept(int nn)
{
int i=0;
Scanner sc=new Scanner(System.in);
n=nn;
a=new int[n];
System.out.println("Enter" +n + "elements");
for(i=0;i< n;i++)
{
a[i]=sc.nextInt();
}
}
public boolean check()
{
int i=0,j=0;
r=a[0]+a[n-1];
if(n%2==0)
{
for(i=0;i< n/2;i++)
{
if((a[i]+a[n-1-i])!=r)
{
flag=false;
}
}
 2011

}
else
{
for(j=0;j<= n/2;j++)
{
if((a[j]+ a[n-1-j])!=r)
{
ans=false;
}
}
}
if(flag ==true)
{
sum=n/2*r;
}
if(ans=true)
{
sum=(n/2+1)*r;
}
if(ans==false || flag==false)
{
return false;
}
else
{
return true;
}
}
public static void main()
{
Scanner sc=new Scanner(System.in);
System.out.println("enter size of sequence");
int nn=sc.nextInt();
Pseudoarithmetic ob1=new Pseudoarithmetic();
ob1.accept(nn);
System.out.println(ob1.check());
}
 2011

}
Question 11 2011
A SUPER CLASS RECORD HAS BEEN DEFINED TO STORE THE NAMES AND RANKS OF 50
STUDENTS. DEFINE A SUB-CLASS
RANK TO FIND THE HIGHEST RANK ALONG WITH THE NAME.THE DETAILS OF BOTH CLASSES ARE
GIVEN BELOW:
CLASSNAME:RECORD
DATA MEMBERS / INSTANCE VARIABLES:
NAME[ ]:TO STORE THE NAMES OF STUDENTS
MK[ ]:TO STORE THE RANKS OF STUDENTS
MEMBER FUNCTIONS:
RECORD():CONSTRUCTOR TO INITIALIZE DATA MEMBERS
VOID READVALUES():TO STORE THE NAMES AND RANKS
VOID DISPLAY():DISPLAY THE NAMES AND THE CORRESPONDING RANKS
CLASSNAME:RANK
DATA MEMBERS/ INSTANCE VARIABLES:
INDEX: INTEGER TO STORE THE INDEX OF THE TOP MOST RANK
MEMBER FUNCTIONS:
RANK():CONSTRUCTOR TO INVOKE THE BASE CLASS CONSTRUCTOR AND TO INITIALIZE
INDEX=0
VOID HIGHEST():FINDS THE INDEX/LOCATION OF THE TOP MOST RANK AND STORES IT IN INDEX
WITHOUT SORTING THE ARRAY.
VOID DISPLAY():DISPLAYS THE NAMES AND RANKS ALONG WITH THE NAME HAVING THE TOP
MOST RANK.
SPECIFY THE CLASS RECORD GIVING DETAILS OF THE CONSTRUCTOR(), VOID READVALUES()
AND VOID DISPLAY().USING THE CONCEPT OF INHERITANCE, SPECIFY THE CLASS RANK GIVING
DETAILS OF CONSTRUCTOR( ),VOID HIGHEST() AND VOID DISPLAY().
THE MAIN() FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2011

import java.util.Scanner;

public class Record

{
Scanner sc=new Scanner(System.in);
String name[]=new String[50];
int rnk[]=new int[50];
public Record()
{
for(int i=0;i< 50;i++)
{
name[i]="";
rnk[i]=0;
}
}
public void readvalue()
{
int i=0;
System.out.println("enter names & ranks");
for(i=0;i< 50;i++)
{
name[i]=sc.nextLine();
}
rnk[i]=sc.nextInt();

}
public void display()
{
int i=0;
for(i=0;i< 50;i++)
{
System.out.println(name[i]+","+rnk[i]);
}
}
}
 2011

import java.util.Scanner;
public class Rank extends Record
{
Scanner sc=new Scanner(System.in);
int index;
public Rank()
{
super();
index=0;
}
public void highest()
{
int i=0;
for(i=0;i< 50;i++)
{
if(rnk[index]>rnk[i])
{
index=i;
}
}
}
public void display()
{
readvalue();
highest();
super.display();
System.out.println("Name of the highest rank holder:"+name[index]);
}
}
Question 12 2011
STACK IS A KIND OF DATA STRUCTURE WHICH CAN STORE ELEMENTS WITH THE RESTRICTION
THAT AN ELEMENT CAN BE ADDED OR REMOVED FROM THE TOP ONLY.
THE DETAILS OF THE CLASS STACK IS GIVEN BELOW:
CLASSNAME:STACK
DATA MEMBERS/ INSTANCE VARIABLES:
ST[]: THE ARRAY TO HOLD THE NAMES
SIZE:THE MAXIMUM CAPACITY OF THE STRING ARRAY
TOP: THE INDEX OF THE TOP MOST ELEMENT OF THE STACK
CTR: TO COUNT THE NUMBER OF ELEMENTS OF THE STACK
MEMBER FUNCTIONS:
STACK( ): DEFAULT CONSTRUCTOR
STACK(INT CAP):CONSTRUCTOR TO INITIALIZE SIZE=CAP AND TOP=-1
VOID PUSHNAME(STRING N):TO PUSH A NAME INTO THE STACK. IF THE STACK IS FULL, DISPLAY
THE MESSAGE"OVERFLOW'
STRING POPNAME( ):REMOVES A NAME FROM THE TOP OF THE STACK AND RETURNS IT. IF THE
STACK IS EMPTY,DISPLAY THE MESSAGE "UNDERFLOW"
VOID DISPLAY():DISPLAY THE ELEMENTS OF THE STACK.
(A) SPECIFY CLASS STACK GIVING DETAILS OF THE CONSTRUCTORS( ), VOID PUSHNAME
(STRING N), STRING POPNAME() AND VOID DISPLAY().
THE MAIN() FUNCTION AND ALGORITHM NEED NOT BE WRITTEN.
Answer 2011

public class Stack

{
String st[]=new String[50];
int size,top,ctr,f;

public Stack(int cap)

{
size=cap;
f=0;
top=-1;
st=new String[size];
}

public void pushname(String n)

{
if(top< size)
{
top=top+1;
st[top]=n;
}
else
{
System.out.println("OVERFLOW");
}
}
public String popname()
{

String v;
if(top>=0)
{
top=top-1;
v=st[top];
return v;
}
else
{
 2011

System.out.println("UNDERFLOW");
return " ";
}

public void display()

{

for(int i=top;i>=0;i--)
{
System.out.println(st[i]);
}
}
}
Question 13 2011
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS ,
CLASS NODE
{
INT INFO;
NODE LINK;
}
WRITE A METHOD OR AN ALGORITHM DELETING A NODE IN THE LINKED LIST .THE METHOD
DECLARATION IS SPECIFIED BELOW:
VOID DELETENODE(NODE START);
Answer 2011

void deleteNode(Node start)

{
Scanner sc=new Scanner(System.in);
int n=0;
System.out.println("ENTER INFO FOR THE NODE TO BE DELETED");
n=sc.nextInt();
Node a=new Node(start);
if(start.info==n)
{
a=start;
start=start.link;
a.link=null;
}
else
{
a=a.link;
Node b=new Node(start);
while(a.info!=null)
{
if(a.info==n)
{
b.link=a.link;
a.link=null;
break;
}
}
}

}
Question 8 2010
THE COORDINATES OF A POINT P ON A TWO DIMENSIONAL PLANE CAN BE REPRESENTED BY
P(X,Y) WITH X AS THE X-COORDINATE AND Y AS THE Y-COORDINATE.THE COORDINATES OF
MIDPOINT OF TWO POINTS P1(X1,YI) AND P2(X2,Y2) CAN BE CALCULATED AS P(X,Y) WHERE:

X=(XL+X2)/2,Y=(Y1+Y2)/2
DESIGN A CLASS POINT WITH THE FOLLOWING DETAILS:

CLASSNAME : POINT

DATAMEMBERS / INSTANCEVARIABLES:
X: STORES THE X-COORDINATE
Y : STORES THE Y-COORDINATE

MEMBER FUNCTIONS:
POINT():CONSTRUCTOR TO INITIALIZE X=0,Y=0
VOID READPOINT():ACCEPTS THE COORDINATES X AND Y OF A POINT
POINT MIDPOINT(POINTA,POINTB):CALCULATES AND RETURNS THE MIDPOINT OF THE TWO
POINTS A AND B
VOID DISPLAYPOINT():DISPLAYS THE COORDINATES OF A POINT

SPECIFY THE CLASS POINT GIVING DETAILS OF THE CONSTRUCTOR() , MEMBER FUNCTIONS
VOID READPOINT() ,POINT MIDPOINT(POINT,POINT) AND VOID DISPLAYPOINT() ALONG WITH
THE MAIN() FUNCTION TO CREATE AN OBJECT AND CALL THE FUNCTIONS ACCORDINGLY TO
CALCULATE THE MIDPOINT BETWEEN ANY TWO GIVEN POINTS.
Answer 2010

import java.util.Scanner;
public class Point
{
double x,y;
Scanner sc = new Scanner(System.in);

public Point()
{
x=0.0;
y=0.0;
}

public void readpoint()

{
System.out.println("enter x");
x=sc.nextDouble();
System.out.println("enter y");
y=sc.nextDouble();
}

public void displaypoint()

{
System.out.println(x);
System.out.println(y);
}

public Point midpoint(Point A,Point B)

{
Point C=new Point();
C.x=(A.x+B.x)/2;
C.y =(A.y+B.y)/2;
return C;
}
 2010

public static void main()

{
Point p=new Point();
Point q=new Point();
Point r=new Point();
p.readpoint();
q.readpoint();
r=r.midpoint(p,q);
p.displaypoint();
q.displaypoint();
r.displaypoint();
}
}
Question 9 2010
INPUT A WORD IN UPPERCASE AND CHECK FOR THE POSITION OF THE FIRST OCCURRING VOWEL
AND PERFORM THE
FOLLOWING OPERATION.
(I)WORDS THAT BEGIN WITH A VOWEL ARE CONCATENATED WITH "Y".
FOR EXAMPLE:- EUROPE BECOMES EUROPEY.
(II) WORDS THAT CONTAINS A VOWEL IN-BETWEEN SHOULD HAVE THE FIRST PART FROM THE
POSITION OF THE VOWEL TILL END , FOLLOWED BY THE PART OF THE STRING FROM BEGINNING
TILL POSITION OF THE VOWEL AND IS CONCATENATED BY "C".
FOR EXAMPLE - PROJECT BECOMES OJECTPRC.
(III) WORDS WHICH DO NOT CONTAIN A VOWEL ARE CONCATENATED WITH "N".
FOR EXAMPLE - SKY BECOMES SKYN.
DESIGN A CLASS REARRANGE USING THE DESCRIPTION OF THE DATA MEMBERS AND MEMBER
FUNCTIONS GIVEN BELOW:
CLASSNAME:REARRANGE
DATA MEMBERS/INSTANCE VARIABLES:
TXT: TO STORE A WORD
CXT: TO STORE THE REARRANGED WORD
LEN: TO STORE THE LENGTH OF THE WORD
MEMBER FUNCTIONS:
REARRANGE():CONSTRUCTOR TO INITIALIZE THE INSTANCE VARIABLES
VOID READWORD():TO ACCEPT THE WORD INPUT IN UPPERCASE
VOID CONVERT():CONVERTS THE WORD INTO ITS CHANGED FORM AND STORES IT IN STRING
CXT
VOID DISPLAY():DISPLAYS THE ORIGINAL AND THE CHANGED WORD
SPECIFY THE CLASS REARRANGE GIVING THE DETAILS OF THE CONSTRUCTOR( ), VOID
READWORD( ),VOID CONVERT() AND VOID DISPLAY() . DEFINE A MAIN() FUNCTION TO CREATE
AN OBJECT AND CALL THE FUNCTION ACCORDINGLY TO ENABLE THE TASK.

INPUT:
ENTER THE SIZE OF ARRAY:10
ENTER THE ELEMENT IN THE ARRAY:
1 2 3 4 5 6 7 8 9 10

ARRAY AFTER DELETING EVEN POSITION ELEMENTS:

2 4 6 8 10
Answer 2010

import java.util.Scanner;
public class Rearrange
{
String Txt,Cxt;
int len;
Scanner sc = new Scanner(System.in);
public Rearrange()
{
Txt="";
Cxt="";
len=0;
}
public void readword()
{
System.out.println("enter word in UPPERCASE");
Txt=sc.nextLine();
len=Txt.length();
}
public void convert()
{
int flag=-1,i=0;
char ch=' ';
for(i=0;i< len;i++)
{
ch=Txt.charAt(i);
if(ch=='A'|| ch=='E'||ch=='I'||ch=='O'|| ch=='U')
{
flag=i;
break;
}
}
if(flag==-1)
{
Cxt=Txt.concat("N");
}
else if(flag==0)
{
 2010

Cxt=Txt.concat("Y");
}
else

{
String d=Txt.substring(flag,len);
String e=Txt.substring(0,flag);
Cxt=d+e+"C";
}
}
public void display()
{
System.out.println("Originalword=" +Txt);
System.out.println("Changedword="+Cxt);
}
public static void main()
{
Rearrange ob1=new Rearrange();
ob1.readword();
ob1.convert();
ob1.display();
}
}
Question 10 2010
DESIGN A CLASS CHANGE TO PERFORM STRING RELATED OPERATIONS . THE DETAILS OF THE
CLASS ARE GIVEN BELOW:
CLASSNAME: CHANGE
DATA MEMBERS / INSTANCE VARIABLES:
STR :STORES THE WORD
NEWSTR : STORES THE CHANGED WORD
LEN: STORE THE LENGTH OF THE WORD
MEMBERFUNCTIONS:
CHANGE():DEFAULT CONSTRUCTOR
VOID INPUTWORD():TO ACCEPT A WORD
CHAR CASECONVERT(CHAR CH) : CONVERTS THE CASE OF THE CHARACTER AND RETURNS IT
VOID RECCHANGE(INT):EXTRACTS CHARACTERS USING RECURSIVE TECHNIQUE AND CHANGES
ITS CASE USING CASECONVERT() AND FORMS A NEW WORD
VOID DISPLAY():DISPLAYS BOTH THE WORDS
(A) SPECIFY THE CLASS CHANGE, GIVING DETAILS OF THE CONSTRUCTOR(),MEMBER
FUNCTIONS
VOID INPUTWORD(), CHAR CASECONVERT(CHAR CH),VOID RECCHANGE(INT) AND VOID
DISPLAY().
DEFINE THE MAIN() FUNCTION TO CREATE AN OBJECT AND CALL THE FUNCTIONS ACCORDINGLY
TO ENABLE THE ABOVE CHANGE IN THE GIVEN WORD.
Answer 2010

import java.util.Scanner;
public class Change
{
String str,newstr;
int len;
Scanner sc = new Scanner(System.in);

public Change()
{
str="";
newstr="";
len=0;
}
public void inputword()
{
System.out.println("ENTER A Word");
str=sc.next();
len=str.length();
}
public char caseconvert(char ch)
{
if(ch>='A' && ch<='Z')
{
ch=Character.toLowerCase(ch);
}
else if(ch>='a' &&ch<='z')
{
ch=Character.toUpperCase(ch);
}
return ch;
}

public void recchange(int pos)

{
char c=' ';
 2010

if(pos>-1)
{
c=str.charAt(pos);
recchange(pos-1);
newstr+=caseconvert(c);
}
}
public void display()
{
System.out.println("ChangedWord:"+newstr);
System.out.println("OriginalWord:"+str);
}
public static void main()
{
Change ob1=new Change();
ob1.inputword();
int length=ob1.len;
ob1.recchange(length-1);
ob1.display();
}
}
Question 11 2010
A SUPER CLASS WORKER HAS BEEN DEFINED TO STORE THE DETAILS OF A WORKER .DEFINE A
SUB CLSS WAGES TO COMPUTE THE MONTHLY WAGES FOR THE WORKER. THE DETAILS /
SPECIFICATIONS OF BOTH THE CLASSES ARE
GIVEN BELOW:
CLASSNAME:WORKER
DATA MEMBERS / INSTANCE VARIABLES:
NAME:TO STORE THE NAME OF THE WORKER
BASIC:TO STORE THE BASIC PAY IN DECIMALS
MEMBERFUNCTIONS:
WORKER(...): PARAMETERISED CONSTRUCTOR TO ASSIGN VALUES TO THE INSTANCE VARIABLES
VOID DISPLAY():
CLASSNAME: WAGES
DATA MEMBERS / INSTANCE VARIABLES:
HRS:STORES THE HOURS WORKED
RATE:STORES RATE PER HOUR
WAGE:STORES THE OVERALL WAGE OF THE WORKER
MEMBER FUNCTIONS:
WAGES(...):PARAMETERISED CONSTRUCTOR TO ASSIGN VALUES TO THE INSTANCE VARIABLES
OF BOTH THE CLASSES
DOUBLE OVERTIME():CALCULATES AND RETURNS THE OVERTIME AMOUNT AS (HOURS*RATE)
VOID DISPLAY():CALCULATES THE WAGE USING THE FORMULA
WAGE = OVERTIME AMOUNT+BASIC PAY
AND DISPLAYS IT ALONG WITH THE OTHER DETAILS
SPECIFY THE CLASS WORKER GIVING, DETAILS OF THE CONSTRUCTOR() AND VOID
DISPLAY().USING THE CONCEPT OF INHERITANCE, SPECIFY THE CLASS WAGES GIVING DETAILS
OF CONSTRUCTOR( ), DOUBLE OVERTIME() AND VOID DISPLAY().THE MAIN() FUNCTION NEED
NOT BE WRITTEN.
Answer 2010

public class Worker

{
String Name;
double Basic;

public Worker(String n,double b)

{
Name=n;
Basic=b;
}
public void display()
{
System.out.println("Name of worker :"+Name);
System.out.println("Basic Pay of worker :"+Basic);
}
}

public class Wages extends Worker

{
int hrs;
double rate,wage;

public Wages(String a,double b,int c,double d)

{
super(a,b);
hrs=c;
rate=d;
wage=0.0;
}
public double overtime()
{
return(rate*hrs);
}
public void display()
{
double x=overtime();
 2010

wage=x+super.Basic;
super.display();
System.out.println("Wage="+wage);
}
}
Question 12 2010
DEFINE A CLASS REPEAT WHICH ALLOWS THE USER TO ADD ELEMENTS FROM ONE END(REAR)
AND REMOVE ELEMENTS FROM THE OTHER END(FRONT)ONLY.
THE FOLLOWING DETAILS OF THE CLASS REPEAT ARE GIVEN BELOW:
CLASSNAME:REPEAT
DATA MEMBERS/ INSTANCE VARIABLES:
ST[]:AN ARRAY TO HOLD A MAXIMUM OF
100 INTEGER ELEMENTS
CAP:STORES THE CAPACITY OF THE ARRAY
F:TO POINT THE INDEX OF THE FRONT
R:TO POINT THE INDEX OF THE REAR
MEMBER FUNCTIONS:
REPEAT(INT M):CONSTRUCTOR TO INITIALIZE THE DATA MEMBERS CAP=M, F=0,R=0 AND TO
CREATE THE INTEGER ARRAY
VOID PUSHVALUE(INT V):TO ADD INTEGERS FROM THE REAR INDEX IF POSSIBLE ELSE DISPLAY
THE MESSAGE("OVERFLOW")
INT POPVALUE():TO REMOVE AND RETURN ELEMENT FROM THE FRONT.IF ARRAY IS EMPTY THEN
RETURN -9999
VOID DISP():DISPLAYS THE ELEMENTS PRESENT IN THE LIST
A) SPECIFY.THE CLASS REPEAT GIVING DETAILS OF THE CONSTRUCTOR(INT), MEMBER
FUNCTION VOID PUSHVALUE(INT) , INT POPVALUE() AND VOID DISP() . THE MAIN() FUNCTION
NEED NOT BE WRITTEN.
Answer 2010

public class Repeat

{
int st[]=new int[100];
int cap,f,r;

public Repeat(int m)
{
cap=m;
f=0;
r=0;
st=new int[cap];
}

public void pushvalue(int v)

{
if((r+1)<=cap)
{
r=r+1;
st[r]=v;
}
else
{
System.out.println("OVERFLOW");
}
}
public int popvalue()
{

int v;
if(r!=f)
{
f=f+1;
v=st[f];
return v;
}
else
{
 2010

return -9999;
}

public void display()

{
if(r!=f)
{
for(int i=f+1;i<=r;i++)
{
System.out.println(st[i]);
}
}
else
{
System.out.println("Queue is empty");
}
}
}
Question 13 2010
A LINKED LIST IS FORMED FROM THE OBJECTS OF THE CLASS ,
CLASS LISTNODES
{
INT ITEM;
LISTNODES NEXT;
}
WRITE A METHOD OR AN ALGORITHM TO COMPUTE AND RETURN THE SUM OF ALL INTEGERS
ITEMS STORED IN THE LINKED LIST .THE METHOD DECLARATION IS SPECIFIED BELOW:
INT LISTSUM(LISTNODES START);
Answer 2010

int listsum(ListNodes start)

{
int total=0;
ListNodes runner=start;
while(runner!=null)
{
total +=runner.item;
runner=runner.next;
}
return total;
}