ICSE Class 10 Computer Applications — All Questions

Java Virtual Machine

Reason — JVM stands for Java Virtual Machine, which is responsible for executing Java bytecode and enables Java programs to run on any platform (platform independence).

\\

Reason —

1. 25 is an integer literal. In Java, an int occupies 4 bytes, hence it is not correct.
2. AM represents a string consisting of two characters. Each character occupies 2 bytes, so total memory required is 4 bytes, hence it is not correct.
3. 35.2 is a double literal. In Java, a double occupies 8 bytes, hence it is not correct.
4. \\ represents a single character (backslash) using an escape sequence ('\\'). In Java, a char occupies 2 bytes, hence it is correct.

c

Reason — In the statement c = c + (x * d + e);, the variable c appears on both sides of the assignment and continuously stores the updated result by adding new values to its previous value, which is the defining property of an accumulator. The variables x, d, and e are only used to compute the expression once and do not store cumulative results, hence they are not accumulators.

package

Reason — In Java, the valid access specifiers are private, protected, and public.

36.0

Reason — In the expression Math.pow(36, 6/5), the division 6/5 is performed first using integer division, which results in 1 (not 1.2). Therefore, the expression becomes Math.pow(36, 1), which evaluates to 36.0 since the pow() method returns a double value.

z = a > b ? 25 : 35;

Reason — The ternary operator follows the format condition ? value_if_true : value_if_false. In the given if-else statement, when a > b is true, z is assigned 25, otherwise it is assigned 35. Hence, the correct equivalent ternary expression is z = a > b ? 25 : 35;.

68

Reason — The method Character.toUpperCase('b') converts 'b' to 'B'. In Java, when a character is used in an arithmetic expression, it is converted to its ASCII (Unicode) value. The ASCII value of 'B' is 66, and adding 2 gives 66 + 2 = 68. Hence, the output is 68.

desktop, Mainframe

Reason — In the given statements, Computer is the class name, while desktop and Mainframe are the object names (variables that store object references). Therefore, the objects of the class are desktop and Mainframe.

Nested loop

Reason — The Earth performs two repeated motions:

• it rotates on its axis once every day, and
• it revolves around the Sun in 365 days.

This means that for one complete revolution, the rotation is repeated many times. One activity is taking place repeatedly within another activity.

In Java, such a situation is represented by a nested loop, where:

• the outer loop represents the revolution of the Earth around the Sun, and
• the inner loop represents the daily rotation of the Earth on its axis.

Hence, the Java concept illustrated in this scenario is nested loop.

String

Reason — The method is required to return "YES" or "NO", which are textual values. In Java, such values are represented using the String data type. Hence, the return type of the method should be String, not boolean, int, or double.

The complete method prototype:

public String someMethod(char ch, int n)

polymorphism

Reason — Polymorphism in Java allows multiple methods with the same name but different parameters (method overloading). In a calculator, different operations like addition, subtraction, etc., can be implemented using methods with the same name calculate() but with different parameter lists, which is a feature of polymorphism.

(A) is true and (R) is false.

Reason — In the expression 3 + 7/2, division has higher precedence than addition, so 7/2 is evaluated first using integer division, giving 3, and then added to 3 → 3 + 3 = 6, so Assertion (A) is true. However, the Reason (R) is incorrect because it wrongly states that addition is performed before division, which is not true in Java operator precedence.

String

Reason — The method Integer.parseInt() is used to convert a numeric value given in String form into an integer. Therefore, it requires a String parameter as input, not double, char, or int.

6

Reason — The method substring(beginIndex, endIndex) extracts characters from the starting index up to (but not including) the ending index. In "ACKNOWLEDGEMENT", the word "NOW" starts at index 3 (N) and ends at index 5 (W). Since the ending index is exclusive, we use 5 + 1 = 6 to include index 5. Hence, substring(3, 6) correctly extracts "NOW".

d*a

Reason — In the array, a[1] is "Aditi", so a[1].charAt(1) gives 'd'. Similarly, a[2] is "Anant", so a[2].charAt(2) gives 'a'. The expression uses "*" as a String, so the + operator performs concatenation, resulting in "d*a".

compareTo()

Reason — The compareTo() method compares two strings lexicographically and returns an integer value which can be positive, zero, or negative depending on the comparison. The methods length() returns the length (non-negative), equals() returns a boolean, and charAt() returns a character, so none of them can return a negative value.

Bubble sort

Reason — The array is arranged in ascending order by repeatedly comparing and swapping adjacent elements. First, 4 and 1 are swapped to get 1 4 3, and then 4 and 3 are swapped to get 1 3 4. This step-by-step swapping of adjacent elements is the characteristic feature of Bubble Sort.

100

Reason — The data is stored in a two-dimensional array for 5 salesmen and 5 products, so total elements = 5 × 5 = 25. Each element is of type int, and in Java an int occupies 4 bytes. Therefore, total memory required = 25 × 4 = 100 bytes.

(A) is false and (R) is true.

Reason — In Java, Strings are immutable, so the substring() method does not modify the original String, it returns a new String, making Assertion (A) false. However, the method does extract a part of the String starting from a specific index, which makes Reason (R) true.

Parameters

Reason — In constructor overloading, all constructors must have the same name as the class but differ in their parameter list (number, type, or order of parameters).

int a = 5, b = 10;
for( ; b > 0; b -= 2)
{
}
System.out.println(a * b);

x = a * b % (++c) + (++a) + (--b)
x = 7 * 8 % (++c) + (++a) + (--b)
x = 7 * 8 % 3 + 8 + 7 (c becomes 3, a becomes 8, b becomes 7)
x = 56 % 3 + 8 + 7
x = 2 + 8 + 7
x = 17

Math.cbrt(x) + Math.abs(y)

String idStatus = (age > 10) ? "Eligible" : "Not Eligible";
System.out.println(idStatus);

IOUS
false

• The substring() method is used to extract a part of a string starting from a specified index. In the given statement, "GRACIOUS".substring(4) extracts characters from index 4 to the end, resulting in "IOUS".

• The endsWith() method checks whether a string ends with a specified sequence of characters and returns a boolean value. Here, "GLAMOROUS".endsWith("IOUS") checks if the string ends with "IOUS", which is false, so it prints false.

Number of times the loop is executed: 3 times

3
5
7

• The do-while loop executes the block first and then checks the condition.
• Initial value: K = 1
  • 1st iteration: K = 1 + 2 = 3 → printed
  • Condition: 3 <= 6 → true
• 2nd iteration: K = 3 + 2 = 5 → printed
  • Condition: 5 <= 6 → true
• 3rd iteration: K = 5 + 2 = 7 → printed
  • Condition: 7 <= 6 → false → loop stops

Hence, the loop executes 3 times.

The logical error occurs because the factorial variable f is initialized to 0. Since multiplication with 0 always results in 0, the loop will never produce the correct factorial value.

The corrected code is as follows:

int p, n = 5, f = 1;
for(p = n; p > 0; p--)
f *= p;
System.out.println(f);

Maximum element index: X[2][0]
Minimum element index: X[1][1]

This is a 2D array (matrix) with 4 rows and 2 columns. Each element is accessed using X[row][column].

To find the maximum element, all values in the array are compared. The largest value is 19, which is located in row 2 and column 0. Hence, its index is X[2][0].

To find the minimum element, all values are compared again. The smallest value is 2, which is located in row 1 and column 1. Hence, its index is X[1][1].

void swap()
{ int x[] = {4, 8, 19, 24, 15};
x[0] = x[0] * x[1];
x[1] = x[0] / x[1];
x[0] = x[0] / x[1];
System.out.println(x[0] + " " + x[1]); }

Explanation

The first two elements of the array are:

• x[0] = 4
• x[1] = 8

The swapping is done without using a third variable by using multiplication and division.

Step 1

x[0] = x[0] * x[1];

So,

x[0] = 4 * 8 = 32

Now:

• x[0] = 32
• x[1] = 8

Step 2

x[1] = x[0] / x[1];

So,

x[1] = 32 / 8 = 4

Now:

• x[0] = 32
• x[1] = 4

Step 3

x[0] = x[0] / x[1];

So,

x[0] = 32 / 4 = 8

Now:

• x[0] = 8
• x[1] = 4

Thus, the values of the first and second elements are interchanged.

Output

8 4

(a) boolean

(b) toUpperCase()

import java.util.Scanner;

class StepTracker
{
    String name;
    int sw;
    double cb, km;

    public void accept()
    {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter name: ");
        name = sc.nextLine();
        System.out.print("Enter steps walked: ");
        sw = sc.nextInt();
    }

    public void calculate()
    {
        cb = sw * 0.04;
        km = sw / 1300.0;
    }

