Question

This is a challenging problem I came across while I was giving my internship exam in Microsoft. The question goes like this:

User inputs a decimal number. The output should show whether the number is even or odd subject to constraint that only one printf, and no binary operator, logical operator, arithmetic operator, if-else and switch-case can be used.

So any ideas?

Answer 1

Seth Carnegie’s answer can fail for certain inputs. In particular, on my system, it fails for an input of 2147483647, indicating that it’s even (at least on my system), because converting that value to float loses precision.

Here’s an improved solution based on his:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(int argc, char **argv) {
    const char *const even_or_odd[] = { "even", "odd" };
    for (int i = 1; i < argc; i ++) {
        const int n = atoi(argv[i]);
        printf("%d is %s\n",
               n,
               even_or_odd[(int)fmod((unsigned char)n, 2.0)]);
    }
    return 0;
}

The for (int i = ... syntax is “new” in C99; if your compiler doesn’t support it, declare int i; above the loop.

The values to be tested are taken from the command line arguments. It would be easy enough to modify the program so they’re taken from stdin or elsewhere.

The atoi() function does no error checking, so don’t expect meaningful results if you give it something that’s not a decimal integer.

Converting the value of n to unsigned char before passing it to fmod() give a result with the same parity (odd-or-evenness) as n, but that won’t lose precision when converted to double (that conversion happens implicitly because fmod() takes double arguments). The standard-defined semantics of conversion to an unsigned type are such that this will work correctly even on systems that use a representation other than two’s-complement.

It’s just barely possible that converting from unsigned char to double could lose precision. This would require unsigned char to have an implausibly large upper bound. double must have at least 10 decimal digits of precision, or about 33 or 34 bits; losing precision would require unsigned char to be at least 34 or so bits (it’s likely I have an off-by-one error or two in there). Such a system could be conforming, but I doubt that any such systems exist in the real world.