Blog

Solved 2023 Question Paper ICSE: In this blog post, we are going to solve the Question Paper ICSE Class 10 Computer Applications of 2023. We are here to provide section A of the question paper for ICSE Class 10 Computer Applications. We also give all the detailed answers with explanations. So enjoy (Solved 2023 Question Paper ICSE Class 10 Computer Applications)

Solved 2023 Question Paper ICSE Class 10 Computer Applications

Section A

Question 1(i)

A mechanism where one class acquires the properties of another class:

1. Polymorphism
2. Inheritance
3. Encapsulation
4. Abstraction

Answer

Inheritance

Reason — Inheritance creates a blueprint for new classes, enabling them to inherit the blueprints and capabilities of existing classes.

Question 1(ii)

Identify the type of operator &&:

1. ternary
2. unary
3. logical
4. relational

Answer

logical

Reason — When it comes to making decisions in code, logical operators are your trusty sidekicks. They work exclusively with “true or false” values and help you build intricate expressions that guide program flow.

The logical AND operator, symbolized by a double ampersand (&&), is a strict gatekeeper. It only gives the green light to “true” if both of its companions are also “true.” Think of it as two bouncers at a club, both needing to nod for you to enter.

Question 1(iii)

The Scanner class method used to accept words with space:

1. next()
2. nextLine()
3. Next()
4. nextString()

Answer

nextLine()

Reason —

• “nextLine() captures all characters until it encounters a newline character, enabling it to read complete sentences with spaces.”
• “To retrieve an entire line of text, including any spaces, use nextLine(), as it reads input up to the line break.”
• “When you need to read a full sentence with spaces intact, employ nextLine(), which consumes everything leading to the end of the line.”
• “nextLine() excels at reading full sentences: it grabs all characters up to the newline, preserving spaces for accurate text capture.”
• “Spaces are no obstacle for nextLine()! It confidently reads entire lines of text, including spaces, until it reaches the end.”

Read also: Best 50 Java Multiple-Choice Questions to Test Your Skills, and Boost Your Knowledge

Question 1(iv)– 10 Computer Applications

The keyword used to call package in the program:

1. extends
2. export
3. import
4. package

Answer

import

• Reason — “The import keyword grants Java programs access to classes and features within both built-in and user-created packages.”
• “To utilize elements from external java packages, Java programs employ the import keyword, enabling them to leverage both pre-existing and custom-built functionality.”

Question 1(v)

What value will Math.sqrt(Math.ceil(15.3)) return?

1. 16.0
2. 16
3. 4.0
4. 5.0

Answer

4.0

Reason — 1. Rounding up with Math.ceil:

• The expression starts with Math.ceil(15.3).
• The Math.ceil method rounds a number up to the nearest integer.
• In this case, it rounds 15.3 up to 16.

2. Calculating the square root with Math.sqrt:

• The expression then becomes Math.sqrt(16).
• The Math.sqrt method calculates the square root of a number.
• It finds the number that, when multiplied by itself, equals the given number.
• The square root of 16 is 4.

3. Final result:

• Therefore, the entire expression Math.sqrt(Math.ceil(15.3)) evaluates to 4.0.

Key points:

• Math.ceil always rounds up to the next integer, even if the decimal part is very small.
• Math.sqrt returns a double value, even if the square root is a whole number.

Question 1(vi)

The absence of which statement leads to fall through situation in the switch case statement?

1. continue
2. break
3. return
4. System.exit(0)

Answer

break

• Reason — Omitting a break statement in a switch case can lead to unintended code execution.
• A missing break in a switch case causes code to fall through.
• When a break statement is not present after a case in a switch statement, the program continues to execute the code for subsequent cases as well, even if their conditions are not met. This is known as a fall-through situation.
• The absence of a break statement in a switch case creates a “fall through” scenario, where the program doesn’t stop after matching a case and instead executes all the following case blocks until it encounters a break or the end of the switch statement.
• Neglecting to use break statements in a switch case can lead to unpredictable and potentially buggy code due to unintentional code execution, known as falling through.
• Omitting breaks in a switch case can cause unexpected behavior as code falls through subsequent cases, making it crucial to explicitly control the flow with proper breaks.

ICSE Class 10 Computer Applications

Question 1(vii)

State the type of loop in the given program segment:

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

    System.out.println(i);

1. finite
2. infinite
3. null
4. fixed

Answer

infinite

