Should it be in Computer Science?

Solutions to this equation have $d(n) > \sqrt{n}$ , so they should be "small." There are some upper bounds on $d(n)$ . One I found here

Link

was $d(n) \le n^{\frac{1.5379 \log 2}{\log \log n}}$ and that exponent is less than $1/2$ if $n \ge 4590$ . So you should only have to check for $n$ up to $4589$ .

Here's a C++ code:

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

#include<iostream.h>
#include<conio.h>
void main()
{       unsigned long int num;

         for(unsigned long int x=1;x<=100000;x++)
     {     num=x;
          int dn=1,exp=1,i=2;

      while(i<=num)
      {    if(num%i==0)
          {     exp++;
                  num/=i;
                           }
          else 
           {    dn*=exp;
                  exp=1;
                      i++;
                            }
              }
         dn*=exp;
        if(x+dn==dn*dn)
        cout<<x<<endl;
                   }
getch();
         }

The output comes out to be:

2

56

132

1260

Hence, the sum is $1450$

Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from math import sqrt

def d(m):
    res = 0
    for i in range (1, int(sqrt(m)) + 1):
        if m % i == 0: res += 2
    if sqrt(m) % 1 == 0: res -= 1
    return res

total = 0

for n in range (1, 10000):
    if n + d(n) == d(n) * d(n):
        total += n
        print n

print "\n", total

Output

1
2
3
4
5
6

2
56
132
1260

1450

Answer: $\fbox{1450}$

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

def factors(n):    
    return set(reduce(list.__add__, 
                ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))

try:
    c=1
    summ=0
    while True:
        if len(factors(c))+c==(len(factors(c)))**2:
            summ+=c
        c+=1
except(KeyboardInterrupt):
    print summ

Not sure if theres infinite n's or not, so added an except so I can exit out of program and view current sum which turns out to be correct, only 4 numbers, (2,56,132,1260) work.

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

#include<iostream>
using namespace std;

int d(int &n)
{
    int i=1,j=0;
    for(i=1;i<=n;i++)
        {
            if(n%i==0)
                {
                    j++;
                }
        }
        return j;
}
main()

{
    int k=1,s=0;
    for(k=1;k<=10000;k++)
        {
            if(d(k)*d(k)-d(k)==k)
                {
                    s=s+k;
                }
        }
        cout<<s;
}

Gave $1450$ . (Luckily!)

Can anyone help me out with large integers?

A solution that checks for the number of divisors of a very large number can also be easily implemented using some Computer Science algorithms. The divisor function $\sigma (n)$ can be defined by the mathematical equation,

$\sigma (n)=\prod _{ i=1 }^{ r }{ ({ a }_{ i }+1) } _{ }$ represents the number of occurrences of the ${ i }^{ th }$ prime factor of $n$ and $r$ denotes the number of distinct prime factors of $n$ .

Therefore by using this mathematical equation and simple primality testing algorithms , one can easily find the number of divisors of any number quite efficiently.