All Number Program (With Digit Extraction):-

1. **Armstrong Number Program**

```java
Import java.util.Scanner;

Public class ArmstrongNumber {

Public static boolean isArmstrong(int num) {
Int temp = num, n = 0, result = 0;
While (temp > 0) {
N++;
Temp /= 10;
}
Temp = num;
While (temp > 0) {
Int digit = temp % 10;
Result += Math.pow(digit, n);
Temp /= 10;
}
Return result == num;
}
}
```
 2. **Tech Number Program**
```java
Import java.util.Scanner;

Public class TechNumber {

Public static void main(String[] args) {
Int num, leftNumber, rightNumber, sumSquare;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
Num = sc.nextInt(); // Example: 2025
rightNumber = num % 100;
leftNumber = num / 100;
sumSquare = (leftNumber + rightNumber) * (leftNumber +
rightNumber);
if (num == sumSquare) {
System.out.println(“Tech Number”);
} else {
System.out.println(“Not Tech Number”);
}
}
}
```

2
 3. **Automorphic Number Program**
```java
Import java.util.Scanner;

Public class AutomorphicNumber {

Public static void main(String[] args) {
Int n, sqrNum, sqrNumRemainder, c = 0;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Int temp = n;
While (temp > 0) {
Temp /= 10;
C++;
}
sqrNum = n * n;
sqrNumRemainder = sqrNum % (int) Math.pow(10, c);
if (sqrNumRemainder == n) {
System.out.println(“Automorphic Number”);
} else {
System.out.println(“Not Automorphic Number”);
}
}
}
```

3
 4. **Trimorphic Number Program**
```java
Import java.util.Scanner;

Public class TrimorphicNumber {

Public static void main(String[] args) {
Int n, cuNum, cuNumRemainder, c = 0;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Int temp = n;
While (temp > 0) {
Temp /= 10;
C++;
}
cuNum = n * n * n;
cuNumRemainder = cuNum % (int) Math.pow(10, c);
if (cuNumRemainder == n) {
System.out.println(“Trimorphic Number”);
} else {
System.out.println(“Not Trimorphic Number”);
}
}
}
```

4
 5. **Buzz Number Program**
```java
Import java.util.Scanner;

Public class BuzzNumber {

Public static void main(String[] args) {
Int n;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
If (n % 10 == 7 || n % 7 == 0) {
System.out.println(“Buzz Number”);
} else {
System.out.println(“Not Buzz Number”);
}
}
}
```

5
 6. **CoPrime Numbers Program**
```java
Import java.util.Scanner;

Public class CoPrimeNumbers {

Public static void main(String[] args) {
Int a, b;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter a=”);
A = sc.nextInt();
System.out.print(“Enter b=”);
B = sc.nextInt();
If (gcd(a, b) == 1) {
System.out.println(“Co Prime Numbers”);
} else {
System.out.println(“Not Co Prime Numbers”);
}
}

Static int gcd(int a, int b) {

If (b == 0) return a;
Return gcd(b, a % b);
}
}
```

6
 7. **Duck Number Program**
```java
Import java.util.Scanner;

Public class DuckNumber {

Public static void main(String[] args) {
Int n, r;
Boolean flag = false;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
While (n > 0) {
R = n % 10;
If (r == 0) {
Flag = true;
Break;
}
N /= 10;
}
If (flag) {
System.out.println(“Duck Number”);
} else {
System.out.println(“Not Duck Number”);
}
}
}

7
 ```

8. **Factorial Program**
```java
Import java.util.Scanner;

Public class Factorial {

Public static void main(String[] args) {
Int n, fact = 1;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
For (int I = 1; I <= n; i++) {
Fact *= I;
}
System.out.println(“Factorial=” + fact);
}
}
```

8
 9. **Factors Program**
```java
Import java.util.Scanner;

Public class Factors {

Public static void main(String[] args) {
Int n;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
For (int I = 1; I <= n; i++) {
If (n % I == 0) {
System.out.println(i);
}
}
}
}
```

9
 10. **Fibonacci Series Program**
```java
Import java.util.Scanner;

Public class FibonacciSeries {

Public static void main(String[] args) {
Int n, a = 0, b = 1, c;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number of terms=”);
N = sc.nextInt();
For (int I = 1; I <= n; i++) {
System.out.println(a);
C = a + b;
A = b;
B = c;
}
}
}
```

