Number Classification Program in Java
Uploaded by
ananyachandan.1201Number Classification Program in Java
Uploaded by
ananyachandan.12011.
Write a menu-driven program to check if the input number is a:
I] Prime number: A number is said to be prime, if it is only divisible by 1 and itself
II] Automorphic number: the number which is contained in the last digit(s) of its
square
III] Perfect number: A number is said to be perfect if the sum of all its factor
excluding the number to its original number
IV] Twist number: A number is said to be twist if its starting number is odd and
ending number is even.
import [Link]. *;
import [Link].*;
class digits
{
static Scanner sc = new Scanner([Link]);
void calculation () throws IOException
{
int n, ch, f = 0, j, d = 0, N, p, r;
int S = 0, i, LD = 0, FD = 0;
[Link]("MAIN MENU");
[Link]("1. Prime Number");
[Link]("2. Automorphic Number");
[Link]("3. Perfect Number");
[Link]("4. Twist Number");
[Link]("Enter your choice");
ch = [Link]();
[Link]("Enter a number");
n = [Link]();
switch (ch)
{
case 1:
for (j = 1; j <= n; j++)
{
if (n % j == 0)
f++;
}
if (f == 2)
{
[Link](n + " is a Prime Number");
}
else
{
[Link](n + " is NOT a Prime Number");
}
break;
case 2:
N = n;
d = 0;
while (N > 0)
{
N = N / 10;
d++;
}
p = (int) [Link](10, d);
r = (n * n) % p;
if (n == r)
{
[Link](n + " is an Automorphic Number");
}
else
{
[Link](n + " is NOT an Automorphic Number");
}
break;
case 3:
N = n;
S = 0;
for (i = 1; i < N; i++)
{
if (N % i == 0)
{
S = S + i;
}
}
if (S == n)
{
[Link](n + " is a Perfect Number");
}
else
{
[Link](n + " is NOT a Perfect Number");
}
break;
case 4:
LD = n % 10;
N = n;
while (N >= 10)
{
N = N / 10;
}
FD = N;
if (FD % 2 != 0 && LD % 2 == 0)
{
[Link](n + " is a Twist Number");
}
else
{
[Link](n + " is NOT a Twist Number");
}
break;
default:
[Link]("Invalid input!");
}
}
public static void main (String args[]) throws IOException
{
digits obj = new digits ();
[Link]();
}
}
2. Write a menu driven program to check whether the input number is a:
I] Spy number: A number where the sum of its digits is equal to the product of its
digits.
II] Armstrong number: A number where the sum of its cube is equal to its number
III] Niven number: A number when it is divisible by the sum of its digits
IV] Palindrome number: A number that reads the same when read from both sides
import [Link].*;
import [Link].*;
public class digits
{
static Scanner sc = new Scanner([Link]);
void calculation() throws IOException
{
int n, ch, N, S = 0, d = 0, P = 1, v = 0, r = 0;
[Link]("MAIN MENU");
[Link]("1. Spy Number");
[Link]("2. Armstrong Number");
[Link]("3. Niven Number");
[Link]("4. Palindromic Number");
[Link]("Enter your choice");
ch = [Link]();
[Link]("Enter a number");
n = [Link]();
switch (ch)
{
case 1:
N = n;
S = 0;
P = 1;
while (N > 0)
{
d = N % 10;
S = S + d;
P = P * d;
N = N / 10;
}
if (S == P)
{
[Link]("It is a Spy Number");
}
else
{
[Link]("It is NOT a Spy Number");
}
break;
case 2:
N = n;
S = 0;
while (n > 0)
{
d = n % 10;
S = S + (d * d * d);
n = n / 10;
}
if (N == S)
{
[Link]("It is an Armstrong number");
}
else
{
[Link]("It is NOT an Armstrong number");
}
break;
case 3:
N = n;
S = 0;
while (N > 0)
{
v = N % 10;
S = S + v;
N = N / 10;
}
if (n % S == 0)
{
[Link]("It is a Niven Number");
}
else
{
[Link]("It is NOT a Niven Number");
}
break;
case 4:
N = n;
r = 0;
while (N > 0) {
v = N % 10;
r = r * 10 + v;
N = N / 10;
}
if (n == r) {
[Link]("It is a Palindromic Number");
} else {
[Link]("It is NOT a Palindromic Number");
}
break;
default:
[Link]("Invalid input!");
}
}
public static void main(String args[]) throws IOException
{
digits obj = new digits();
[Link]();
}
}
Common questions
Powered by AIIn a Java-based menu-driven system, IO operations facilitate interaction by reading user inputs, while logical evaluations process these inputs to classify numbers. The program reads the choice and number, triggering specific logical evaluations based on the selected option. This synchronization allows for streamlined execution as input-driven logic results in targeted evaluations such as divisibility checks or digit manipulation . The unified function of IO and logic supports robust classification capabilities within the system.
Detecting a Niven number is computationally more efficient than identifying a prime number. The Niven check involves summing digits and performing a single modulo operation to verify divisibility . In contrast, prime number detection requires checking divisibility against numbers up to the square root of the candidate number, potentially involving multiple division operations for non-prime numbers . Thus, Niven checks are simpler and possess less time complexity due to fewer operations needed.
Checking for an automorphic number involves determining if the number fits within its square's last digits. This requires calculating the square, counting digits, and comparing the number with the remainder obtained from dividing the square by ten raised to the digit count . In contrast, palindromic number checks involve reversing the digits of the number and then comparing the reverse with the original number . The automorphic check focuses on numerical properties in squaring while palindromic relies on the sequence of digits.
A perfect number is one where the sum of its factors, excluding the number itself, equals the number. For example, 6 is a perfect number because its factors are 1, 2, 3, and 6, and 1 + 2 + 3 = 6 . This distinguishes perfect numbers from prime numbers, which have no divisors other than 1 and themselves, and from others like automorphic numbers which are embedded as the last digits in their squares.
The complexity of checking an Armstrong number is generally higher than that for a Niven number. Armstrong number determination involves cubing each digit of the number and summing these cubes, then comparing to the original number, which is computationally intensive because of power operations . Niven number checking, by contrast, involves simple arithmetic: summing the digits and verifying divisibility. The latter is less computationally demanding, making Armstrong checks more complex due to the cubic computations involved.
Determining a twist number involves checking if the first digit is odd and the last digit is even. This logical thinking process requires determining the digit positions, extracting each, and evaluating their parity. The need to check both oddity and evenness is due to the constraints that define a twist number, ensuring that the initial and terminal digits meet specific numeric conditions .
The determination of a palindromic number heavily relies on iteration to reverse the number and compare it with the original. The process involves repeated extraction of digits, reconstruction of the number in reverse order, and then conducting a direct comparison. Iterative loops control the digit processing, ensuring each numeral is handled to build the reversed equivalent . This iterative role captures the essence of how sequences can be manipulated to assess symmetry.
The menu-driven construct allows users to interact with programs by presenting them with options to choose from. In the number classification program, the menu lists different types of number checks (e.g., Prime, Perfect, Automorphic, etc.) and waits for user input. This setup enables users to select a specific type of check, streamlining the decision-making process, as the program only executes the logic associated with the chosen option .
A menu-driven program differentiates these checks using switch-case logic. For a prime number, a loop checks divisibility by counting factors, halting if more than two divisors are found . For an automorphic number, the program calculates the square and verifies if the number is embedded at the end of its square by matching remainder conditions . Each case executes under different logical operations based on user selection through menu options.
A spy number maintains balance between operations because it is defined by equality between the sum of its digits and the product of its digits. To identify a spy number, both summation and multiplication are applied to the digits, producing two metrics that must match for the number to qualify. This dual operation underscores the relationship between additive and multiplicative processes in number theory .