The short explanation is that 2^x mod 10^k will repeat with a cycle length of 5^(k-1)*4. This is easily obtained from Euler's phi formula on 2^x mod 5^k, plus the fact that 2^x === 0 mod 2^k for all x >= k. So, after the k'th term, the rest will repeat with a particular cycle period. We'll manually test all of the 2^x for x < k (there aren't many) and then rely on the cycles to test all of the larger powers.

The algorithm itself is a kind of sieving + lifting procedure: it inductively identifies all of the candidate exponents mod 5^(k-1)*4 which yield numbers with k trailing even digits (i.e. all even digits mod 10^k). Each such exponent will yield 5 possible exponents mod 10^(k+1) via a lifting procedure, which we can test; on average, half of these will have a top digit that is even and is therefore a candidate for the next power of 10 (10^(k+1)). Therefore, on average, we grow our candidate list by a factor of 2.5 per added digit - thus, for each 10^k, we test O(2.5^k) candidates (approximately 1.6*2.5^k, experimentally). This isn't too bad - at mod 10^19, we test only 55097940 candidates, representing every exponent below 5^18*4 = 15258789062500.

My rather hasty prototype is actually implemented in Python - not a language you want to do tons of arithmetic in - but it's still fast enough to chew through all those candidates in ~20 minutes on a single core. Obviously, there's ample room to make this faster; I figure a good, parallelized native (C/C++/Rust etc.) implementation could easily be 100x faster.

That's awesome!

2^k mod 10 is never odd; it's the cycle (2, 4, 8, 6).

Related here is the length of the cycles mod 2^k, https://oeis.org/A005054. Interestingly, the number of all-even-digit elements in those cycles does not appear to be in the oeis, I get 4, 10, 25, 60, 150 as the first five terms.

This does appear to get more efficient as k gets higher; for k=11 I get a cycle length of 39,062,500 with an even subset of 36,105, meaning only .09% of the cycle is all-even.

This is all brute force; there's probably a more elegant way of computing this.

For instance you could store the number in question in a 128 bit integer, shift left (double), check for odd digits (a series of modulo & divide operations) and then truncate using a modulo and subtract. You can repeat this process as long as you like. If you find an all evens number than you can do a more expensive indepth check.

Aren't those operations divisions? One division would usually be considered more than one operation.

For example, 2^(10^10) is 10^10 bits and about 3 billion decimals digits.

So for n up to 10^10, you need to do about (10^10)/2 = 5×10^19 elemental operations. At one operation per nanosecond that takes 1584 years of CPU time. Not at all easy to brute force!

    for i in range(1, 10**10):
        for k in range(1, 5):
            s = str(pow(2, i, 10**(10**k)))
            if '1' in s or '3' in s or '5' in s or '7' in s or '9' in s:
                break
        else:
            print(2**i)

if we marked sequences of integers with 3 options. even, odd, other. then these lists are not finite in bases of 3^k.

for four options. even, odd, other, another. then these lists are not finite in bases of 4^k.

there is an intersection in the infinite lists where the base is equivalent to the power of an earlier base.

so infinite lists for 2^k would overlap a subset of the infinite lists for 2^2^k=4^k

all prime bases, p, p^k would admit infinite lists that cover all the infinite lists for some composite base, c, c^k.

Of course, such a problem could yield deep insight into number theory blah blah blah, but it's unlikely.

2^0 is a power of two and has all odd digits.

Edit: If we include negative powers, there is also 2^-1, which is all odd except for the leading zero before the decimal point.

"Powers of 2" means this:

Here are the powers of 2 from \( 2^{-11} \) to \( 2^{11} \) in a table format:

     | Power of 2   | Value              |
     |--------------|--------------------|
     | \( 2^{-11} \) | 0.00048828125      |
     | \( 2^{-10} \) | 0.0009765625       |
     | \( 2^{-9} \)  | 0.001953125        |
     | \( 2^{-8} \)  | 0.00390625         |
     | \( 2^{-7} \)  | 0.0078125          |
     | \( 2^{-6} \)  | 0.015625           |
     | \( 2^{-5} \)  | 0.03125            |
     | \( 2^{-4} \)  | 0.0625             |
     | \( 2^{-3} \)  | 0.125              |
     | \( 2^{-2} \)  | 0.25               |
     | \( 2^{-1} \)  | 0.5                |
     | \( 2^{0} \)   | 1                  |
     | \( 2^{1} \)   | 2                  |
     | \( 2^{2} \)   | 4                  |
     | \( 2^{3} \)   | 8                  |
     | \( 2^{4} \)   | 16                 |
     | \( 2^{5} \)   | 32                 |
     | \( 2^{6} \)   | 64                 |
     | \( 2^{7} \)   | 128                |
     | \( 2^{8} \)   | 256                |
     | \( 2^{9} \)   | 512                |
     | \( 2^{10} \)  | 1024               |
     | \( 2^{11} \)  | 2048               |