    public void display()
    {
        System.out.println("Name: " + name);
        System.out.println("Calories Burned: " + cb);
        System.out.println("Distance (km): " + km);
    }

    public static void main(String args[])
    {
        StepTracker obj = new StepTracker();
        obj.accept();
        obj.calculate();
        obj.display();
    }
}

import java.util.Scanner;

class EmployeeDesignation
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);

        String desig[] = new String[100];
        int i, count = 0;
        String search;

        for(i = 0; i < 100; i++)
        {
            System.out.print("Enter designation: ");
            desig[i] = sc.nextLine();
        }

        System.out.print("Enter designation to search: ");
        search = sc.nextLine();

        for(i = 0; i < 100; i++)
        {
            if(desig[i].equalsIgnoreCase(search))
            count++;
        }

        System.out.println("Total employees with designation " + search + ": " + count);
    }
}

import java.util.Scanner;

class SparseMatrix
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);

        int a[][] = new int[4][5];
        int i, j, zero = 0, nonzero = 0;

        for(i = 0; i < 4; i++)
        {
            for(j = 0; j < 5; j++)
            {
                System.out.print("Enter element: ");
                a[i][j] = sc.nextInt();
            }
        }

        for(i = 0; i < 4; i++)
        {
            for(j = 0; j < 5; j++)
            {
                if(a[i][j] == 0)
                    zero++;
                else
                    nonzero++;
            }
        }

        System.out.println("Number of zero elements = " + zero);
        System.out.println("Number of non zero elements = " + nonzero);

        if(zero > nonzero)
            System.out.println("Matrix is a Sparse Matrix");
        else
            System.out.println("Matrix is not a Sparse Matrix");
    }
}

import java.util.Scanner;

class MarkNumber
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);

        int n, d, sum = 0, temp;

        System.out.print("Enter number: ");
        n = sc.nextInt();

        temp = n;

        while(n > 0)
        {
            d = n % 10;
            sum += d * d;
            n = n / 10;
        }

        if(sum % 2 == 0 && (sum % 10 == temp % 10))
            System.out.println("It is a Mark Number");
        else
            System.out.println("It is not a Mark Number");
    }
}

1 2 3 4 5
2 3 4 5
3 4 5
4 5
5

int format(String s): To calculate and return the sum of ASCII codes of each character of the String.

Example: CAB
Output: 67 + 65 + 66
198

void format(int n): To calculate and display the sum of natural numbers up to n given by the formula.

$\frac{n(n+1)}{2}$

import java.util.Scanner;

class OverloadFormat
{
    public void format()
    {
        int i, j;
        for(i = 1; i <= 5; i++)
        {
            for(j = i; j <= 5; j++)
            {
                System.out.print(j + " ");
            }
            System.out.println();
        }
    }

    public int format(String s)
    {
        int i, sum = 0;
        for(i = 0; i < s.length(); i++)
        {
            sum += (int)s.charAt(i);
        }
        return sum;
    }

    public void format(int n)
    {
        int sum;
        sum = n * (n + 1) / 2;
        System.out.println("Sum = " + sum);
    }

    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        OverloadFormat obj = new OverloadFormat();

        obj.format();

        System.out.print("Enter a string: ");
        String str = sc.nextLine();
        int result = obj.format(str);
        System.out.println("Sum of ASCII = " + result);

        System.out.print("Enter a number: ");
        int num = sc.nextInt();
        obj.format(num);
    }
}

import java.util.Scanner;

class SymbolicWord
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);

        String w, res;
        int i, pos = -1;

        System.out.print("Enter a word: ");
        w = sc.nextLine();
        int l = w.length();

        for(i = 0; i < l; i++)
        {
            char ch = Character.toUpperCase(w.charAt(i));
            if(!(ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U'))
            {
                pos = i;
                break;
            }
        }

        if(pos != -1)
            res = w.substring(pos) + w.substring(0, pos) + "TR";
        else
            res = w + "TR";

        System.out.println("Symbolic word: " + res);
    }
}

java.lang

Reason — The Character class methods are found in the java.lang package because this package contains fundamental classes that are automatically available in every Java program. The Character class provides methods to work with characters, such as checking whether a character is a letter, digit, uppercase, or lowercase.

122

Reason — In the statement System.out.println('Z' + 32);, the character 'Z' is converted to its ASCII value 90, and then 32 is added to it, giving the result 122. Since the + operator with a character and an integer results in an integer, the output displayed will be 122.

32

Reason — The double data type in Java occupies 8 bytes of memory. In the array double x[] = {2.5, 4.5, 5.5, 6.4};, there are 4 elements, and each element takes 8 bytes. So, the total memory occupied is 4 × 8 = 32 bytes.

1

Reason — According to operator precedence in Java, division (/) and modulus (%) have the same priority and are evaluated from left to right.

42 / 6 % 2

= 7 % 2

= 1

P[1][1]

Reason — In a two-dimensional array P[2][3], the first index represents the row and the second index represents the column. The device "barcode scanner" is located in the second row (index 1) and the second column (index 1), so its index is P[1][1].

1 and 3

Reason — A user-defined data type is a data type defined by the user. In the given options, array and class are user-defined data types because they are created by the user to store multiple values or define their own structure. double and boolean are predefined (primitive) data types.

for(int i = 2; i != 0; i -= 3)

Reason — The loop for(int i = 2; i != 0; i -= 3) is an infinite loop because the value of i starts at 2 and decreases by 3 in every iteration. Since i will never become 0 (it will take values like 2, -1, -4, -7, etc.), the condition i != 0 will always be true. Therefore, the loop will continue to run forever.

-5

Reason — The method Math.min(-5, -4) returns the smaller of the two values, which is -5. Then, Math.max(-7, -5) returns the greater of the two values, which is -5. Hence, the final output of Math.max(-7, Math.min(-5, -4)) is -5.

Game is a class and cricket is an object

Reason — In the statement Game cricket = new Game();, Game is the name of the class, and cricket is the object (or instance) created from that class. The new keyword is used to create a new object of the class. Therefore, Game is the class, and cricket is the object.

public

Reason — A Post Office is accessible to everyone in a community, just like a public access specifier in programming, which allows members of a class to be accessible from any other class or part of the program. Hence, a Post Office is an example of public access specifier.

Both (A) and (R) are true and (R) is a correct explanation of (A).

Reason — In a switch case, the break statement stops the program from executing the next cases after a match is found. Without the break, the program would continue to run all the cases below the matched one (called fall through). Therefore, the break statement helps to execute only one case at a time.

for

Reason — The teacher asks the students to do the side stretch 10 times, which means repeating the same action multiple times. In programming, the for loop is used to repeat a block of code a specific number of times. Hence, the teacher is using the concept similar to a for loop to instruct repetition.

ar.length – 1

Reason — In Java, the length of an array ar is given by ar.length (without parentheses). Since array indexing starts from 0, the last element's index is always one less than the total length of the array. Therefore, the index of the last element is ar.length – 1.

Both (A) and (R) are true and (R) is a correct explanation of (A).

Reason — A clock is a real-life example of nested loops because the hour hand moves through 12 positions, and within each hour, the minute hand moves through 60 positions. This shows that one loop (minute hand) runs inside another loop (hour hand), which is similar to the concept of nested loops in programming.

void test(int a) and int test(int a)

Reason — In Java, method overloading depends on the method's name and its parameter list (number or type of parameters). The return type alone is not considered for method overloading. So, void test(int a) and int test(int a) have the same name and same parameter list, which causes a compile-time error because they differ only in return type, not in parameters.

Double.parseDouble("25")

Reason — In Java, the method Double.parseDouble("25") is used to convert a string containing a numeric value into a double data type. It belongs to the Double class and takes a string as an argument, returning its equivalent double value.

00

Reason

1. Initialization: int p = 0;

• This line declares an integer variable p and initializes it to 0.

2. For Loop: for(p = 4; p > 0; p -= 2);

• p = 4 → loop starts with p assigned the value 4.
• Condition: p > 0 is true (since 4 > 0).
• The semicolon (;) at the end means the loop body is empty and does nothing.
• Update: p -= 2 decreases p by 2.
• Next value of p = 2 → still > 0, so the loop continues.
• Decrease again: p -= 2 → p = 0 → now the condition p > 0 is false, loop stops.

3. After the Loop: p is now 0.

4. Output Statements:

• System.out.print(p); prints 0 without moving to the next line.
• System.out.println(p); prints 0 and moves to the next line.

I said, "It's wise to obey elders."

Reason — In Java, the backslash \ is used as an escape character. The statement uses escape sequences:

• \" to include double quotes inside a string.
• \' to include a single quote inside a string.

So the output preserves both the double quotes around "It's wise to obey elders." and the apostrophe in It's.

Hence, the output is: I said, "It's wise to obey elders."

6

