Suppose $$2^n = \sum_{i=0}^{k-1} (m+i) = km + \frac{k(k-1)}{2}$$ for some $k>1$ and $m>0$, then $2^{n+1}=2km+k(k-1)=k(2m+k-1)$. Note then that this implies that $k=2^\ell$ for some $\ell > 0$, and therefore that $2m+k-1$ is odd, and therefore that in fact, $k=2^{n+1}$, and $2m+k-1=1$. Therefore we have $2m+2^{n+1}=2$, and $m+2^n = 1$, so $m=1-2^n\le 0$. Thus $2^n$ is not expressible as a sum of consecutive positive integers.
Edit:
I realized I posted this answer without really addressing the actual question, although I sort of answered in the comments. Everything other than the argument to show that powers of $2$ can't be expressed looked ok to me. I didn't follow your argument for the powers of $2$, which is why I wrote this answer.
One way to compute $D(n)$ is as follows:
From right to left, number the digits of a number as 0, 1, 2, ...
We work from right to left. At step $i$, we have already represented digits 0, 1, $\dots$, $i-1$ of $n$ with a vector $f$ of digits from the set 0, $(\pm 1)^3$, $\dots$, $(\pm 9)^3$, and we wish to represent the digits at and to the left of the digit $i$ in $n$. The vector $f$ may have generated some carries into digit $i$, and we need to take care of those as well.
At step $i$, we have a list of pairs $(f, n')$, each consisting of a vector $f=(f_{i-1},\dots,f_0)$ of already generated output digits together with the number $n'$ which we still need to express. For each pair in the list, we try all possible candidates (either one or two) for the output digit $f_i$ which give the correct result modulo 10. Then, we generate new pairs $((f_i, f_{i-1}, \dots, f_0), (n'-f_i)/10)$ and add them to the list for step $i+1$. If a pair containing $(n'-f_i)/10$ is already in the list, we can either do nothing or replace it with the new pair.
At step 0, the list is initialized with $(\epsilon, n)$, where $\epsilon$ is the empty vector and $n$ is the number we wish to express. We stop at the earliest step when a pair $(f, n')$ with $n'=0$ is in the list and output $f$.
This algorithm does not result in exponential blowup because the carries into digit $i$ are bounded: the generated carries must amount to a sum of strictly less than
$$
\sum_{j>0} \frac{9^3}{10^j}=81
$$
and similarly the carries must strictly exceed $-81$. So, the possible values for $n'$ at each step are confined to an interval of length less than $2\cdot 81=162$, meaning that there are never more than 162 entries in the list at any step.
Here is an implementation in Python 3.
import sys
n = int(sys.argv[1])
digits = [(i, i ** 3) for i in range(-9, 10)]
reps = {n : []}
max_count = 1
while 0 not in reps:
reps_next = {}
for remdr, rep in reps.items():
for dig_name, dig_val in digits:
if dig_val % 10 == remdr % 10:
reps_next[(remdr - dig_val) // 10] = [dig_name] + rep
reps = reps_next
max_count = max(max_count, len(reps))
print('Maximum alternative count:', max_count)
print('Representation:', *(digit for digit in reps[0]))
Best Answer
You should instead go like $$ 125^{14} \times 48^8 = 5^{42} \times 2^{32} \times 3^{8} = 10^{32} \times 5^{10} \times 3^{8},$$ so there should be 32 zeroes.