Reason — The loop is designed to run endlessly because its termination condition can never be met. It begins with the variable i set to 5, and in each iteration, i is decremented by 2. However, the loop is set to continue as long as i is greater than 0. Since i will only ever be odd numbers (5, 3, 1, -1, -3, etc.), it will never reach 0, preventing the loop from naturally ending.

Here’s a breakdown of how the loop’s values progress:

Iteration	Value of i	Remark
1	5	Initial value of i
2	3	i is decremented by 2
3	1	i is decremented by 2 again
4	-1	i becomes negative but still not 0
5	-3	i continues to decrease without reaching 0
…	…	…

Question 1(viii)

Write a method prototype name check() which takes an integer argument and returns a char:

1. char check()
2. void check (int x)
3. check (int x)
4. char check (int x)

Answer

char check (int x)

Question 1(ix)

The number of values that a method can return is:

1. 1
2. 2
3. 3
4. 4

Answer

1

Reason — A method can return only one value.

Question 1(x)

Predict the output of the following code snippet:

String P = “20”, Q =”22″;

int a = Integer.parseInt(P);

int b = Integer.valueOf(Q);

System.out.println(a + ” ” + b);

1. 20
2. 20 22
3. 2220
4. 22

Answer

20 22

• Reason — The Integer.parseInt(P) and Integer.valueOf(Q) methods convert the strings “20” and “22” to integers 20 and 22, respectively.
• The System.out.println(a + ” ” + b) statement prints the values of a and b (separated by a space) to the console.

Therefore, the output is “20 22”.

Question 1(xi)

The String class method to join two strings is:

1. concat(String)
2. <string>.joint(string)
3. concat(char)
4. Concat()

Answer

concat(String)

Question 1(xii): Solved 2023 Question Paper ICSE

The output of the function “COMPOSITION”.substring(3, 6):

1. POSI
2. POS
3. MPO
4. MPOS

Answer

POS

1. Reason — String Indexing: Strings are indexed starting from 0, so the characters in “COMPOSITION” have the following indices:

C  O  M  P  O  S  I  T  I  O  N

0  1  2  3  4  5  6  7  8  9  10

2. Substring Parameters: The substring(3, 6) function extracts a portion of the string, taking two arguments:
   • The first argument (3) indicates the starting index (inclusive), which is the position of the character “P”.
   • The second argument (6) indicates the ending index (exclusive), meaning the characters up to, but not including, the character at index 6 (“I”) will be extracted.
3. Extracting Characters: Based on the indices and function behavior, the substring method extracts the characters at indices 3, 4, and 5, which are “P”, “O”, and “S”.

Therefore, the output of the function “COMPOSITION”.substring(3, 6) is POS.

Question 1(xiii)

int x = (int)32.8; is an example of …………… typecasting.

1. implicit
2. automatic
3. explicit
4. coercion

Answer

explicit

Reason — Explanation:

• Explicit typecasting occurs when you intentionally convert a value from one data type to another using a specific operator or function. In this case, the (int) operator is used to explicitly cast the floating-point value 32.8 to an integer.
• Implicit typecasting (or coercion) happens automatically without your direct intervention. For example, in some languages, assigning a smaller integer type to a larger integer type might be implicitly converted.

Why explicit typecasting is necessary here:

• Integers can only store whole numbers, not decimals. To assign the floating-point value 32.8 to the integer variable x, it needs to be explicitly converted to an integer, discarding the decimal part.

Breakdown of the code:

1. int x declares an integer variable named x.
2. (int)32.8 explicitly casts the value 32.8 to an integer, resulting in 32.
3. = assigns the integer value 32 to the variable x.

After this code:

The variable x will hold the value 32, not 32.8, as the decimal part has been removed due to explicit typecasting.

Question 1(xiv)

The code obtained after compilation is known as:

1. source code
2. object code
3. machine code
4. java byte code

Answer

java byte code

1. Reason — Source code: This is the human-readable code that programmers write, using a specific programming language’s syntax and rules. It’s the starting point of the compilation process.
2. Object code: This is the result of compilation. It’s a machine-readable form of the source code, typically in binary format, that the computer can directly execute. However, it’s often not yet fully executable and might require further processing.
3. Machine code: This is the final, executable code that runs directly on the computer’s hardware. It’s typically generated from object code by a linker, which resolves references to external libraries and combines multiple object files into a complete executable program.
4. Java bytecode: This is a special kind of object code specific to Java. It’s not directly executable by the hardware but is instead executed by the Java Virtual Machine (JVM). This allows Java programs to run on different platforms without needing to be recompiled for each one.