10
 11. **Greatest Common Divisor (GCD) Program**
```java
Import java.util.Scanner;

Public class GCD {

Public static void main(String[] args) {
Int a, b;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter a=”);
A = sc.nextInt();
System.out.print(“Enter b=”);
B = sc.nextInt();
Int gcd = findGCD(a, b);
System.out.println(“GCD=” + gcd);
}

Static int findGCD(int a, int b) {

If (b == 0) return a;
Return findGCD(b, a % b);
}
}
```

11
 12. **Happy Number Program**
```java
Import java.util.Scanner; ** }
```
Public class HappyNumber {
Public static void main(String[] args) {
Int n, num, sum = 0, r;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Num = n;
While (num > 9) {
Sum = 0;
While (num > 0) {
R = num % 10;
Sum += r * r;
Num /= 10;
}
Num = sum;
}
If (num == 1) {
System.out.println(“Happy Number”);
} else {
System.out.println(“Not Happy Number”);
}
} **

12
 13. **Niven/Harshad Number Program**
```java
Import java.util.Scanner; ** ```

Public class HarshadNumber {

Public static void main(String[] args) {
Int n, sum = 0, r, num;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Num = n;
While (num > 0) {
R = num % 10;
Sum += r;
Num /= 10;
}
If (n % sum == 0) {
System.out.println(“Harshad Number”);
} else {
System.out.println(“Not Harshad Number”);
}
}
} **

13
 14. **Least Common Multiple (LCM) Program**
```java
Import java.util.Scanner;

Public class LCM {

Public static void main(String[] args) {
Int a, b;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter a=”);
A = sc.nextInt();
System.out.print(“Enter b=”);
B = sc.nextInt();
Int gcd = findGCD(a, b);
Int lcm = (a * b) / gcd;
System.out.println(“LCM=” + lcm);
}

Static int findGCD(int a, int b) {

If (b == 0) return a;
Return findGCD(b, a % b);
}
}
```

14
 15. **Multiply of Digits Program**
```java
Import java.util.Scanner;

Public class MultiplyOfDigits {

Public static void main(String[] args) {
Int n, r, mul = 1;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
While (n > 0) {
R = n % 10;
Mul *= r;
N /= 10;
}
System.out.println(“Multiply of digits=” + mul);
}
}
```

15
 16. **Neon Number Program**
```java
Import java.util.Scanner;

Public class NeonNumber {

Public static void main(String[] args) {
Int n, sqr, sum = 0, r;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Sqr = n * n;
While (sqr > 0) {
R = sqr % 10;
Sum += r;
Sqr /= 10;
}
If (n == sum) {
System.out.println(“Neon Number”);
} else {
System.out.println(“Not Neon Number”);
}
}
}
```

16
 17. **Palindrome Number Program**
```java
Import java.util.Scanner;

Public class PalindromeNumber {

Public static void main(String[] args) {
Int n, num, r, rev = 0;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Num = n;
While (num > 0) {
R = num % 10;
Rev = rev * 10 + r;
Num /= 10;
}
If (n == rev) {
System.out.println(“Palindrome Number”);
} else {
System.out.println(“Not Palindrome Number”);
}
}
}
```

17
 18. **Perfect Number Program**
```java
Import java.util.Scanner;

Public class PerfectNumber {

Public static void main(String[] args) {
Int n, sum = 0;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
For (int I = 1; I < n; i++) {
If (n % I == 0) {
Sum += I;
}
}
If (n == sum) {
System.out.println(“Perfect Number”);
} else {
System.out.println(“Not Perfect Number”);
}
}
}
```

18
 19. **Prime Number Program**
```java
Import java.util.Scanner;

Public class PrimeNumber {

Public static void main(String[] args) {
Int n, I = 2;
Boolean flag = true;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
While (n > i) {
If (n % I == 0) {
Flag = false;
Break;
}
I++;
}
If (flag) {
System.out.println(“Number is prime.”);
} else {
System.out.println(“Number is not prime.”);
}
}
}
```

19
 20. **Reverse Number Program**
```java
Import java.util.Scanner;

Public class ReverseNumber {

Public static void main(String[] args) {
Int n, num, r, rev = 0;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Num = n;
While (num > 0) {
R = num % 10;
Rev = rev * 10 + r;
Num /= 10;
}
System.out.println(“Reverse of Number=” + rev);
}
}
```

20
 21. **Krishnamurthy/Special Number Program**
```java
Import java.util.Scanner; ** Fact *= I;
}
Public class KrishnamurthyNumber { Return fact;
Public static void main(String[] args) { }
Int n, num, r, sumOfFactorial = 0; }
Scanner sc = new Scanner(System.in); ```
System.out.print(“Enter number=”);
N = sc.nextInt();
Num = n;
While (num > 0) {
R = num % 10;
sumOfFactorial += factorial®;
num /= 10;
}
If (n == sumOfFactorial) {
System.out.println(“Special Number”);
} else {
System.out.println(“Not Special Number”);
}
}

