How many odd digits?
Given a positive integer, count its odd digits.
Input
- An integer from 1 to 999,999,999, inclusive, in any of the following formats:
- A number (such as an integer or floating point number), like
123. - A string, like
"123". - A sequence of characters (such as an array or list), like
['1', '2', '3']. - A sequence of single digit numbers, like
[1, 2, 3].
- A number (such as an integer or floating point number), like
Output
- The number of odd digits in the input.
Test cases
Test cases are in the format input : output.
1 : 1
2 : 0
3 : 1
4 : 0
5 : 1
6 : 0
7 : 1
8 : 0
9 : 1
10 : 1
11 : 2
12 : 1
13 : 2
14 : 1
15 : 2
16 : 1
17 : 2
18 : 1
19 : 2
20 : 0
111111111 : 9
222222222 : 0
123456789 : 5
999999999 : 9
Scoring
This is a code golf challenge. Your score is the number of bytes in your code. Lowest score for each language wins.
Explanations are optional, but I'm more likely to upvote answers that have one.
[C (gcc)], 37 bytes This ta …
1mo ago
[C (gcc)], 41 bytes …
1mo ago
Vyxal, 4 bytes Expects a stri …
2mo ago
JavaScript, 25 bytes Input …
3mo ago
Japt `-mx`, 2 1 byte u …
1mo ago
Python, 37 27 bytes First, …
3mo ago
6 answers
You are accessing this answer with a direct link, so it's being shown above all other answers regardless of its score. You can return to the normal view.
Python, 37 27 bytes
First, with input as an integer:
lambda i:sum(ord(x)&1for x in str(i))
This converts the number to string (in the base-10 default) and processes each character. It exploits the fact that digit symbols 0..9 are consecutive in Unicode and 0 corresponds to an even code point (if it were odd, the code would have to use ord(~x) instead).
ord is used to process each character individually. The alternative would be to convert the string to bytes and use the numeric values that come (assuming Python 3.x) from iterating over the bytes directly. However, any such conversion results in longer code. Also, while Python offers direct int->bytes conversions, they do the wrong thing: bytes(i) creates an object of that many bytes with all zero values, and i.to_bytes() gives a binary representation.
As a list of digit values, of course we can just process them directly:
lambda i:sum(x&1for x in i)
This can be done in pure FP primitives instead of using a comprehension. But it's longer, despite the eta reduction:
lambda i:sum(map((1).__and__,i))
(The parentheses around 1 are syntactically necessary.)
C (gcc), 37 bytes
This takes an integer as input. It uses the fact that the last digit is odd if and only if the number is odd, and that integer division by 10 removes the last digit.
Testing if the number is odd is by doing bitwise and with 1, which conveniently gives 1 for odd and 0 for even numbers, so the number of odd digits is obtained by just adding those up.
r;f(i){for(;i;i/=10)r+=i&1;return r;}
0 comment threads
JavaScript, 25 bytes
Input as an array of digits
a=>a.map(x=>t+=x%2,t=0)|t
26 bytes
With input as a string (or an array of digit strings).
f=([d,...a])=>d?d%2+f(a):0
1 comment thread
C (gcc), 41 bytes
r;o(char*s){for(;*s;r+=*s++&1);return r;}
This is under the assumption that in a function solution, input has to be passed as parameter and output through the return value. The result variable is allocated outside the function to get gcc implicit int declaration and zero initialization for free.
It's very straight-forward: input as string, iterate until null terminator found. Mask each character's ASCII value with 1 to see if odd or even, under the assumption that '0' == 48, an even value. From there, ASCII character are guaranteed to be adjacent in the symbol table.
I also tried to write it with recursion but got exactly the same amount of characters (41):
r;o(char*s){r+=*s&1;*s&&o(s+1);return r;}
Printing the result inside the function also works but is longer:
r=48;o(char*s){for(;*s;r+=*s++&1);puts(&r);}
1 comment thread