## Java program to check if a number is evil number or not:

This post will show you how to check if a user given number is *evil* number or not. A positive number is called an *Evil* number if its binary equivalent holds *even* number of *1*‘s. A number is called *even* if it is exactly divisible by *2*. For example, *2*, *4*, *6* etc. are even numbers.

Let’s take an example. *15* is a evil number. Because, its binary value is *1111* and it has even number of *1*.

### Algorithm to check if a number is evil number or not:

We can use the below algorithm to check if a number is *Evil* or not.

- Take the number as input from the user.
- Find the
*binary*equivalent for the number. - Count the number of
*1*in the binary value.- If the count is
*even*, print that it is a*evil*number. Else, it is not a*evil*number.

- If the count is

Now, we have to follow one more algorithm to find the *binary* value of a number.

- Divide the number by
*2*and store the*quotient*and*remainder*. - Keep dividing the
*quotient*by*2*until it become*0*. Also, keep the*remainder*stored. - Once done, if you join the remainders in reverse, it will be the binary value.

Let’s try to convert *23* to binary:

*23/2*, quotient is*11*and remainder is*1**11/2*, quotient is*5*and remainder is*1**5/2*, quotient is*2*and remainder is*1**2/2*, quotient is*1*and remainder is*0**1/2*, quotient is*0*and remainder is*1*

So, the binary value is *10111*.

### Method 1: Java program to check if a number is Evil number or not:

Let’s write a program to check if a user given number is an *Evil* number or not:

```
import java.util.Scanner;
public class Main {
public static long getBinary(int d) {
long b = 0;
int multiplier = 1;
int remainder;
while (d != 0) {
remainder = d % 2;
b += remainder * multiplier;
multiplier *= 10;
d /= 2;
}
return b;
}
public static boolean isEvil(int n) {
long binary = getBinary(n);
int oneCount = 0;
while (binary != 0) {
if (binary % 10 == 1) {
oneCount += 1;
}
binary /= 10;
}
return oneCount % 2 == 0;
}
public static void main(String[] args) {
int no;
Scanner scanner = new Scanner(System.in);
System.out.println("Enter a number");
no = scanner.nextInt();
if (isEvil(no)) {
System.out.println(no + " is an evil number");
} else {
System.out.println(no + " is not an evil number");
}
}
}
```

Here,

*getBinary*method takes one integer value and returns its binary value in*long**b*is a*long*variable to hold the binary value.*multiplier*is used to add the*remainder*to the end of the binary value, because we need to keep appending the remainders to the end.*remainder*is used to hold the remainder.- The
*while*loop runs until the value of*d*is*0*. It uses the*modulo*operator to find the remainder, multiply it with the multiplier and adds it to the current value of*b*. - It also updates the value of the
*multiplier*and changes the value of*d*to*d/2* - Finally, it returns
*b*.

*isEvil*method takes one integer and returns one*boolean*value. It returns*true*if the argument integer is*evil*, else it returns*false*.- It uses
*getBinary*method to find the binary value of the given number. *oneCount*is a variable to hold the total number of*1*in the binary.- The
*while*loop runs until the value of the binary is*0*. - Inside the loop, it uses
*%10*to check the last digit of the binary value. If it is*1*, it increments the value of*oneCount*by*1*. Also, it removes the last digit from the binary value by dividing it by*10*. - Once the
*while loop*ends, it checks the total count of*1*and returns*true*if it is*even*. Else, it returns*false*.

- It uses
- The
*main*method uses a*Scanner*object to read the number from the user. It calls*isEvil*to check if the number is an*evil*number or not and prints one message based on that.

If you run this program, it will print result as like below:

```
Enter a number
10
10 is an evil number
Enter a number
9
9 is an evil number
Enter a number
11
11 is not an evil number
```

### Method 2: Java program to check if a number is Evil number or not using one method:

In the above program, we used two methods. But, we can use only one method to check if a number is *evil* or not. i.e. instead of finding the *binary* equivalent and finding the total number of *1* again, we can find the total number or *1* while finding the *binary value* in only one method.

