Extracting powers of a sum

Question

Given a sum in the form

Sum[n^k, {k, kl}]

for some natural n and natural list kl, is it possible to extract the values of kl? In other words, I want to know if a sum of the form $ \sum_{i=1}^n n^{k_i} $ uniquely determines the tuple $(k_1,...,k_n)$ (up to permutations). This seems true due to the uniqueness of base-$n$ representation, but I am not sure how to implement a function to extract the tuple $(k_1,...,k_n)$. Any ideas?

My attempt: Following the discussion here, I tried to use BaseForm. If we assume $\{k_i\}$ are different, then, as an example,

n = 3;
kl = {1, 2, 3};
BaseForm[Sum[n^k, {k, kl}], n]

yields $1110_3$ which tells me that kl = {1, 2, 3} (in no particular order). How can I produce this list from BaseForm? Alternatively, is there a way to transform the representation $1110_3$ into the list {1, 1, 1, 0}?

Also, in the case where $\{k_i\}$ are all the same, we may simply take

ConstantArray[Log[n, Sum[n^k, {k, kl}]] - 1, n]

Could a straightforward computation for both cases (equal $\{k_i\}$ and not) be done? Perhaps using base $n+1$ instead?

Edit: I forgot to mention. The length of kl must be exactly n. Apologies to whoever started working on this without this assumption.

Answer 1

Use IntegerDigits instead of BaseForm.

(* some prior computations... *)
n = 3;
kl = {1, 2, 3}; 
value = Sum[n^k, {k, kl}];

Now, assuming that you know what n was used,

IntegerDigits[value, 3]
(* returns {1, 1, 1, 0} *)

Edit I'm still not sure I entirely get the second part, but if the goal is to reconstruct the "exponent list" (we've been using the variable kl for this), then maybe this does what you want:

ToExponentList[base_, num_] := 
  Flatten[
    MapIndexed[ConstantArray[#2 - 1, #1] &, Reverse@IntegerDigits[num, base]]]

(probably a cleaner way to do this, but does this at least produce the correct behavior?)

Proof:

ToExponentList[3, Sum[3^k, {k, {1, 2, 3}}]] == {1, 2, 3}
ToExponentList[10, Sum[10^k, {k, {0, 0, 0, 1, 1, 2}}]] == {0, 0, 0, 1, 1, 2}

Edit 2

ToWolfeList[base_Integer, num_Integer] :=
  With[
    {digits = IntegerDigits[num, base]},
    Which[
      1 == Total[digits], ConstantArray[Length@digits - 2, base],
      base != Total[digits], NullWolfeList[],
      True, Flatten[MapIndexed[ConstantArray[#2 - 1, #1] &, Reverse@digits]]]]

It seems like if the sum of the digits does not equal the base, then there is no solution (so I return a NullWolfeList[]). If there is just a digit 1, then we construct a constant array of the appropriate value. Otherwise, we fall back to my previous implementation, which still feels too awkward, but I haven't thought of anything better without resorting to computing logs or some such.