Question 1(xv): ICSE Computer Applications

Missing a semicolon in a statement is what type of error?

1. Logical
2. Syntax
3. Runtime
4. No error

Answer

Syntax

Question 1(xvi)

Consider the following program segment and select the output of the same when n = 10 :

switch(n)

{

    case 10 : System.out.println(n*2);

    case 4 : System.out.println(n*4); break;

    default : System.out.println(n);

}

1. 20
   40
2. 10
   4
3. 20, 40
4. 10
   10

Answer

20

40

1. Switch Statement: The switch(n) statement evaluates the value of n (which is 10 in this case) and branches to the corresponding case block.
2. Case 10: Since n is 10, it matches the first case 10. The code within this case, System.out.println(n*2), prints 20 (10 multiplied by 2).
3. Missing Break: Crucially, there’s no break statement after the first case. This means the code execution continues to the next case, even though a match has already been found.
4. Case 4: The code falls through to the case 4 block, even though n is not 4. The code within this case, System.out.println(n*4), prints 40 (10 multiplied by 4).
5. Break in Case 4: The break statement in the case 4 block finally terminates the switch statement, preventing further execution of other cases.

Therefore, the output is “20 40”, as both the first and second cases are executed due to the missing break in the first case.

Question 1(xvii): Solved 2023 Question Paper ICSE

A method which does not modify the value of variables is termed as:

1. Impure method
2. Pure method
3. Primitive method
4. User defined method

Answer

Pure method

Reason — A method that does not modify the value of variables is termed as a pure method.

Question 1(xviii)

When an object of a Wrapper class is converted to its corresponding primitive data type, it is called as …………….

1. Boxing
2. Explicit type conversion
3. Unboxing
4. Implicit type conversion

Answer

Unboxing

Reason — Here’s a breakdown of the concepts involved:

• Wrapper classes: These are classes in Java that represent primitive data types as objects. They provide additional functionality and methods for working with primitive values. For example, the Integer class wraps the primitive int type.
• Primitive data types: These are the basic building blocks of data in Java, representing simple values like numbers, characters, and booleans. Examples include int, double, char, and boolean.
• Boxing: This is the process of converting a primitive value to its corresponding wrapper class object. For instance, converting an int value to an Integer object.
• Unboxing: This is the reverse process of unwrapping a wrapper class object back to its primitive data type. For example, extracting an int value from an Integer object.

In the given scenario, we’re specifically dealing with the conversion of a wrapper object to its primitive type, which is unboxing.

Question 1(xix)-Solved 2023 Question Paper ICSE

The number of bits occupied by the value ‘a’ are:

1. 1 bit
2. 2 bits
3. 4 bits
4. 16 bits

Answer

16 bits

Reason — A char data type occupies 2 bytes in the memory and one byte is 8 bits so 2 bytes mean 16 bits

Question 1(xx)

Method which is part of a class rather than an instance of the class is termed as:

1. Static method
2. Non static method
3. Wrapper class
4. String method

Answer

Static method

Reason — A static method is a method that belongs to the class itself, rather than individual objects of the class.

Question 2(i)

Write the Java expression for (a + b)^x.

Answer

Math.pow(a + b, x)

Question 2(ii)

Evaluate the expression when the value of x = 4:

x *= –x + x++ + x

Answer

The given expression is evaluated as follows:

x *= –x + x++ + x (x = 4)
x *= 3 + x++ + x (x = 3)
x *= 3 + 3 + x (x = 4)
x *= 3 + 3 + 4 (x = 4)
x *= 10 (x = 4)
x = x * 10 (x = 4)
x = 4 * 10
x = 40

Explanation: The evaluation of the expression x *= --x + x++ + x when x = 4, breaking it down step by step:

1. –x: The pre-decrement operator --x first decrements the value of x to 3 and then uses this new value in the expression. So, x becomes 3.
2. x++: The post-increment operator x++ uses the current value of x (which is 3) in the expression and then increments it afterward. So, x becomes 4 (for the next use of x).
3. –x + x++ + x: Now, the expression becomes 3 + 3 + 4 (since x is 4 for this part).
4. Calculation: The expression evaluates to 3 + 3 + 4 = 10.
5. *x = 10: The multiplication assignment operator *= multiplies the current value of x (which is 4) by 10 and assigns the result back to x.
6. Final value of x: x becomes 4 * 10 = 40.