Let’s write down the program:

```
import java.util.Scanner;
public class Main {
public static boolean isEvil(int n) {
int oneCount = 0;
int remainder;
while (n != 0) {
remainder = n % 2;
if (remainder == 1) {
oneCount++;
}
n /= 2;
}
return oneCount % 2 == 0;
}
public static void main(String[] args) {
int no;
Scanner scanner = new Scanner(System.in);
System.out.println("Enter a number");
no = scanner.nextInt();
if (isEvil(no)) {
System.out.println(no + " is an evil number");
} else {
System.out.println(no + " is not an evil number");
}
}
}
```

Here,

- We are not building the final binary string. We are only finding the number of
*1*in the binary value. - It finds the
*remainder*and if it is*1*, it increases the value of*oneCount*by*1*. - At the end of the loop, it assigns
*n/2*to*n*.

It is almost similar to the above program, but it will be faster because we are doing it in one loop.

If you

```
Enter a number
17
17 is an evil number
```

### Method 3: Java program to check if a number is Evil number or not using toBinaryString:

*toBinaryString* method can be used to get the binary representation of an integer value. This method is defined as like below:

`public static String toBinaryString(int i)`

This is a *static* method and it returns one *String*. It is defined in the *Integer* class and we can call this method directly without creating any object of *Integer* class.

It returns one string value, i.e. the string representation of the integer parameter. Once we get the binary string, we can iterate through the characters of the string one by one and find out the total number of *1* in that string.

Let’s write it down in code:

```
import java.util.Scanner;
public class Main {
public static boolean isEvil(int n) {
int oneCount = 0;
String binary = Integer.toBinaryString(n);
for (char c : binary.toCharArray()) {
if (c == '1') {
oneCount++;
}
}
return oneCount % 2 == 0;
}
public static void main(String[] args) {
int no;
Scanner scanner = new Scanner(System.in);
System.out.println("Enter a number");
no = scanner.nextInt();
if (isEvil(no)) {
System.out.println(no + " is an evil number");
} else {
System.out.println(no + " is not an evil number");
}
}
}
```

- This is similar to the above program. We are using the
*isEvil*method to check if a number is evil or not. - The number is converted to a binary string and we are iterating through the characters of the string one by one.
- If we find any character is
*1*, we are incrementing the variable that holds the total number of*1*by one. - At the end, it returns one boolean value.

If you run this program, it will print similar output.

```
Enter a number
17
17 is an evil number
```

### Java program to print all evil numbers from 1 to 100:

We can use any of these three methods to find and print all *evil* numbers in a range. We have to use a *loop* and for each number in the loop, we can check if it is evil or not and we can print a message.

```
public class Main {
public static boolean isEvil(int n) {
int oneCount = 0;
String binary = Integer.toBinaryString(n);
for (char c : binary.toCharArray()) {
if (c == '1') {
oneCount++;
}
}
return oneCount % 2 == 0;
}
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
if (isEvil(i)) {
System.out.print(i + " ");
}
}
}
}
```

In this program, we are using a *for loop* that runs from *1* to *100* and for each value of *i*, it checks if it is *evil* or not. If it is *evil*, it prints the value of *i*.

You can change the loop range to any other values as well. If you run this program, it will print:

`3 5 6 9 10 12 15 17 18 20 23 24 27 29 30 33 34 36 39 40 43 45 46 48 51 53 54 57 58 60 63 65 66 68 71 72 75 77 78 80 83 85 86 89 90 92 95 96 99 `

### You might also like:

- Java program to check if a number is a ugly number or not
- Java program to check if a number is a unique number or not
- Java program to check if a number is Nelson number or not
- Java.util.Arrays.copyOf() method explanation with example
- Java program to print a cross star pattern
- 3 different Java programs to print Pascal’s triangle for a given height
- Java program to check if a number is a spy number or not
- Java program to check if a number is a duck number or not