ICSE Class 10 Java programs: the six Section B families, practised until any four are easy.

class Floyd {
  public static void main(String args[]) {
    int n = 1;
    for (int i = 1; i <= 4; i++) {
      for (int j = 1; j <= i; j++) {
        System.out.print(n + " ");
        n++;
      }
      System.out.println();
    }
  }
}
// n int  the next number to print
// i int  row number, 1 to 4
// j int  position within the row
// 1 / 2 3 / 4 5 6 / 7 8 9 10

Three variables, three roles. A student who can say what n, i and j each do can turn this into any triangle the paper draws; a student who cannot has memorised one picture.

import java.util.Scanner;
class Shapes {
  public static void main(String args[]) {
    Scanner in = new Scanner(System.in);
    System.out.println("1. Square  2. Circle");
    int ch = in.nextInt();
    switch (ch) {
      case 1:
        double s = in.nextDouble();
        System.out.println("Area = " + s * s);
        break;
      case 2:
        double r = in.nextDouble();
        System.out.println("Area = " + 3.14 * r * r);
        break;
      default:
        System.out.println("Invalid choice");
    }
  }
}
// ch int  menu choice; s, r double  side, radius

The missing break and the missing default are the two classic mark losses in this family. Both are visible in a variable-and-structure check before the program is declared finished.

class Search {
  public static void main(String args[]) {
    int a[] = {12, 45, 7, 89, 23};
    int key = 89, pos = -1;
    for (int i = 0; i < a.length; i++) {
      if (a[i] == key) {
        pos = i;
        break;
      }
    }
    if (pos == -1)
      System.out.println("Not found");
    else
      System.out.println("Found at index " + pos);
  }
}
// a int[]  the data; key int  value sought
// pos int  index if found, else -1; i int  loop

The sentinel value pos = -1 is the idea being tested: how does the program know the key was never found? Say that sentence in the viva and the examiner knows you wrote it.

class Bubble {
  public static void main(String args[]) {
    int a[] = {5, 3, 9, 1, 7};
    for (int i = 0; i < a.length - 1; i++) {
      for (int j = 0; j < a.length - 1 - i; j++) {
        if (a[j] > a[j + 1]) {
          int t = a[j];
          a[j] = a[j + 1];
          a[j + 1] = t;
        }
      }
    }
    for (int i = 0; i < a.length; i++)
      System.out.print(a[i] + " ");
  }
}
// a int[]  data; i int  pass; j int  compare position
// t int  temporary for the swap
// 1 3 5 7 9

The inner loop's upper limit shrinks by i each pass, and knowing why, the largest value has already bubbled to the end, is what separates a written sort from a copied one.

class Word {
  public static void main(String args[]) {
    String s = "Madam";
    String w = s.toLowerCase();
    String rev = "";
    int v = 0;
    for (int i = 0; i < w.length(); i++) {
      char c = w.charAt(i);
      rev = c + rev;
      if ("aeiou".indexOf(c) != -1) v++;
    }
    if (w.equals(rev))
      System.out.println("Palindrome");
    else
      System.out.println("Not a palindrome");
    System.out.println("Vowels: " + v);
  }
}
// s String  input; w String  lowercase copy
// rev String  reversed; c char  current; v int  vowels

One loop, two jobs: rev = c + rev builds the reversal by prepending, and indexOf on a vowel string replaces five comparisons. Both are Section A questions in disguise.

class Words {
  public static void main(String args[]) {
    String s = "Learn Java well";
    String out = "", word = "";
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      if (c == ' ') {
        out = out + word + " ";
        word = "";
      } else {
        word = c + word;
      }
    }
    out = out + word;
    System.out.println(out);
  }
}
// s String  input; out String  result built up
// word String  current word reversed; c char  current
// nraeL avaJ llew

The last word has no space after it, so it must be added after the loop. Forgetting that line is the most common bug in the family, and finding it alone is a Wednesday well spent.

class Student {
  String name;
  int marks;
  Student(String n, int m) {
    name = n;
    marks = m;
  }
  char grade() {
    if (marks >= 80) return 'A';
    else if (marks >= 60) return 'B';
    else return 'C';
  }
  void display() {
    System.out.println(name + " : " + grade());
  }
  public static void main(String args[]) {
    Student s = new Student("Riya", 85);
    s.display();
  }
}
// name String, marks int  data members
// n, m  constructor parameters; s Student  object

The paper gives the skeleton and asks for the body. Marks go to a constructor that initialises, a method that returns, and a main that creates an object and calls both.

class Matrix {
  public static void main(String args[]) {
    int m[][] = {{1, 2, 3},
                 {4, 5, 6},
                 {7, 8, 9}};
    for (int i = 0; i < 3; i++) {
      int sum = 0;
      for (int j = 0; j < 3; j++)
        sum += m[i][j];
      System.out.println("Row " + (i + 1)
                         + " sum = " + sum);
    }
  }
}
// m int[][]  the matrix; i int  row; j int  column
// sum int  running total, reset per row
// Row 1 sum = 6 / Row 2 sum = 15 / Row 3 sum = 24

Where sum is declared decides everything: inside the outer loop it resets per row, outside it accumulates forever. The paper's column-sum variation just swaps which index the outer loop owns.