Reason — The compareTo() method compares two strings lexicographically by comparing their characters one by one. It returns the difference between the first pair of characters that differ in the two strings.

Here, comparing "ANGER" and "ANGEL":

• Characters 'A', 'N', 'G', and 'E' are the same in both strings at positions 0 to 3.
• At position 4, 'R' (ASCII value 82) in "ANGER" is compared with 'L' (ASCII value 76) in "ANGEL".
• The difference is 82 - 76 = 6.

Thus, the output is 6.

3, 1, 4, 2

Reason — To calculate and return the factorial of 4 using a loop, we must follow the proper sequence of statements:

1. long fa = 1, k; – This is the declaration and initialization of variables fa and k.
2. for(k = 1; k <= 4; k++) – This sets up a loop to run from 1 to 4.
3. fa *= k; – This multiplies the current value of fa by k during each iteration.
4. return fa; – This returns the final calculated factorial value.

So, the correct order is: 3, 1, 4, 2, which correctly calculates and returns the factorial.

Math.sqrt(P) * Math.sqrt(Q)

entrix

• x.substring(3) returns the substring of "talent" from index 3 onwards, i.e., "ent".
• y.substring(3) returns the substring of "matrix" from index 3 onwards, i.e., "rix".
• The concat() method joins both substrings: "ent" + "rix" = "entrix".

Robot sifra = new Robot(2.5, 3.5, 4.5);

int a = 10, b = 1;
do {
    b += a;
    b++;
    a -= 2;
} while(a >= 1);
System.out.print(b);

150
20

1. Class Definition:

• The class report is defined with two integer variables: a and b.

2. Constructors:

• Default constructor: report()
  This constructor sets the values of a and b to 10 and 15, respectively, when an object is created without any parameters.

• Parameterized constructor: report(int x, int y)
  This constructor accepts two integer values x and y and assigns them to a and b.

3. Method print():

• This method prints the product of the two variables a and b.

4. Static method main():
Inside the main() method:

• First, an object r of class report is created using the default constructor.
• Then, the print() method is called on r which prints the product 10 * 15 = 150.
• Next, an object p is created using the parameterized constructor with values 4 and 5.
• The print() method is called on p which prints the product 4 * 5 = 20.

(a) length()

(b) charAt()

The compile-time error occurs because the variable l is used before it is initialized.

The corrected code is as follows:

class area{
    double area(double r, double h){
        double l, a;
        l = Math.sqrt(r * r + h * h);
        a = 22.0 / 7 * r * l;
        return a;
    }
}

(a) 14

(b) The largest element in the array is 12, which is at index 0.

• a[0] is 12.
• a[5] is 2.
• Sum = 12 + 2 = 14.

(a) x[3][2] = {{1, 3}, {5, 7}, {9, 11}};

(b) 14

• x[0][1] = 3.
• x[2][1] = 11.
• Sum = 3 + 11 = 14.

JAVA
VA

The loop executes 2 times.

• The string x contains the value "JAVA", which has a length of 4.
• The for loop initializes i to 0 and increments it by 2 in each iteration (i = 0, 2).
• In the first iteration, when i is 0, x.substring(0) extracts the substring from index 0 to the end, which is "JAVA". This is printed.
• In the second iteration, when i is 2, x.substring(2) extracts the substring from index 2 to the end, which is "VA". This is printed.
• When i becomes 4, the condition i < x.length() (i.e., 4 < 4) becomes false, so the loop terminates.
• Therefore, the loop executes exactly 2 times, printing the substrings "JAVA" and "VA".

import java.util.Scanner;
class CloudStorage{
    int acno;
    int space;
    double bill;
    public void accept(){
        Scanner in = new Scanner(System.in);
        System.out.print("Account number: ");
        acno = in.nextInt();
        System.out.print("Space: ");
        space = in.nextInt();
    }
    public void calculate(){
        if(space <= 15)
            bill = space * 15;
        else if(space <= 30)
            bill = 225 + (space - 15) * 13;
        else
            bill = 420 + (space - 30) * 11;
    }
    public void display(){
        System.out.println("Account No. " + acno);
        System.out.println("Storage space: " + space);
        System.out.println("Bill: " + bill);
    }
    public static void main(String[] args){
        CloudStorage obj = new CloudStorage();
        obj.accept();
        obj.calculate();
        obj.display();
    }
}

1	2	1	3
5	2	1	6
3	6	1	2
3	4	6	3

Sum of squares of elements = 1 + 4 + 1 + 9 + 25 + 4 + 1 + 36 + 9 + 36 + 1 + 4 + 9 + 16 + 36 + 9 = 201
NORM = Square root of 201 = 14.177446878757825

import java.util.Scanner;
class Norm{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int a[][] = new int[4][4];
        int sum = 0;
        System.out.println("Enter array elements:");
        for(int i = 0; i < 4; i++){
            for(int j = 0; j < 4; j++){
                a[i][j] = in.nextInt();
            }
        }
        
        for(int i = 0; i < 4; i++){
            for(int j = 0; j < 4; j++){
                sum += a[i][j] * a[i][j];
            }
        }
        
        double root = Math.sqrt(sum);
        System.out.println("NORM = " + root);
    }
}

import java.util.Scanner;
class SuperString{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.print("Enter the string: ");
        String s = in.nextLine();
        int upper = 0;
        int lower = 0;
        int l = s.length();
        for(int i = 0; i < l; i++){
            char ch = s.charAt(i);
            if(Character.isUpperCase(ch))
                upper++;
            else if(Character.isLowerCase(ch))
                lower++;
        }
        if(upper == lower)
            System.out.println("String is a Super String");
        else
            System.out.println("String is not a Super String");
    }
}

import java.util.Scanner;
class Search{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        char a[] = {'A', 'H', 'N', 'P', 'S', 'U', 'W', 'Y', 'Z', 'b', 'd'};
        System.out.print("Character to be searched: ");
        char key = in.next().charAt(0);
        int low = 0;
        int high = a.length - 1;
        int mid = 0;
        while(low <= high){
            mid = (low + high) / 2;
            if(key == a[mid])
                break;
            else if(key < a[mid])
                high = mid - 1;
            else
                low = mid + 1;
        }
        if(low > high)
            System.out.println("Search is not successful");
        else
            System.out.println("Search is successful");
    }
}

@#@#@
@#@#@
@#@#@
@#@#@

double print(double a, double b) – To display the sum of numbers between a and b with difference of 0.5.
e.g. if a = 1.0, b = 4.0
Output is: 1.0 + 1.5 + 2.0 + 2.5 + … + 4.0
int print(char ch1, char ch2) – Compare the two characters and return the ASCII code of the largest character.

import java.util.Scanner;

class Overload {
    public void print() {
        for(int i = 0; i < 4; i++) {
            for(int j = 0; j < 5; j++) {
                if (j % 2 == 0) {
                    System.out.print('@');
                }
                else {
                    System.out.print('#');
                }
            }
            System.out.println();
        }
    }

    public double print(double a, double b) {
        double sum = 0.0;
        for(double i = a; i <= b; i += 0.5)
            sum += i;
        System.out.println("Sum = " + sum);
        return sum;
    }

    public int print(char ch1, char ch2) {
        int maxAscii = (ch1 > ch2) ? (int)ch1 : (int)ch2;
        System.out.println("Larger ASCII code = " + maxAscii);
        return maxAscii;
    }

    public static void main(String[] args) {
        Overload obj = new Overload();
        Scanner sc = new Scanner(System.in);
        System.out.println("Pattern:");
        obj.print();
        System.out.print("\nEnter two decimal values (a and b): ");
        double a = sc.nextDouble();
        double b = sc.nextDouble();
        obj.print(a, b);
        System.out.print("\nEnter two characters: ");
        char ch1 = sc.next().charAt(0);
        char ch2 = sc.next().charAt(0);
        obj.print(ch1, ch2);
    }
}

import java.util.Scanner;

class Find{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.print("Enter the number: ");
        
        int num = in.nextInt();
        int sum = 0;
        int s = 10;
        int l = -1;
        
        while (num != 0) {
            int d = num % 10;
            
            if (d < s)
                s = d;
                
            if (d > l)
                l = d;
                
            num /= 10;
        }
        
        sum = s + l;
        
        if(sum % 2 == 0)
            System.out.println("Sum is even");
        else
            System.out.println("Sum is odd");
    }
}

equals()

Reason — In Java, the equals() method compares the contents of two strings and returns a boolean value (true or false), whereas trim(), replace(), and concat() return new strings, not boolean values.

switch construct

Reason — The switch construct can be used to select and execute only the case that matches the required ice cream choice, skipping all other cases, which makes it suitable when only one specific ice cream needs to be selected from several options.

check() has return type int

