Un número que es divisible por 2 y genera un resto de 0 se llama número par. Todos los números que terminan en 0, 2, 4, 6 y 8 son números pares. Por otro lado, el número que no es divisible por 2 y genera un residuo de 1 se llama número impar. Todos los números que terminan en 1, 3, 5, 7 y 9 son números impares. Consulte la ilustración a continuación para obtener lo que se supone que debe transmitirse aquí a través de la ilustración genérica para cualquier número entero aleatorio, verifique si es par o impar.
Input : 13 Output: ODD
Input : 24 Output: EVEN
Métodos:
Hay varias formas de comprobar si el número dado es par o impar. Algunos de ellos son los siguientes, comenzando desde el enfoque de fuerza bruta y terminando en el enfoque más óptimo.
- Uso de la fuerza bruta: enfoque ingenuo
- Uso de operadores bit a bit
- Uso de bit a bit O
- Uso de AND bit a bit
- Uso de XOR bit a bit
- Al marcar el bit menos significativo
Método 1: enfoque ingenuo de fuerza bruta
Es para verificar el resto después de dividir por 2. Los números que son divisibles por 2 son incluso impares.
Ejemplo
Java
// Java Program to Check if Given Integer is Odd or Even
// Using Brute Forcew Approach
// Importing required classes
import java.io.*;
import java.util.Scanner;
// Main class
class GFG {
// Main Driver Method
public static void main(String[] args)
{
// Declaring and initializing integer variable
int num = 10;
// Checking if number is even or odd number
// via remainder
if (num % 2 == 0) {
// If remainder is zero then this number is even
System.out.println("Entered Number is Even");
}
else {
// If remainder is not zero then this number is
// odd
System.out.println("Entered Number is Odd");
}
}
}
Entered Number is Even
Complejidad de tiempo: O(1)
Espacio Auxiliar: O(1)
Ahora, detengámonos en los enfoques óptimos de la siguiente manera con la ayuda de operadores bit a bit.
Método 2: usar operadores bit a bit
- O bit a bit
- AND bit a bit o XOR bit a bit
2-A: Uso de OR bit a bit
La operación OR bit a bit del número par en 1 incrementa el valor del número en 1; de lo contrario, permanece sin cambios.
Ilustración: bit a bit O
Number = 12 1 1 0 0 - Representation of 12 in Binary Format
Bitwise OR 0 0 0 1 - Representation of 1 in Binary Format
1 1 0 1 - Representation of 13 in Binary Format
Result- Number was even so bitwise Or by 1 increment the value by 1
Number = 15 1 1 1 1 - Representation of 15 in Binary Format
Bitwise OR 0 0 0 1 - Representation of 1 in Binary Format
1 1 1 1 - Representation of 15 in Binary Format
Result- Number was odd so bitwise Or by 1 doesn't increment the value by 1
Ejemplo
Java
// Java Program to Check if Given Integer is Odd or Even
// Using Bitwise OR
// Importing required classes
import java.util.*;
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Declaring and initializing integer variable
// to be checked
int n = 100;
// Condition check
// if n|1 if greater than n then this number is even
if ((n | 1) > n) {
// Print statement
System.out.println("Number is Even");
}
else {
// Print statement
System.out.println("Number is Odd");
}
}
}
Number is Even
Complejidad de tiempo : O(1)
Espacio Auxiliar: O(1)
2-B: Uso de AND bit a bit
La operación AND bit a bit del número impar por 1 será 1 porque el último bit ya estará configurado; de lo contrario, dará 0.
Ilustración: bit a bit Y
Number = 5 0 1 0 1 - Representation of 5 in Binary Format
Bitwise AND 0 0 0 1 - Representation of 1 in Binary Format
0 0 0 1 - Representation of 1 in Binary Format
Result- Number was odd so bitwise And by 1 is 1
Number = 8 1 0 0 0 - Representation of 8 in Binary Format
Bitwise AND 0 0 0 1 - Representation of 1 in Binary Format
0 0 0 0 - Representation of 0 in Binary Format
Result- Number was even so bitwise And by 1 is 0
Ejemplo
Java
// Java Program to Check if Given Integer is Odd or Even
// Using Bitwise AND
// Importing required classes
import java.util.*;
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Declare and initializing integer variable
int n = 91;
// Condition Check
// Bitwise AND of any odd number by 1 gives 1
if ((n & 1) == 1) {
// Print statement
System.out.println("Number is Odd");
}
else {
// Print statement
System.out.println("Number is Even");
}
}
}
Number is Odd
Complejidad de tiempo: O(1)
Espacio Auxiliar: O(1)
2-C: Uso de XOR bit a bit
La operación XOR bit a bit del número par en 1 incrementa el valor del número en 1; de lo contrario, disminuye el valor del número en 1 si el valor es impar. Es el enfoque más óptimo.
Ilustración: XOR bit a bit
Number = 5 0 1 0 1 - Representation of 5 in Binary Format
Bitwise XOR 0 0 0 1 - Representation of 1 in Binary Format
0 1 0 0 - Representation of 4 in Binary Format
Result- Number was odd so bitwise And by 1 decrement the value
Number = 8 1 0 0 0 - Representation of 8 in Binary Format
Bitwise XOR 0 0 0 1 - Representation of 1 in Binary Format
1 0 0 1 - Representation of 9 in Binary Format
Result- Number was even so bitwise And by 1 increment the value
Ejemplo
Java
// Java Program to Check if Given Integer is Odd or Even
// Using Bitwise XOR
// Importing required classes
import java.util.*;
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Declare and initializing integer variable
int num = 99;
// Condition Check
// if number^1 increments by 1 then its even number,
// else odd
if ((num ^ 1) == num + 1) {
// Print statement
System.out.println("Number is Even");
}
else {
// Print statement
System.out.println("Number is Odd");
}
}
}
Number is Odd
Complejidad de tiempo: O(1)
Espacio Auxiliar: O(1)
Método 3: Comprobación del LSB del número
El LSB (Least Significant Bit) de un número par siempre es 0 y el de un número impar siempre es 1.
Ejemplo
Java
// Java Program to Check if Given Integer is Odd or Even
// by checking the LSB of the Number
// Importing required classes
import java.util.*;
// Main class
// TestEvenOddByCheckingLSB
public class GFG {
// Method 1
// To test number is even or odd
public static String testOddEvenByCheckingLSB(int a)
{
if (a != 0) {
if (Integer.toBinaryString(a).endsWith("0")) {
return "Even";
}
else {
return "Odd";
}
}
// Here we will land if
// it does not ends with 0
else {
return "Zero";
}
}
// Method 2
// Main driver method
public static void main(String[] args)
{
// Iterationg over using for loop
for (int i = 0; i <= 10; i++) {
// Calling the function and printing
// corresponding number is even or odd
System.out.println(
i + " : " + testOddEvenByCheckingLSB(i));
}
}
}
0 : Zero 1 : Odd 2 : Even 3 : Odd 4 : Even 5 : Odd 6 : Even 7 : Odd 8 : Even 9 : Odd 10 : Even
Complejidad de tiempo: O(1)
Espacio Auxiliar: O(1)
Publicación traducida automáticamente
Artículo escrito por prateekc231 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA