정수가 짝수인지 홀수인지 확인하려면 어떻게 해야 하나요?
C에서 주어진 숫자가 짝수인지 홀수인지 어떻게 확인할 수 있나요?
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 사용)의 어셈블리 출력을 조사했더니, 및 .c와 modulo.c의 출력은 모두 동일했습니다(양쪽 모두 andl $1, %eax 명령을 사용).저는 이것이 "새로운" 기능인지 의심스럽고, 고대 버전으로 거슬러 올라간다고 생각합니다.또, 최신(과거 20년간 제조된) 아크산 이외의 컴파일러, 상업용 또는 오픈 소스에는 이러한 최적화가 결여되어 있지 않은지도 의문입니다.다른 컴파일러로 테스트하고 싶지만, 현재 사용할 수 있는 컴파일러가 없습니다.
다른 컴파일러나 플랫폼의 타겟을 테스트하고 싶다고 생각하고, 다른 결과를 얻을 수 있는 사람이 있다면, 꼭 알고 싶습니다.
마지막으로, 모듈로 버전은 구현의 부호 있는 정수 표현에 관계없이 정수가 양수인지 음수인지 0인지 여부에 관계없이 작동하도록 표준에 의해 보증된다.bitwise-and 버전은 그렇지 않습니다.네, 저는 2의 보수가 어느 정도 어디에나 있다는 것을 알고 있습니다. 그래서 이것은 정말로 문제가 되지 않습니다.
너희들은 너무 효율적이다.당신이 정말로 원하는 것은:
public boolean isOdd(int num) {
int i = 0;
boolean odd = false;
while (i != num) {
odd = !odd;
i = i + 1;
}
return odd;
}
하다를 반복해 주세요.isEven.
물론, 그것은 음수에는 효과가 없습니다.하지만 명석함에는 희생이 따르죠
비트 산술 사용:
if((x & 1) == 0)
printf("EVEN!\n");
else
printf("ODD!\n");
이는 나눗셈 또는 계수를 사용하는 것보다 빠릅니다.
[장난 모드='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: 혼란스러운 값을 열거형에 추가했습니다.
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);
}
@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
-O3를 사용하는 GCC 6.2:
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와 비슷합니다. 이 세 가지 기능에 대해 분해 릴리스 x64(VS2015)를 검사하면 비교 부분이 "mod"와 "and" 케이스에 대해 동일하고 Roy의 "or" 케이스에 대해 약간 더 크다는 것을 알 수 있습니다.
// 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)
그러나 이 세 가지 옵션(일반 모드, 비트 단위 또는 비트 단위)을 비교하기 위한 실제 벤치마크를 실행한 결과 결과는 완전히 동일했습니다(Visual Studio 2005 x86/x64, Release build, debugger 없음).
어셈블리는 ""를 사용합니다.test를 참조해 주세요.and ★★★★★★★★★★★★★★★★★」mod는 ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★.cmp eax,0FFFFFFFFh접근은 가능하지만 상당히 확장되고 최적화되어 있기 때문에 실제적인 차이는 없습니다.
20회 실행 후 결과(i7 3610QM, Windows 10 전원 관리 옵션을 하이 퍼포먼스로 설정):
[테스트: 플레인 모드2] 평균 시간: 689.29 ms (상대 차이): +0.000%)[테스트: 비트 단위 또는 ]평균 시간: 689.63 ms (상대 차이): +0.048%)[테스트: 비트 및 ]평균시간: 687.80 ms (상대차: -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;
}
i % 2 == 0
해보세요: 이이시시해시 try try try try try try try try 。return (((a>>1)<<1) == a)
예:
a = 10101011
-----------------
a>>1 --> 01010101
a<<1 --> 10101010
b = 10011100
-----------------
b>>1 --> 01001110
b<<1 --> 10011100
ffpf에 대한 대응 - 저는 몇 년 전에 동료와 정확히 같은 논쟁을 벌였고, 대답은 "아니오"입니다. 음수에는 효과가 없습니다.
C 표준에서는 음수가 다음 세 가지 방법으로 표현될 수 있도록 규정하고 있습니다.
- 2의 보충
- 1의 보완물
- 부호 및 규모
다음과 같이 확인합니다.
isEven = (x & 1);
는 2의 보완, 부호 및 크기 표현에 대해 작동하지만 1의 보완에는 작동하지 않습니다.
다만, 이하의 것은 모든 경우에 유효하다고 생각합니다.
isEven = (x & 1) ^ ((-1 & 1) | ((x < 0) ? 0 : 1)));
ffpf가 문자상자가 나의 문자이하의 모든 것을 먹어치우고 있다고 지적해줘서 고마워!
좋은 점은 다음과 같습니다.
/*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 컴파일러와 같은 테일 재귀 기능을 지원한다면 효율적으로 구현될 수 있습니다.이 경우 스택은 오버플로하지 않습니다!
2로 나누었을 때 나머지가 0인 경우에도 숫자는 짝수입니다.2로 나누었을 때 나머지가 1이면 숫자는 홀수입니다.
// Java
public static boolean isOdd(int num){
return num % 2 != 0;
}
/* C */
int isOdd(int num){
return num % 2;
}
방법은 훌륭합니다!
2로 나누면 0이 남으면 짝수이고, 남으면 홀수입니다.
계수(%)를 사용하면 쉽게 할 수 있습니다.
예: 4% 2 = 0이므로 4는 짝수 5% 2 = 1이므로 5는 홀수이다.
또
bool isEven(unsigned int x)
{
unsigned int half1 = 0, half2 = 0;
while (x)
{
if (x) { half1++; x--; }
if (x) { half2++; x--; }
}
return half1 == half2;
}
정수의 parity(홀수인 경우 0) 표를 작성합니다(lookup: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은 n = 2k인 정수 k가 존재하는 경우에도 마찬가지입니다.
정수 n은 n = 2k + 1인 정수 k가 존재하는 경우 홀수이다.
코드는 다음과 같습니다.
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-는 입니다.intC는 정수의 는 정수의(C-정수는 정수의 서브셋입니다).
이제 C-정수의 n에 대해 대응하는 정수 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을 취합니다. (n이 짝수일 경우 이러한 k가 존재하지만 여기서는 증명하지 않습니다. n의 .even어쨌든 일찍 돌아오지 않기 때문에 상관없습니다.)그러나 이는 n x 0(*)이 아니라면 k < n을 의미하며, 모든 m에 대해 2m = z의 정수 z는 주어진 m과 같지 않은 z를 의미한다는 사실(여기서 다시 증명되지 않음)을 의미한다.2*0=일 경우 n=에 있습니다). 은 C-정수 안에 있습니다(n = 0일 경우 C-정수 C).evenk = 0 ℃ ) 。따라서 c-정수의 k는 n이 짝수일 경우 c-정수의 n에 대해 존재합니다.
유사한 인수는 n이 홀수이면 c-정수에 n = 2k + 1인 k가 존재한다는 것을 나타냅니다.
에, 함수는 「」, 「 」, 「 」, 「 」입니다.even ★★★★★★★★★★★★★★★★★」odd모든 C 정수에서 올바르게 작동합니다.
// C#
bool isEven = ((i % 2) == 0);
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();
}
이 다소 재미있는 토론을 읽으면서, 나는 메인 루프 안에서 홀수와 짝수를 테스트하는 실제 세계의 시간에 민감한 함수를 가지고 있다는 것을 기억했다.이는 다음과 같이 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;
}
3억 루프의 경우 벤치마크타이밍은 다음과 같습니다
3.962 | 및 마스크 접근법
4.851 및 어프로치
5.850 % 접근법
이론, 즉 어셈블리 언어 목록이 이와 같은 논쟁을 해결한다고 생각하는 사람들에게 이것은 경고적인 이야기일 것이다.천지에는 당신의 철학에서 꿈꾸던 것보다 더 많은 것들이 있다, 호레이쇼.
이게 통사설탕일 뿐이고 .net에서만 적용되는 건 알지만 확장 방법은...
public static class RudiGroblerExtensions
{
public static bool IsOdd(this int i)
{
return ((i % 2) != 0);
}
}
이제 다음을 수행할 수 있습니다.
int i = 5;
if (i.IsOdd())
{
// Do something...
}
"창의적이지만 혼란스러운 카테고리"에서 다음을 제안합니다.
int isOdd(int n) { return n ^ n * n ? isOdd(n * n) : n; }
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
}
}
비트 방법은 정수의 내부 표현에 따라 달라집니다.모듈로는 모듈로 오퍼레이터가 있는 곳이면 어디서든 일할 겁니다.예를 들어 일부 시스템에서는 태그 붙이기(동적인 언어 등)에 저레벨 비트를 실제로 사용하고 있기 때문에 이 경우 raw x&1은 실제로 동작하지 않습니다.
IsOdd(int x) {return true;}
정확성 증명 - 모든 양의 정수 집합을 고려하고 홀수가 아닌 빈 정수 집합이 있다고 가정합니다.양의 정수는 순서가 좋기 때문에 홀수가 아닌 가장 작은 숫자가 존재하게 되는데, 이 숫자 자체는 상당히 홀수이기 때문에 이 숫자는 집합에 포함될 수 없습니다.따라서 이 집합은 비워 둘 수 없습니다.홀수가 아닌 최대 정수를 제외하고 음수 정수에 대해 반복합니다.
휴대용:
i % 2 ? odd : even;
포터블:
i & 1 ? odd : even;
i << (BITS_PER_INT - 1) ? odd : even;
몇몇 사람들이 게시한 바와 같이, 이것을 하는 방법은 여러 가지가 있다.이 웹사이트에 따르면 가장 빠른 방법은 계수 연산자입니다.
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
얼마나 많은 사람들이 수학에 대해 알고 있었을까.System.DivRem 메서드 또는 왜 사용하는가?
int isOdd(int i){
return(i % 2);
}
다 했어요.
연구 중에 부울 대수를 많이 하지 않은 사람들을 위해 비트 연산자 방법에 대해 더 자세히 설명하겠습니다.OP에는 별로 도움이 되지 않을 것입니다만, 왜 NUMBER & 1이 기능하는지를 분명히 하고 싶다고 생각했습니다.
위의 답변과 같이 음수가 표시되는 방식으로 인해 이 방법이 작동하지 않을 수 있다는 점에 유의하시기 바랍니다.각 언어가 음의 피연산자를 처리하는 방식이 다를 수 있기 때문에 모듈로 연산자 방식도 깨질 수 있습니다.
그러나 NUMBER가 항상 긍정적이라는 것을 알고 있다면 이 방법은 잘 작동합니다.
위의 Toony가 지적했듯이 이진법(및 10진법)의 마지막 자리만 중요합니다.
부울 로직 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
임의의 숫자를 사용하여 비트 AND(Java에서 &)를 1만큼 사용하면 00000001, = 1이 반환되며, 이는 숫자가 홀수임을 의미합니다.또는 00000000 = 0으로, 짝수임을 의미합니다.
예
이상해요?
1 & 1 =
00000001 및
00000001 =
00000001 <: 홀수
2 & 1 =
00000010 및
00000001 =
00000000 <- 짝수
54 & 1 =
00000001 및
00110110 =
00000000 <- 짝수
이것이 동작하는 이유입니다.
if(number & 1){
//Number is odd
} else {
//Number is even
}
중복되었다면 죄송합니다.
넘버 제로 패리티| 제로 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
논의를 위해...
짝수인지 홀수인지를 확인하려면 임의의 숫자의 마지막 자리만 보면 됩니다.서명, 서명 없음, 긍정, 부정 모두 이와 관련하여 동일합니다.이 작업은 모든 면에서 유효합니다. -
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");
하지만 앞으로 암호를 유지하기가 더 어려워질 거야홀수 텍스트를 "짝수 아님"으로 변경한다고 상상해 보십시오.그 후 나중에 다른 사용자가 어떤 변경을 했는지 확인하고 svn diff 또는 유사한 작업을 수행하려고 합니다.
휴대성이 아니라 속도가 걱정된다면 가장 중요하지 않은 부분을 살펴 볼 수 있습니다.이 비트가 1로 설정되어 있는 경우는 홀수이고, 0인 경우는 짝수입니다.인텔의 x86 아키텍처와 같은 작은 endian 시스템에서는 다음과 같습니다.-
if (iToTest & 1) {
// Even
} else {
// Odd
}
, 연산자 「 」 )를 합니다.x & 1 수 모듈로 2)를 사용합니다x % 2)
짝수 또는 홀수 확인은 간단한 작업입니다.
정확히 2로 나눌 수 있는 숫자는 짝수라는 것을 알고 있습니다.
우리는 단지 어떤 숫자의 약수여부를 확인하고 우리가 사용하는 약수여부를 확인할 필요가 있다.%교환입니다.
if를 사용하여 짝수 확인
if(num%2 ==0)
{
printf("Even");
}
else
{
printf("Odd");
}
조건 연산자/삼진 연산자
(num%2 ==0) printf("Even") : printf("Odd");
조건 연산자를 사용하여 짝수 또는 홀수를 확인하는 C 프로그램.
비트 연산자 사용
if(num & 1)
{
printf("Odd");
}
else
{
printf("Even");
}
+66% 고속>!(i%2) / i%2 == 0
int isOdd(int n)
{
return n & 1;
}
코드는 정수의 마지막 비트가 2진수일 경우 체크합니다.
설명.
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...
홀수일 경우 맨 오른쪽 비트는 항상 1입니다.
& bitwise AND 연산자는 리턴 라인의 오른쪽 끝 비트가 1인지 확인합니다.
진실과 거짓으로 생각하라
n과 1을 비교하면0001바이너리(제로의 수는 상관없습니다.
그러면 크기가 1바이트인 정수 n이 있다고 가정해 보겠습니다.
8비트/8진수로 표시됩니다.
int n이 7이고 1과 비교해보면
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
F는 false, T는 true를 나타냅니다.
둘 다 사실일 경우 맨 오른쪽 부분만 비교합니다.즉, 자동으로
7 & 1맞는 말이다.
오른쪽 끝에 있는 부분을 체크하려면 어떻게 해야 하나요?
간단하게 변경n & 1로.n & 2어떤 2가0010바이너리 등입니다.
비트 조작의 초보자라면 16진 표기를 사용하는 것이 좋습니다.
return n & 1;return n & 0x01;.
언급URL : https://stackoverflow.com/questions/160930/how-do-i-check-if-an-integer-is-even-or-odd
'programing' 카테고리의 다른 글
| 매개 변수를 사용하여 생성자 모의 (0) | 2022.09.03 |
|---|---|
| FILE*로 메모리 버퍼에 쓰는 방법 (0) | 2022.09.03 |
| Java 동적 어레이 크기 (0) | 2022.09.03 |
| 새 목록을 만들지 않고 집합을 목록으로 변환 (0) | 2022.09.03 |
| 내부 분할:1/3의 결과가 0인 이유는 무엇입니까? (0) | 2022.09.03 |