Problem:


Score : 400 points

Problem Statement

For a positive integer X, let f(X) be the number of positive divisors of X.

Given a positive integer N, find \sum_{K=1}^N K\times f(K).

Constraints

1 \leq N \leq 10^7

Input

Input is given from Standard Input in the following format:

N

Output

Print the value \sum_{K=1}^N K\times f(K).

Sample Input 1

4

Sample Output 1

23

We have f(1)=1, f(2)=2, f(3)=2, and f(4)=3, so the answer is 1\times 1 + 2\times 2 + 3\times 2 + 4\times 3 =23.

Sample Input 2

100

Sample Output 2

26879

Sample Input 3

10000000

Sample Output 3

838627288460105

Watch out for overflows.



Sample input:
4


Sample output:
23

Submission status: Time Limit Exceeded

Solution code:
import collections
n=int(input())
def prime_emu(n):
    pn=[2]
    for L in range(3,int(n**0.5)+1):
        chk=True
        for L2 in pn:
            if L%L2==0:
                chk=False
                break
        if chk:
            pn.append(L)
    
    return(pn)
  
def is_prime(q):
    q = abs(q)
    if q == 2: return True
    if q < 2 or q&1 == 0: return False
    return pow(2, q-1, q) == 1  
  
pn=prime_emu(n)  
def prime_fact(n):
    a=[]
    for i in pn:
      if i>int(n**0.5)+1:
        break
      cnt=0
      while n%i==0:
        n//=i
        cnt+=1
      a.append(cnt)
        
    if n!=1:
      a.append(1)
    return a
  
cnt=0
for k in range(1,n+1):
  if is_prime(k):
    cnt+=k*2
    continue
  c=prime_fact(k)
  if len(c)==0:
    cnt+=1
  else:
    e=1
    for i in range(len(c)):
      e*=(c[i]+1)
    cnt+=e*k
print(cnt)

Submission status: Time Limit Exceeded

Solution code:
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline 
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_list(N): return [s_list() for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []
from functools import lru_cache

@lru_cache(maxsize=100000)
def len_make_divisors(n: int) -> list:
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    return len(divisors)

def main():
    n = i_input()

    count = 0

    for i in range(1, n+1):
        count += i * len_make_divisors(i)

    print(count)

if __name__ == '__main__':
    main()

Submission status: Time Limit Exceeded

Solution code:
def num_divisors_table(n):
    table = [0] * (n + 1)
    
    for i in range(1, n + 1):
        for j in range(i, n + 1, i):
            table[j] += 1
    
    return table

a = int(input())
b = num_divisors_table(a)
ans = 0
for i in range(len(b)):
  ans += i * b[i]
print(ans)

Submission status: Time Limit Exceeded

Solution code:

import math 
def sumDivisors(n) :
  i = 1
  sum = 0
  while i <= math.sqrt(n):
    if (n % i == 0) :
      if (n / i == i) :
        sum += 1
      else :
        sum += 2
    i = i + 1
  return sum
n = int(input())
answer = 0
for i in range(n + 1):
  answer += (i * sumDivisors(i))
print(answer)

Submission status: Time Limit Exceeded

Solution code:
def num_divisors_table(n):
  table = [0] * (n + 1)
    
  for i in range(1, n + 1):
    for j in range(i, n + 1, i):
      table[j] += 1
    
  return table

N = int(input())
table = num_divisors_table(N)

def f(n):
  return table[n]

res = 0

for K in range(1, N + 1):
  #tmp = f(K)
  #print(tmp)
  res += K * f(K)

print(res)

Submission status: Time Limit Exceeded

Solution code:
import math
def num_divisors_trial_division(n):
    num = 0
    for i in range(1, int(math.sqrt(n) + 1e-9) + 1):
        if n % i == 0:
            num += 1
            if n != i**2:
                num += 1

    return num

def main():
    N = int(input())
    ans = 0
    for i in range(1,N+1):
        ans += i*num_divisors_trial_division(i)
    print(ans)
main()

Submission status: Time Limit Exceeded

Solution code:
N=int(input())

def div(n):
    res=0
    for i in range(1,int(n**0.5)+1):
        if n%i==0:
            res+=2
        if i**2==n:
            res-=1
    return res

ans=0
for i in range(1,N+1):
    ans+=i*div(i)
print(ans)

Submission status: Time Limit Exceeded

Solution code:
N = int(input())
ans = 0
for i in range(1, N+1):
    j = 1
    while i * j <= N:
        ans += i * j
        j += 1
print(ans)

Submission status: Time Limit Exceeded

Solution code:
import numpy as np
from functools import reduce
from copy import deepcopy
N = int(input())
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973]
factors = {1: {}}
results = {1: 1}
for p in primes:
    results[p] = 2
    factors[p] = {p: 1}