Reason — In the method prototype int check(char ch, String s), the keyword int before the method name specifies that the method returns an integer value. The parameters char ch and String s are formal parameters, and the method is not a constructor as it has a return type.

round()

Reason — The round() method returns an int. Other methods like cbrt() and ceil() return double, while random() returns a double value between 0.0 and 1.0.

5

Reason — In the string "MONOPOLY", the character 'O' occurs at indexes 1, 3, and 5 (indexing starts from 0). The lastIndexOf('O') method returns the last occurrence of 'O', which is at index 5.

int amount = (int) valueINR;

Reason — The correct syntax to typecast a double to an int in Java is by placing (int) before the double variable, which converts it to an integer by removing its decimal part.

5 4

Reason — In System.out.print(lives--), the post-decrement operator (lives--) prints the current value of lives (which is 5) first, then decreases it to 4. The next System.out.print(lives) prints the updated value 4.

PROGRAM

Reason — In the string "JavaProgramming", indexing starts at 0. substring(4, 11) extracts characters from index 4 to 10, which is "Program". Calling .toUpperCase() converts it to "PROGRAM".

private

Reason — In Java, the private access specifier restricts a member’s visibility so it can be accessed only within the same class where it is declared.

false

Reason — The method Character.isLetterOrDigit('\n') checks whether the given character is a letter or a digit. The character '\n' represents a newline, which is neither a letter nor a digit, so the method returns false.

only 1

Reason — In Java, the main types of tokens are keywords, identifiers, literals, operators, and separators. A method is not considered a token; it is a block of code that performs a task.

Method prototype

Reason — In Java, a method prototype specifies the method’s access specifier, return type, name, and parameter list without including its body. The statement public void Accept(int a) shows these elements but does not contain a method body, so it is a method prototype.

False

Reason — The code declares a boolean variable flag with the value false, checks it in the if condition, and since it evaluates to false, the if block is skipped and the else block executes, printing False to the output.

isLetter(char)

Reason — The method isLetter(char) belongs to the Character class and is a static method, meaning it can be called using the class name without creating an object. The other methods (length(), nextLine(), substring(int)) are instance methods that require an object to be invoked.

jeev

Reason — In the array, the element at position 2 is "Rajeev". In Java, string indexing starts from 0, so index 0 = R, index 1 = a, and index 2 = j. Using substring(2) means we take all characters from index 2 to the end, giving "jeev".

-8

Reason — First, Math.ceil(-8.8) returns -8.0 because ceil() rounds a number up to the nearest integer (for negative numbers, “up” means closer to zero). Then, Math.round(-8.0) returns the integer -8, as round() converts a floating-point number to the nearest whole number.

x[2][2]=100;

Reason — In Java, array indexing starts from 0, so a 3 × 3 array has valid row and column indices 0, 1, and 2. The last element is at row index 2 and column index 2, so x[2][2] = 100; correctly assigns the value 100 to that element.

S[1][0]

Reason — In a two-dimensional array S[2][3], the first index represents the row and the second index represents the column, both starting from 0. Based on the given arrangement of storage devices, the element "Hard disk" is located in the second row (index 1) and first column (index 0), so its index is S[1][0].

11

Reason — The loop starts with k = 10 and runs while k >= 0. This includes both k = 10 and k = 0, so the values of k will be: 10, 9, 8, ..., 1, 0 — a total of 11 iterations.

3 1 4 2

Reason — To return the sum of first 10 natural numbers, we must follow the proper sequence of statements:

1. int sum = 0, i; – Declare the variables sum and i, and initialize sum to 0.
2. for(i=1; i<=10; i++) – Start the loop to go through numbers 1 to 10.
3. sum+=i; – Add the current number i to sum during each loop iteration.
4. return sum; – After the loop completes, return the total sum.

Math.pow(x, 10) + Math.pow(y, 10)

x *= --x + x-- + x
x = x * (--x + x-- + x)
x = 4 * (--x + x-- + x)
x = 4 * (3 + x-- + x)
x = 4 * (3 + 3 + x)
x = 4 * (3 + 3 + 2)
x = 4 * 8
x = 32

if (x == 'T' || x == 't') {
    System.out.print("Teacher");
} else {
    System.out.print("Student");
}

1  3  5  7  9

1. The loop control variable a is initialized to 1 and is incremented by 1 after each iteration until it attains the value 10.
2. The condition if (a % 2 == 0) tests whether a is an even number. If the condition is true, the continue statement transfers control to the next iteration of the loop, thereby skipping the print statement.
3. Consequently, only the odd values 1, 3, 5, 7, and 9 are displayed by the statement System.out.print(a + " ");.

Variable: Name

Methods: meow(), eat(), play()

100
60
20

The loop is executed 3 times.

• Initial value: k = 100 → printed, then reduced to 60.
• Second iteration: k = 60 → printed, then reduced to 20.
• Third iteration: k = 20 → printed, then reduced to -20.
• Loop stops when k < 10.

(a) The order of the array z[ ][ ] is 3 × 3.

(b) The value in z[2][0] is 7.

(a)

9

The method compareTo() compares two strings lexicographically by evaluating the Unicode value of each character from left to right until a mismatch is found.

1. 'R' (82) vs 'R' (82) → same.
2. 'O' (79) vs 'O' (79) → same.
3. 'S' (83) vs 'J' (74) → difference = 83 - 74 = 9.

Since a mismatch occurs at the third character, the comparison stops; therefore, the characters 'E' and 'A' are not compared.

Hence, the method returns 9.

(b)

LELICATE

The replace('D', 'L') method substitutes every occurrence of the character 'D' in the string "DEDICATE" with 'L', resulting in "LELICATE".

(a) In Java, each element of type char occupies 2 bytes of memory. The given array has 6 elements, therefore:

Total memory = 6 × 2 = 12 bytes.

(b)

true

• The element ch[4] contains the character '7'.
• The method Character.isDigit('7') returns true because '7' is a numeric digit.

(a)

Xavier     95

• A perform object ob1 is created using new perform(95, "Xavier").
• The constructor assigns m = 95 and name = "Xavier".
• The print() method outputs the name followed by spaces and then m.

(b) The constructor perform(int x, String y) accepts arguments, hence it is a parameterized constructor.

import java.util.Scanner;

class Hotel {
    String name;
    long mobno;
    int days;
    int bill;

    void input() {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter customer name: ");
        name = sc.nextLine();
        System.out.print("Enter mobile number: ");
        mobno = sc.nextLong();
        System.out.print("Enter number of days stayed: ");
        days = sc.nextInt();
    }

    void charge() {
        if (days <= 3) {
            bill = days * 1000;
        } else if (days <= 7) {
            bill = (3 * 1000) + (days - 3) * 900;
        } else {
            bill = (3 * 1000) + (4 * 900) + (days - 7) * 800;
        }
        bill += bill * 0.18;
    }

    void print() {
        System.out.println("Customer Name : " + name);
        System.out.println("Mobile Number : " + mobno);
        System.out.println("Total Bill    : Rs " + bill);
    }

    public static void main(String[] args) {
        Hotel h = new Hotel();
        h.input();
        h.charge();
        h.print();
    }
}

import java.util.Scanner;

public class RowProduct {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[][] arr = new int[3][3];

        System.out.println("Enter 9 integers for the 3x3 array:");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                arr[i][j] = sc.nextInt();
            }
        }

        for (int i = 0; i < 3; i++) {
            int product = 1;
            for (int j = 0; j < 3; j++) {
                product *= arr[i][j];
            }
            System.out.println("Row " + i + " – " + product);
        }
    }
}

@@@  
@@@
@@@

import java.util.Scanner;

public class OverloadTransform {

    int transform(int n) {
        int sum = 0;
        while (n > 0) {
            int d = n % 10;
            sum += d;
            n /= 10;
        }
        return sum;
    }

    void transform(String s) {
        String str = s.toUpperCase();
        System.out.println(str);
    }

    void transform(char ch) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(ch);
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        OverloadTransform obj = new OverloadTransform();

        System.out.print("Enter an integer: ");
        int num = sc.nextInt();
        System.out.println("Sum of digits: " + obj.transform(num));

        sc.nextLine();
        System.out.print("Enter a string: ");
        String str = sc.nextLine();
        obj.transform(str);

        System.out.print("Enter a character: ");
        char ch = sc.next().charAt(0);
        obj.transform(ch);
    }
}

import java.util.Scanner;

public class SpecialString {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter a string: ");
        String str = sc.nextLine().toUpperCase();

        int vowels = 0, consonants = 0;
        int len = str.length();

        for (int i = 0; i < len; i++) {
            char ch = str.charAt(i);
            if (ch >= 'A' && ch <= 'Z') {
                if (ch == 'A' 
                    || ch == 'E' 
                    || ch == 'I' 
                    || ch == 'O' 
                    || ch == 'U')
                    vowels++;
                else
                    consonants++;
            }
        }

