Дружественные числа до 10000

limit = 10000
pairs = {}
    
def divisors_sum(number):
    return sum(x for x in range(1, (number//2)+1) if number%x == 0)
    
for i in range(1, limit+1):
    aggr = divisors_sum(i)
    if i == divisors_sum(aggr) and i != aggr :
        if i and aggr not in pairs:
            pairs[i] = aggr
print(pairs)

{1184: 1210, 2620: 2924, 5020: 5564, 220: 284, 6232: 6368}

import numpy as np
 
n = 10000
div_sum = np.zeros(n, dtype=np.int)
 
for i in xrange(n):
    r = np.arange(1, i/2+1)
    div_sum[i] = np.sum(r[np.remainder(i, r)==0])
                                 
print div_sum[220], div_sum[284]
 
rn = np.arange(n)
div_sum1 = div_sum.copy()
div_sum1[div_sum1 >= n] = 0
friendly = rn[np.logical_and(rn[div_sum1][div_sum1] == rn, rn[div_sum1] != rn)]
print friendly

print zip(friendly, div_sum[friendly])

# second variant
r1 = np.arange(1, n)
d_arr, n_arr = np.meshgrid(r1, r1)
rem = np.remainder(n_arr, d_arr)
 
d0 = np.where(rem==0, d_arr, np.zeros((n-1, n-1)))
div_sum0 = np.sum(d0, axis=1, dtype=int) - r1
div_sum = np.insert(div_sum0, 0, 0)

# second variant
r1 = np.arange(1, n)
#d_arr, n_arr = np.meshgrid(r1, r1)
#rem = np.remainder(n_arr, d_arr)
rem = np.zeros((n-1, n-1))
rem[:, :] = np.remainder(r1[:, np.newaxis], r1[ np.newaxis, :])
 
#d0 = np.where(rem==0, d_arr, np.zeros((n-1, n-1)))
d0 = np.zeros((n-1, n-1))
d0[:, :] = np.where(rem==0, r1[ np.newaxis, :], 0)
div_sum0 = np.sum(d0, axis=1, dtype=int) - r1
div_sum = np.insert(div_sum0, 0, 0)

from math import sqrt
    
limit = 10000
pairs = {}
     
def divisors_sum(number):
    lst = []
    for x in range(1, int(sqrt(number))+1):
        if number%x == 0:
            if (number or x) != number//x:
                lst.append(x)
                lst.append(number//x)
            else:
                lst.append(1)
    return sum(lst)
    
for i in range(1, limit+1):
    aggr = divisors_sum(i)
    if i == divisors_sum(aggr) and i != aggr :
        if i not in pairs:
            pairs[i] = aggr

ds = [0] * (limit + 1)
for i in range(1, limit+1):
    ds[i] = divisors_sum(i)
    
for i in range(1, limit+1):
    aggr = ds[i]# divisors_sum(i)
    if aggr <= limit and i == ds[aggr] and i != aggr :
        if i not in pairs:
            pairs[i] = aggr

for num1 in range(1, 10001):
    num1_del = [num for num in range(1, num1) if num1 % num == 0]
    num2 = sum(num1_del)
    num2_del = [num for num in range(1, num2) if num2 % num == 0]
    if num1 == sum(num2_del) and num2 == sum(num1_del):
        print(f'{num1} and {num2} is friend!')

import time
 
t_start=time.time()
result=[]
for num in range(2,10001):
    sd_num=1 
    i=2 
    while(i*i<=num):
        (p,q)=divmod(num,i)
        if q==0:
            sd_num+=i
            if p!=i:
                sd_num+=p
        i=i+1        
    mun=sd_num
    sd_mun=1
    i=2 
    while(i*i<=mun):
        (p,q)=divmod(mun,i)
        if q==0:
            sd_mun+=i
            if p!=i:
                sd_mun+=p
        i=i+1  
    if num==sd_mun and mun==sd_num:
        if (num != mun) and (num < mun):
            result.append((num,mun))
print(result)
    
t_fin=time.time()
print(t_fin-t_start)

from time import time
 
 
def sumdiv(n):
    d = 2
    s = 1
    while d * d < n:
        if n % d == 0:
            s += d
            s += n // d
        d += 1
    return s + d if d * d == n else s
 
 
k = int(input())
st = time()
for i in range(2, k + 1):
    b = sumdiv(i)
    if k >= b > i == sumdiv(b):
        print(i, b)
 
print(time() - st)