Special number programs in Java for ICSE, built on one template.

int t = n;            // copy: keep n for the answer
while (t > 0) {
    int d = t % 10;   // 1. take the last digit
    ... use d ...       // 2. sum, product, power, factorial
    t = t / 10;       // 3. drop the last digit
}
// now compare the result with n

Only step 2 changes from number to number. Steps 1 and 3 never change.

import java.util.Scanner;
class ArmstrongN {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int k = String.valueOf(n).length();     // number of digits
        int t = n, sum = 0;
        while (t > 0) {
            int d = t % 10;
            sum = sum + (int) Math.pow(d, k);   // digit raised to k
            t = t / 10;
        }
        if (sum == n)
            System.out.println(n + " is an Armstrong number");
        else
            System.out.println(n + " is not an Armstrong number (sum = " + sum + ")");
    }
}

Math.pow returns a double, so the (int) cast is needed before adding to an int sum.

import java.util.Scanner;
class Duck {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter the number: ");
        String s = sc.next();                   // read as text so leading zeros survive
        int i = 0;
        while (i < s.length() && s.charAt(i) == '0')
            i++;                                // skip the leading zeros
        boolean duck = false;
        for (int j = i + 1; j < s.length(); j++) {
            if (s.charAt(j) == '0') {
                duck = true;                    // a zero after the first real digit
                break;
            }
        }
        System.out.println(s + (duck ? " is a Duck number" : " is not a Duck number"));
    }
}

If you read the number with nextInt, 0703 arrives as 703 and the leading zero is lost before you can test it.

import java.util.Scanner;
class MagicPerfect {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        // Magic: keep adding the digits until one digit is left
        int m = n;
        while (m > 9) {
            int s = 0;
            while (m > 0) {
                s = s + m % 10;
                m = m / 10;
            }
            m = s;
        }
        System.out.println(n + (m == 1 ? " is" : " is not") + " a Magic number (ends at " + m + ")");
        // Perfect: the factors below n add up to n
        int f = 0;
        for (int i = 1; i < n; i++)
            if (n % i == 0)
                f = f + i;
        System.out.println(n + (f == n ? " is" : " is not") + " a Perfect number (factor sum = " + f + ")");
    }
}

The outer while keeps going until one digit is left; the inner while is the template.

import java.util.Scanner;
class SpecialDisarium {
    static int fact(int d) {                    // d! for one digit
        int f = 1;
        for (int i = 2; i <= d; i++)
            f = f * i;
        return f;
    }
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int k = String.valueOf(n).length();     // position of the last digit
        int t = n, sf = 0, sp = 0;
        while (t > 0) {
            int d = t % 10;
            sf = sf + fact(d);                  // Special: add d!
            sp = sp + (int) Math.pow(d, k);     // Disarium: d to the power of its position
            k--;                                // the next digit sits one place to the left
            t = t / 10;
        }
        System.out.println("Sum of digit factorials = " + sf + (sf == n ? ", Special number" : ", not Special"));
        System.out.println("Sum of positional powers = " + sp + (sp == n ? ", Disarium number" : ", not Disarium"));
    }
}

The loop meets the rightmost digit first, so its position is k, the digit count, and k falls by one each pass.