        System.out.println("Number of vowels = " + vowels);
        System.out.println("Number of consonants = " + consonants);

        if (vowels == consonants)
            System.out.println("It is a Special String");
        else
            System.out.println("It is not a Special String");
    }
}

            N = 2396    N = 9316
First digit:   2         9
Last digit:    6         6
Sum:           8         15
Output: Sum is even  Sum is odd

import java.util.Scanner;

public class FirstLastSum {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter a number: ");
        int n = sc.nextInt();

        int lastDigit = n % 10;
        int firstDigit = n;
        while (firstDigit >= 10) {
            firstDigit /= 10;
        }

        int sum = firstDigit + lastDigit;

        System.out.println("First digit: " + firstDigit);
        System.out.println("Last digit: " + lastDigit);
        System.out.println("Sum: " + sum);

        if (sum % 2 == 0)
            System.out.println("Sum is even");
        else
            System.out.println("Sum is odd");
    }
}

import java.util.Scanner;
public class LinearSearchArray {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[10];

        System.out.println("Enter 10 integers:");
        for (int i = 0; i < 10; i++) {
            arr[i] = sc.nextInt();
        }
        System.out.print("Enter the value to search: ");
        int key = sc.nextInt();
        int i = 0;

        for (i = 0; i < 10; i++) {
            if (arr[i] == key) {
                break;
            }
        }
        
        if (i < 10)
            System.out.println("Value found at position: " + (i + 1));
        else
            System.out.println("Value not found in the array");
    }
}

Two Dimensional array with 4 rows and 5 columns

Reason — A two-dimensional array is like a grid or table with rows and columns. The image shows a table with 4 rows and 5 columns.

Platform Independent

Reason — The feature of "Platform Independence" allows Java compiled code (bytecode) to run on any operating system. This is achieved through the Java Virtual Machine (JVM), which interprets the bytecode and executes it on the specific platform.

2 bytes

Reason — In Java, \n (newline character) is a character literal. All character literals in Java, including escape sequences like \n, are stored as char data type, which occupies 2 bytes (16 bits) in memory.

%

Reason — % and * have the highest precedence. Since % appears first in the expression, it takes precedence during evaluation.

static

Reason — In Java, keywords are reserved words that have a specific meaning and purpose in the language. Keywords must always be written in lowercase. Analysing the given options:

1. If: Incorrect because Java keywords are case-sensitive, and the correct keyword is if (in lowercase).
2. BOOLEAN: Incorrect because the keyword in Java is boolean (in lowercase).
3. static: Correct. static is a valid Java keyword used to declare static methods, variables, or blocks.
4. Switch: Incorrect because the correct keyword is switch (in lowercase).

4.0

Reason — Let's evaluate the expression step by step:

System.out.println(Math.ceil(6.4) + Math.floor(-1 - 2));

Step 1: Evaluate Math.ceil(6.4)

• The ceil method rounds a number up to the nearest integer.
• Math.ceil(6.4) → 7.0 (as ceil returns a double).

Step 2: Evaluate -1 - 2

• -1 - 2 = -3

Step 3: Evaluate Math.floor(-3)

• Math.floor(-3): The floor method rounds a number down to the nearest integer.
• Math.floor(-3) → -3.0 (as floor also returns a double).

Step 4: Add the Results

• Math.ceil(6.4) + Math.floor(-3) → 7.0 + (-3.0)
• Result = 4.0

replace(char, char)

Reason — The given methods return:

supports floating point constants

Reason — The switch statement does not support float or double constants as case labels. It supports byte, short, int, char, String and enum.

130

Reason — The given array is:

char ch[] = {'A', 'E', 'I', 'O', 'U'};

Step-by-Step Execution:

1. ch[0]:

• The element at index 0 of the array is 'A'.

2. Character Multiplication in Java:

• In Java, a char is treated as a numeric value based on its ASCII code when used in arithmetic operations.
• The ASCII value of 'A' is 65.

3. ch[0] * 2:

• Substituting ch[0] with its ASCII value:

65 * 2 = 130

4. Output:

• System.out.println(ch[0] * 2); will print 130.

for (int i=11;i<=30;i+=2)

Reason — To execute a loop 10 times, the total number of iterations should match 10, based on the condition and increment values. Let's analyse each option:

1. for (int i = 11; i <= 30; i += 2)

• The loop starts at 11 and increments by 2.
• The sequence is: 11, 13, 15, 17, 19, 21, 23, 25, 27, 29.
• This loop executes 10 times.

2. for (int i = 11; i <= 30; i += 3)

• The loop starts at 11 and increments by 3.
• The sequence is: 11, 14, 17, 20, 23, 26, 29.
• This loop executes only 7 times, so it is incorrect.

3. for (int i = 11; i < 20; i++)

• The loop starts at 11 and increments by 1.
• The sequence is: 11, 12, 13, 14, 15, 16, 17, 18, 19.
• This loop executes only 9 times, so it is incorrect.

4. for (int i = 11; i <= 21; i++)

• The loop starts at 11 and increments by 1.
• The sequence is: 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21.
• This loop executes 11 times, so it is incorrect.

x[49]=100

Reason — In Java, arrays use zero-based indexing, meaning the first element of the array is at index 0. For an array with n elements, the last element is at index n - 1.
Given a single-dimensional array with 50 elements, the indices range from 0 to 49. Thus, the correct index for the last element is 49.

boolean compute (int a, int b)

Reason — Let's analyse the given options:

1. void compute (int a, int b) — Incorrect because void means the method does not return any value, but the question requires the method to return true/false.

2. boolean compute (int a, int b) — Correct because it returns a boolean value (true or false) and accepts two integer arguments.

3. Boolean compute (int a, b) — Incorrect due to syntax error (int b is not fully declared). Also, Boolean is a wrapper class, not a primitive boolean.

4. int compute (int a, int b) — Incorrect because the return type is int, not boolean.

return

Reason — The return statement in Java is used to bring the control back to the calling method. If the method has a return type other than void, the return statement also passes back a value to the calling method.

false

Reason — In Java, the default value of a variable depends on its data type. For a boolean variable, the default value is false (in lowercase). This is because Java uses the primitive boolean type, which has only two possible values: true or false.

Character.toUpperCase( char )

Reason — The method Character.toUpperCase(char) is used to convert a single lowercase character to its uppercase equivalent. It belongs to the Character class in Java.

Both Assertion (A) and Reason (R) are true and Reason (R) is a correct explanation of Assertion (A)

Reason — The Integer class can indeed be used in a program without explicitly importing any package. This is because it is part of the java.lang package, which is automatically imported in every Java program by default.

Both A and C

Reason — The student's code x = +2; is incorrect because it doesn't actually increment x by 2. Instead, it simply assigns the value +2 to x.

The correct way to increment the value of x by 2 is:

1. Option A: x += 2;
   This is shorthand for x = x + 2; and correctly increments x by 2.

2. Option C: x = x + 2;
   This is the full, explicit version of incrementing x by 2. It is also correct.

Option B: x = 2;
This assigns 2 to x, which is not incrementing its value. Hence, this is incorrect.

s.length

Reason — In Java, arrays have a property called length, which gives the total number of elements in the array. This applies to any type of array, including arrays of Strings.

For a string array String s[], the correct way to get the number of elements is:

s.length

Analysing other options:

1. s.length():

   • Incorrect. The length() method is used for String objects to get the number of characters in a String, not for arrays.

2. length(s):

   • Incorrect. This is not a valid syntax in Java.

3. len(s):

   • Incorrect. Java does not have a function called len() for arrays or strings.

(3) (4) (1) (2)

Reason — To swap two variables a and b using a third variable t, the correct sequence of statements is:

Step 1: Declare and initialize the third variable t.

int t = 0;  // (3)

Step 2: Assign the value of a to t.

t = a;  // (4)

Step 3: Assign the value of b to a.

a = b;  // (1)

Step 4: Assign the value of t (original value of a) to b.

b = t;  // (2)

Correct Order:

int t = 0;  // (3)
t = a;      // (4)
a = b;      // (1)
b = t;      // (2)

Assertion (A) is true and Reason (R) is false

Explanation — Arguments are the actual values passed to a method when it is invoked. For example:

void exampleMethod(int x) { ... }  
exampleMethod(5);  // Here, 5 is the argument.

Hence, Assertion (A) is true.

The variables declared in a method prototype (or header) to receive values are called formal parameters, not actual parameters. For example:

void exampleMethod(int x) {  // x is the formal parameter
    System.out.println(x);
}
exampleMethod(5);  // 5 is the actual parameter

Hence, Reason (R) is false.

The code can be rewritten using a single if statement as follows:

