Finding the percentage of even numbers in an array

Question

I wrote a method which computes the ratio of even to odd numbers in an array. I know it's a simple piece of code, but I wanted to see if you have any feedback for improving it.

public double percentEven(int[] a) {
if(a.length <= 1) {
    return 0.0;
}
double even = 0.0;
for(int i = 0; i < a.length; i++) {
    if(a[i] % 2 == 0) {
        even++;
    } 
}
return (double) (even / a.length) * 100; 
}

If the array contains zero elements, or zero even elements, return 0.

Answer 1

Potential bug: What if the array contains a single element, and it is even?

if(a.length <= 1) {
    return 0.0;
}

That's what happens.

Easy fix, change to:

if(a.length == 0) {

---

Your indentation is slightly screwed up, but that might just be a copy-paste error.

---

double even should be int even.

---

You could use a for-each loop,

for (int i : a) {
    if(i % 2 == 0) {

---

int[] a could be named int[] array or int[] values or int[] input.

---

When using even as an int, use the following return statement to cast only even to a double, which will then make it use double division and not int division:

return (double) even / a.length * 100;

Alternatively you could use:

return even * 100.0 / a.length;

But I think return (double) even / a.length * 100; is better.

Answer 2

If you're using Java 8, IntStream can be used to solve the problem along with its filter and count methods:

public static double percentEven(int[] values) {
  IntStream evens = IntStream.of(values).filter(x -> x % 2 == 0);
  return (double) evens.count() / values.length * 100;
}

It's not a big win in this particular case, but I think it is a bit cleaner. Processing Data with Java SE 8 Streams, Part 1 has more examples of where streams can be a powerful tool.

Note that unlike the original code, this will return NaN for zero-length arrays. You can of course change it to return 0 instead, if you want.

Answer 3

I was just surprised by the very short Java 8 solution by mjolka, so I'm giving it a try in Java 7.

public double percentEven(int[] values) {
    int even = 0;
    for (int x : values) even += 1 - (x & 1);
    return 100.0 * even / values.length;
}

I violated the braces-everywhere convention in order to save 2 lines, but this is still not good enough. Java 8 still wins by 1 line, and that seems impossible to beat.

OTOH the Java 8 solution produces some garbage and I'm afraid it's one or two orders of magnitude slower.

Reaction to comments

To those thinking that the following would be clearer

even += (x%2 == 0 ? 1 : 0);

No, it wouldn't. The former is hard to understand for people unfamiliar with bitwise operation, the latter is hard to understand for people unfamiliar with ternary expressions. While bitwise operations are a bit more exotic, it makes no sense to reduces everyone's capabilities to the lowest common denominator. It's no hack, no magic, no code golf, just learn it!

Once we know that x & 1 extracts the lowest binary digit, we could even argue that it's much cleaner than a conditional expression.

Note on optimizations

Division and modulus are pretty expensive and JIT is pretty smart on optimizing them. However, x % 2 is not the same as x & 1 for negative numbers, so more work has to be done, see this answer for some benchmarks.

OTOH x % 2 == 0 is the same as (x & 1) == 0, but I don't know if JIT uses this fact.

---

A maximally optimized code could look like this

public double percentEven(int[] values) {
    int even = values.length;
    for (int x : values) even -= x & 1;
    return 100.0 * even / values.length;
}

Problems with modulus

Using modulus is a bit error prone as both

even += x%2 == 1 ? 0 : 1;

and

even += 1 - x%2;

are wrong. The problem is that % for negative numbers does not do what we usually need (i.e., rounding towards negative infinity rather than rounding towards zero).