Как проверить, является ли заданное число четным или нечетным в C?
Как проверить, четное или нечетное целое?
Ответ 1
Используйте оператор modulo (%), чтобы проверить, есть ли остаток при делении на 2:
if (x % 2) { /* x is odd */ }
Несколько человек критиковали мой ответ выше, заявляя, что использование x и 1 "быстрее" или "более эффективно". Я не думаю, что это так.
Из любопытства я создал две тривиальные тестовые программы:
/* 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;
}
Затем я скомпилировал их с gcc 4.1.3 на одной из моих машин 5 раз:
- Без флагов оптимизации.
- С -O
- С -Os
- С -O2
- С -O3
Я изучил сборку каждого компилята (используя gcc -S) и обнаружил, что в каждом случае вывод для and.c и modulo.c был идентичен (оба они использовали команду andl $1,% eax). Я сомневаюсь, что это "новая" функция, и я подозреваю, что она восходит к древним версиям. Я также сомневаюсь, что любой современный (сделанный за последние 20 лет) неарганный компилятор, коммерческий или открытый источник не испытывает такой оптимизации. Я бы тестировал другие компиляторы, но на данный момент у меня нет доступных.
Если кто-либо еще захочет проверить другие компиляторы и/или целевые платформы, и получит другой результат, мне было бы очень интересно узнать.
Наконец, версия modulo гарантирована стандартом для работы, является ли целое положительным, отрицательным или нулевым, независимо от представления реализации целых чисел со знаком. Побитно - и версия - нет. Да, я понимаю, что два дополнения несколько повсеместны, так что это не проблема.
Ответ 2
Вы, ребята, waaaaaaaay слишком эффективны. Вы действительно хотите:
public boolean isOdd(int num) {
int i = 0;
boolean odd = false;
while (i != num) {
odd = !odd;
i = i + 1;
}
return odd;
}
Повторите для isEven.
Конечно, это не работает для отрицательных чисел. Но с блеском приходит жертва...
Ответ 3
Использовать битовую арифметику:
if((x & 1) == 0)
printf("EVEN!\n");
else
printf("ODD!\n");
Это быстрее, чем использование деления или модуля.
Ответ 4
[Шуточный режим = "on"]
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;
}
}
[Шуточный режим = "выкл." ]
EDIT: добавлены недопустимые значения для перечисления.
Ответ 5
В ответ на ffpf - у меня был точно такой же аргумент с коллегой несколько лет назад, и ответ нет, он не" t работает с отрицательными номерами.
В стандарте C указано, что отрицательные числа могут быть представлены тремя способами:
- 2 дополнения
- 1 дополнение
- знак и величина
Проверка:
isEven = (x & 1);
будет работать для представления 2 дополнений и знаков и величин, но не для 1 дополнения.
Однако я считаю, что для всех случаев будет работать следующее:
isEven = (x & 1) ^ ((-1 & 1) | ((x < 0) ? 0 : 1)));
Благодаря ffpf для указания, что текстовое поле ест все после моего меньшего характера!
Ответ 6
Хороший вариант:
/*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
}
Обратите внимание, что этот метод использует хвостовую рекурсию, включающую две функции. Он может быть эффективно реализован (превращается в какое-то время/до определенного цикла), если ваш компилятор поддерживает хвостовую рекурсию, как компилятор Scheme. В этом случае стек не должен переполняться!
Ответ 7
Число даже если при делении на два остаток равен 0. Число нечетно, если при делении на 2 остаток равен 1.
// Java
public static boolean isOdd(int num){
return num % 2 != 0;
}
/* C */
int isOdd(int num){
return num % 2;
}
Способы отличные!
Ответ 8
i % 2 == 0
Ответ 9
Я бы сказал, просто разделите его на 2 и, если есть 0 остаток, он даже, в противном случае это нечетно.
Использование модуля (%) делает это легким.
например. 4% 2 = 0, поэтому 4 четное 5% 2 = 1, поэтому 5 нечетно
Ответ 10
Еще одно решение проблемы
(дети могут голосовать)
bool isEven(unsigned int x)
{
unsigned int half1 = 0, half2 = 0;
while (x)
{
if (x) { half1++; x--; }
if (x) { half2++; x--; }
}
return half1 == half2;
}
Ответ 11
Я бы построил таблицу четностей (0, если даже 1, если нечетно) целых чисел (поэтому можно было выполнить поиск: D), но gcc не позволит мне создавать массивы таких размеров:
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];
}
Итак, давайте вместо этого применим математическое определение четного и нечетного.
Целое число n равномерное, если существует целое число k такое, что n = 2k.
Целое n нечетно, если существует целое число k такое, что n = 2k + 1.
Вот код для него:
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;
}
Пусть C-целые числа обозначают возможные значения int в данной компиляции C. (Заметим, что C-целые числа являются подмножеством целых чисел.)
Теперь можно подумать, что для данного n из C-целых чисел соответствующее целое число k может не существовать внутри C-целых чисел. Но с небольшим доказательством можно показать, что для всех целых чисел n, | n | <= | 2n | (*), где | n | является "n, если n положительно и -n в противном случае". Другими словами, для всех n целых чисел, по крайней мере, одно из следующих утверждений (точно либо случаи (1 и 2), либо случаи (3 и 4) на самом деле, но я не буду здесь этого доказывать):
Случай 1: n <= 2n.
Случай 2: -n <= -2n.
Случай 3: -n <= 2n.
Случай 4: n <= -2n.
Теперь возьмите 2k = n. (Такой ak существует, если n четно, но я не буду его здесь доказывать.Если n не четно, то цикл в even в любом случае не сможет вернуться раньше, поэтому это не имеет значения.) Но это означает, что k < n, если n не 0 по (*) и факт (опять же не доказанный здесь), что для всех m, z в целых числах 2m = z влечет z, не равный m, если m не равно 0. В случае n равно 0, 2 * 0 = 0, так что 0 мы даже делаем (если n = 0, то 0 находится в C-целых числах, так как n находится в C-целом в функции even, поэтому k = 0 в C-целых числах). Таким образом, такое k в C-целых числах существует для n в C-целых числах, если n четно.
Аналогичный аргумент показывает, что если n нечетно, то существует такое k в C-целых числах, что n = 2k + 1.
Следовательно, представленные здесь функции even и odd будут корректно работать для всех C-целых чисел.
Ответ 12
// C#
bool isEven = ((i % 2) == 0);
Ответ 13
Это продолжение обсуждения с @RocketRoy в отношении его ответа, но это может быть полезно для всех, кто хочет сравнить эти результаты.
tl; dr Из того, что я видел, подход Роя ((0xFFFFFFFF == (x | 0xFFFFFFFE)) не полностью оптимизирован для x & 1 как подход mod, но на практике время работы должно получиться равен во всех случаях.
Итак, сначала я сравнил скомпилированный вывод, используя "Компилятор" :
Проверенные функции:
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 с -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 с -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
Шляпы до CLang, он понял, что все три случая функционально равны. Однако подход Roy не оптимизирован в GCC, поэтому YMMV.
Он похож на Visual Studio; проверяя разборку Release x64 (VS2015) для этих трех функций, я мог видеть, что сравнительная часть равна для случаев "mod" и "and" и немного больше для Roy "или" case:
// x % 2
test bl,1
je (some address)
// x & 1
test bl,1
je (some address)
// Roy bitwise or
mov eax,ebx
or eax,0FFFFFFFEh
cmp eax,0FFFFFFFFh
jne (some address)
Однако после выполнения фактического теста для сравнения этих трех параметров (обычный mod, побитовый или бит) и результаты были полностью равны (опять же, Visual Studio 2005 x86/x64, Release build, без отладчика).
Выпуск сборки использует инструкцию test для случаев and и mod, в то время как случай Роя использует подход cmp eax,0FFFFFFFFh, но он сильно разворачивается и оптимизируется, поэтому на практике нет никакой разницы.
Мои результаты после 20 запусков (i7 3610QM, план питания Windows 10 установлен на высокую производительность):
[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%)
Разница между этими параметрами составляет менее 0,3%, поэтому довольно очевидно, что сборка одинакова во всех случаях.
Вот код, если кто-то хочет попробовать, с предостережением, которое я тестировал только в Windows (проверьте #if LINUX условное значение для определения get_time и реализуйте его, если необходимо, взятый из этот ответ).
#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;
}
Ответ 14
Вот ответ в 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();
}
Ответ 15
Прочитав это довольно интересное обсуждение, я вспомнил, что у меня была функция реального времени, чувствительная к времени, которая тестировалась на нечетные и четные числа внутри основного цикла. Это целочисленная функция мощности, размещенная в другом месте в StackOverflow, следующим образом. Тесты были довольно неожиданными. По крайней мере, в этой реальной функции по модулю медленнее, и значительно. Победителем с большим размахом, требующим 67% времени по модулю, является подход или (|), и его нигде не найти нигде на этой странице.
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;
}
Для 300 миллионов циклов контрольные тайминги заключаются в следующем.
3.962 the | и маска
4.851 и подход
5.850% -ный подход
Для людей, которые думают о теории или листинге на ассемблере, решает такие аргументы, это должно быть предостерегающим рассказом. На небесах и на земле есть нечто большее, Горацио, о чем мечтают в вашей философии.
Ответ 16
Попробуйте следующее: return (((a>>1)<<1) == a)
Пример:
a = 10101011
-----------------
a>>1 --> 01010101
a<<1 --> 10101010
b = 10011100
-----------------
b>>1 --> 01001110
b<<1 --> 10011100
Ответ 17
Как сообщают некоторые люди, существует множество способов сделать это. Согласно этот сайт, самым быстрым способом является оператор модуля:
if (x % 2 == 0)
total += 1; //even number
else
total -= 1; //odd number
Однако, вот какой-то другой код, который был помечен знаком автором, который работал медленнее, чем операция общего модуля выше:
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
Сколько людей даже знали о методе Math.System.DivRem или почему они его использовали?
Ответ 18
Я знаю, что это просто синтаксический сахар и применим только в .net, но как насчет метода расширения...
public static class RudiGroblerExtensions
{
public static bool IsOdd(this int i)
{
return ((i % 2) != 0);
}
}
Теперь вы можете сделать следующее
int i = 5;
if (i.IsOdd())
{
// Do something...
}
Ответ 19
В "творческой, но запутанной категории" я предлагаю:
int isOdd(int n) { return n ^ n * n ? isOdd(n * n) : n; }
Вариант этой темы, специфичный для Microsoft С++:
__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
}
}
Ответ 20
Побитовый метод зависит от внутреннего представления целого числа. Modulo будет работать везде, где есть оператор modulo. Например, некоторые системы на самом деле используют бит низкого уровня для тегов (например, динамические языки), поэтому исходные x и 1 на самом деле не будут работать в этом случае.
Ответ 21
IsOdd (int x) {return true; }
Доказательство корректности - рассмотрим множество всех натуральных чисел и предположим, что существует непустое множество целых чисел, которые не являются нечетными. Поскольку положительные целые числа хорошо упорядочены, будет наименьшее нечетное число, что само по себе довольно странно, поэтому ясно, что число не может быть в наборе. Поэтому этот набор не может быть непустым. Повторите для отрицательных целых чисел, кроме поиска наибольшего нечетного числа.
Ответ 22
Портативный:
i % 2 ? odd : even;
непереносимым:
i & 1 ? odd : even;
i << (BITS_PER_INT - 1) ? odd : even;
Ответ 23
int isOdd(int i){
return(i % 2);
}
сделано.
Ответ 24
Чтобы дать более подробную информацию о методе побитового оператора для тех из нас, кто не делал много булевой алгебры во время наших исследований, вот объяснение. Вероятно, это не очень полезно для OP, но мне хотелось пояснить, почему работает NUMBER и 1.
Обратите внимание, что, как кто-то ответил выше, способ представления отрицательных чисел может остановить этот метод работы. На самом деле он может даже сломать метод modulo operator, так как каждый язык может отличаться в том, как он имеет дело с отрицательными операндами.
Однако, если вы знаете, что NUMBER всегда будет положительным, это хорошо работает.
Как указано выше, Туони отметил, что важна только последняя цифра в двоичном (и значении).
Логическая логическая логика AND определяет, что оба входа должны быть 1 (или высоким напряжением) для возврата 1.
1 и 0 = 0.
0 и 1 = 0.
0 и 0 = 0.
1 и 1 = 1.
Если вы представляете какое-либо число в виде двоичного кода (я использовал здесь 8-битное представление), нечетные числа имеют 1 в конце, четные числа - 0.
Например:
1 = 00000001
2 = 00000010
3 = 00000011
4 = 00000100
Если вы берете какое-то число и используете побитовое И (& в java), то оно равно 1, либо оно вернет 00000001, = 1, что означает, что число нечетно. Или 00000000 = 0, что означает, что число четное.
например
Нечетно?
1 и 1 =
00000001 &
00000001 =
00000001 < - Нечетный
2 и 1 =
00000010 &
00000001 =
00000000 < - Even
54 и 1 =
00000001 &
00110110 =
00000000 < - Even
Вот почему это работает:
if(number & 1){
//Number is odd
} else {
//Number is even
}
Извините, если это избыточно.
Ответ 25
Число с нулевой четностью | zero http://tinyurl.com/oexhr3k
Кодовая последовательность 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))
Вывод:
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
Ответ 26
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);
}
Ответ 27
Ради обсуждения...
Вам нужно только посмотреть последнюю цифру в любом заданном номере, чтобы увидеть, является ли она четной или нечетной. Подписанные, неподписанные, положительные, отрицательные - они все равно относятся к этому. Так что это должно работать повсюду: -
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);
}
}
Ключ здесь находится в третьей строке кода, оператор деления выполняет целочисленное деление, так что в результате отсутствует фрагментарная часть результата. Так, например, 222/10 даст 22. Затем умножьте его на 10 и у вас есть 220. Вычтите из оригинала 222, и вы получите 2, что по манере будет тем же номером, что и последняя цифра в исходном номере.;-) Скобки заключаются в том, чтобы напомнить нам о порядке, в котором выполняется вычисление. Сначала сделайте деление и умножение, а затем вычтите результат из исходного числа. Мы можем оставить их, так как приоритет выше для деления и умножения, чем для вычитания, но это дает нам "более читаемый" код.
Мы могли бы сделать все это совершенно нечитаемым, если бы захотели. Для современного компилятора не имело никакого значения: -
printf("%d%s\n",iToTest,0==(iToTest-iToTest/10*10)%2?" is even":" is odd");
Но это сделало бы код более сложным в будущем. Представьте себе, что вы хотите изменить текст для нечетных чисел на "is not even". Затем кто-то еще позже захочет узнать, какие изменения вы внесли, и выполнить svn diff или подобное...
Если вы не беспокоитесь о переносимости, но скорее о скорости, вы можете взглянуть на наименее значимый бит. Если этот бит установлен в 1, это нечетное число, если оно равно четному числу. В маленькой системной системе, такой как архитектура Intel x86, это будет примерно так: -
if (iToTest & 1) {
// Even
} else {
// Odd
}
Ответ 28
Если вы хотите быть эффективными, используйте побитовые операторы (x & 1), но если вы хотите быть читаемыми, используйте modulo 2 (x % 2)
Ответ 29
Проверка четной или нечетной является простой задачей.
Мы знаем, что любое число, точно делящееся на 2, четное число else нечетно.
Нам просто нужно проверить делимость любого числа и для проверки делимости мы используем оператор %
Проверка даже нечетного использования, если else
if(num%2 ==0)
{
printf("Even");
}
else
{
printf("Odd");
}
C-программа для проверки четного или нечетного использования, если else
Использование условного/тернарного оператора
(num%2 ==0) printf("Even") : printf("Odd");
Программа C для проверки четного или нечетного использования условного оператора.
Использование побитового оператора
if(num & 1)
{
printf("Odd");
}
else
{
printf("Even");
}
Ответ 30
Оператор модуля '%' может использоваться для проверки того, является ли число нечетным или четным. То есть, когда число делится на 2, а если остаток равен 0, то это четное число else его нечетное число.
#include <stdio.h>
int main()
{
int n;//using modulus operator
scanf("%d",&n);//take input n from STDIN
printf("%s",n%2==0?"Even":"Odd");//prints Even/Odd depending on n to STDOUT
return 0;
}
Но использование бит-манипуляции выполняется намного быстрее, чем вышеупомянутый метод, поэтому, если вы берете число и логически применяете AND '&' к нему, если ответ равен 1, то его еще больше его нечетному. В основном мы должны проверить последний бит числа n в двоичном формате. Если последний бит равен 0, то n еще четнее его нечетное.
например: предположим, что N = 15, в двоичном N = 1111, теперь мы И это с 1
1111
0001
&-----
0001
Поскольку результат равен 1, число N = 15 нечетное.
Опять же, предположим, что N = 8, в двоичном N = 1000, теперь мы И это с 1
1000
0001
&-----
0000
Поскольку результат равен 0, число N = 8 равно Even.
#include <stdio.h>
int main()
{
int n;//using AND operator
scanf("%d",&n);//take input n from STDIN
printf("%s",n&1?"Odd":"Even");//prints Even/Odd depending on n to STDOUT
return 0;
}