We're trying to solve this equation
$$
(b_{0}^{e_o}b_{1}^{e_1}\dots b_{n}^{e_n})_k = b_{0} + ke_{0} + k^{2}b_{1} + k^{3}e_{1} + \dots + k^{2n - 1}b_{n} +k^{2n}e_{n},
$$
where $k$ denotes the numerical base.
Here's the program I wrote in C (I first wrote it in python but realized that C would be much better in terms of compile time)
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
// Function to compute the product of digit pairs
long long product_digits(int digits, int num_digits) {
long long total = 1;
for (int i = 0; i < num_digits; i += 2) {
int x = digits[i];
int y = digits[i + 1];
total = (long long)pow(x, y);
}
return total;
}
// Function to compute base conversion
long long base_to_ten(int digits, int num_digits, int base) {
long long sum = 0;
for (int i = 0; i < num_digits; i++) {
sum += digits[num_digits - 1 - i] (long long)pow(base, i);
}
return sum;
}
// Recursive function to generate digit combinations and check the equation
void generate_combinations(int base, int num_digits, int *digits, int index) {
if (index == num_digits) {
long long lhs = product_digits(digits, num_digits);
long long rhs = base_to_ten(digits, num_digits, base);
if (lhs == rhs) {
printf("Solution found (base %d): ", base);
for (int i = 0; i < num_digits; i++) {
printf("%d ", digits[i]);
}
printf("= %lld\n", lhs);
}
return;
}
// Generate all possible digits (1 to base-1)
for (int i = 1; i < base; i++) {
digits[index] = i;
generate_combinations(base, num_digits, digits, index + 1);
}
}
// Function to start checking equations for a given base and digit count
void check_equation(int base, int num_digits) {
int digits = (int )malloc(num_digits * sizeof(int));
if (!digits) {
fprintf(stderr, "Memory allocation failed\n");
return;
}
generate_combinations(base, num_digits, digits, 0);
free(digits);
}
int main() {
int num_digits = 8; // Adjust as needed
int base = 10;
// Iterate over even digit counts
for (int num_digit = 2; num_digit <= num_digits; num_digit += 2) {
check_equation(base, num_digit);
}
return 0;
}
Interest $1$
Checking up to $n = 4$ (8 digits) for $k = 10$ yields only $2^{5}9^{2}$ as an answer.
I'd like to note that for larger $n$'s, the product (LHS) will result in a number with a number of digits $\geq2n$, because of this I believe it's possible to prove that there exist finite solutions for base $10$. Particularly, some minimum value, say, $k =\underbrace{2^{4}2^{4}\dots} _\text{$n$ times}$, such that the number of digits in $k$ is greater than $2n$. I'm not exactly sure how to prove this, so I'll leave it as a conjecture for now.
So, to answer the question, not likely. It's hard to compute at the moment for higher values of $n$.
Interest $2$
Checking up to $n = 6$, $k = 10$, and increasing the possible digits to $[1, 100]$, I couldn't find a solution. And this makes sense. Take $2^{10} = 1024$, for example, this already attributes $4$ digits. But we can sort of "cheat the system". Here's the method: Since $1^{n}$ for $n \geq 1$ is $1$, we just need to find a number that starts with $1$, has some numbers $n$ between, then ends with $xy$ so that we can write it as $1^{n}x^{y}$.
I searched up to $x, y \in [1, 1000]$ and found:
$$
1^{844674407370955}16^{16} = 18446744073709551616,
$$
pretty neat. We can do something similar for four digits and an interval of $[1, 100]$ to obtain the following:
$$
1^{A}6^{88}8^{96} = \overline{A688896}
$$
where $A=$ 49261837930424181019782306980112000220529917757320182269028725210958882068540501080877333683282833234761504686305466752126923092015623395616828168020
and
$$
1^{B}81^{1}7^{83} = \overline{B811783}
$$
where $B=$ 126217677935462499355285958106810248209716299799868722720464961928
and
$$
1^{C}4^{42}6^{496} = \overline{C4426496}
$$
where $C=$ 77639616149170183337496905014553824675277932849536369386649820645372361449190489637626678015518085702298093149509480620671632214451835574765888159311459082678179264350547076482449615727891548893204840176012914249489156305948368663946858037186326014142014080031067989541411905654690680896047802285331626672703551588831423345725677690111832053407287254594706993093724057899428747007045660445690532017662674
and
$$
1^{D}8^{7} 2^{192} = \overline{D872192}
$$
where $D=$ 3164036458569648337239753460458804039861886925068638906788
Given this trick, Interest $2$ has a lot of intriguing solutions.
The program for this is separate:
def check_power_condition(x, y):
power_str = str(x ** y)
xy_str = str(x) + str(y)
# Check if the first digit is '1'
if power_str[0] == '1' and power_str.endswith(xy_str):
return True
return False
for x in range(1, 1000):
for y in range(1, 1000):
if check_power_condition(x, y):
print(f"{x}^{y} meets the condition!!!!!!!!!!!!!!!")
Interest $3$
Compared to Interest $3$, there does appear to be an abundance of solutions across $k$ but fewer across $n$. Here are some solutions I found given different $n$'s (I'll be using $[d]$ for non-base$10$ numbers):
$n = 1$:
$$
\begin{align}
2^{4} = 24_{6} \quad & 2^{8} = 28_{124}\\
3^{3} = 33_{8} \quad & 3^{6} = 36_{241}\\
2^{6} = 26_{29} \quad & 2^{[10]} = 2[10]_{507}\\
4^{4} = 44_{63} \quad & 5^{5} = 55_{624}\\
\end{align}
$$
$n = 2$:
$$
\begin{align}
2^{5}9^{2} = 2592 &\\
2^{9}9^{2} = 2992_{26} &\\
1^{[21]}[23]^{4} = 1[21][23]4_{59}&
\end{align}
$$
$n = 3$:
No small base solutions for $n =3$ and searching any higher requires much more computation time. EDIT More solutions found:
$$
5^{[12]}[23]^{[20]}[10]^{[21]} = 5[12][23][20][10][21]_{34} \\
[27]^{[17]}[36]^{6}[37]^{[26]} = [27][17][36]6[37][26]_{38}
$$
$n = 4$:
$$
5^{1}2^{3}2^{8}7^{4} = 51232874_{9}
$$
As you can see, the depth of which we can search for base-$k$ gets smaller for larger $n$'s.
Final
For the specific case of base 10 numbers, $2^{5}9^{2}$ seems to be incredibly rare.
I hope this helped.
However, it does include a solution to the third "order of interest":
– FishDrowned Feb 26 '25 at 10:45