The bonus isn't too hard: let $f(x)$ be the number obtained by summing the cubes of the digits of $x.$ Now here are two facts:

(1) If $x < 10000,$ then $f(x) < 10000$ (in fact, it's less than $4 \cdot 9^3 = 2916$ ).

(2) If $x \ge 10000,$ $f(x) < x.$ (Proof: let $g = \log_{10}(x).$ Then $x$ has $\lceil g \rceil$ digits, so $f(x) \le 9^3 \lceil g \rceil,$ which is less than $x = 10^g$ for $g \ge 4,$ because e.g. $729 \lceil g \rceil < 729(g+1),$ and for $g=4$ $729(g+1) < 10^g$ and the derivative of the left side is a constant $729$ and the derivative of the right side is $10^g \ln(10) \ge 10000 \ln(10),$ so the right side increases faster than the left side.)

This implies that for any $x,$ iterating $f$ enough times will leave a result $< 10000,$ and iterating $f$ after that will keep us in the range $[1,10000].$ By the Pigeonhole Principle , the sequence of iterates will eventually repeat, at which point we are in the limit set.

This shows that everything eventually leads to a point in the limit set, and that the limit set is finite, because no number $> 10000$ can ever appear in the limit set.

To generate the limit set, I wrote some code to check the integers $< 10000.$ I got the cycles $1 \\ 55, 250, 133 \\ 136, 244 \\ 153 \\ 160, 217, 352 \\ 370 \\ 371 \\ 407 \\ 919, 1459$ The sum is $\fbox{5227}.$

Let's call a number made of k 9's a ninber . A ninber has clearly the highest possible output of $f(n)$ for a number with k digits. Also, it's easy to check that its output is equal to $k\times 9^3$ . So the output increases linearly with k, as the ninber itself (which consists of k 9's) grows exponentially. So, if we find the least k for which the ninber is bigger than its output, we are guaranteed that greater numbers will always be greater than their outputs, so we don't need to check them as it's impossible for them to form fixed points or limit cycles.

$f(9999)=2916<9999$

Bonus : This also proves that the limit set contains finitely many numbers, as numbers greater 2916 can't be part of the set and there are finitely many positive integers smaller or equal to 2916.

Here is a concise example that computes the limit set:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

found = []
for n in range(1, 2917):
    previous = []
    k = n
    while k not in previous:
        n = k
        k = sum([int(a)**3 for a in str(n)])
        previous.append(n)
    if k not in found:
        for i in range(previous.index(k), len(previous)):
            if previous[i] not in found:
                found.append(previous[i])
print(sum(found))

My C code.

include <stdio.h>

int c[100] = { 0 };

int count = 0;

bool isprintf = false;

void function(int n)

{

int a[100] = { 0 }, b[100] = { 0 };

a[1] = n;

int i;

for (i = 2; i <= 99; i++)

{

    while (a[i - 1] != 0)

    {

        a[i] = a[i] + (a[i - 1] % 10) * (a[i - 1] % 10) * (a[i - 1] % 10);

        a[i - 1] = a[i - 1] / 10;

    }

    b[i] = a[i];

}

int j, k;

for (i = 2; i <= 99; i++)

{

    for (j = 1; j < i; j++)

    {

        if (b[j] == b[i] && (b[j] != 0))

        {

            for (k = j; k<i; k++)

            {

                int x;

                for(x = 0; x < count; x++)

                {

                    if(c[x] == b[k])
                    {

                        isprintf = true;

                        break;
                    }

                }
                if(isprintf == false)

                {

                    printf("%d\n", b[k]);

                    c[count++] = b[k];

                }

                isprintf = false;

            }

            for (k = i; k <= 99; k++) 

                b[k] = 0;

        }

    }

}

}

int main()

{ int n;

for (n = 0; n <= 200; n++)

{

    function(n);

}

return 0;

}

the output is

1

371

153

133

55

250

370

217

352

160

407

1459

919

244

136

the sum is 5227.

Python 3

MAXRANGE = 2195 # 2^3 + 3 * 9**3 
UNCHECKED, NOT_IN_LS, TESTING_NOW, BELONGS_LS = 0, 1, 2, 3 # LS - limit set

# Every cell winth index 'i' in the list 'state' represents state of number i
state = [UNCHECKED] * MAXRANGE

