Solved 2025 Specimen Paper ICSE Class 10 Computer Applications

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.