if(code == 'g' || code == 'G')
    System.out.println("GREEN");

Explanation:

• The logical OR operator (||) is used to check if code is either 'g' or 'G'.
• If either condition is true, the statement System.out.println("GREEN"); will execute. This simplifies the multiple if-else blocks into a single if statement.

a = 4, b = 6

Explanation:

The given expression is evaluated as follows:

b*=a++ - ++b + ++a
b = b * (a++ - ++b + ++a) [a=2, b=3]
b = 3 * (2 - 4 + 4) [a=4, b=4]
b = 3 * 2
b = 6

Statement having the error is:

boolean x = true;

Corrected code:

int x = 1; // Change boolean to int
switch(x)
{ 
  case 1: System.out.println("WIN"); break;
  case 2: System.out.println("LOOSE");
}

Explanation:

The error occurs because the switch statement in Java does not support the boolean data type. A switch expression must be one of the following types:

• int, byte, short, char, String, or an enum.

Replacing boolean x = true; with int x = 1; ensures that the switch statement now uses a valid data type (int). Assigning x = 1 makes the case 1 to execute printing WIN as the output.

The Java expression for the given mathematical expression can be written as:

Math.cbrt(x) + Math.sqrt(y);

The loop executes two times.

Output

20
22

Explanation:

Step-by-Step Execution of the Code

Initial Value of x:
x = 10

Iteration 1:
System.out.println(x++ * 2);

• x++ → Use the current value of x (10), then increment x to 11.
• Output: 10 * 2 = 20

if (x % 3 == 0):

• x = 11, so 11 % 3 = 2 → Condition is false.

Iteration 2:
System.out.println(x++ * 2);

• x++ → Use the current value of x (11), then increment x to 12.
• Output: 11 * 2 = 22

if (x % 3 == 0):

• x = 12, so 12 % 3 = 0 → Condition is true.

break;

• The break statement exits the loop.

The outputs are:

(a) true

(b) -1

Explanation:

Given Strings:

String x = "Galaxy";
String y = "Games";

(a) System.out.println(x.charAt(0) == y.charAt(0));

1. x.charAt(0): Retrieves the character at index 0 of x → 'G'.

2. y.charAt(0): Retrieves the character at index 0 of y → 'G'.

3. Comparison: 'G' == 'G' → true.

(b) System.out.println(x.compareTo(y));

1. x.compareTo(y): Compares x ("Galaxy") with y ("Games") lexicographically (character by character based on Unicode values). The comparison is based on the first differing character:

   • 'G' == 'G' → Equal, move to the next characters.
   • 'a' == 'a' → Equal, move to the next characters.
   • 'l' == 'm' → 'l' (Unicode 108) is less than 'm' (Unicode 109).

2. Result:

   • x.compareTo(y) → 108 - 109 = -1.

X	b

Step-by-Step Execution:

char ch = 'B';

• ch is assigned the character 'B'.

char chr = Character.toLowerCase(ch);

• Character.toLowerCase(ch) converts 'B' to its lowercase equivalent 'b'.
• chr = 'b'.

int n = (int) chr - 10;

• (int) chr converts the character 'b' to its ASCII value.
• ASCII value of 'b' is 98.
• n = 98 - 10 = 88.

System.out.println((char) n + "\t" + chr);

• (char) n: Converts the integer 88 back to a character.
  • ASCII value 88 corresponds to the character 'X'.
• + "\t" + adds a tab space between the characters.
• chr: The value of chr is 'b'.

Syntax error in the line:
int y=Double.parseDouble(x);

Corrected code:

String x= "25";
double y=Double.parseDouble(x); //int changed to double
double r=Math.sqrt(y); 
System.out.println(r);

Explanation:

The error is a syntax error because the method Double.parseDouble(x) returns a double, but the code is trying to assign it to an int variable without proper casting, which is not allowed in Java.

The type of constructors used in the above program segment are:

1. Default constructor
2. Parameterized constructor

Explanation:

The types of constructors used in the given program are:

1. Default Constructor:

calculate() {
    a = 0;
    b = 0.0;
}

• A default constructor is a constructor that does not take any parameters.
• It initializes the instance variables a and b with default values (0 and 0.0 respectively).

2. Parameterized Constructor:

calculate(int x, double y) {
    a = x;
    b = y;
}

• A parameterized constructor is a constructor that takes arguments (int x and double y in this case).
• It allows for initializing the instance variables a and b with specific values provided during object creation.

(a) The position of 34 is x[2][0]

(b) x[2][3] + x[1][2] = 9 + 8 = 17

Explanation:

(a) Position of 34

• The array x is a 2D array, where elements are accessed using row and column indices.
• The element 34 is located in the 3rd row and 1st column.
• In zero-based indexing:
  • Row index: 2
  • Column index: 0

Position: x[2][0]

(b) Result of x[2][3] + x[1][2]

Step 1: Locate x[2][3]

• x[2][3] refers to the element in the 3rd row and 4th column.
• Value at x[2][3] = 9.

• x[1][2] refers to the element in the 2nd row and 3rd column.
• Value at x[1][2] = 8.

• x[2][3] + x[1][2] = 9 + 8 = 17.

Principal	Time	Rate	Amount

XXX	        XXX	    XXX	    XXX

Write the main method to create an object and call the above methods.

import java.util.Scanner;

public class Bank
{
    private double p;
    private double n;
    private double r;
    private double a;

    void accept() {
        Scanner in = new Scanner(System.in);

        System.out.print("Enter principal amount: ");
        p = in.nextDouble();

        System.out.print("Enter time period in years: ");
        n = in.nextDouble();
    }
    
    void calculate() {
        if (n <= 0.5) {
            r = 9;
        } else if (n <= 1) {
            r = 10;
        } else if (n <= 3) {
            r = 11;
        } else {
            r = 12;
        }

        a = p * Math.pow(1 + (r / 100), n);
    }
    
    void display() {
        System.out.println("Principal\tTime\tRate\tAmount");
        System.out.println(p + "\t" + n + "\t" + r + "\t" + a);
    }
    
    public static void main(String args[]) {
        Bank b = new Bank();
        b.accept();
        b.calculate();
        b.display();
    }
}

import java.util.Scanner;

public class KboatBinarySearch
{
    void search(double[] arr, double key) {
        int low = 0;
        int high = arr.length - 1;
        boolean found = false;

        while (low <= high) {
            int mid = (low + high) / 2;

            if (arr[mid] == key) {
                found = true;
                break;
            } else if (arr[mid] < key) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }

        if (found) {
            System.out.println("Search successful");
        } else {
            System.out.println("Search element not found");
        }
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        double[] values = {5.6, 11.5, 20.8, 35.4, 43.1, 52.4, 66.6, 78.9, 80.0, 95.5};

        System.out.print("Enter the value to search: ");
        double key = in.nextDouble();

        KboatBinarySearch obj = new KboatBinarySearch();
        obj.search(values, key);
    }
}

import java.util.Scanner;

public class KboatStringConvert
{
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter a string: ");
        String str = in.nextLine();
        str = str.toUpperCase();
        int l = str.length();
        
        String res = "";
        
        for (int i = 0; i < l; i++) {
            char ch = str.charAt(i);
            if ("AEIOU".indexOf(ch) != -1) {
                res += (char)(ch + 1);
            }
            else if (Character.isLetter(ch)) {
                res += (char)(ch - 1);
            }
            else {
                res += ch;
            }
        }
        
        System.out.println("Output String:");
        System.out.println(res);
    }
}

sum of row 1 = 10 (1+2+3+4)
sum of row 2 = 26 (5+6+7+8)
sum of row 3 = 16 (1+3+5+7)
sum of row 4 = 11 (2+5+3+1)

import java.util.Scanner;

public class KboatDDARowSum
{
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int arr[][] = new int[4][4];

        System.out.println("Enter 4x4 DDA elements:");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                arr[i][j] = in.nextInt();
            }
        }

        for (int i = 0; i < 4; i++) {
            int rowSum = 0;
            for (int j = 0; j < 4; j++) {
                rowSum += arr[i][j];
            }
            System.out.println("Sum of Row" + (i+1) 
                                + " = " + rowSum);
        }
    }
}

Input: 1021
output: SUPERSPY number [SUM OF THE DIGITS = 1+0+2+1 = 4,
NUMBER OF DIGITS = 4 ]

Example2:

Input: 125
output: Not an SUPERSPY number [1+2+5 is not equal to 3]

import java.util.Scanner;

public class KboatSuperSpy
{
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int num = in.nextInt();
        
        int sum = 0;
        int dc = 0;
        int orgNum = num;
        
        while (num > 0) {
            int d = num % 10;
            sum += d;
            dc++;
            num /= 10;
        }
        
