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: Accepted

Solution code:
# import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
# import heapq
# from collections import deque
# import sympy

N = int(input())
# S = input()
# n, *a = map(int, open(0))
# N, M = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()

# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)

# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)

# def dfs(tree, s):
#     for l in tree[s]:
#         if depth[l[0]] == -1:
#             depth[l[0]] = depth[s] + l[1]
#             dfs(tree, l[0])
# dfs(tree, 1)

# def factorization(n):
#     arr = []
#     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])
#     if temp!=1:
#         arr.append([temp, 1])
#     if arr==[]:
#         arr.append([n, 1])
#     return arr

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n = inp()
res = [0]*(n+1)
for i in range(1,n+1):
    for j in range(1,n+1):
        if i*j > n: break
        res[i*j] += 1
print(sum(i*x for i,x in enumerate(res)))

Submission status: Accepted

Solution code:
import sys
def I(): return int(sys.stdin.readline().rstrip())


N = I()
print(sum((i*(N//i)*(N//i+1)//2) for i in range(1,N+1)))

Submission status: Accepted

Solution code:
N = int(input())
memo = [1]*(N+1)
for i in range(2,N+1):
    tmp = i
    while tmp <= N:
        memo[tmp] += 1
        tmp += i
ans = 0
for key,val in enumerate(memo):
    ans += key*val
print(ans)

Submission status: Accepted

Solution code:
n = int(input())

ans = 0
for i in range(1, n + 1):
    m = n // i
    ans += (m + 1) * m // 2 * i
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  #空白あり
def LS2(): return list(sys.stdin.readline().rstrip())  #空白なし


N = I()
print(sum((i*(N//i)*(N//i+1)//2) for i in range(1,N+1)))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n=int(input())
print(sum(i*(n//i*(n//i+1))//2 for i in range(1,n+1)))

Submission status: Accepted

Solution code:
n=int(input())

bp = [0] * (n+10)
for i in range(2, n+10):
    if bp[i] == 0:
        bp[i] = i
        for j in range(i*i, n+1, i):
            if bp[j]==0:
                bp[j] = i

def fact(n):
    ret=1
    while n>1:
        now=n
        cnt=0
        p=bp[now]
        while now % p == 0:
            now//=p
            cnt+=1
        ret*=cnt+1
        n=now
    return ret

ans=0
for i in range(1,n+1):
    ans += i*fact(i)

print(ans)

Submission status: Accepted

Solution code:
n=int(input())

bp = [0] * (n+10)
for i in range(2, n+10):
    if bp[i] == 0:
        bp[i] = i
        for j in range(i*i, n+1, i):
            bp[j] = i


def fact(n):
    ret=1
    while n>1:
        now=n
        cnt=0
        p=bp[now]
        while now % p == 0:
            now//=p
            cnt+=1
        ret*=cnt+1
        n=now
    return ret
ans=0
for i in range(1,n+1):
    ans += i*fact(i)

print(ans)

Submission status: Accepted

Solution code:
n=int(input())

bp = [0] * (n+10)
for i in range(2, n+10):
    if bp[i] == 0:
        bp[i] = i
        for j in range(i*i, n+1, i):
            if bp[j]==0:
                bp[j] = i


def f(k):
    if k==1:
        return 1
    z=[]
    p=bp[k]
    cnt=1
    ans=1

    while k>=2:
        k//=p
        if p==bp[k]:
            cnt+=1
        else:
#            print(" ",k,p)
            ans*=cnt+1
            cnt=1
            p=bp[k]

    return ans

ans=0
for i in range(1,n+1):
    #print(i,f(i))
    ans += i*f(i)

print(ans)

Submission status: Accepted

Solution code:
n=int(input())

x=[-1]*(10**7+5)
x[0]=0
x[1]=1
i=2
prime=[]
while i<=10**7+1:

    if x[i]==-1:
        x[i]=i
        prime.append(i)

    for j in prime:
        if i*j>10**7+1 or j>x[i]:break
        x[j*i]=j
    i+=1



def f(k):
    if k==1:
        return 1

    z=[]
    p=x[k]
    m=1
    ans=1
    while k>=2:
        k=k//p
        if p==x[k]:
            m+=1
        else:
            z.append(m)
            m=1
            p=x[k]

    for i in range(len(z)):
        ans*=z[i]+1
    return ans
ans=0
for i in range(1,n+1):
    #print(i,f(i))
    ans += i*f(i)

print(ans)

Submission status: Accepted

Solution code:
n = int(input())
ans = 0
for i in range(1,n+1):
    ans += ((i+i*(n//i))*(n//i))//2
    #print(ans)
print(ans)

Submission status: Accepted

Solution code:
N = int(input())

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

Submission status: Accepted

Solution code:
import math , sys

N = int(input())
Ns = int(math.sqrt(N))+1
if N == 1:
    print(1)
    sys.exit()
if N == 2:
    print(5)
    sys.exit()
if N == 3:
    print(11)
    sys.exit()
if N == 4:
    print(23)
    sys.exit()
if N == 5:
    print(33)
    sys.exit()  

ans = [ 2 for _ in range(N+1)]
ans[0]=0
ans[1]=1
for i in range(2,Ns):
    num=i
    while num < N+1:
        if math.sqrt(num)<i:
            flag=True
        elif num == i**2:
            ans[num]+=1
        else:
            ans[num]+=2
        num+=i
tot = 0
for i in range(N+1):
    tot+=i*ans[i]
print(tot)

Submission status: Accepted

Solution code:
n = int(input())

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

Submission status: Accepted

Solution code:
N=int(input())
res=0
for i in range(1,N+1):
    n=N//i
    res+=(n*(n+1)*i)//2
print(res)

Submission status: Accepted

Solution code:
N = int(input())

ans = 0

for i in range(1, N + 1):
  ans += i * (1 + N // i) * (N // i) // 2
  
print(ans)

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    n = int(input())
    ans = 0
    for i in range(1, n+1):
        ans += i*(1 + n//i)*(n//i)//2
    print(ans)



if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
def g(k):
    gans = k*(k+1)/2
    return gans
N = int(input())
ans = 0
for i in range(1,N+1):
    ans += i*g(N//i)
    # print(ans)
 
print(int(ans))

Submission status: Accepted

Solution code:
N = int(input())

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

Submission status: Accepted

Solution code:
N= int(input())
ans = 0
for j in range(1,N+1):
  N_j = N//j
  ans += j*(1+N_j)*N_j//2
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

#n = int(input())
#l = list(map(int, input().split()))

'''
a=[]
b=[]
for i in range():
    A, B = map(int, input().split())
    a.append(A)   
    b.append(B)'''


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

Submission status: Accepted

Solution code:
# compiled by pythran
"""
#pythran export main2()
import numpy as np
i4 = np.int32
i8 = np.int64

def nmul(i, j):
    count = 2
    while j % i == 0:
        j //= i
        count += 1
    return count


def main(in_file):
    stdin = open(in_file)
    N = int(stdin.readline())

    a = np.ones(N + 1, i8)
    for i in range(2, N + 1):
        if a[i] == 1:
            j = 1
            while i * j <= N:
                a[i * j] *= nmul(i, j)
                j += 1

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

def main2():
    main('/dev/stdin')
"""
import os, sys
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
if len(sys.argv) == 1:
    import subprocess
    if p == "":
        pymain = "./" + pymain
    subprocess.call(pymain)
else:
    import gzip, base64, stat
    gz = b'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'
    bin = gzip.decompress(base64.b64decode(gz))
    with open(pymain, "wb") as f:
        f.write(bin)
    os.chmod(pymain, 0o775)

Submission status: Accepted

Solution code:
n = int(input())

i = 1
ans = 0
while (i <= n):
    total = sum(j for j in range(i, n+1, i))
    ans += total
    i += 1
print(ans)

Submission status: Accepted

Solution code:
import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array

# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
INF = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = ii()
    ans = 0
    for x in range(1, N + 1):
        n = N // x  # Nのうちにxがいくつ含まれるか（等差数列の項数）
        ans += (n * (2 * x + (n - 1) * x)) // 2  # 初項と公差がxでn項の等差数列の和
    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())

ans = 0
for j in range(1, n+1):
    y = n // j
    ans += y * (2 * j + (y - 1) * j) // 2

print(ans)

Submission status: Accepted

Solution code:
def resolve():
    N = int(input())
    ans = 0
    for i in range(1, N+1):
        n = N//i
        ans += (n*(n+1)*i)//2
    print(ans)


if '__main__' == __name__:
    resolve()

Submission status: Accepted

Solution code:

def resolve():
    N = int(input())
    ans = 0
    counts = [1 for _ in range(N+1)]
    for i in range(2, N+1):
        j = 1
        while i*j <= N:
            counts[i*j] += 1
            j += 1

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


if '__main__' == __name__:
    resolve()

Submission status: Accepted

Solution code:
import math
import sys
import os
from operator import mul
import numpy as np
# import sympy

sys.setrecursionlimit(10**7)

def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))

if os.getenv("LOCAL"):
    inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
    sys.stdin = open(inputFile, "r")
INF = float("inf")

N = I()
ans = 0

# 足し方の見方を変える。等差数列の和をKまで足す
# 1 + 2 + 3 + 4 +...
#   + 2     + 4 +...
for i in range(1,N+1):
    # Nを超えない整数
    y = N//i
    sum = y*(y+1)*i/2
    ans += sum

print(int(ans))





# 素数 エラトステネス
def seachPrimeNum(N):
   max = int(np.sqrt(N))
   seachList = [i for i in range(2,N+1)]
   primeNum = []
   while seachList[0] <= max:
       primeNum.append(seachList[0])
       tmp = seachList[0]
       seachList = [i for i in seachList if i % tmp != 0]
   primeNum.extend(seachList)
   return primeNum

# 約数
def divisor_count(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

Submission status: Accepted

Solution code:
n = int(input())

ans = 0
for i in range(1, n + 1):
  for j in range(1, n//i + 1):
    if i * j <= n:
      ans += i * j
    else:
      break
      
print(ans)

Submission status: Accepted

Solution code:
n=int(input())
x=[-1]*(10**7+5)
x[0]=0
x[1]=1
i=2

x=[-1]*(10**7+5) #2以上の自然数に対して最小の素因数を表す
x[0]=0
x[1]=1
i=2
prime=[]
while i<=10**7+1:

    if x[i]==-1:
        x[i]=i
        prime.append(i)

    for j in prime:
        if i*j>10**7+1 or j>x[i]:break
        x[j*i]=j
    i+=1

def f(k):
    if k==1:
        return 1

    z=[]
    p=x[k]
    m=1
    ans=1
    while k>=2:
        k=k//p
        if p==x[k]:
            m+=1
        else:
            z.append(m)
            m=1
            p=x[k]

    for i in range(len(z)):
        ans*=z[i]+1
    return ans
s=0
for i in range(1,n+1):
    s+=i*f(i)
print(s)

Submission status: Accepted

Solution code:
N = int(input())

f = [0] * (N+1)

for i in range(1, N+1):
    cnt = i
    while cnt <= N:
        f[cnt] += 1
        cnt += i

ans = 0

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

print(ans)

Submission status: Accepted

Solution code:
n=int(input())
ans=0
for i in range(n):
    
    m=n//(i+1)
    
    ans += (i+1) *m*(m+1)/2
    
print(int(ans))

Submission status: Accepted

Solution code:
N = int(input())
sum_ = lambda n:(n*(n+1))//2
ret = sum(d*sum_(N//d) for d in range(1,N+1))
# print([d*sum_(N//d) for d in range(1,N+1)])
print(ret)

Submission status: Accepted

Solution code:
def g(x, n): #g(x, n): xの倍数(< n)の和
  y = n // x
  return x * y * (y + 1) // 2

n = int(input())

sum = 0
for i in range(1, n + 1):
  k = n // i
  sum += g(i, n)
  
print(sum)