Static int factorial(int r) {

Int fact = 1;
For (int I = 1; I <= r; i++) { **

21
 22. **Spy Number Program**
```java
Import java.util.Scanner;

Public class SpyNumber {

Public static void main(String[] args) {
Int n, num, r, mul = 1, sum = 0;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Num = n;
While (num > 0) {
R = num % 10;
Sum += r;
Mul *= r;
Num /= 10;
}
If (mul == sum) {
System.out.println(“Spy Number”);
} else {
System.out.println(“Not Spy Number”);
}
}
}
```

22
 23. **Twin Prime Program**
```java
Import java.util.Scanner; ** ```

Public class TwinPrime {

Public static void main(String[] args) {
Int a, b;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter a=”);
A = sc.nextInt();
System.out.print(“Enter b=”);
B = sc.nextInt();
If (isPrime(a) && isPrime(b) && Math.abs(a – b) == 2) {
System.out.println(“Twin Prime”);
} else {
System.out.println(“Not Twin Prime”);
}
}

Static boolean isPrime(int n) {

For (int I = 2; I <= Math.sqrt(n); i++) {
If (n % I == 0) return false;
}
Return true;
}
} **

23
 24. **Twisted Prime Program**
```java
Import java.util.Scanner; ** }
Return true;
Public class TwistedPrime { }
Public static void main(String[] args) { }
Int n, num, r, rev = 0; ```
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Num = n;
While (num > 0) {
R = num % 10;
Rev = rev * 10 + r;
Num /= 10;
}
If (isPrime(n) && isPrime(rev)) {
System.out.println(“Twisted Prime”);
} else {
System.out.println(“Not Twisted Prime”);
}
}