def count_factors(K):
    if K in factors:
        return results[K]
    for p in primes:
        if K % p == 0:
            f1 = factors[p]
            f2 = factors[K // p]
            f = deepcopy(f1)
            for k, v in f2.items():
                f[k] = f1.get(k, 0) + v
            factors[K] = f
            res = reduce(lambda x, y: x * (y + 1), f.values(), 1)
            results[K] = res
            return res
    factors[K] = {K: 1}
    return 2


total = 1
for k in range(2, N + 1):
    total += k * count_factors(k)

print(total)

Submission status: Time Limit Exceeded

Solution code:
n = int(input())
from operator import mul
from functools import reduce
def factorization(n):
    if n==1:
        return 1
    arr = []
    # arr2 = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append(cnt)
            # arr2.append(i)
    if temp!=1:
        arr.append(1)
        # arr2.append(temp)


    if arr==[]:
        arr.append(1)
        arr2.append(n)
    # if len(arr)>1:
    arr = [i+1 for i in arr]
    return reduce(mul, arr)*float(n)

ans = 0.0
for i in range(1,n+1):
    ans +=factorization(i)
print(int(ans))

Submission status: Time Limit Exceeded

Solution code:
def sieve_of_eratosthenes(n): #エラトステネスのふるい
    candidate = list(range(2, n+1)) #候補
    prime = []
    limit = n**0.5 + 1 #+1がないと平方数を素数にしてしまう

    while True:
        p = candidate[0]
        if limit <= p:
            prime.extend(candidate) #この時点での残っているのは素数
            break
        prime.append(p) #pを素数リストに登録

        candidate = [i for i in candidate if i % p != 0]

        # i = 0
        # while True:
            # if i >= len(candidate): #iはcandidateの長さ分
                # break
            # elif candidate[i] % p == 0: #余りがゼロなら
                # candidate.pop(i) #素数ではないのでpop(取り除く)する
            # i += 1

    return prime

def factorization(n,plist):
    arr = []
    temp = n
    for i in plist: #range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

#print(factorization(24)) #[[2, 3], [3, 1]]

N=int(input())
if N==1:
    print(1)
else:
    plist=sieve_of_eratosthenes(10000)
    sum=0
    for i in range(2,N+1):
        temp=1
        arr=factorization(i,plist)
        for j in range(len(arr)):
            temp*=arr[j][1]+1
        temp*=i
        sum+=temp
        #print(temp)
    print(1+sum)

Submission status: Time Limit Exceeded

Solution code:
import sys
sys.setrecursionlimit(10 ** 6)
n = int(input())

def factorization(n):
    arr = []
    ret = 1
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
            ret = ret * (cnt+1)

    if temp!=1:
        arr.append([temp, 1])
        ret = ret*2

    if arr==[]:
        arr.append([n, 1])
        ret = ret *2

    return ret


ans = 1
if n != 1:
    for i in range(2,n+1):
        ans += i * factorization(i)

print(ans)

Submission status: Time Limit Exceeded

Solution code:
N = int(input())
K = 1
total = 0

while K <= N :
  total += len([i for i in range(1,K+1) if K % i == 0]) * K
  K += 1

print(total)

Submission status: Time Limit Exceeded

Solution code:
N = int(input())
import numpy as np
a = np.array([0] * (N+1))
for i in range(1, N+1):
    a[::i] += 1
answer = 0
for i in range(1, N+1):
    answer += i * a[i]
print(answer)

Submission status: Time Limit Exceeded

Solution code:
def num_divisors_table(n):
    table=[0]*(n+1)

    for i in range(1,n+1):
        for j in range(i,n+1,i):
            table[j]+=1
    
    return table

N=int(input())
table=num_divisors_table(N)
ans=0
for K in range(1,N+1):
    ans+=K*table[K]
print(ans)

Submission status: Time Limit Exceeded

Solution code:
import numpy as np
n=int(input())
f=np.zeros(n+1,dtype=np.int64)
num=list(range(n+1))
num=np.array(num)
for i in range(1,n+1):
    f[i::i]+=1
ans=np.sum(f*num)
print(ans)

Submission status: Time Limit Exceeded

Solution code:
def factorization(n):
    def factor_sub(n, m):
        c = 0
        while n % m == 0:
            c += 1
            n /= m
        return c, n
    #
    buff = []
    c, m = factor_sub(n, 2)
    if c > 0: buff.append((2, c))
    c, m = factor_sub(m, 3)
    if c > 0: buff.append((3, c))
    x = 5
    while m >= x * x:
        c, m = factor_sub(m, x)
        if c > 0: buff.append((x, c))
        if x % 6 == 5:
            x += 2
        else:
            x += 4
    if m > 1: buff.append((m, 1))
    return buff

def divisor_num(n):
    a = 1
    for _, x in factorization(n):
        a *= x + 1
    return a

n = int(input())
ans = 0
for i in range(n):
  ans += (i+1)*divisor_num(i+1)
print(ans)

Submission status: Time Limit Exceeded

Solution code:
def SieveOfEratosthenes(n, prime, primesquare, a):
    # Create a boolean array "prime[0..n]"
    # and initialize all entries it as
    # true. A value in prime[i] will finally
    # be false if i is not a prime, else true.
    for i in range(2, n + 1):
        prime[i] = True

    # Create a boolean array "primesquare[0..n*n+1]"
    # and initialize all entries it as false.
    # A value in squareprime[i] will finally be
    # true if i is square of prime, else false.
    for i in range((n * n + 1) + 1):
        primesquare[i] = False

    # 1 is not a prime number
    prime[1] = False

    p = 2
    while (p * p <= n):
        # If prime[p] is not changed,
        # then it is a prime
        if (prime[p] == True):
            # Update all multiples of p
            i = p * 2
            while (i <= n):
                prime[i] = False
                i += p
        p += 1

    j = 0
    for p in range(2, n + 1):
        if (prime[p] == True):
            # Storing primes in an array
            a[j] = p

            # Update value in primesquare[p*p],
            # if p is prime.
            primesquare[p * p] = True
            j += 1


# Function to count divisors
def countDivisors(n):
    # If number is 1, then it will
    # have only 1 as a factor. So,
    # total factors will be 1.
    if (n == 1):
        return 1



    # ans will contain total
    # number of distinct divisors
    ans = 1

    # Loop for counting factors of n
    i = 0
    while (1):
        # a[i] is not less than cube root n
        if (a[i] * a[i] * a[i] > n):
            break

        # Calculating power of a[i] in n.
        cnt = 1  # cnt is power of
        # prime a[i] in n.
        while (n % a[i] == 0):  # if a[i] is a factor of n
            n = n / a[i]
            cnt = cnt + 1  # incrementing power

        # Calculating number of divisors
        # If n = a^p * b^q then total
        # divisors of n are (p+1)*(q+1)
        ans = ans * cnt
        i += 1

    # if a[i] is greater than
    # cube root of n

    n = int(n)
    # First case
    if (prime[n] == True):
        ans = ans * 2

    # Second case
    elif (primesquare[n] == True):
        ans = ans * 3

    # Third casse
    elif (n != 1):
        ans = ans * 4

    return ans  # Total divisors


# Driver Code
if __name__ == '__main__':
    n = int(input())
    ans = 0
    prime = [False] * (n + 2)
    primesquare = [False for i in range( n * n + 2)]

    # for storing primes upto n
    a = [0] * n

    # Calling SieveOfEratosthenes to
    # store prime factors of n and to
    # store square of prime factors of n
    SieveOfEratosthenes(n, prime, primesquare, a)
    for i in range(1,n+1):
        ans += i*countDivisors(i)
    print(ans)

Submission status: Time Limit Exceeded

Solution code:
import scipy
import math

N = int(input())

def main(N):
  yakusu =[]
  for i in range(1,math.floor(math.sqrt(N+1))+1):
    if N % i ==0:
      yakusu.append(i)
      yakusu.append(int(N/i))
  return len(set(yakusu))
#print(main(10))

price =0
for j in range(1,N+1):
  #print(main(j))
  price += j *main(j)
  #print(price)import scipy


print(price)

Submission status: Time Limit Exceeded

Solution code:
N = int(input())
dp = [0]*(N+1)

for i in range(1, N+1):
    j = 1
    while i * j <= N:
        dp[i*j] += 1
        j += 1

ans = 0
for k in range(1, N+1):
    ans += k * dp[k]

print(ans)

Submission status: Time Limit Exceeded

Solution code:
def count(num):
    ans = 1
    x = 2
    while x * x <= num:
        cnt = 1
        while num % x == 0:
            cnt += 1
            num /= x
        ans *= cnt
        x += 1
    return ans * (1 + (num > 1))

n = int(input())
res = 0
for i in range(1, n+1):
    res += i * count(i)

print(res)

Submission status: Time Limit Exceeded

Solution code:
n=int(input())
res=0
for i in range(1,n+1):
  for j in range(i,n+1,i):
    res+=j
print(res)

Submission status: Time Limit Exceeded

Solution code:
mod=10**9+7
import math
import sys
def mi() : return map(int,sys.stdin.readline().split())
def ii() : return int(sys.stdin.readline().rstrip())
def i() : return sys.stdin.readline().rstrip()
def make_prime_list_2(num):
    prime_list = [i for i in range(num + 1)]
    prime_list[1] = 0 
    num_sqrt = math.sqrt(num)

    for prime in prime_list:
        if prime == 0:
            continue
        if prime > num_sqrt:
            break

        for non_prime in range(2 * prime, num, prime):
            prime_list[non_prime] = 0

    return [prime for prime in prime_list if prime != 0]
l=make_prime_list_2(int(math.sqrt(10**7))+1)
a=ii()
ans=0
ll=[2]*(a+1)
ll[1]=1
if a==1:
  print(1)
  sys.exit()
for s in range(2,a+1):
  j=s
  ans=0
  c=0
  for k in l:
    if s==k:
      ll[k]=2
      s=1
      break
    elif s%k==0:
      while s%k==0:
        s=s//k
        c+=1
      ll[j]=ll[s]*(c+1)
      break
for i in range(2,a+1):
  ans+=i*ll[i]
print(ans+1)

Submission status: Time Limit Exceeded

Solution code:
import math
import collections
def main():

    N = int(input())
    d = collections.defaultdict(int)

    ans = 0
    for i in range(1, int(math.sqrt(N))+1):
        p = i
        while p <= N:
            d[p] += 1
            if p // i > int(math.sqrt(N)):
                d[p] += 1
            p += i

    for i in range(1, N+1):
        ans += i * d[i]

    return ans

if __name__ == '__main__':
    print(main())

Submission status: Time Limit Exceeded

Solution code:
N = int(input())

import sys
sys.setrecursionlimit(1000)

def make_divisors(n):
    divisors = 0
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors += 1
            if i != n // i:
                divisors += 1
    return divisors*n/1000
  
ans= 0
for i in range(1,N+1):
  ans += make_divisors(i)
print(int(1000*ans))

Submission status: Time Limit Exceeded

Solution code:
import math 
def num_divisors_table(n):
  maxnum=math.floor((n + 1)/2) 
  length=n-maxnum
  aftersum=int(maxnum*length+length*(length+1)/2)
  aftersum+=(1+n)*n/2
  if n>=2:
    if n%2==0:
      aftersum+=(1+n/2)*n/2
    else:
      aftersum+=(1+(n-1)/2)*(n-1)/2

  for i in range(3, maxnum+1):
    for j in range(i, n+1, i):
      aftersum += j
  return aftersum

N=int(input())
print(int(num_divisors_table(N)))

Submission status: Time Limit Exceeded

Solution code:

from collections import Counter
N = int(input())
X = [i for i in range(1,N+1)]

counts = []
for i in range(N):
    x = X[i]
    d = 2
    tmp = []
    while d**2<=x:
        if x%d==0:
            tmp.append(d)
            x //= d
        else:
            d += 1
    if x != 1:
        tmp.append(x)
    counts.append(Counter(tmp))

memo = []
for i in range(1,N+1):
    tmp = 1
    for v in counts[i-1].values():
        tmp *= (v+1)
    memo.append(i*tmp)

print(sum(memo))

Submission status: Time Limit Exceeded

Solution code:
n = int(input())

def num_divisors_table(n):
    table = [0] * (n + 1)
    
    for i in range(1, n + 1):
        for j in range(i, n + 1, i):
            table[j] += 1
    
    return table

a = num_divisors_table(n)
b = 0
for i in range(1, n+1):
    b += i * a[i]
print(b)

Submission status: Time Limit Exceeded

Solution code:
def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return len(lower_divisors) + len(upper_divisors[::-1])

N = int(input())
ans = 0
for i in range(1,N+1):
  ans += i * make_divisors(i)
  #print(make_divisors(i))
print(ans)

Submission status: Time Limit Exceeded

Solution code:
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline 
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_list(N): return [s_list() for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

def len_make_divisors(n: int) -> list:
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    return len(divisors)

def main():
    n = i_input()

    count = 0

    for i in range(1, n+1):
        count += i * len_make_divisors(i)

    print(count)

if __name__ == '__main__':
    main()

Submission status: Time Limit Exceeded

Solution code:
n = int(input())

def factorization(n):
    arr = []
    ret = 1
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
            ret = ret * (cnt+1)

    if temp!=1:
        arr.append([temp, 1])
        ret = ret*2

    if arr==[]:
        arr.append([n, 1])
        ret = ret *2

    return ret


ans = 1
if n != 1:
    for i in range(2,n+1):
        ans += i * factorization(i)

print(ans)

Submission status: Time Limit Exceeded

Solution code:
import numpy as np
n = int(input())
A = [int(i) for i in range(1, n+1)]
dp = [[] for _ in range(A[-1]+1)]
f = np.array([True for _ in range(A[-1]+1)])
A = np.array(A)
prev = 0
ans = 1
for a in A[1:]:
  if f[a]:
    if prev == a:
      f[a] = False
    for i in range(A[-1]//a+1):
      if i >= 1:
        cnt = 1
        tmp = i
        while tmp % a == 0:
          cnt += 1
          tmp = tmp // a
        dp[i*a].append(cnt)
        f[i*a] = False
  prev = a
  t = 1
  for d in dp[a]:
    t = t * (d+1)
  ans += a * t
print(ans)

Submission status: Time Limit Exceeded

Solution code:
n= int(input())
a=[-1]*10000010
a[0]=0
a[1]=1
a[2]=2
a[3]=2
a[4]=3
for i in range(5,n+10):
    ans=2
    for j in range(2,int(i**0.5)+1):
        if i % j ==0:
            ans+=2
    if i==int(i**0.5) **2:
        ans=ans-1
    a[i]=ans

sum=0
for i in range(1,n+1):
    sum+= i*a[i]
print(sum)

Submission status: Time Limit Exceeded

Solution code:
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()

def divisors(n):
    S, T = [], []
    i = 1
    while i * i <= n:
        if n % i == 0:
            S.append(i)
            T.append(n // i)
        i += 1
    T.reverse()
    return S + T if S[-1] != T[0] else S + T[1:]

def resolve():
    n = int(input())
    print(sum(k * len(divisors(k)) for k in range(1, n + 1)))
resolve()

Submission status: Time Limit Exceeded

Solution code:
p = 10**7+10
K = int(p**0.5)
P = [1 for _ in range(K)]
P[0]=0
P[1]=0
for i in range(2,int(K**0.5)+1):
    for j in range(i*i,K,i):
        P[j]=0
Q = []
for i in range(2,K):
    if P[i]==1:
        Q.append(i)
def f(x):
    if x==1:
        return 1
    C = {}
    for q in Q:
        k = 0
        while x%q==0:
            x = x//q
            k += 1
        if k>0:
            C[q]=k
        if x==1:break
    if x>1:
        C[x] = 1
    res = 1
    for y in C:
        res = res*(C[y]+1)
    return res
N = int(input())
tot = 0
for i in range(1,N+1):
    tot += i*f(i)
print(tot)

Submission status: Time Limit Exceeded

Solution code:
import sys
input=sys.stdin.readline
#sys.setrecursionlimit(10**6)
from numba import jit

@jit(nopython=True)
def Ed(num):
    cnt=0
    for i in range(1,int(num**0.5)+1):
        if num%i==0:
            cnt+=1
            if num//i!=i:
                cnt+=1
    #ret.sort()
    return cnt


def main():
    n=int(input().rstrip())
    ans=0
    for i in range(1,n+1):
        ans+=i*Ed(i)
    print(ans)

if __name__=="__main__":main()

Submission status: Time Limit Exceeded

Solution code:
def make_divisors(n):
        lower_divisors , upper_divisors = [], []
        i = 1
        while i*i <= n:
                if n % i == 0:
                        lower_divisors.append(i)
                        if i != n // i:
                                upper_divisors.append(n//i)
                i += 1
        return lower_divisors + upper_divisors[::-1]

def count_div(n):
        return int(len(make_divisors(n)))

def main():
        N = int(input())
        ans = 0

        for i in range(N):
                ans+=(i+1)*count_div(i+1)

        return ans

if __name__=="__main__":
        ans = main()
        print(ans)

Submission status: Time Limit Exceeded

Solution code:
N = int(input())
S = 0

for j in range(1,N+1):
  divisors = 0
  for i in range(1, int(j**0.5)+1):
    if j % i == 0:
      divisors += 1
      if i != j // i:
        divisors += 1
  a = divisors
  S += a*j
print(S)

Submission status: Time Limit Exceeded

Solution code:
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors


N = int(input())
A = 0

for k in range(N):
    A += (k+1)*len(make_divisors(k+1))
print(A)