        if (sum == dc) {
            System.out.println(orgNum + " is a SUPERSPY number");
        }
        else {
            System.out.println(orgNum + " is not a SUPERSPY number");
        }
    }
}

public class KboatOverloadDisplay
{
    void display() {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 5; j++) {
                if (j % 2 == 0) {
                    System.out.print("1  ");
                } else {
                    System.out.print("2  ");
                }
            }
            System.out.println();
        }
    }
    
    void display(int n, int m) {
        if (m > n) {
            double q = m / n;
            System.out.println("Quotient: " + q);
        } else {
            int sum = 2 * n + 3 * m;
            System.out.println("Sum: " + sum);
        }
    }
    
    double display(double a, double b, double c) {
        double p = (a + b) / c;
        double q = a + b + c;
        double z = p * q;
        System.out.println("Z = " + z);
        return z;
    }
}

Polygon is the class and the pictures are objects

Reason — In object-oriented programming (OOP), a class is a blueprint or template that defines the properties and behaviours (methods) of objects. An object is an instance of a class that holds specific data defined by the class.

In this case:

• Polygon represents the class because it defines the general structure, properties, and methods common to all polygons (e.g., sides, vertices, perimeter calculation).
• The pictures are specific examples or instances of polygons, such as triangles, parallelogram, or pentagons, making them objects created from the Polygon class.

b

Reason — In Java, when an int value is cast to char, it is converted based on the ASCII code. Since, 98 is the ASCII code of the letter b, hence value of ch is 'b'.

6

Reason — The method indexOf(char ch) in Java returns the index of the first occurrence of the specified character ch in the string. If the character is not found, it returns -1.

Consider the string:
"CONCENTRATION"

Let’s count the characters by their index (Java uses zero-based indexing):

The first occurrence of the character 'T' is at index 6.

Thus, the output of the statement "CONCENTRATION".indexOf('T') is 6.

private

Reason — In Java, access specifiers determine the visibility or accessibility of classes, methods, and variables. The three main access specifiers are:

1. public: Accessible from anywhere in the program.
2. protected: Accessible within the same package and by subclasses even if they are in different packages.
3. private: Accessible only within the same class.

private gives least accessibility as it provides the most restricted access.

13

Reason — The method compareTo(String str) in Java compares two strings lexicographically based on the ASCII values of characters. It returns:

0 if both strings are equal.
A positive value if the calling string comes after the argument string.
A negative value if the calling string comes before the argument string.

How It Works:
We compare "talent" and "genius" using their first differing characters:

• The ASCII value of 't' = 116
• The ASCII value of 'g' = 103

The difference is:
116 - 103 = 13

Since 't' comes after 'g', the result is 13.

\t

Reason — In Java, an escape sequence is a combination of characters starting with a backslash (\) followed by a specific character that performs a special operation.

Analysing the given options:

1. /n – Incorrect, should be \n (Backslash is required).
2. \t – Correct, it represents a tab.
3. /t – Incorrect, should be \t.
4. //n – Incorrect, this is not an escape sequence; // is used for comments in Java.

a

Reason — The && (Logical AND) operator in Java is used to combine two boolean expressions. It returns true only if both expressions are true. If either of the expressions is false, the entire condition becomes false.

The condition if (a > b && b > c) checks two expressions:

1. a > b – Checks if a is greater than b.
2. b > c – Checks if b is greater than c.

Since both conditions must be true (due to the && operator), the logical sequence becomes:
a > b > c

In this sequence:
a is the largest number because it is greater than both b and c.

11.0

Reason — The method Math.ceil(double value) in Java rounds up a decimal number to the next highest integer, regardless of the fractional part.

Breakdown of the Expression:

1. Math.ceil(5.4):
   5.4 is rounded up to 6.0.

2. Math.ceil(4.5):
   4.5 is rounded up to 5.0.

Adding the Results:
6.0 + 5.0 = 11.0

isLetterOrDigit(char)

Reason — In Java, the method Character.isLetterOrDigit(char ch) is used to check whether a given character ch is either a letter (A-Z or a-z) or a digit (0-9).

Analysing Other Options:

1. isDigit(char) – This method only checks if the character is a digit, not a letter.
2. isLetterOrDigit() – Incorrect because this method requires a character parameter.
3. isLETTERorDIGIT(char) – Java methods are case-sensitive, and method names follow camelCase. This method name does not exist.

java

Reason — In Java, source code files are saved with the .java extension. These files contain the Java program's source code, written in human-readable text format.

24

Reason — In Java, a character (char) takes 2 bytes because Java uses Unicode encoding.

Given:
Character Array: 4 rows and 3 columns
Total Elements = 4 × 3 = 12 characters

Memory Calculation:
Each character = 2 bytes
Total Memory = 12 × 2 = 24 bytes

double

Reason — The switch statement in Java supports specific data types for the case labels. However, double and float data types cannot be used.

Data Types supported in switch statement are:

1. int
2. char
3. String

a and b

Reason — An entry-controlled loop checks the loop condition before executing the loop's body. If the condition is false at the start, the loop's body will not execute even once.
for and while loops check the condition before running the loop's body. If the condition is false, the loop won't run. Therefore, they are entry controlled loops.
The body of the do-while loop executes at least once before checking the condition. Hence, it is an exit controlled loop.

Pure method

Reason — A pure method in Java is a method that:

1. Returns a value based only on its input arguments.
2. Does not modify any external variables or system state.
3. Does not change any class fields or input values.

In the context of reversing a number, a pure method accepts the number as input and returns its reversed form without altering any external state.

Yellow

Reason — In Java, a constructor must have the same name as the class. It initializes an object when it is created. Since the class name is Yellow, the constructor's name must be exactly Yellow, matching the class name including capitalization.

Call by reference

Reason — When an object is passed to a method:

1. The method receives a reference (memory address) to the original object.
2. Any changes made inside the method affect the original object.

fruit mango = new fruit();

Reason — In Java, creating an object follows the syntax:

ClassName objectName = new ClassName();

Where:

• ClassName: The name of the class.
• objectName: The name of the object.
• new: Allocates memory for the object.
• ClassName(): Calls the class's constructor.

Thus, fruit mango = new fruit(); correctly creates mango named object of fruit class.

Assertion and Reason both are false.

Reason — A static method can only access static variables and static methods directly because it belongs to the class, not any specific object. Hence, Assertion is false.
Both instance and static methods can access static variables. Hence, Reason is false.

6

Reason — The given Java code declares and initializes a String array color with three elements. The array elements are:

• color[0] = "Blue"
• color[1] = "Red"
• color[2] = "Violet"

The method length() returns the number of characters in the string "Violet".

Math.round(n)

Reason — In Java, Math.round(n) is the only method in the list that returns an integer when called with a floating-point number (float or double).

The Java expression for the given mathematical expression can be written as:

double result = Math.abs(a + b) / Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));

The given expression is evaluated as follows:

x += x++ * ++x % 2
x = x + (x++ * ++x % 2) (x = 4)
x = 4 + (4 * ++x % 2) (x = 5)
x = 4 + (4 * 6 % 2) (x = 6)
x = 4 + (24 % 2) (x = 6)
x = 4 + 0 (x = 6)
x = 4

Below is the for loop version of the provided do-while segment:

