ICSE Computer Applications: 50 Most Important Java Programs for 2027
Tushar Parik
Author
50 Java Programs Every ICSE Student Must Master Before the Board Exam
Computer Applications (Paper 2) carries 100 marks in the ICSE Class 10 board exam, and roughly 60-70 marks come from writing Java programs. Year after year, examiners draw from the same pool of program types — String manipulation, number logic, arrays, patterns, series, and user-defined functions. This guide compiles the 50 most frequently asked Java programs organised by category, with descriptions, expected output types, and exam weightage so you can prioritise your practice for the 2027 board exam.
In This Article
- Why These 50 Programs Matter
- ICSE 2027 Exam Pattern & Weightage
- Category 1: String Programs (10 Programs)
- Category 2: Number Programs (10 Programs)
- Category 3: Array Programs (10 Programs)
- Category 4: Pattern Programs (8 Programs)
- Category 5: Series Programs (6 Programs)
- Category 6: Function/Method Programs (6 Programs)
- How to Write Programs in the Exam
- Frequently Asked Questions
Why These 50 Programs Matter
The ICSE Computer Applications paper has been remarkably consistent in the types of programs it tests. An analysis of board papers from 2015 to 2026 reveals that over 90% of programming questions fall into six well-defined categories: Strings, Numbers, Arrays, Patterns, Series, and Functions. The programs in this guide are not random selections — they are the exact types that appear year after year, sometimes with minor variations in wording.
If you can write all 50 of these programs from memory, you will be prepared for virtually any programming question the 2027 board exam can throw at you. The key is not just memorising the code, but understanding the logic behind each program so you can adapt it when the examiner changes variable names, conditions, or output formats.
How to Use This Guide
- First pass: Read the description and try to write the logic on paper before looking at any reference.
- Second pass: Code each program in BlueJ and test with different inputs, especially edge cases.
- Third pass: Practise writing programs by hand on ruled paper within the time limit (15 minutes per program).
- Priority: Programs marked with higher exam weightage should be practised first and most often.
ICSE 2027 Exam Pattern & Weightage
The ICSE Computer Applications paper is divided into two sections. Section A (40 marks) covers theory and short-answer questions. Section B (60 marks) requires you to write complete Java programs. You must attempt four out of six programming questions in Section B, each carrying 15 marks.
| Category | Programs in This Guide | Exam Weightage | Frequency (2015-2026) |
|---|---|---|---|
| String Programs | 10 | 15-30 marks | Every year (1-2 Qs) |
| Number Programs | 10 | 15-30 marks | Every year (1-2 Qs) |
| Array Programs | 10 | 15-30 marks | Every year (1-2 Qs) |
| Pattern Programs | 8 | 15 marks | Most years (1 Q) |
| Series Programs | 6 | 15 marks | Most years (1 Q) |
| Function/Method Programs | 6 | 15 marks | Every year (1 Q) |
The marking scheme for each 15-mark program is typically: 2 marks for class declaration and variable declaration, 2 marks for input using Scanner, 8 marks for the core logic, 2 marks for correct output, and 1 mark for proper coding style (comments, indentation, meaningful variable names). Even if your logic has a minor error, you can still score 6-8 marks by getting the structure, input, and output format right.
Category 1: String Programs (10 Programs)
String manipulation is the single most important category in ICSE Computer Applications. At least one or two Section B questions involve String operations every year. You must be fluent with charAt(), length(), substring(), toUpperCase(), toLowerCase(), indexOf(), compareTo(), and equals().
Program 1: Reverse a String
Description: Accept a string and display it in reverse order without using the StringBuffer reverse method. Traverse the string from the last character to the first using a for loop.
Key Concept: Loop from length()-1 to 0, concatenating each character.
Output Type: Single reversed string. Exam Frequency: Very High
Program 2: Check Palindrome String
Description: Accept a string and check whether it reads the same forwards and backwards (ignoring case). Examples: MADAM, LEVEL, RADAR.
Key Concept: Reverse the string using Program 1 logic, then compare using equalsIgnoreCase().
Output Type: Boolean result with message. Exam Frequency: Very High
Program 3: Count Vowels, Consonants, Digits, and Spaces
Description: Accept a string and count the number of vowels, consonants, digits, spaces, and special characters in it. Use Character.isLetter(), Character.isDigit() for classification.
Key Concept: Traverse character by character, classify using conditional checks with aeiouAEIOU.
Output Type: Multiple counts displayed separately. Exam Frequency: Very High
Program 4: Count Words in a String
Description: Accept a sentence and count the total number of words. Handle multiple spaces between words by checking for transitions from space to non-space characters, or by counting spaces and adding one.
Key Concept: Use split(" ") or count spaces manually. Trim the string first to handle leading/trailing spaces.
Output Type: Integer count. Exam Frequency: High
Program 5: Convert to Pig Latin
Description: Accept a word and convert it to Pig Latin. Move the first vowel and all preceding consonants to the end and add "ay". Example: SCHOOL → OOLSCHAY, COMPUTER → OMPUTERCAY.
Key Concept: Find the index of the first vowel using a loop, then use substring() to rearrange.
Output Type: Transformed string. Exam Frequency: Very High
Program 6: Reverse Each Word in a Sentence
Description: Accept a sentence and reverse each word individually while keeping the word order unchanged. Example: "BRIGHT TUTORIALS" → "THGIRB SLAIROTUT".
Key Concept: Extract each word using indexOf(' ') and substring(), reverse it, build the result string.
Output Type: Sentence with each word reversed. Exam Frequency: High
Program 7: Frequency of Each Character
Description: Accept a string and display the frequency of each unique character. Avoid counting a character that has already been counted by checking all previous characters.
Key Concept: Nested loop — outer loop picks each character, inner loop counts its occurrences. Skip if already processed.
Output Type: Character-frequency pairs. Exam Frequency: Medium
Program 8: Arrange Words in Alphabetical Order
Description: Accept a sentence and arrange all words in alphabetical order. Extract words into a String array, then apply bubble sort using compareTo().
Key Concept: Split sentence into words, sort using compareTo() for lexicographic comparison, print sorted result.
Output Type: Sentence with words in alphabetical order. Exam Frequency: High
Program 9: Check Anagram
Description: Accept two strings and check if they are anagrams (contain the same characters with the same frequency in different order). Example: LISTEN and SILENT are anagrams.
Key Concept: Sort both strings alphabetically and compare, or count character frequencies in both strings and verify they match.
Output Type: Boolean result with message. Exam Frequency: Medium
Program 10: Caesar Cipher (Encode/Decode)
Description: Accept a string and a shift value. Encode the string by shifting each letter forward by the shift value. Handle wrap-around (Z + 1 = A). Decode by shifting backwards.
Key Concept: Use ASCII values — (ch - 'A' + shift) % 26 + 'A' for encoding. Preserve spaces and special characters.
Output Type: Encoded or decoded string. Exam Frequency: Medium
Category 2: Number Programs (10 Programs)
Number-based programs test your understanding of loops, modulus operations, and mathematical logic. These programs frequently appear in both Section A (output prediction) and Section B (full program writing). Master the % operator for digit extraction and divisibility checks.
Program 11: Check Prime Number
Description: Accept a number and check whether it is prime. A prime number has exactly two factors: 1 and itself. Optimise by checking divisors only up to the square root of the number.
Key Concept: Loop from 2 to Math.sqrt(n). If any divisor found, it is not prime. Handle edge cases (0, 1, negative numbers).
Output Type: Boolean result. Exam Frequency: Very High
Program 12: Palindrome Number
Description: Accept a number and check if it reads the same forwards and backwards. Example: 12321 is a palindrome, 12345 is not.
Key Concept: Reverse the number using % 10 (extract last digit) and / 10 (remove last digit) in a while loop. Compare reversed number with original.
Output Type: Boolean result. Exam Frequency: Very High
Program 13: Armstrong Number
Description: Check whether a number is an Armstrong number. A number is Armstrong if the sum of its digits each raised to the power of the total number of digits equals the original number. Example: 153 = 1³ + 5³ + 3³ = 1 + 125 + 27 = 153.
Key Concept: Count digits first, then extract each digit with % 10, raise to the power using Math.pow(), and sum.
Output Type: Boolean result. Exam Frequency: High
Program 14: GCD and LCM
Description: Accept two numbers and find their GCD (Greatest Common Divisor) using the Euclidean algorithm, and LCM using the formula: LCM = (a * b) / GCD.
Key Concept: Euclidean algorithm — repeatedly replace the larger number with the remainder of division until one becomes zero.
Output Type: Two integer values (GCD and LCM). Exam Frequency: High
Program 15: Factors and Perfect Number
Description: Accept a number, display all its factors, and check whether it is a perfect number. A perfect number equals the sum of its proper divisors (excluding itself). Example: 6 = 1 + 2 + 3.
Key Concept: Loop from 1 to n/2, check divisibility using n % i == 0, accumulate sum of factors.
Output Type: List of factors + Boolean result. Exam Frequency: High
Program 16: Automorphic Number
Description: Check if a number is automorphic — its square ends with the number itself. Examples: 5 (25), 6 (36), 25 (625), 76 (5776).
Key Concept: Square the number. Extract the last d digits of the square (where d is the digit count of the original) using modulus with 10^d. Compare with original.
Output Type: Boolean result. Exam Frequency: Medium
Program 17: Twin Prime Numbers
Description: Accept two numbers and check if they are twin primes (both prime, and their difference is exactly 2). Examples: (3,5), (11,13), (17,19), (29,31).
Key Concept: Write an isPrime() method. Check if both numbers are prime AND their absolute difference equals 2.
Output Type: Boolean result. Exam Frequency: High
Program 18: Niven (Harshad) Number
Description: Check if a number is a Niven number — it is divisible by the sum of its digits. Example: 18, digit sum = 1 + 8 = 9, and 18 / 9 = 2 (exactly divisible).
Key Concept: Extract digits using % 10 and / 10 loop, sum them, check n % digitSum == 0.
Output Type: Boolean result. Exam Frequency: High
Program 19: Spy Number
Description: Check if a number is a Spy number — the sum of its digits equals the product of its digits. Example: 1124 → sum = 1+1+2+4 = 8, product = 1*1*2*4 = 8.
Key Concept: Extract digits, maintain running sum and running product simultaneously, compare at the end.
Output Type: Boolean result. Exam Frequency: Medium
Program 20: Decimal to Binary Conversion
Description: Accept a decimal (base 10) number and convert it to its binary (base 2) equivalent. Use repeated division by 2, storing remainders in reverse order.
Key Concept: Divide by 2 repeatedly, store remainders. Build the binary number by multiplying each remainder by increasing powers of 10.
Output Type: Binary equivalent as integer or string. Exam Frequency: High
Category 3: Array Programs (10 Programs)
Array programs are guaranteed to appear in every board exam. You need to master single-dimensional arrays (searching, sorting, inserting, deleting) and double-dimensional arrays (matrix operations). Array questions often combine multiple concepts, making them the highest-scoring questions if done correctly.
Program 21: Linear Search
Description: Accept an array of integers and a search element. Find the position of the element using linear search (sequential traversal from index 0 to n-1).
Key Concept: Traverse the array, compare each element with the search value, return index if found, display "not found" otherwise.
Output Type: Index position or not-found message. Exam Frequency: High
Program 22: Binary Search
Description: Accept a sorted array and a search element. Implement binary search by repeatedly dividing the search space in half. Much faster than linear search for large arrays.
Key Concept: Maintain low, high, and mid pointers. Compare mid element with target; adjust low or high accordingly.
Output Type: Index position or not-found message. Exam Frequency: Very High
Program 23: Bubble Sort
Description: Accept an array of integers and sort it in ascending order using the bubble sort algorithm. Display the array before and after sorting.
Key Concept: Nested loops — outer loop runs n-1 times, inner loop compares adjacent elements and swaps if out of order. Largest element "bubbles" to the end each pass.
Output Type: Sorted array. Exam Frequency: Very High
Program 24: Selection Sort
Description: Sort an array using selection sort. In each pass, find the minimum element from the unsorted portion and swap it with the first unsorted element.
Key Concept: Outer loop marks the current position, inner loop finds the minimum in the remaining array, then swap. More intuitive than bubble sort.
Output Type: Sorted array. Exam Frequency: Very High
Program 25: Insert Element in Sorted Array
Description: Accept a sorted array and a new element. Insert the element at the correct position to maintain sorted order by shifting elements to the right.
Key Concept: Create an array with one extra slot. Find the correct position by comparing, shift elements from that position rightward, insert the new element.
Output Type: Updated sorted array. Exam Frequency: High
Program 26: Delete Element from Array
Description: Accept an array and an element to delete. Find the element using linear search, then shift all subsequent elements one position to the left to fill the gap.
Key Concept: Search for the element, then use a loop to shift elements left starting from the found index. Reduce the effective array size by one.
Output Type: Updated array without the deleted element. Exam Frequency: High
Program 27: Merge Two Sorted Arrays
Description: Accept two sorted arrays and merge them into a single sorted array without re-sorting. Use the two-pointer technique.
Key Concept: Maintain two index pointers (one for each array). Compare elements at both pointers, place the smaller one in the result array, advance that pointer.
Output Type: Single merged sorted array. Exam Frequency: High
Program 28: Matrix Addition and Subtraction
Description: Accept two matrices of the same order (m × n) and compute their sum and difference. Display the result matrices in matrix format.
Key Concept: Use nested loops. result[i][j] = a[i][j] + b[i][j] for addition. Print using formatted output with proper alignment.
Output Type: Two result matrices. Exam Frequency: Medium
Program 29: Transpose of a Matrix
Description: Accept a matrix and display its transpose (rows become columns and columns become rows). For a matrix A, the transpose AT has element AT[i][j] = A[j][i].
Key Concept: Create a new matrix where b[i][j] = a[j][i]. For square matrices, you can swap in-place.
Output Type: Transposed matrix. Exam Frequency: High
Program 30: Sum of Diagonals of a Square Matrix
Description: Accept a square matrix (n × n) and find the sum of the primary diagonal (top-left to bottom-right) and secondary diagonal (top-right to bottom-left).
Key Concept: Primary diagonal: elements where i == j. Secondary diagonal: elements where i + j == n - 1. Single loop with index i is sufficient.
Output Type: Two integer sums. Exam Frequency: High
Category 4: Pattern Programs (8 Programs)
Pattern programs test your ability to work with nested loops. The outer loop controls rows, and the inner loop controls columns. The trick is to identify the relationship between the row number and the number of characters/spaces printed in each row. Once you see the pattern in the numbers, the code writes itself.
Program 31: Right-Angled Triangle (Stars)
Print a right-angled triangle pattern with stars. Row i has i stars. Uses two nested loops: outer for rows, inner prints stars equal to row number.
Exam Frequency: High
Program 32: Inverted Triangle
Print an inverted right-angled triangle. Row i has n-i+1 stars. Outer loop decrements from n to 1.
Exam Frequency: High
Program 33: Floyd's Triangle
Print Floyd's Triangle: consecutive natural numbers arranged in rows where row i has i numbers. Maintain a counter starting from 1.
Exam Frequency: High
Program 34: Pascal's Triangle
Print Pascal's Triangle where each element is the sum of the two elements above it. Use the formula: C(n,r) = n! / (r! * (n-r)!).
Exam Frequency: Medium
Program 35: Diamond Pattern
Print a diamond shape using stars. Upper half is a pyramid (increasing stars with leading spaces), lower half is an inverted pyramid. Requires three inner loops per row: spaces, stars, newline.
Exam Frequency: High
Program 36: Number Pyramid
Print a centred pyramid where each row displays the row number repeated. Example: Row 3 shows "3 3 3" with leading spaces for centring.
Exam Frequency: Medium
Program 37: Alphabet Pattern
Print patterns using letters instead of numbers. Example: Row 1 prints A, Row 2 prints A B, Row 3 prints A B C. Use (char)('A' + j) for letter generation.
Exam Frequency: High
Program 38: Hollow Rectangle/Box
Print a hollow rectangle of given dimensions. Print stars only on the border (first row, last row, first column, last column). Print spaces for interior positions.
Exam Frequency: Medium
Category 5: Series Programs (6 Programs)
Series programs require you to identify the mathematical pattern, compute each term, and either display the series or calculate its sum. The key skill is recognising how the numerator, denominator, and sign change with each term. Always test with the first 3-4 terms on paper before writing the loop.
Program 39: Fibonacci Series
Description: Display the first n terms of the Fibonacci series: 0, 1, 1, 2, 3, 5, 8, 13, 21, ... Each term is the sum of the previous two terms.
Key Concept: Initialise a = 0, b = 1. In each iteration: print a, compute c = a + b, shift values a = b, b = c.
Output Type: Series of integers. Exam Frequency: Very High
Program 40: Sum of Series (1 + x/1! + x²/2! + x³/3! + ...)
Description: Accept x and n, then compute the sum of the series up to n terms. This series approximates ex.
Key Concept: Maintain a running term: multiply the previous term by x/i to get the next term. This avoids computing factorial and power separately.
Output Type: Double (sum). Exam Frequency: High
Program 41: Alternating Sign Series (1 - 2 + 3 - 4 + ...)
Description: Compute the sum of a series where signs alternate between positive and negative. Accept n terms.
Key Concept: Use a sign variable initialised to +1. Multiply each term by the sign, then flip: sign = sign * -1 after each iteration.
Output Type: Sum as integer or double. Exam Frequency: High
Program 42: Sum of Squares and Cubes
Description: Compute S = 1² + 2² + 3² + ... + n² and S = 1³ + 2³ + 3³ + ... + n³. Also verify using direct formulae: sum of squares = n(n+1)(2n+1)/6 and sum of cubes = [n(n+1)/2]².
Key Concept: Simple loop with accumulator. Use Math.pow(i, 2) or i * i for squares.
Output Type: Two sums. Exam Frequency: Medium
Program 43: Harmonic Series (1 + 1/2 + 1/3 + ... + 1/n)
Description: Compute the sum of the harmonic series for n terms. Each term is 1/i where i goes from 1 to n.
Key Concept: Use a double accumulator. Ensure division is floating-point by writing 1.0 / i instead of 1 / i.
Output Type: Double (sum). Exam Frequency: Medium
Program 44: Tribonacci Series
Description: Display the first n terms of the Tribonacci series: 0, 0, 1, 1, 2, 4, 7, 13, 24, ... Each term is the sum of the previous three terms.
Key Concept: Similar to Fibonacci but with three initial values. d = a + b + c, then shift all three: a = b, b = c, c = d.
Output Type: Series of integers. Exam Frequency: Medium
Category 6: Function/Method Programs (6 Programs)
ICSE places significant emphasis on user-defined methods. These questions test your understanding of method declaration, parameters, return types, and method calling. Many questions explicitly ask you to write specific methods and call them from main(). Understanding function overloading (same method name, different parameter lists) is also critical.
Program 45: Function Overloading — Area Calculation
Description: Write a class with overloaded methods named area() to compute: (a) area of a circle given radius (double), (b) area of a rectangle given length and breadth (int, int), (c) area of a triangle given base and height (double, double).
Key Concept: Same method name with different parameter lists (number, order, or type of parameters). Return type alone does not differentiate overloaded methods.
Output Type: Multiple area values. Exam Frequency: Very High
Program 46: Function Overloading — Volume Calculation
Description: Write overloaded methods named volume() to compute: (a) volume of a cube given side, (b) volume of a cylinder given radius and height, (c) volume of a cuboid given length, breadth, and height.
Key Concept: Demonstrates overloading with different numbers of parameters. Cube takes 1 parameter, cylinder takes 2, cuboid takes 3.
Output Type: Multiple volume values. Exam Frequency: High
Program 47: Recursive Factorial
Description: Write a recursive method to compute the factorial of a number. Factorial of n (written as n!) = n × (n-1) × (n-2) × ... × 1. Base case: 0! = 1 and 1! = 1.
Key Concept: The method calls itself with n-1 until it reaches the base case. return n * factorial(n - 1).
Output Type: Integer (factorial value). Exam Frequency: High
Program 48: Recursive Fibonacci
Description: Write a recursive method to find the nth Fibonacci number. Base cases: fib(0) = 0, fib(1) = 1. Recursive case: fib(n) = fib(n-1) + fib(n-2).
Key Concept: The method makes two recursive calls. This is computationally expensive for large n but demonstrates recursion clearly. Compare with the iterative version (Program 39).
Output Type: Integer (nth Fibonacci number). Exam Frequency: High
Program 49: Method to Check Prime (Reusable)
Description: Write a boolean method isPrime(int n) that returns true if n is prime, false otherwise. Use this method from main() to display all prime numbers between two given limits, or to check twin primes, circular primes, and other composite problems.
Key Concept: Modular programming — write once, use many times. This method is the building block for at least 5 other programs in this list.
Output Type: Boolean (used by caller). Exam Frequency: Very High
Program 50: Menu-Driven Program Using Functions
Description: Write a menu-driven program using a switch statement that offers multiple operations (e.g., factorial, palindrome check, Armstrong check). Each operation is implemented as a separate method. The menu repeats until the user chooses to exit.
Key Concept: Combines switch-case, user-defined methods, and a do-while loop for menu repetition. Tests multiple concepts in one program.
Output Type: Menu display + operation results. Exam Frequency: Very High
How to Write Programs in the Exam
Writing a perfect program under exam pressure requires a systematic approach. Follow these steps for every 15-mark program question to maximise your score, even if you are unsure about the complete logic.
Step-by-Step Approach (15 Minutes Per Program)
- Read the question twice. Underline the input, the required processing, and the expected output format.
- Write the class declaration and import statement (if using Scanner). This earns you 2 marks immediately.
- Declare variables with meaningful names. Use
intfor whole numbers,doublefor decimals,Stringfor text. - Write the input section using Scanner. This earns another 2 marks. Always create the Scanner object as:
Scanner sc = new Scanner(System.in). - Write the core logic. If you are stuck, write pseudocode in comments first, then convert to Java. Partial logic still scores marks.
- Write the output using
System.out.println(). Match the exact output format asked in the question. - Dry run with the sample input given in the question. Trace through your loop variables on the margin of your answer sheet.
Common Exam Mistakes to Avoid
- Missing semicolons: Every Java statement ends with a semicolon. Examiners do deduct marks for missing semicolons.
- Wrong case sensitivity:
Stringnotstring,Systemnotsystem,Scannernotscanner. Java is case-sensitive. - Integer division trap:
5 / 2gives2in Java, not2.5. Use5.0 / 2or cast todoublewhen you need decimal results. - Off-by-one errors: Arrays are 0-indexed. A String of length 5 has valid indices 0 to 4.
charAt(5)will causeStringIndexOutOfBoundsException. - Not closing Scanner: While not always penalised, writing
sc.close()at the end shows good programming practice and impresses examiners. - Forgetting curly braces: Always use braces for if-else and loop bodies, even for single statements. This prevents logic errors and earns coding style marks.
| Time Period | What to Practise | Programs Per Day |
|---|---|---|
| 60 days before exam | Code all 50 programs in BlueJ. Test with different inputs. | 3-4 |
| 30 days before exam | Write programs on paper (handwriting practice). Focus on logic accuracy. | 2-3 |
| 7 days before exam | Solve previous year papers under timed conditions (2 hours). | 4-6 (full paper) |
| 1 day before exam | Revise the logic flow of all 50 programs mentally. Do not code. Just read and visualise. | Review all 50 |
Frequently Asked Questions
Q: How many programming questions appear in the ICSE Computer Applications board exam?
Section B contains six programming questions, and you must attempt any four. Each question carries 15 marks, so the programming section accounts for 60 out of 100 total marks. You should practise at least 50 programs across all categories to be prepared for any combination of questions the board may ask.
Q: Which category of Java programs is most important for the 2027 ICSE board exam?
String programs and array programs are equally important, as both appear in every board exam. If you can only focus on three categories, prioritise Strings, Arrays, and Function/Method programs (especially function overloading). These three categories together cover 4 out of 6 typical Section B questions.
Q: Can I score full marks even if my program has a small logical error?
Yes, partially. The ICSE marking scheme awards marks for structure (class declaration, variable declaration), input (Scanner usage), logic (step-by-step marking), and output. Even if your core logic has a minor bug, you can still score 8-10 out of 15 marks by getting the structure, input, and output format correct. Never leave a programming question blank.
Q: Should I use BufferedReader or Scanner for input in the board exam?
Use Scanner unless the question specifically asks for BufferedReader. Scanner is simpler, requires less boilerplate code, and is the method taught in most ICSE textbooks. Import it with import java.util.Scanner; and create an object with Scanner sc = new Scanner(System.in);. Use sc.nextInt() for integers, sc.nextDouble() for decimals, and sc.nextLine() for strings.
Q: What is the difference between bubble sort and selection sort in terms of exam questions?
Both are equally likely to appear. Bubble sort compares adjacent elements and swaps them if out of order, making multiple passes until no swaps are needed. Selection sort finds the minimum element in the unsorted portion and places it at the beginning. Examiners may ask you to sort in ascending or descending order using a specific method, so you must know both. The number of comparisons and swaps can also be asked in theory questions.
Q: How do I handle function overloading questions in the exam?
Function overloading means writing multiple methods with the same name but different parameter lists (different number, type, or order of parameters). When the exam asks for overloaded methods, write each version of the method clearly, then call each version from main() with appropriate arguments. Remember that the return type alone cannot differentiate overloaded methods — the parameter list must differ. This is one of the most predictable 15-mark questions.
Q: Is recursion important for ICSE Computer Applications?
Recursion is part of the ICSE syllabus but appears less frequently than iterative programs. You should know recursive solutions for factorial, Fibonacci, and sum of digits at minimum. Understand the base case (when the method stops calling itself) and the recursive case (when it calls itself with a smaller problem). Even if a full recursive program does not appear, theory questions about recursion are common in Section A.
Master These 50 Programs and Section B Becomes Your Scoring Machine
The ICSE Computer Applications board exam rewards preparation and pattern recognition. Every programming question is a variation of these 50 core types. Practise them on paper, test them in BlueJ, and time yourself — 15 minutes per program, no exceptions. Students who do this consistently score 90+ in Paper 2. The code is not complex — the consistency of practice is what separates toppers from the rest.
Need personalised guidance for ICSE Computer Applications? Bright Tutorials provides chapter-wise Java coaching with hands-on BlueJ practice, previous year paper solving, and timed mock tests. Get in touch today.
About Bright Tutorials
Bright Tutorials is a trusted coaching institute in Nashik, providing expert guidance for CBSE, ICSE, SSC, and competitive exam preparation since 2015.
Address: Shop No. 53-57, Business Signature, Hariom Nagar, Nashik Road, Nashik, Maharashtra 422101
Google Maps: Get Directions
Phone: +91 94037 81999 | +91 94047 81990
Email: info@brighttutorials.in | Website: brighttutorials.in
Read More on Bright Tutorials Blog
You May Also Like
- How to Write a Perfect Project File: CBSE & ICSE Guidelines 2027
- Best ICSE Schools in Nashik 2027: Fees, Results & Admissions Guide
- Fee Structure Comparison: CBSE vs ICSE vs IB Schools in India 2027
- Best Reference Books for ICSE Class 10 2027: Subject-Wise Recommendations
- CBSE Class 11 Computer Science: Python Basics to Advanced Notes (Complete 2027 Guide)