Therefore, the final value of x after evaluating the expression is 40.

Question 2(iii)

Convert the following do…while loop to for loop:

int x = 10;

do

{

x––;

System.out.print(x);

}while (x>=1);      

Answer

for(int x = 10; x >= 1; x–)

{

    System.out.print(x);

}

Question 2(iv)

Give the output of the following Character class methods:

(a) Character.toUpperCase (‘a’)

(b) Character.isLetterOrDigit(‘#’)

Answer

(a) Character.toUpperCase (‘a’)

Output

A

Output

false

Question 2(v)

Rewrite the following code using the if-else statement:

int m = 400;

double ch = (m>300) ? (m / 10.0) * 2 : (m / 20.0) – 2;

Answer

int m = 400;

double ch = 0.0;

if(m > 300)

    ch = (m / 10.0) * 2;

else

    ch = (m / 20.0) – 2;

Question 2(vi)

Give the output of the following program segment:

int n = 4279; int d;

while(n > 0)

{ d = n % 10;

System.out.println(d);

n = n / 100;

}

Answer

Output

9

2

Explanation

Step by step explanation of the code:

1. int n = 4279; — Initializes the integer n with the value 4279.
2. int d; — Declares an integer variable d without initializing it. It will be used to store the individual digits.

Now, let’s go through the loop:

The while loop continues as long as n is greater than 0:

• d = n % 10; — This line calculates the remainder when n is divided by 10 and stores it in d. In the first iteration, d will be 9 because the remainder of 4279 divided by 10 is 9.
• System.out.println(d); — This line prints the value of d. In the first iteration, it will print 9.
• n = n / 100; — This line performs integer division of n by 100. In the first iteration, n becomes 42. (Remember, it is integer division so only quotient is taken and fractional part is discarded.)

The loop continues, and in the second iteration:

• d = n % 10; — d will now be 2 because the remainder of 42 divided by 10 is 2.
• System.out.println(d); — It prints 2.
• n = n / 100; — n becomes 0 because 42 divided by 100 is 0. Since n is no longer greater than 0, the loop terminates.

ICSE Computer Applications

Question 2(vii)

Give the output of the following String class methods:

(a) “COMMENCEMENT”.lastIndexOf(‘M’)

(b) “devote”.compareTo(“DEVOTE”)

Answer

(a) “COMMENCEMENT”.lastIndexOf(‘M’) → 8

• Explanation: This method searches for the last occurrence of the character ‘M’ in the string “COMMENCEMENT”. It starts searching from the end of the string and returns the index of the last ‘M’, which is at index 8 (counting from 0).

(b) “devote”.compareTo(“DEVOTE”) → 32

• Explanation: This method compares two strings lexicographically (based on their alphabetical order). It returns:

• A negative number if the first string comes before the second string alphabetically.
• A positive number if the first string comes after the second string alphabetically.
• 0 if the strings are equal.

In this case, “devote” comes after “DEVOTE” alphabetically because the first letter ‘d’ has a higher ASCII value than ‘D’. The difference in their ASCII codes is 32 (100 for ‘d’ – 68 for ‘D’), so the method returns 32.

Question 2(viii)

Consider the given array and answer the questions given below:

int x[ ] = {4, 7, 9, 66, 72, 0, 16};

(a) What is the length of the array?

(b) What is the value in x[4]?

Answer

(a) 7

(b) 72

Question 2(ix)

Name the following:

(a) What is an instance of the class called?

(b) The method which has same name as that of the class name.

Answer

(a) Object.

(b) Constructor.

Question 2(x)

Write the value of n after execution:

char ch =’d’;

int n = ch + 5;     

Answer

The value of n is 105.

Explanation

Here’s the breakdown of how this happens:

1. Character to Integer Conversion:

1. The character ‘d’ has an ASCII code of 100.
2. When a character is used in an arithmetic expression with integers, its ASCII code value is implicitly used.
3. Addition:
4. The expression ch + 5 translates to 100 (ASCII code of ‘d’) + 5, which equals 105.
5. Assignment:
6. The result of the addition, 105, is assigned to the integer variable n.

Therefore, after execution, the value of n will be 105.

ICSE Computer Applications: ICSE Class 10

The Best 50 MCQ on C Language with Answers