public class Main {
    public static void main(String[] args) {
        int x = 10, y = 20;

        for (; x <= 20; x++, y++) {
            // Body is empty because the increments are in the for loop header
        }

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

20

The loop executes 0 times because the loop condition x>20 is false as value of x is 10.

100

Reason — The code converts the strings "45.50" and "54.50" into doubles using Double.parseDouble(), resulting in d1 = 45.5 and d2 = 54.5. Their sum is 100.0.
Casting 100.0 to an integer using (int) removes the decimal part, leaving x = 100.

(a) The order of the array is 4 x 3 as it has 4 rows and 3 columns.

(b) The value is evaluated as follows:

x[0][0] = 4
x[2][2] = 10

x[0][0]+x[2][2] = 4 + 10 = 14

Differences between boxing and unboxing are:

boolean x = a.compareTo(b); has the error.

Corrected statement is:

boolean x = (a.compareTo(b) == 0);

false

Explanation

The error occurs in this line:

boolean x = a.compareTo(b);

• The compareTo() method of the String class returns an int, not a boolean.
• The method compares two strings lexicographically and returns:
  • 0 if the strings are equal.
  • A positive value if the calling string is lexicographically greater.
  • A negative value if the calling string is lexicographically smaller.

Since an int cannot be assigned to a boolean variable, this causes a "incompatible types" error.

To fix the error, we can use a comparison to convert the int result into a boolean:

boolean x = (a.compareTo(b) == 0);  // True if strings are equal

This assigns true or false based on whether the two strings are equal.

Corrected Program:

void calculate() {
    String a = "KING", b = "KINGDOM";
    boolean x = (a.compareTo(b) == 0);  // Check if strings are equal
    System.out.println(x);
}

Output of the Program:

• "KING".compareTo("KINGDOM") compares the strings lexicographically.
• "KING" is lexicographically smaller than "KINGDOM".
• The result of compareTo() will be -3 (difference between the lengths of the two strings ⇒ 4 - 7 = -3).

Since a.compareTo(b) == 0 is false, the output will be:

false

(a) The concept of Constructor Overloading (Polymorphism) is depicted in the program.

(b) Output of the main() method:

10
30

Explanation:

Output of the program is explained below:

1. temp t = new temp();
   Calls the default constructor temp() → a = 10

2. temp x = new temp(30);
   Calls the parameterized constructor temp(int z) → a = 30

3. t.print();
   Prints value of a for t → 10

4. x.print();
   Prints value of a for x → 30

(a) java.lang

(b) import java.util.Scanner

import java.util.Scanner;

public class courier
{
    private String name;
    private double weight;
    private String address;
    private double bill;
    private char type;
    
    public void accept() {
        Scanner in = new Scanner(System.in);

        System.out.print("Enter customer's name: ");
        name = in.nextLine();
        
        System.out.print("Enter recipient's address: ");
        address = in.nextLine();

        System.out.print("Enter parcel weight (in Kgs): ");
        weight = in.nextDouble();

        System.out.println("Enter courier type");
        System.out.print("D (Domestic), I (International): ");
        type = in.next().charAt(0);
    }
    
    public void calculate() {
        if (weight <= 5) {
            bill = weight * 800;
        } else if (weight <= 10) {
            bill = (5 * 800) + ((weight - 5) * 700);
        } else {
            bill = (5 * 800) + (5 * 700) + ((weight - 10) * 500);
        }

        if (type == 'I') {
            bill += 1500;
        }
    }
    
    public void print() {
        System.out.println("Customer's Name: " + name);
        System.out.println("Parcel Weight: " + weight + " Kgs");
        System.out.println("Recipient's Address: " + address);
        System.out.println("Type of Courier: " + type);
        System.out.println("Bill Amount: Rs." + bill);
    }

    public static void main(String[] args) {
        courier obj = new courier();
        obj.accept();
        obj.calculate();
        obj.print();
    }
}

import java.util.Scanner;

public class KboatOverloadPerform
{
    double perform(double r, double h) {
        double l = Math.sqrt((r * r) + (h * h));
        double csa = Math.PI * r * l;
        return csa;
    }
    
    void perform(int r, int c) {
        for (int i = 1; i <= r; i++) {
            for (int j = 1; j <= c; j++) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
    }
    
    void perform(int m, int n, char ch) {
        if (ch == 'Q') {
            int q = m / n;
            System.out.println("Quotient: " + q);
        } else if (ch == 'R') {
            int r = m % n;
            System.out.println("Remainder: " + r);
        } else {
            System.out.println("Invalid Character!");
        }
    }
    
    public static void main(String[] args) {
        KboatOverloadPerform mo = new KboatOverloadPerform();

        // Calculating CSA of a cone
        double csa = mo.perform(3.0, 4.0);
        System.out.println("Curved Surface Area of Cone: " + csa);

        // Generating pattern
        mo.perform(4, 5);

        // Printing quotient or remainder
        mo.perform(20, 6, 'Q');
        mo.perform(20, 6, 'R');
    }
}

import java.util.Scanner;

public class KboatEvenPal
{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        System.out.print("Enter a number: ");
        int num = in.nextInt();
        int org = num;
        int rev = 0;
        int sum = 0;
        
        while (num > 0) {
            int d = num % 10;
            rev = rev * 10 + d;
            sum += d;
            num /= 10;
        }
        

        if (org == rev && sum % 2 == 0) {
            System.out.println(org + " is an EvenPal number.");
        } else {
            System.out.println(org + " is not an EvenPal number.");
        }
    }
}

import java.util.Scanner;

public class KboatDiagonalDDA
{
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int[][] arr = new int[4][4];
        
        System.out.println("Enter elements for 4x4 DDA:");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                arr[i][j] = in.nextInt();
            }
        }
        
        int lSum = 0;
        int rSum = 0;
        
        for (int i = 0; i < 4; i++) {
            lSum += arr[i][i];
            rSum += arr[i][3 - i];
        }
        
        if (lSum == rSum) {
            System.out.println("The array is a DIAGONAL array.");
        } else {
            System.out.println("The array is NOT a DIAGONAL array.");
        }
    }
}

public class Pincode
{
    public static void main(String args[]) {
        int[] arr = {110061, 110001, 
                     110029, 110023, 
                     110055, 110006, 
                     110019, 110033};
                          
        for (int i = 0; i < 7; i++) 
        {
            int idx = i;
            for (int j = i + 1; j < 8; j++) 
            {
                if (arr[j] < arr[idx])
                    idx = j;
            }
            
            int t = arr[i];
            arr[i] = arr[idx];
            arr[idx] = t; 
        }
        
        System.out.println("Sorted Array:");
        for (int i = 0; i < 8; i++) 
        {
            System.out.print(arr[i] + " ");
        }

    }
}

import java.util.Scanner;

public class KboatValidateGmail
{
    public static void main(String args[]) 
    {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter a Gmail ID: ");
        String gmailId = in.nextLine();
        int len = gmailId.length(); 

        if (gmailId.endsWith("@gmail.com")
        && gmailId.indexOf('@') == len - 10)
        {
            System.out.println(gmailId + " is a valid Gmail ID.");
        }
        else
        {
            System.out.println(gmailId + " is NOT a valid Gmail ID.");
        }
    }
}

relational

Reason — Relational expressions are constructed using relational operators — equal to ( == ), not equal to ( != ), less than ( < ), less than equal to ( <= ), greater than ( > ), greater than equal to ( >= )

conditional operator

Reason — Ternary operator is a conditional operator as it evaluates the given condition. Its syntax is as follows:

condition? expression 1 : expression 2

If the condition is true then result of ternary operator is the value of expression 1. Otherwise the result is the value of expression 2.

Boxing

Reason — Boxing is the conversion of primitive data type into an object of its corresponding wrapper class.

20 bytes

Reason — A char data type occupies '2' bytes in the memory. Thus, 10 char type elements occupy (10 x 2) = 20 bytes in memory.

nextDouble()

Reason — The nextDouble() function reads the next token entered by the user as a double value.

case

Reason — case is a keyword. It is used to define switch case construct.

11.0

Reason — The given expression is evaluated as follows:
Math.round(6.6) + Math.ceil(3.4)
⇒ 7 + 4.0
⇒ 11.0

Math.round() rounds off its argument to the nearest mathematical integer and returns its value as an int or long type. Math.ceil method returns the smallest double value that is greater than or equal to the argument and is equal to a mathematical integer. In the addition operation, the type of result is promoted to a double as one operand is double. Hence, the result is 11.0.

syntax

Reason — The given statement is missing a terminator ( ; ) at the end. Thus, it has a syntax error.

X[4]

Reason — Array indexes start from 0. So, X[4] refers to the 5th element of the array.

able

Reason — "Remarkable".substring(6) will extract a substring starting from the character at index 6 (i.e., 7^th character of the string) which is 'a' till the end of the string. Hence the output is able.

Character

Reason — Character is the wrapper class for the data type char.

java.lang

Reason — Wrapper classes are present in java.lang package.

Polymorphism

Reason — In object-oriented programming, Polymorphism provides the means to perform a single action in multiple different ways and constructor overloading follows Polymorphism principle of Object Oriented programming wherein a constructor having the same name behaves differently with different arguments.

Only i

Reason — Integer constants represent whole number values only. Thus, 4 is an integer constant. 4.0 is a double constant, 4.3f is a float constant while "four" is a String constant.

0

Reason — compareTo() method compares two strings lexicographically and returns the difference between the ASCII values of the first differing characters in the strings. Here, the strings are equal so the difference is 0.

Assertion (A) is false and Reason (R) is true

Reason — In Java, statements written in lower case letter or upper case letter are treated differently as Java is a case sensitive language.

Data members and Member methods

Reason — A class encapsulates state and behavior by combining data and functions into a single unit. The state of an object is represented by its member variables and behaviour is represented by member methods.

Both Assertion (A) and Reason (R) are true and Reason (R) is a correct explanation of Assertion (A)

Reason — Call by value is known as pure method as it does not modify the value of original variables. The original value of variable does not change as operation is performed on copied values.

1

Reason — In Java, the Character.toLowerCase(char ch) method is used to convert a given character to its lowercase equivalent, if one exists. If the character is already in lowercase or there is no lowercase equivalent, it will return the original character.

Math.pow((p + q) , 2)