def chain_replace(number, source, destination):
    """This function runs throuhg chain which begins with 'number'
       and replaces every number state in the chain to 'destination'
       while the state is 'source'"""
    while state[number] == source:
        state[number] = destination
        number = sum([int(i)**3 for i in str(number)]) # Sums up cubes of digits
    return number

for number in range(MAXRANGE):
    cycle_start = chain_replace(number, UNCHECKED, TESTING_NOW)
    chain_replace(cycle_start, TESTING_NOW, BELONGS_LS)
    chain_replace(number, TESTING_NOW, NOT_IN_LS)

print(sum([i for i, n in enumerate(state) if n==BELONGS_LS]))

Python 3 code:

nums = {}    # dictionary of all numbers and what they iterate to
ends = []    # limit set
def f(num):    # this is the iterative function, which works in a creative way
    sum = 0
    for digit in str(num):
        sum += int(digit)**3
    return(sum)
for num in range(1, 100000):    # adds each number up to 99,999 and what it iterates to to the nums dictionary
    path = []
    iter = num
    nums[iter] = f(iter)
    while iter not in path:
        path.append(iter)
        nums[iter] = f(iter)
        iter = f(iter)
for maybe in nums:    # checks for numbers in the limit set
    iter = maybe
    cycle = 0
    uncompleted = True
    while cycle < 20 and uncompleted:
        iter = f(iter)
        if iter == maybe:
            ends.append(maybe)
            uncompleted = False
        a += 1
sum = 0
for num in ends:     # sums all the numbers in the limit set to get to the final sum
    sum += num
print(sum)    # final sum

$f=\text{Plus}\text{@@}\text{Table}\left[i^3,\{i,\text{IntegerDigits}[\text{\$\#\$1}]\}\right]\&;$

$\text{limitSet}=\{\}; \\ \text{Do}[ \\ \text{limitSet}=\text{limitSet}\cup \text{With}[\{\text{result}=\text{NestWhileList}[f,i,\text{UnsameQ},\text{All}]\}, \\ \text{result}[[\text{Position}[\text{result},\text{Last}[\text{result}]][[1,1]]+1\text{;;}-1]]], \\ \{i,0,9999\}],i]$

$\text{Plus}\text{@@}\text{limitSet} \Longrightarrow 5227$

I noticed that, we need to iterate only from 1 to 137 to cover all the numbers in limit set. Trying to figure out what is it about '137'...

Python solution:

def sumOfDigitsCubed(n):
    result = 0;
    while n > 0:
        d = n % 10
        result += d*d*d
        n = n // 10
    return result

def findLimitCycle(parm):
    tempList = [];
    n = parm
    while n not in tempList:
        tempList.append(n)
        n = sumOfDigitsCubed(n)
    indx = tempList.index(n)
    return tempList[indx:]

result = []
for i in range(1,1000):
      thisCycle =  findLimitCycle(i)
      if thisCycle[0] not in result:
          result.extend(thisCycle)
result.sort()
print (result)
print(sum(result))

By the way, how do you format code with line numbers, like I see in other solutions posted here?

The maximum value of $f$ for an $n$ -digit number is $9^3 \cdot n$ . Since this is equal to $2916$ , which has 4 digits, for 4-digit numbers and stays smaller than the numbers as they get larger, only numbers up to $2916$ need to be considered.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def f(n):
    return sum(int(x) ** 3 for x in str(n))

table = {n: f(n) for n in range(1, 2917)}
limit = set()
while table:
    cur = next(iter(table))
    seq = [cur]
    while True:
        try:
            cur = table[cur]
        except KeyError:
            for x in seq[:-1]:
                del table[x]
            break
        if cur in seq:
            limit |= set(seq[seq.index(cur):])
            for x in seq:
                del table[x]
            break
        else:
            seq.append(cur)
print(sum(limit))

Yes, proper Python coders will probably stone me for breaking every principle of the Zen of Python, but it works, so...

I used c++

Here's a compact solution using dictionaries in Python:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def f(n): # function f
    s = 0
    while n > 0:
        s += (n % 10)**3
        n //= 10
    return s

Dict = {}
for i in range(10000):
    seq = [i]
    j = f(i)
    while True:
        if j in Dict:
            Dict[i] = Dict[j] # could be also [] since it won't count
            break
        elif j in list:
            Dict[i] = seq[seq.index(j):] # limit set starting from first repeated number
            break
        else:
            seq.append(j)
            j = f(j)

print(sum(i for i in range(10000) if i in Dict[i])) # a number is in the limit set iff it appears in its own limit set