Static boolean isPrime(int n) {

For (int I = 2; I <= Math.sqrt(n); i++) {
If (n % I == 0) return false; **

24
 25. **Unique Number Program**
```java
Import java.util.Scanner;

Public class UniqueNumber {

Public static void main(String[] args) {
Int n, num1, num2, r1, r2, c = 0;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt(); ** System.out.println(“Not Unique Number”);
Num1 = n; }
Num2 = n; }
While (num1 > 0) { }
R1 = num1 % 10; ```
While (num2 > 0) {
R2 = num2 % 10;
If (r1 == r2) {
C++;
}
Num2 /= 10;
}
Num1 /= 10;
}
If (c == 1) {
System.out.println(“Unique Number”);
} else { **

25
 26. **Disarium Number Program**
```java
Import java.util.Scanner;

Public class DisariumNumber { ** }

Public static void main(String[] args) { }
Int n, num, r, digits = 0, sum = 0; }
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Num = n;
While (num > 0) {
Digits++;
Num /= 10;
}
Num = n;
While (num > 0) {
R = num % 10;
Sum += (int) Math.pow(r, digits);
Num /= 10;
Digits--;
}
If (n == sum) {
System.out.println(“Disarium Number”);
} else {
System.out.println(“Not Disarium Number”); **

26
 27. **Prime Number Up to N Terms Program**
```java
Import java.util.Scanner;

Public class PrimeNumbersUpToN {

Public static void main(String[] args) {
Int n, c;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter size of prime=”);
N = sc.nextInt();
For (int j = 1; j <= n; j++) {
C = 0;
For (int I = 1; I <= j; i++) {
If (j % I == 0) {
C++;
}
}
If (c == 2) {
System.out.println(“Prime number=” + j);
}
}
}
}
```

27
 28. **Magic Number Program**
```java
Import java.util.Scanner;

Public class MagicNumber { ** }

Public static void main(String[] args) { ```
Int n, num, sum = 0, r;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
Num = n;
While (num > 9) {
While (num > 0) {
R = num % 10;
Sum += r;
Num /= 10;
}
Num = sum;
Sum = 0;
}
If (num == 1) {
System.out.println(“Magic Number”);
} else {
System.out.println(“Not Magic Number”);
}
} **

28
 29. **Pronic Number Program**
```java
Import java.util.Scanner;

Public class PronicNumber {

Public static void main(String[] args) {
Int n;
Boolean flag = false;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
For (int I = 1; I < n; i++) {
If (I * (I + 1) == n) {
Flag = true;
Break;
}
}
If (flag) {
System.out.println(“Pronic Number”);
} else {
System.out.println(“Not Pronic Number”);
}
}
}
```

29
 30. **Ugly Number Program**
```java
Import java.util.Scanner;

Public class UglyNumber {

Public static void main(String[] args) {
Int n;
Boolean flag = true;
Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
N = sc.nextInt();
While (n != 1) {
If (n % 5 == 0) { ** System.out.println(“Not Ugly Number”);
N /= 5; }
} else if (n % 3 == 0) { }
N /= 3; }
} else if (n % 2 == 0) { ```
N /= 2;
} else {
Flag = false;
Break;
}
}
If (flag) {
System.out.println(“Ugly Number”);
} else { **

30
31.**Composite Number Program**
```java
Import java.util.Scanner;

Public class CompositeNumber {

Public static boolean isComposite(int number) {
If (number <= 1) return false;
For (int I = 2; I < number; i++) {
If (number % I == 0) return true;
}
Return false;
}

Public static void main() {

Scanner sc = new Scanner(System.in);
System.out.print(“Enter a number: “);
Int number = sc.nextInt();
If (isComposite(number)) {
System.out.println(number + “ is a composite number.”);
} else {
System.out.println(number + “ is not a composite number.”);
}
}
```

31
 32. **Perfect Square Program**
```java
Import java.util.Scanner;

Public class PerfectSquare {

Static boolean isPerfect(int x) {
If (x >= 0) {
Int sr = (int) Math.sqrt(x);
Return sr * sr == x;
}
Return false;
}

Public static void main(String[] args) {

Int x = 25;
If (isPerfect(x)) {
System.out.println(x + “ is a perfect square”);
} else {
System.out.println(x + “ is not a perfect square”);
}
}
}
```

32
 33.**Dudeney Number Program**
```java
Import java.util.Scanner;

Public class DudeneyNumber {

Public static void checkDudeney(int n) {
Int cRoot = (int) Math.round(Math.cbrt(n)), sum = 0, t = n;
If (cRoot * cRoot * cRoot == n) {
While (t > 0) { **checkDudeney(n);
Sum += t % 10; }
T /= 10; }
} ```
If (sum == cRoot) {
System.out.println(n + “ is a Dudeney number”);
} else {
System.out.println(n + “ is not a Dudeney number”);
}
} else {
System.out.println(n + “ is not a Dudeney number”);
}
}

Public static void main(String[] args) {

Scanner sc = new Scanner(System.in);
System.out.print(“Enter number=”);
Int n = sc.nextInt(); **

33
 34.**Twisted Prime Number Program**
```java
Import java.util.*; **System.out.println(“Not Twisted Prime”);
}
Public class ABC { }
Int reverse(int n) { Public static void main(String[] args) {
Int rev = 0; ABC obj = new ABC();
While (n > 0) { Int n = 31;
Int r = n % 10; Obj.prime(n);
Rev = rev * 10 + r; }
N = n / 10; }
} ```
Return rev;
}
Void prime(int t) {
Int tr = reverse(t);
Int c1 = 0, c2 = 0;
For (int I = 1; I <= t; i++) {
If (t % I == 0) c1++;
}
For (int I = 1; I <= tr; i++) {
If (tr % I == 0) c2++;
}
If (c1 == 2 && c2 == 2) {
System.out.println(“Twisted Prime”);
} else { **

34