recibir - saber si es par o impar en c
¿Cómo verifico si un entero es par o impar? (30)
+ 66% más rápido>!(i%2) / i%2 == 0
int isOdd(int n)
{
return n & 1;
}
El código comprueba el último bit del entero si es 1 en binario
Explicación
Binary : Decimal
-------------------
0000 = 0
0001 = 1
0010 = 2
0011 = 3
0100 = 4
0101 = 5
0110 = 6
0111 = 7
1000 = 8
1001 = 9
and so on...
Observe que el bit más a la derecha siempre es 1 para los números impares .
El operador & bitwise Y verifica el bit más a la derecha en nuestra línea de retorno si es 1
Piense en ello como verdadero y falso
Cuando comparamos n con 1, que significa 0001en binario (el número de ceros no importa).
entonces imaginemos que tenemos el entero n con un tamaño de 1 byte.
Se representaría mediante dígitos de 8 bits / 8 binarios.
Si el int n era 7 y lo comparamos con 1 , es como
7 (1-byte int)| 0 0 0 0 0 1 1 1
&
1 (1-byte int)| 0 0 0 0 0 0 0 1
********************************************
Result | F F F F F F F T
Qué F significa falso y T para verdadero.
Se compara solamente el bit más a la derecha si son ambas verdaderas. Entonces, automágicamente
7 & 1es T rue.
¿Qué pasa si quiero comprobar el bit antes de la derecha?
Simplemente cambia n & 1a lo n & 2que 2 representa 0010en binario y así sucesivamente.
Sugiero usar la notación hexadecimal si eres un principiante en operaciones bitwise
return n & 1;>>return n & 0x01; .
¿Cómo puedo verificar si un número dado es par o impar en C?
Al leer esta discusión bastante entretenida, recordé que tenía una función sensible al tiempo del mundo real que probaba los números pares e impares dentro del bucle principal. Es una función de potencia entera, publicada en otro lugar en , de la siguiente manera. Los puntos de referencia fueron bastante sorprendentes. Al menos en esta función del mundo real, el módulo es más lento y significativamente más. El ganador, por un amplio margen, que requiere el 67% del tiempo de módulo, es un enfoque o (|) , y no se encuentra en ningún otro lugar en esta página.
static dbl IntPow(dbl st0, int x) {
UINT OrMask = UINT_MAX -1;
dbl st1=1.0;
if(0==x) return (dbl)1.0;
while(1 != x) {
if (UINT_MAX == (x|OrMask)) { // if LSB is 1...
//if(x & 1) {
//if(x % 2) {
st1 *= st0;
}
x = x >> 1; // shift x right 1 bit...
st0 *= st0;
}
return st1 * st0;
}
Para 300 millones de bucles, los tiempos de referencia son los siguientes.
3.962 la | y enfoque de máscara
4.851 el enfoque &
5.850 el enfoque%
Para las personas que piensan en la teoría, o en un listado en lenguaje ensamblador, resuelven argumentos como estos, esto debería ser una advertencia. Hay más cosas en el cielo y en la tierra, Horacio, de las que sueñas en tu filosofía.
Aquí hay una respuesta en Java:
public static boolean isEven (Integer Number) {
Pattern number = Pattern.compile("^.*?(?:[02]|8|(?:6|4))$");
String num = Number.toString(Number);
Boolean numbr = new Boolean(number.matcher(num).matches());
return numbr.booleanValue();
}
Como algunas personas han publicado, hay muchas maneras de hacerlo. Según este sitio web , la forma más rápida es el operador de módulo:
if (x % 2 == 0)
total += 1; //even number
else
total -= 1; //odd number
Sin embargo, aquí hay otro código que fue marcado por el autor y que se ejecutó más lento que la operación de módulo común anterior:
if ((x & 1) == 0)
total += 1; //even number
else
total -= 1; //odd number
System.Math.DivRem((long)x, (long)2, out outvalue);
if ( outvalue == 0)
total += 1; //even number
else
total -= 1; //odd number
if (((x / 2) * 2) == x)
total += 1; //even number
else
total -= 1; //odd number
if (((x >> 1) << 1) == x)
total += 1; //even number
else
total -= 1; //odd number
while (index > 1)
index -= 2;
if (index == 0)
total += 1; //even number
else
total -= 1; //odd number
tempstr = x.ToString();
index = tempstr.Length - 1;
//this assumes base 10
if (tempstr[index] == ''0'' || tempstr[index] == ''2'' || tempstr[index] == ''4'' || tempstr[index] == ''6'' || tempstr[index] == ''8'')
total += 1; //even number
else
total -= 1; //odd number
¿Cuánta gente sabía del método Math.System.DivRem o por qué lo usarían?
El método a nivel de bits depende de la representación interna del entero. Modulo trabajará en cualquier lugar donde haya un operador de modulo. Por ejemplo, algunos sistemas realmente usan los bits de bajo nivel para el etiquetado (como los lenguajes dinámicos), por lo que el x & 1 no funcionará en ese caso.
En la "categoría creativa pero confusa" ofrezco:
int isOdd(int n) { return n ^ n * n ? isOdd(n * n) : n; }
Una variante de este tema que es específica de Microsoft C ++:
__declspec(naked) bool __fastcall isOdd(const int x)
{
__asm
{
mov eax,ecx
mul eax
mul eax
mul eax
mul eax
mul eax
mul eax
ret
}
}
En respuesta a ffpf , tuve exactamente la misma discusión con un colega hace años, y la respuesta es no , no funciona con números negativos.
El estándar de C estipula que los números negativos se pueden representar de 3 maneras:
- Complemento de 2
- Complemento de 1
- signo y magnitud
Comprobando así:
isEven = (x & 1);
trabajará para el complemento de 2 y la representación de signo y magnitud, pero no para el complemento de 1.
Sin embargo, creo que lo siguiente funcionará para todos los casos:
isEven = (x & 1) ^ ((-1 & 1) | ((x < 0) ? 0 : 1)));
¡Gracias a ffpf por señalar que el cuadro de texto estaba comiendo todo después de mi carácter inferior!
Este es un seguimiento de la discusión con @RocketRoy sobre su respuesta , pero podría ser útil para cualquiera que quiera comparar estos resultados.
tl; dr Según lo que he visto, el enfoque de Roy ( (0xFFFFFFFF == (x | 0xFFFFFFFE) ) no está completamente optimizado para x & 1 como el enfoque de mod , pero en la práctica los tiempos de ejecución deberían ser iguales en todos los casos.
Entonces, primero comparé la salida compilada usando Compiler Explorer :
Funciones probadas:
int isOdd_mod(unsigned x) {
return (x % 2);
}
int isOdd_and(unsigned x) {
return (x & 1);
}
int isOdd_or(unsigned x) {
return (0xFFFFFFFF == (x | 0xFFFFFFFE));
}
CLang 3.9.0 con -O3:
isOdd_mod(unsigned int): # @isOdd_mod(unsigned int)
and edi, 1
mov eax, edi
ret
isOdd_and(unsigned int): # @isOdd_and(unsigned int)
and edi, 1
mov eax, edi
ret
isOdd_or(unsigned int): # @isOdd_or(unsigned int)
and edi, 1
mov eax, edi
ret
GCC 6.2 con -O3:
isOdd_mod(unsigned int):
mov eax, edi
and eax, 1
ret
isOdd_and(unsigned int):
mov eax, edi
and eax, 1
ret
isOdd_or(unsigned int):
or edi, -2
xor eax, eax
cmp edi, -1
sete al
ret
Desde los sombreros hasta CLang, se dio cuenta de que los tres casos son funcionalmente iguales. Sin embargo, el enfoque de Roy no está optimizado en GCC, por lo que YMMV.
Es similar con Visual Studio; inspeccionando el Desmontaje Release x64 (VS2015) para estas tres funciones, pude ver que la parte de comparación es igual para "mod" y "y" casos, y ligeramente más grande para el caso de Roy "o":
// x % 2
test bl,1
je (some address)
// x & 1
test bl,1
je (some address)
// Roy''s bitwise or
mov eax,ebx
or eax,0FFFFFFFEh
cmp eax,0FFFFFFFFh
jne (some address)
Sin embargo, después de ejecutar un punto de referencia real para comparar estas tres opciones (mod simple, bitwise o, bitwise y), los resultados fueron completamente iguales (nuevamente, Visual Studio 2005 x86 / x64, compilación de la versión, sin depurador adjunto).
El ensamblaje de liberación usa la instrucción de test para and casos mod , mientras que el caso de Roy usa el enfoque cmp eax,0FFFFFFFFh , pero está muy desenrollado y optimizado, por lo que no hay diferencias en la práctica.
Mis resultados después de 20 ejecuciones (i7 3610QM, plan de energía de Windows 10 configurado en Alto rendimiento):
[Test: Plain mod 2 ] AVERAGE TIME: 689.29 ms (Relative diff.: +0.000%) [Test: Bitwise or ] AVERAGE TIME: 689.63 ms (Relative diff.: +0.048%) [Test: Bitwise and ] AVERAGE TIME: 687.80 ms (Relative diff.: -0.217%)
La diferencia entre estas opciones es inferior al 0,3%, por lo que es bastante obvio que el ensamblaje es igual en todos los casos.
Aquí está el código si alguien quiere intentarlo, con una advertencia de que solo lo probé en Windows (verifique la condicional #if LINUX para la definición de get_time e get_time si es necesario, tomada de esta respuesta ).
#include <stdio.h>
#if LINUX
#include <sys/time.h>
#include <sys/resource.h>
double get_time()
{
struct timeval t;
struct timezone tzp;
gettimeofday(&t, &tzp);
return t.tv_sec + t.tv_usec*1e-6;
}
#else
#include <windows.h>
double get_time()
{
LARGE_INTEGER t, f;
QueryPerformanceCounter(&t);
QueryPerformanceFrequency(&f);
return (double)t.QuadPart / (double)f.QuadPart * 1000.0;
}
#endif
#define NUM_ITERATIONS (1000 * 1000 * 1000)
// using a macro to avoid function call overhead
#define Benchmark(accumulator, name, operation) { /
double startTime = get_time(); /
double dummySum = 0.0, elapsed; /
int x; /
for (x = 0; x < NUM_ITERATIONS; x++) { /
if (operation) dummySum += x; /
} /
elapsed = get_time() - startTime; /
accumulator += elapsed; /
if (dummySum > 2000) /
printf("[Test: %-12s] %0.2f ms/r/n", name, elapsed); /
}
void DumpAverage(char *test, double totalTime, double reference)
{
printf("[Test: %-12s] AVERAGE TIME: %0.2f ms (Relative diff.: %+6.3f%%)/r/n",
test, totalTime, (totalTime - reference) / reference * 100.0);
}
int main(void)
{
int repeats = 20;
double runningTimes[3] = { 0 };
int k;
for (k = 0; k < repeats; k++) {
printf("Run %d of %d.../r/n", k + 1, repeats);
Benchmark(runningTimes[0], "Plain mod 2", (x % 2));
Benchmark(runningTimes[1], "Bitwise or", (0xFFFFFFFF == (x | 0xFFFFFFFE)));
Benchmark(runningTimes[2], "Bitwise and", (x & 1));
}
{
double reference = runningTimes[0] / repeats;
printf("/r/n");
DumpAverage("Plain mod 2", runningTimes[0] / repeats, reference);
DumpAverage("Bitwise or", runningTimes[1] / repeats, reference);
DumpAverage("Bitwise and", runningTimes[2] / repeats, reference);
}
getchar();
return 0;
}
IsOdd (int x) {return true; }
Prueba de corrección: considere el conjunto de todos los enteros positivos y suponga que hay un conjunto de enteros no vacíos que no son impares. Debido a que los enteros positivos están bien ordenados, habrá un número no impar más pequeño, que en sí mismo es bastante extraño, por lo que claramente ese número no puede estar en el conjunto. Por lo tanto, este conjunto no puede estar vacío. Repita para enteros negativos, excepto busque el número más grande no impar.
Número cero paridad |cero http://tinyurl.com/oexhr3k
Secuencia del código de Python.
# defining function for number parity check
def parity(number):
"""Parity check function"""
# if number is 0 (zero) return ''Zero neither ODD nor EVEN'',
# otherwise number&1, checking last bit, if 0, then EVEN,
# if 1, then ODD.
return (number == 0 and ''Zero neither ODD nor EVEN'') /
or (number&1 and ''ODD'' or ''EVEN'')
# cycle trough numbers from 0 to 13
for number in range(0, 14):
print "{0:>4} : {0:08b} : {1:}".format(number, parity(number))
Salida:
0 : 00000000 : Zero neither ODD nor EVEN
1 : 00000001 : ODD
2 : 00000010 : EVEN
3 : 00000011 : ODD
4 : 00000100 : EVEN
5 : 00000101 : ODD
6 : 00000110 : EVEN
7 : 00000111 : ODD
8 : 00001000 : EVEN
9 : 00001001 : ODD
10 : 00001010 : EVEN
11 : 00001011 : ODD
12 : 00001100 : EVEN
13 : 00001101 : ODD
Para dar más información sobre el método del operador bitwise para aquellos de nosotros que no hicimos mucho álgebra booleana durante nuestros estudios, aquí hay una explicación. Probablemente no sea de mucha utilidad para el OP, pero tenía ganas de dejar claro por qué funciona NUMBER & 1.
Tenga en cuenta que al igual que alguien respondió anteriormente, la forma en que se representan los números negativos puede impedir que este método funcione. De hecho, incluso puede romper el método del operador de módulo, ya que cada idioma puede diferir en la forma en que trata los operandos negativos.
Sin embargo, si sabe que NUMBER siempre será positivo, esto funciona bien.
Como Tooony anterior señaló que solo el último dígito en binario (y denario) es importante.
Una puerta AND lógica booleana dicta que ambas entradas deben ser 1 (o alta tensión) para que se devuelva 1.
1 y 0 = 0.
0 y 1 = 0.
0 y 0 = 0.
1 & 1 = 1.
Si representa algún número como binario (aquí he usado una representación de 8 bits), los números impares tienen 1 al final, los números pares tienen 0.
Por ejemplo:
1 = 00000001
2 = 00000010
3 = 00000011
4 = 00000100
Si tomas cualquier número y lo usas AND (y en java) en modo bit 1, devolverá 00000001, = 1, lo que significa que el número es impar. O 00000000 = 0, lo que significa que el número es par.
P.ej
¿Es impar?
1 & 1 =
00000001 y
00000001 =
00000001 <- Impar
2 y 1 =
00000010 y
00000001 =
00000000 <- Incluso
54 & 1 =
00000001 y
00110110 =
00000000 <- Incluso
Por eso funciona esto:
if(number & 1){
//Number is odd
} else {
//Number is even
}
Lo siento si esto es redundante.
Portátil:
i % 2 ? odd : even;
Unportable:
i & 1 ? odd : even;
i << (BITS_PER_INT - 1) ? odd : even;
Prueba esto: return (((a>>1)<<1) == a)
Ejemplo:
a = 10101011
-----------------
a>>1 --> 01010101
a<<1 --> 10101010
b = 10011100
-----------------
b>>1 --> 01001110
b<<1 --> 10011100
Sé que esto es solo azúcar sintáctica y solo es aplicable en .net, pero ¿qué pasa con el método de extensión ...
public static class RudiGroblerExtensions
{
public static bool IsOdd(this int i)
{
return ((i % 2) != 0);
}
}
Ahora puedes hacer lo siguiente
int i = 5;
if (i.IsOdd())
{
// Do something...
}
Un número es par si, cuando se divide por dos, el resto es 0. Un número es impar si, cuando se divide entre 2, el resto es 1.
// Java
public static boolean isOdd(int num){
return num % 2 != 0;
}
/* C */
int isOdd(int num){
return num % 2;
}
¡Los métodos son geniales!
Una bonita es:
/*forward declaration, C compiles in one pass*/
bool isOdd(unsigned int n);
bool isEven(unsigned int n)
{
if (n == 0)
return true ; // I know 0 is even
else
return isOdd(n-1) ; // n is even if n-1 is odd
}
bool isOdd(unsigned int n)
{
if (n == 0)
return false ;
else
return isEven(n-1) ; // n is odd if n-1 is even
}
Tenga en cuenta que este método utiliza la recursión de la cola que implica dos funciones. Puede implementarse de manera eficiente (convertida en un tipo de bucle de tiempo / hasta) si su compilador admite la recursión de la cola como un compilador Scheme. En este caso la pila no debe desbordarse!
Una solución más al problema.
(los niños son bienvenidos a votar)
bool isEven(unsigned int x)
{
unsigned int half1 = 0, half2 = 0;
while (x)
{
if (x) { half1++; x--; }
if (x) { half2++; x--; }
}
return half1 == half2;
}
Use el operador de módulo (%) para verificar si hay un resto al dividir por 2:
if (x % 2) { /* x is odd */ }
Algunas personas han criticado mi respuesta anterior al afirmar que el uso de x & 1 es "más rápido" o "más eficiente". No creo que este sea el caso.
Por curiosidad, creé dos programas de casos de prueba triviales:
/* modulo.c */
#include <stdio.h>
int main(void)
{
int x;
for (x = 0; x < 10; x++)
if (x % 2)
printf("%d is odd/n", x);
return 0;
}
/* and.c */
#include <stdio.h>
int main(void)
{
int x;
for (x = 0; x < 10; x++)
if (x & 1)
printf("%d is odd/n", x);
return 0;
}
Luego los compilé con gcc 4.1.3 en una de mis máquinas 5 veces diferentes:
- Sin banderas de optimización.
- Con -O
- Con -Os
- Con -O2
- Con -O3
Examiné la salida de ensamblaje de cada compilación (usando gcc -S) y encontré que en cada caso, la salida para y.c y modulo.c era idéntica (ambas usaban la instrucción andl $ 1,% eax). Dudo que esta sea una característica "nueva", y sospecho que se remonta a versiones antiguas. También dudo que cualquier compilador no arcano moderno (hecho en los últimos 20 años), comercial o de código abierto, carezca de tal optimización. Probaría en otros compiladores, pero no tengo ninguno disponible en este momento.
Si alguien más quisiera probar otros compiladores y / o objetivos de plataforma, y obtiene un resultado diferente, estaría muy interesado en saberlo.
Finalmente, el estándar garantiza que la versión de módulo funcione si el entero es positivo, negativo o cero, independientemente de la representación de la implementación de enteros con signo. El bitwise y la versión no lo es. Sí, me doy cuenta de que el complemento de dos es algo omnipresente, así que esto no es realmente un problema.
Ustedes son muy eficientes. Lo que realmente quieres es:
public boolean isOdd(int num) {
int i = 0;
boolean odd = false;
while (i != num) {
odd = !odd;
i = i + 1;
}
return odd;
}
Repetir para isEven .
Por supuesto, eso no funciona para los números negativos. Pero con brillantez viene el sacrificio ...
Utilizar aritmética de bits:
if((x & 1) == 0)
printf("EVEN!/n");
else
printf("ODD!/n");
Esto es más rápido que usar división o módulo.
Yo construiría una tabla de las paridades (0 si es 1 si es impar) de los enteros (por lo que uno podría hacer una búsqueda: D), pero gcc no me deja hacer matrices de tales tamaños:
typedef unsigned int uint;
char parity_uint [UINT_MAX];
char parity_sint_shifted [((uint) INT_MAX) + ((uint) abs (INT_MIN))];
char* parity_sint = parity_sint_shifted - INT_MIN;
void build_parity_tables () {
char parity = 0;
unsigned int ui;
for (ui = 1; ui <= UINT_MAX; ++ui) {
parity_uint [ui - 1] = parity;
parity = !parity;
}
parity = 0;
int si;
for (si = 1; si <= INT_MAX; ++si) {
parity_sint [si - 1] = parity;
parity = !parity;
}
parity = 1;
for (si = -1; si >= INT_MIN; --si) {
parity_sint [si] = parity;
parity = !parity;
}
}
char uparity (unsigned int n) {
if (n == 0) {
return 0;
}
return parity_uint [n - 1];
}
char sparity (int n) {
if (n == 0) {
return 0;
}
if (n < 0) {
++n;
}
return parity_sint [n - 1];
}
Así que, en lugar de eso, recurramos a la definición matemática de par e impar.
Un entero n es par si existe un entero k tal que n = 2k.
Un entero n es impar si existe un entero k tal que n = 2k + 1.
Aquí está el código para ello:
char even (int n) {
int k;
for (k = INT_MIN; k <= INT_MAX; ++k) {
if (n == 2 * k) {
return 1;
}
}
return 0;
}
char odd (int n) {
int k;
for (k = INT_MIN; k <= INT_MAX; ++k) {
if (n == 2 * k + 1) {
return 1;
}
}
return 0;
}
Deje que los enteros C denoten los valores posibles de int en una compilación de C dada. (Tenga en cuenta que los enteros C son un subconjunto de los enteros).
Ahora, uno podría preocuparse de que para un n dado en enteros C, el entero k correspondiente no exista dentro de los enteros C. Pero con una pequeña prueba se puede demostrar que para todos los enteros n, | n | <= | 2n | (*), donde | n | es "n si n es positivo y -n de lo contrario". En otras palabras, para todos los n en números enteros, al menos uno de los siguientes casos (exactamente cualquiera de los casos (1 y 2) o casos (3 y 4) de hecho, pero no lo demostraré aquí):
Caso 1: n <= 2n.
Caso 2: -n <= -2n.
Caso 3: -n <= 2n.
Caso 4: n <= -2n.
Ahora toma 2k = n. (Tal ak existe si n es par, pero no lo demostraré aquí. Si n no es par, entonces el bucle even regresa antes, así que no importa). Pero esto implica que k <n si n no 0 por (*) y el hecho (de nuevo no demostrado aquí) de que para todos m, z en los enteros 2m = z implica que z no es igual a m dado que m no es 0. En el caso de que n sea 0, 2 * 0 = 0, por lo que 0 es que hemos terminado (si n = 0, entonces 0 está en C-enteros porque n está en C-entero en la función even , por lo tanto k = 0 está en C-enteros). Por lo tanto, tal ak en enteros C existe para n en enteros C si n es par.
Un argumento similar muestra que si n es impar, existe ak en enteros C de manera que n = 2k + 1.
Por lo tanto, las funciones even e odd aquí presentadas funcionarán correctamente para todos los C-enteros.
Yo diría que simplemente divídalo entre 2 y si hay un resto de 0, es par, de lo contrario es extraño.
Usar el módulo (%) hace que esto sea fácil.
p.ej. 4% 2 = 0 por lo tanto, 4 es par 5% 2 = 1 por lo tanto, 5 es impar
[Modo broma = "en"]
public enum Evenness
{
Unknown = 0,
Even = 1,
Odd = 2
}
public static Evenness AnalyzeEvenness(object o)
{
if (o == null)
return Evenness.Unknown;
string foo = o.ToString();
if (String.IsNullOrEmpty(foo))
return Evenness.Unknown;
char bar = foo[foo.Length - 1];
switch (bar)
{
case ''0'':
case ''2'':
case ''4'':
case ''6'':
case ''8'':
return Evenness.Even;
case ''1'':
case ''3'':
case ''5'':
case ''7'':
case ''9'':
return Evenness.Odd;
default:
return Evenness.Unknown;
}
}
[Modo broma = "apagado"]
EDITAR: Se agregaron valores confusos a la enumeración.
Por el bien de la discusión ...
Solo necesita mirar el último dígito en cualquier número dado para ver si es par o impar. Firmados, no firmados, positivos, negativos, todos son iguales con respecto a esto. Así que esto debería funcionar todo el tiempo: -
void tellMeIfItIsAnOddNumberPlease(int iToTest){
int iLastDigit;
iLastDigit = iToTest - (iToTest / 10 * 10);
if (iLastDigit % 2 == 0){
printf("The number %d is even!/n", iToTest);
} else {
printf("The number %d is odd!/n", iToTest);
}
}
La clave aquí está en la tercera línea de código, el operador de división realiza una división entera, de modo que al resultado le falta la parte de la fracción del resultado. Así, por ejemplo, 222/10 dará 22 como resultado. Luego, multiplícalo de nuevo con 10 y tienes 220. Resta eso de los 222 originales y obtienes 2, que por magia es el mismo número que el último dígito del número original. ;-) Los paréntesis están ahí para recordarnos el orden en que se realiza el cálculo. Primero haz la división y la multiplicación, luego resta el resultado del número original. Podríamos dejarlos fuera, ya que la prioridad es mayor para la división y la multiplicación que para la resta, pero esto nos da un código "más legible".
Podríamos hacerlo todo completamente ilegible si quisiéramos. No haría ninguna diferencia en absoluto para un compilador moderno:
printf("%d%s/n",iToTest,0==(iToTest-iToTest/10*10)%2?" is even":" is odd");
Pero haría que el código fuera más difícil de mantener en el futuro. Imagina que te gustaría cambiar el texto de los números impares a "no es par". Luego, otra persona más adelante desea averiguar qué cambios ha realizado y realizar un svn diff o similar ...
Si no está preocupado por la portabilidad, sino más por la velocidad, puede echar un vistazo al bit menos significativo. Si ese bit se establece en 1 es un número impar, si es 0 es un número par. En un pequeño sistema endian, como la arquitectura x86 de Intel, sería algo como esto:
if (iToTest & 1) {
// Even
} else {
// Odd
}
Verificación par o impar es una tarea simple.
Sabemos que cualquier número exactamente divisible por 2 es un número par o impar.
Solo necesitamos verificar la divisibilidad de cualquier número y para verificar la divisibilidad usamos el %operador
Comprobando incluso extraño utilizando si otra cosa
if(num%2 ==0)
{
printf("Even");
}
else
{
printf("Odd");
}
Programa de C para comprobar si es par o impar, si no
Usando operador condicional / ternario
(num%2 ==0) printf("Even") : printf("Odd");
Programa C para verificar el par o impar utilizando el operador condicional .
Usando el operador de Bitwise
if(num & 1)
{
printf("Odd");
}
else
{
printf("Even");
}
Si quieres ser eficiente, usa operadores bitwise ( x & 1), pero si quieres que sea legible usa modulo 2 ( x % 2)
// C#
bool isEven = ((i % 2) == 0);
I execute this code for ODD & EVEN:
#include <stdio.h>
int main()
{
int number;
printf("Enter an integer: ");
scanf("%d", &number);
if(number % 2 == 0)
printf("%d is even.", number);
else
printf("%d is odd.", number);
}
i % 2 == 0
int isOdd(int i){
return(i % 2);
}
hecho.