input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(10000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in input().split()]
# --------------------------------------------
dp = None
def main():
N, M = li_input()
A = li_input()
ans = 0
cumsum = [0]
c_sum = 0
for a in A:
c_sum += a
cumsum.append(c_sum)
for r in range(1, len(cumsum)):
for l in range(r):
if (cumsum[r] - cumsum[l]) % M == 0:
ans += 1
print(ans)
main()
| import sys
import math
import collections
import itertools
import array
import inspect
# Set max recursion limit
sys.setrecursionlimit(10000)
# Debug output
def chkprint(*args):
names = {
id(v): k
for k, v in list(inspect.currentframe().f_back.f_locals.items())
}
print((', '.join(
names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args)))
# Binary converter
def to_bin(x):
return bin(x)[2:]
def li_input():
return [int(_) for _ in input().split()]
# --------------------------------------------
dp = None
def main():
N, M = li_input()
A = li_input()
ans = 0
d = collections.defaultdict(lambda: 0)
cumsum = [0]
c_sum = 0
for a in A:
c_sum = (c_sum + a) % M
cumsum.append(c_sum)
for c in cumsum:
d[c] += 1
for v in list(d.values()):
if v >= 2:
ans += v * (v - 1) // 2
print(ans)
main()
| p03287 |
import math
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
s = []
k = 0
for i in range(0,n):
k += a[i]
s.append(k)
for i in range(0,n):
s[i] = s[i]%m
d = [0]
ass = 0
w = s.count(0)
ass += w*(w+1)//2
for i in range(0,n):
if s[i] not in d:
d.append(s[i])
w = s.count(s[i])
if w != 1:
ass += w*(w-1)//2
print(ass) | import bisect
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
s = []
k = 0
for i in range(0,n):
k += a[i]
s.append(k%m)
ass = 0
w = s.count(0)
ass += w*(w+1)//2
s.sort()
hj = w
while hj <= n-1:
jkl = bisect.bisect_right(s,s[hj])
w = jkl - hj
if w != 1:
ass += w*(w-1)//2
hj = jkl
print(ass) | p03287 |
import collections
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
# 普通の累積和
cumsum = [0]
for i in range(N):
cumsum.append(cumsum[-1] + A[i])
# 上で作った累積和のmodMを計算
cumsum_2 = []
for i in range(N + 1):
cumsum_2.append(cumsum[i] % M)
c = collections.Counter(cumsum_2)
ans = 0
for v in list(c.values()):
ans += v * (v - 1) // 2
print(ans)
| import collections
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
# 普通の累積和
cumsum = [0]
for i in range(N):
cumsum.append(cumsum[-1] + A[i])
# 上で作った累積和のmodMを計算
cumsum_mod = []
for i in range(N + 1):
cumsum_mod.append(cumsum[i] % M)
c = collections.Counter(cumsum_mod)
ans = 0
for v in list(c.values()):
ans += v * (v - 1) // 2
print(ans)
| p03287 |
def candy_distribution(N: int, M: int, A: list)->int:
S = [0] * (N+1)
for i, a in enumerate(A):
S[i+1] = S[i] + a
count = 0
for l in range(1, N+1):
for r in range(l, N+1):
if (S[r] - S[l-1]) % M == 0:
# print('S({}, {}) = {}'.format(l, r, S[r] - S[l-1]))
count += 1
return count
if __name__ == "__main__":
N, M = list(map(int, input().split()))
A = [int(s) for s in input().split()]
ans = candy_distribution(N, M, A)
print(ans)
| def candy_distribution(N: int, M: int, A: list)->int:
S = 0
remainders = {}
remainders[0] = 1
for a in A:
S = (S + a) % M
if S not in remainders:
remainders[S] = 0
remainders[S] += 1
count = sum(r*(r-1)//2 for r in list(remainders.values()))
# for l in range(1, N+1):
# for r in range(l, N+1):
# if (S[r] - S[l-1]) % M == 0:
# # print('S({}, {}) = {}'.format(l, r, S[r] - S[l-1]))
# count += 1
return count
if __name__ == "__main__":
N, M = list(map(int, input().split()))
A = [int(s) for s in input().split()]
ans = candy_distribution(N, M, A)
print(ans)
| p03287 |
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(n):
A[i]=A[i]%m
B=[]
for i in range(n):
sumi=A[i]
ri=i+1
while ri<n and sumi%m!=0 :
sumi=(sumi+A[ri])%m
ri+=1
if ri==n and sumi%m!=0 :
ri=-1
B.append(ri)
#print(B)
mco=0
for i in range(n):
coi=0
ms=0
s=i
while s!=n and s!=-1 :
ms=s
s=B[s]
B[ms]=-1
coi+=1
#print("s"+str(s))
if s==-1 :
coi-=1
#print(coi)
mco+=coi*(coi+1)//2
print(mco)
| n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
B=[]
su=0
for i in range(n):
su+=A[i]
B.append(su)
#print(B)
C={}
C[0]=1
for i in range(n):
C[B[i]%m]=C.get(B[i]%m,0)+1
#print(C)
#D=C.values()
su=0
#print(C.values())
for i in list(C.values()):
su+=i*(i-1)//2
print(su)
| p03287 |
#list_int 並べて出力 print (' '.join(map(str,ans_li)))
#list_str 並べて出力 print (' '.join(list))
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
AtoZ = [chr(i) for i in range(65,65+26)]
atoz = [chr(i) for i in range(97,97+26)]
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())
N,M = inpl()
aa = inpl()
ans = 0
ed = [0]
SUM_L = defaultdict(int)
SUM_R = defaultdict(int)
SUM_L[0] += 1
SUM_R[0] += 1
SUM = sum(aa) % M
tmpL = tmpR = 0
for i in range(N):
tmpL += aa[i]
tmpL %= M
if SUM_L[tmpL] == 0:
ed.append(tmpL)
SUM_L[tmpL] += 1
tmpR += aa[N-i-1]
tmpR %= M
SUM_R[tmpR] += 1
ans = 0
for l in ed:
numL = SUM_L[l]
r = (SUM - l) % M
numR = SUM_R[r]
ans += numL * (numR-1)
print((ans//2))
| from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
AtoZ = [chr(i) for i in range(65,65+26)]
atoz = [chr(i) for i in range(97,97+26)]
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())
N,M = inpl()
aa = inpl()
ans = 0
modSUM = defaultdict(int)
tmp = 0
modSUM[0] += 1
for a in aa:
tmp += a
tmp %= M
ans += modSUM[tmp]
modSUM[tmp] += 1
print(ans)
| p03287 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, A):
sa = [0] + list(accumulate(A))
sam = [a % M for a in sa]
ans = 0
for n in Counter(sam).values():
ans += n*(n-1)//2
return ans
def main():
N, M = read_int_n()
A = read_int_n()
print(slv(N, M, A))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, A):
return reduce(lambda x, y: x + y*(y-1)//2, Counter(accumulate([0]+A, lambda x, y: (x+y) % M)).values(), 0)
def main():
N, M = read_int_n()
A = read_int_n()
print(slv(N, M, A))
if __name__ == '__main__':
main()
| p03287 |
n, m = list(map(int, input().split()))
aa = [int(ak) % m for ak in input().split()]
mod = {}
ans = 0
zi = 0
for a in aa:
zi = (zi - a) % m
ai = (zi + a) % m
mod.setdefault(ai,0)
mod[ai] += 1
ans += mod.get(zi,0)
print(ans)
| def f(n, m):
aa = [int(ak) % m for ak in input().split()]
mod = {}
ans = 0
zi = 0
for a in aa:
zi = (zi - a) % m
ai = (zi + a) % m
mod.setdefault(ai, 0)
mod[ai] += 1
ans += mod.get(zi, 0)
print(ans)
n, m = list(map(int, input().split()))
f(n, m)
| p03287 |
def f(n, m):
aa = [int(ak) % m for ak in input().split()]
mod = {}
ans = 0
zi = 0
for a in aa:
zi = (zi - a) % m
ai = (zi + a) % m
mod.setdefault(ai, 0)
mod[ai] += 1
ans += mod.get(zi, 0)
print(ans)
n, m = list(map(int, input().split()))
f(n, m)
| def f(m):
aa = [int(ak) % m for ak in input().split()]
mod = {}
ans = 0
zi = 0
for a in aa:
mod.setdefault(zi, 0)
mod[zi] += 1
zi = (zi - a) % m
ans += mod.get(zi, 0)
print(ans)
_, m = list(map(int, input().split()))
f(m)
| p03287 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = [0] + [sum(A[:i+1]) % M for i in range(N)]
B.sort()
ans = 0
k = 1
C = []
for i in range(N):
if B[i] == B[i + 1]:
k += 1
else:
C.append(k)
k = 1
C.append(k)
for k in C:
if k > 1:
ans += k * (k - 1) // 2
print(ans) | N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = [0]
b = 0
for i in range(N):
b += A[i]
B.append(b % M)
B.sort()
ans = 0
k = 1
C = []
for i in range(N):
if B[i] == B[i + 1]:
k += 1
else:
C.append(k)
k = 1
C.append(k)
for k in C:
if k > 1:
ans += k * (k - 1) // 2
print(ans) | p03287 |
def inpl(): return [int(i) for i in input().split()]
def solve(n,S):
Ctr = set([])
for i in range(n+1):
Ctr = Ctr | set([S[i]])
Ans = {}
for i in range(n+1):
Ans[S[i]] = 0
for i in range(n+1):
Ans[S[i]] += 1
ans = 0
for i in Ctr:
ans += Ans[i] * (Ans[i] - 1) // 2
return(ans)
N,M = inpl()
H = inpl()
SumH = [0]
for i in range(N):
SumH.append((SumH[-1] + H[i]) % M)
print((solve(N,SumH))) | def inpl(): return [int(i) for i in input().split()]
N,M = inpl()
H = {0: 1}
k = 0
ans = 0
for i in inpl():
k += i
t = k % M
if t not in H:
H[t] = 0
H[t] += 1
for i in list(H.values()):
ans += i * (i - 1) // 2
print(ans) | p03287 |
class Combination:
def __init__(self, size):
self.size = size + 2
self.fact = [1, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] // self.fact[r] // self.fact[n - r]
from collections import defaultdict
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [a % M for a in A]
accA = [0] * (N + 1)
for i, a in enumerate(A, start=1):
accA[i] = accA[i - 1] + a
cnt = defaultdict(int)
for a in accA:
cnt[a % M] += 1
comb = Combination(N + 100)
ans = 0
for c in list(cnt.values()):
ans += comb.ncr(c, 2)
print(ans) | from collections import defaultdict
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [a % M for a in A]
accA = [0] * (N + 1)
for i, a in enumerate(A, start=1):
accA[i] = accA[i - 1] + a
cnt = defaultdict(int)
for a in accA:
cnt[a % M] += 1
def ncr(n, r):
if n < 0 or r < 0 or n < r:
return 0
ret = 1
for i in range(n, n - r, -1):
ret *= i
for i in range(1, r + 1):
ret //= i
return ret
ans = 0
for c in list(cnt.values()):
ans += ncr(c, 2)
print(ans) | p03287 |
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
n, k = LI()
if n % k:
print((1))
else:
print((0))
return
#B
def B():
n = II()
dp = [0] * (100 + 1)
dp[4] = 1
dp[7] = 1
for i in range(8,n + 1):
if dp[i - 4] or dp[i - 7]:
dp[i] = 1
print((["No", "Yes"][dp[n]]))
return
#C
def C():
n = II()
ans = []
if n == 0:
print((0))
while n:
ans.append("{}".format(n % 2))
n = (n-1) // -2
print(("".join(ans[::-1])))
return
#D
def D():
n, m = LI()
a = LI()
a = list([x % m for x in a])
a = [0] + a
d = defaultdict(int)
ans = 0
for i in range(1, n + 1):
a[i] += a[i - 1]
a[i] %= m
d[a[i]] += 1
d[0] += 1
for value in list(d.values()):
ans += value * (value - 1) // 2
print(ans)
return
#Solve
if __name__ == '__main__':
D()
| #!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys, math, bisect, random, itertools
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
n, m = LI()
a = LI()
for i in range(n-1):
a[i + 1] += a[i]
a = [i % m for i in a]
d = defaultdict(int)
for i in range(n):
d[a[i]] += 1
ans = d[0]
for i in list(d.values()):
ans += i * (i-1) // 2
print(ans)
return
#B
def B():
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == '__main__':
A() | p03287 |
from collections import defaultdict
N, M = list(map(int, input().split()))
A = [int(x) for x in input().split()]
B = [0] * N
B[0] = A[0]
for i in range(1, N):
B[i] = B[i - 1] + A[i]
B = [0] + B
c = defaultdict(int)
for i in range(N + 1):
c[B[i] % M] += 1
ans = 0
for k, v in list(c.items()):
if v >= 2:
ans += v * (v - 1) // 2
print(ans) | from collections import Counter
from itertools import accumulate
N, M = list(map(int, input().split()))
A = [int(x) for x in input().split()]
c = Counter([0] + [x % M for x in accumulate(A)])
ans = 0
for k, v in list(c.items()):
if v >= 2:
ans += v * (v - 1) // 2
print(ans) | p03287 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
acs = [0] * (n + 1)
for i in range(1, n + 1):
acs[i] = (acs[i - 1] + a[i - 1]) % m
cnt = 0
for l in range(n):
for r in range(l, n):
if acs[r] == acs[l - 1]:
cnt += 1
print(cnt) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
table = {0: 0}
buf = 0
cnt = 0
for i in range(n):
buf = (buf + a[i]) % m
if buf in table:
cnt += table[buf]
table[buf] += 1
else:
table[buf] = 1
print((cnt + table[0])) | p03287 |
import sys
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
A_sum = [0]
for a in A:
A_sum.append((A_sum[-1] + a) % m)
D = defaultdict(int)
res = 0
for i in range(n + 1):
res += D.get(A_sum[i], 0)
D[A_sum[i]] += 1
print(res)
if __name__ == '__main__':
resolve()
| import sys
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
A_sum = [0]
D = defaultdict(int)
D[A_sum[-1]] += 1
for a in A:
A_sum.append((A_sum[-1] + a) % m)
D[A_sum[-1]] += 1
res = 0
for v in list(D.values()):
res += v * (v - 1) // 2
print(res)
if __name__ == '__main__':
resolve()
| p03287 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
R = [A[0]%M]
for i in range(1,N):
R.append((R[-1]+A[i])%M)
import collections
c = collections.Counter(R)
ans = 0
for key in c:
if key == 0:
ans += (c[key]*(c[key]+1))/2
else:
ans += (c[key]*(c[key]-1))/2
print((int(ans)))
| N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
R = [A[0]%M]
for i in range(1,N):
R.append((R[-1]+A[i])%M)
k = set(R)
dic = {i:0 for i in k}
for item in R:
dic[item]+=1
ans = 0
if 0 in dic:
ans = (dic[0]*(dic[0]+1))/2
for i in k:
if i !=0 :
ans += (dic[i]*(dic[i]-1))/2
print((int(ans)))
| p03287 |
from math import factorial
from math import sqrt
from math import ceil
from itertools import permutations
from heapq import *
from collections import defaultdict
from copy import deepcopy
from math import log
N,M=list(map(int,input().split()))
def nCr(n,r):
a=factorial(n)
b=factorial(n-r)
c=factorial(r)
return int(a//(b*c))
A=[int(i)%M for i in input().split()]
L=[0]
dic=defaultdict(int)
dic[0]+=1
for i in range(N):
a=(L[-1]+A[i])%M
L.append(a)
dic[a]+=1
sum=0
for i in list(dic.keys()):
if dic[i]>=2:
sum+=nCr(dic[i],2)
print(sum)
| from collections import defaultdict
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
B=[0]*(N+1)
C=defaultdict(int)
C[0]+=1
for i in range(N):
B[i+1]=(B[i]+A[i])%M
C[B[i+1]]+=1
ans=0
for i in list(C.values()):
ans+=i*(i-1)//2
print(ans)
| p03287 |
n, m = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
t = 0
s = [0 for _ in range(n+1)]
for i in range(n):
s[i+1] = (a[i] + t) % m
t += a[i] % m
counter = 0
for i in range(0, n+1):
for j in range(i+1, n+1):
if s[i] == s[j]:
counter += 1
print(counter) | def main():
n, m = [int(_) for _ in input().split()]
A = [int(_) for _ in input().split()]
ans = 0
d = {}
cumsum = [0]
c_sum = 0
for a in A:
c_sum = (c_sum + a) % m
cumsum.append(c_sum)
for c in cumsum:
if c not in list(d.keys()):
d[c] = 0
d[c] += 1
for v in list(d.values()):
if v >= 2:
ans += v * (v - 1) // 2
print(ans)
main() | p03287 |
f = lambda: list(map(int,input().split()))
def s(l,m):
ans = 0
for i in range(len(l)):
ans += l[i]
ans %= m
return ans
n,m = f()
a = f()
a = [s(a[:i],m) for i in range(n+1)]
ans = 0
from collections import Counter
for v in list(Counter(a).values()):
ans += v*(v-1)//2
print(ans) | f = lambda: list(map(int,input().split()))
n,m = f()
a = f()
b = [0]
for i in range(n):
b.append((b[-1]+a[i])%m)
ans = 0
from collections import Counter
for v in list(Counter(b).values()):
ans += v*(v-1)//2
print(ans) | p03287 |
from itertools import accumulate
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = [0] + A
B = list(accumulate(B))
ans = []
cnt = 0
for i in range(1, len(B)):
for j in range(i):
if (B[i] - B[j])%M == 0:
cnt += 1
print(cnt) | from itertools import accumulate
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = [0] + A
C = {}
B = list(accumulate(B))
for i in range(1, len(B)):
if B[i]%M not in C:
C[B[i]%M] = 1
else:
C[B[i]%M] += 1
ans = 0
for i in list(C.values()):
ans += i*(i-1)//2
if 0 in C:
ans += C[0]
print(ans) | p03287 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
s = [0]#s[i]はaからi個取った累積和
for i in range(len(a)):
s.append((s[i] + a[i]) % m)
ans = 0
d = dict()
for i in range(len(s)):
t = d.get(s[i], 0)
ans += t
d[s[i]] = t + 1
print(ans) | def iin(): return int(eval(input()))
def nl(): return list(map(int, input().split()))
n, m = nl()
a = nl()
csum = [0]
for x in a:
csum.append((csum[-1] + x) % m)
d = dict()
ans = 0
for x in csum:
t = d.get(x, 0)
ans += t
d[x] = t + 1
print(ans) | p03287 |
from collections import defaultdict
N, M = list(map(int, input().split()))
a = tuple(map(int, input().split()))
ans = 0
d = defaultdict(int)
d[0] = 1
t = 0
for aa in a:
t += aa
ans += d[t % M]
d[t % M] += 1
print(ans)
| def main():
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
d = {0: 1}
ans = 0
t = 0
for x in A:
t = (t + x) % M
ans += (cnt := d.get(t, 0))
d[t] = cnt + 1
print(ans)
if __name__ == '__main__':
main()
| p03287 |
#!/mnt/c/Users/moiki/bash/env/bin/python
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
from collections import defaultdict
d = defaultdict(int)
ans = 0
for i in range(N-1, -1, -1):
b = defaultdict(int)
b[ A[i] % M ] += 1
for dkey in list(d.keys()):
b[ (A[i] + dkey)%M ] += d[dkey] # b[A[i]] + d[dkey]
ans += b[0]
d = b
#print("ans: ", ans)
# print(d)
print(ans)
| #!/mnt/c/Users/moiki/bash/env/bin/python
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
from collections import defaultdict
# d = defaultdict(int)
d = defaultdict(list)
# d = defaultdict(set)
# d = {}
B = [0] * (N+1)
B[0] = 0
# B[1] = A[0]
for i in range(0,N):
B[i+1] = A[i]
B[i+1] += B[i]
# print(B)
for i in range(0,N+1):
d[ B[i] % M] += [i]
# d[ B[i] % M] |= set([i])
# print(d)
# exit(0)
from bisect import bisect_left
ans = 0
for i in range(0,N+1):
m = B[i] % M
# print(d[m])
ans += bisect_left( d[m], i)
# print("{i:3d}: d[{m}]: {d} bisect({i}): {bi}".format(m=m, d=d[m], i=i, bi=bisect_left(d[m], i)))
# for i in range(N-1, -1, -1):
print(ans)
| p03287 |
#!/mnt/c/Users/moiki/bash/env/bin/python
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
from collections import defaultdict
# d = defaultdict(int)
d = defaultdict(list)
# d = defaultdict(set)
# d = {}
B = [0] * (N+1)
B[0] = 0
# B[1] = A[0]
for i in range(0,N):
B[i+1] = A[i]
B[i+1] += B[i]
# print(B)
for i in range(0,N+1):
d[ B[i] % M] += [i]
# d[ B[i] % M] |= set([i])
# print(d)
# exit(0)
from bisect import bisect_left
ans = 0
for i in range(0,N+1):
m = B[i] % M
# print(d[m])
ans += bisect_left( d[m], i)
# print("{i:3d}: d[{m}]: {d} bisect({i}): {bi}".format(m=m, d=d[m], i=i, bi=bisect_left(d[m], i)))
# for i in range(N-1, -1, -1):
print(ans)
| #!/mnt/c/Users/moiki/bash/env/bin/python
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
from collections import defaultdict
d = defaultdict(list)
B = [0] * (N+1)
B[0] = 0
for i in range(0,N):
B[i+1] = A[i]
B[i+1] += B[i]
for i in range(0,N+1):
d[ B[i] % M] += [i]
from bisect import bisect_left
ans = 0
for i in range(0,N+1):
m = B[i] % M
ans += bisect_left( d[m], i)
print(ans)
| p03287 |
# coding: utf-8
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
acc = [0]
for i in range(n):
acc.append(acc[i]+a[i])
count = 0
for i in range(n+1):
for j in range(i):
if (acc[i]- acc[j]) %m == 0:
count += 1
print(count) | # coding: utf-8
#始点を定めて(n)終点を定めて(n)その間の数を足し合わせる(～n)と計算量オーダーはO(n^3)
#累積和を用いると、始点を定めて(n)終点を定めて(n)差をとればいいので計算量オーダーはO(n^2)
#以下のコードでは、Aのループ処理(n)において随時累積和のmod mを算出し、そのmod mが何回現れたかを示す辞書の検索、挿入を行う(1)ので、計算量オーダーはO(n)
#（辞書の検索計算量オーダーについていまいち理解できていない。本当にO(1)なのだろうか？）
n,m = list(map(int,input().split()))
A = list(map(int,input().split()))
modm = 0
#累積和を別のリストに格納する必要はなく、bという変数を1つ用意して、modmにその時点での累積和のmod mを格納すればよい
dic = {0:1}
#{x:y}:Aの各要素を順に処理していくとき、mod mがxである要素が現時点までにy個見つかっていることを表す
cnt = 0
for a in A:
modm = (modm+a) %m
cnt += dic.get(modm,0)
dic[modm] = dic.get(modm,0) + 1
#c[b]では、bをキーとする要素が見つからなかった場合エラーが発生してしまう。
#c.get(b,default)なら、bをキーとする要素が見つからなかった場合デフォルト値を返してくれる。
print(cnt)
| p03287 |
from collections import defaultdict
def main():
num, person_num = list(map(int, input().split()))
data = list(map(int, input().split()))
dp = [defaultdict(int) for i in range(num)]
dp[0][data[0] % person_num] += 1
ans = 0
for i in range(1, num):
now_data = data[i]
ans += dp[i - 1][0]
for key in list(dp[i - 1].keys()):
now_ind = (key + now_data) % person_num
dp[i][now_ind] += dp[i - 1][key]
dp[i][now_data % person_num] += 1
ans += dp[num - 1][0]
print(ans)
if __name__ == '__main__':
main()
|
from collections import defaultdict
def main():
num_box, num_people = list(map(int, input().split()))
data = list(map(int, input().split()))
dp = defaultdict(int)
dp[0] += 1
count = 0
for i in range(num_box):
count += data[i]
count %= num_people
dp[count] += 1
ans = 0
for ele in list(dp.values()):
if ele >= 2:
ans += (ele - 1) * ele // 2
print(ans)
if __name__ == '__main__':
main()
| p03287 |
# def f(As, M):
# prev = None
# c = 0
#
# for i, A in enumerate(As):
# A %= M
# if i == 0:
# prev = {A: 1}
# if A == 0:
# c += 1
# continue
#
# ccc = {A: 1}
# for k in prev.keys():
# v = prev[k]
# newv = (k + A) % M
# if newv in ccc:
# ccc[newv] += v
# else:
# ccc[newv] = v
# c += ccc[0] if 0 in ccc else 0
# prev = ccc
# return c
def f(As, M):
totals = [As[0] % M]
for A in As[1:]:
totals.append((totals[-1] + A) % M)
res = 0
N = len(As)
for i in range(N):
ii = totals[N - 1 - i]
if ii == 0:
res += 1
for j in range(i + 1, N):
jj = totals[N - 1 - j]
if jj == ii:
res += 1
return res
def main():
N, M = [int(a) for a in input().split()]
As = [int(a) for a in input().split()]
print((f(As, M)))
if __name__ == '__main__':
main()
| # def f(As, M):
# prev = None
# c = 0
#
# for i, A in enumerate(As):
# A %= M
# if i == 0:
# prev = {A: 1}
# if A == 0:
# c += 1
# continue
#
# ccc = {A: 1}
# for k in prev.keys():
# v = prev[k]
# newv = (k + A) % M
# if newv in ccc:
# ccc[newv] += v
# else:
# ccc[newv] = v
# c += ccc[0] if 0 in ccc else 0
# prev = ccc
# return c
def f(As, M):
totals = [As[0] % M]
res = 1 if As[0] % M == 0 else 0
for A in As[1:]:
l = (totals[-1] + A) % M
if l == 0:
res += 1
totals.append(l)
# N = len(As)
ddd = {}
for t in totals:
if t not in ddd:
ddd[t] = 0
res += ddd[t]
ddd[t] += 1
# for i in range(N):
# ii = totals[N - 1 - i]
# if ii == 0:
# res += 1
# for j in range(i + 1, N):
# jj = totals[N - 1 - j]
#
# if jj == ii:
# res += 1
return res
def main():
N, M = [int(a) for a in input().split()]
As = [int(a) for a in input().split()]
print((f(As, M)))
if __name__ == '__main__':
main()
| p03287 |
import itertools
N, M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
acc = [0] + list(itertools.accumulate(A))
count = 0
for l in range(N + 1):
for r in range(l + 1, N + 1):
if (acc[r] - acc[l]) % M == 0:
count += 1
print(count) | import itertools
N, M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
acc = [0] + list(itertools.accumulate(A))
B = [ai % M for ai in acc]
B.sort()
B.append(-1)
result = 0
count = 1
for i in range(N + 1):
if B[i + 1] == B[i]:
count += 1
else:
result += count * (count - 1) // 2
count = 1
print(result)
| p03287 |
n,m = list(map(int,input().split(" ")))
def bar_M(t):
return int(t)%m
array = list(map(bar_M,input().split(" ")))
array_sum = [0 for i in range(n+1)]
for i in range(1,n+1):
array_sum[i] = (array_sum[i-1] + array[i-1])%m
nums = set(array_sum)
sums = []
for i in nums:
p = array_sum.count(i)
if p > 1:
sums.append(p)
ans = 0
for i in sums:
ans+=int((i-1)*i/2)
print(ans) | n,m = list(map(int,input().split(" ")))
array = list(map(int,input().split(" ")))
array_sum,sums = [0,0],{0:1}
for i in range(1,n+1):
array_sum[0] = array_sum[1]
array_sum[1] = (array_sum[0] + array[i-1])%m
sums[array_sum[1]] = sums.get(array_sum[1],0) + 1
ans = 0
for i in list(sums.values()):
ans+=int((i-1)*i/2)
print(ans) | p03287 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
accumA=[]
tmp=0
for i in range(len(A)):
tmp+=A[i]
accumA.append(tmp)
accumA=[0]+accumA
cnt=0
for i in range(1,N+1):
for j in range(i,N+1):
s=accumA[j]-accumA[i-1]
if s%M==0:
cnt+=1
print(cnt) | N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
B=[0]
tmp=0
for i in A:
tmp+=i
B.append(tmp)
d = {}
for i in B:
i %= M
if i not in d:
d[i] = 0
d[i] += 1
ans = 0
for i in list(d.values()):
ans += i*(i-1)//2
print(ans) | p03287 |
from collections import Counter
N, M = list(map(int,input().split()))
A = list(map(int, input().split()))
ans = 0
S = [0 for k in range(N)]
S[0] = A[0]
for k in range(1,N):
S[k] = S[k-1] + A[k]
S = [0] + S
for k in range(N+1):
S[k] %= M
C = Counter(S)
for a in C:
if C[a] >= 2:
ans += (C[a]*(C[a]-1))//2
print(ans) | import sys
from collections import Counter
def input():
return sys.stdin.readline()[:-1]
def main():
N, M = list(map(int,input().split()))
A = list(map(int,input().split()))
S = [0]*N
S[0] = A[0]%M
for k in range(1,N):
S[k] = (S[k-1] + A[k])%M
C = Counter(S)
C[0] += 1
ans = 0
for e in C:
ans += (C[e]*(C[e]-1))//2
print(ans)
if __name__ == '__main__':
main()
| p03287 |
from itertools import accumulate
from collections import defaultdict
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
#1 累積和をとる
B = [0] + list(accumulate(A))
#2 そのmodをとる
B = [b%M for b in B]
#3 1～Nまで、辞書内の当該キーをansにプラスしながら進む
cnt = defaultdict(int)
ans = 0
for b in B:
ans += cnt[b]
cnt[b] += 1
print(ans)
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import Counter
from itertools import accumulate
n,m = li()
a = list(li())
acum = list(accumulate(a))
acum = [acumi%m for acumi in acum]
cnt = Counter(acum)
ans = cnt[0]
for k,v in list(cnt.items()):
ans += v*(v-1)//2
print(ans) | p03287 |
from collections import Counter
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
SUM = [0]
for i in a:
SUM.append((SUM[-1]+i)%m)
#SUM.pop(0)
c = Counter(SUM)
C = c.most_common()
C_srt = sorted(C)
ans = 0
for i in C:
if i[1] > 1:
'''
if i[0] == 0:
ans += i[1]*(i[1]+1)//2
else:
'''
ans += i[1]*(i[1]-1)//2
else:
break
print(ans)
| from collections import Counter
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
SUM = [0]
for i in a:
SUM.append((SUM[-1]+i)%m)
c = Counter(SUM)
C = c.most_common()
C_srt = sorted(C)
ans = 0
for i in C:
if i[1] > 1:
ans += i[1]*(i[1]-1)//2
else:
break
print(ans) | p03287 |
from collections import Counter
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A.insert(0,0)
cnt = Counter()
for i in range(N): A[i+1] += A[i]
for i in range(N+1): cnt[A[i]%M] += 1
print((sum(n*(n-1)//2 for n in list(cnt.values()))))
| from collections import Counter
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
A[0] = A[0] % M
for i in range(1,N): A[i] = (A[i]+A[i-1])%M
cnt = Counter([0]+A)
print((sum(n*(n-1)//2 for n in list(cnt.values()))))
| p03287 |
from itertools import accumulate as ac
from math import factorial as fc
from collections import Counter
f=lambda a,b:fc(a)//(fc(a-b)*fc(b)) if a>=b>=0 else 0
n,m=list(map(int,input().split()))
*a,=list(map(int,input().split()))
*aa,=[x%m for x in ac([0]+a)]
d=Counter(aa)
v=sum(f(i,2) for i in list(d.values()))
print(v)
| from collections import Counter
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
ac = [0]*(N+1)
for i in range(1, N+1):
ac[i] = (ac[i-1]+A[i-1])%M
c = Counter(ac)
ans = 0
for i in list(c.values()):
ans += i*(i-1)//2
print(ans)
| p03287 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
S=[0]*(N+1)
for i in range(N):
S[i+1]=(A[i]+S[i])%M
def tr(k):
return k*(k-1)//2
countlist=dict()
check=set()
for i in range(1,N+1):
countlist[S[i]]=countlist.get(S[i],0)+1
ANS=countlist.get(0,0)
for i in list(countlist.keys()):
ANS+=tr(countlist[i])
print(ANS)
|
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
S=[0]*(N+1)
for i in range(N):
S[i+1]=(A[i]+S[i])%M
def tr(k):
return k*(k-1)//2
S.sort()
S=[-1]+S+[-1]
count=0
ANS=0
for i in range(1,N+3):
if S[i]==S[i-1]:
count+=1
else:
ANS+=tr(count)
count=1
print(ANS)
| p03287 |
N, M = list(map(int, input().split()))
A = list([x % M for x in list(map(int, input().split()))])
ans = 0
nums = []
for a in A:
for i in range(len(nums)):
nums[i] = (nums[i]+a) % M
if not nums[i]:
ans += 1
if not a:
ans += 1
nums.append(a)
print(ans) | def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
b = 0
count = {0:1}
ans = 0
for a in A:
b = (a+b) % M
if b in count:
ans += count[b]
count[b] += 1
else:
count[b] = 1
print(ans)
if __name__ == '__main__':
main() | p03287 |
import math
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
b=[a[0]]
c={}
c[b[0]%m]=1
for i in range(1,n):
b.append(b[i-1]+a[i])
c[b[i]%m]=c.get(b[i]%m,0)+1
print((sum([math.factorial(x)//(math.factorial(x-2)*math.factorial(2))if x>1else 0 for x in list(c.values())])+c.get(0,0))) | import math
n,m=list(map(int,input().split()))
b=0
c={}
for a in input().split():
b+=int(a)
c[b%m]=c.get(b%m,0)+1
print((sum([math.factorial(x)//(math.factorial(x-2)*math.factorial(2))if x>1else 0 for x in list(c.values())])+c.get(0,0))) | p03287 |
import math
n,m=list(map(int,input().split()))
b=0
c={}
for a in input().split():
b+=int(a)
c[b%m]=c.get(b%m,0)+1
print((sum([math.factorial(x)//(math.factorial(x-2)*math.factorial(2))if x>1else 0 for x in list(c.values())])+c.get(0,0))) | n,m=list(map(int,input().split()));d={0:1};r=s=0
for i in input().split():s+=int(i);s%=m;x=d.get(s,0);r+=x;d[s]=x+1
print(r) | p03287 |
import math
def f(x):return math.factorial(x)
def g(x):return f(x)//(f(x-2)*f(2))if x>1else 0
n,m=list(map(int,input().split()))
b=0
c={}
for a in input().split():
b+=int(a)
c[b%m]=c.get(b%m,0)+1
print((sum([g(x) for x in list(c.values())])+c.get(0,0))) | n,m,*c=list(map(int,open(0).read().split()))
d={0:1}
r=s=0
for i in c:s+=i;x=d.get(s%m,0);r+=x;d[s%m]=x+1
print(r) | p03287 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
from itertools import accumulate
from collections import Counter
acc = [0]
acc.extend(accumulate(A))
cnt = Counter(ac % M for ac in acc)
print((sum(v * (v - 1) // 2 for v in list(cnt.values())))) | N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
from itertools import accumulate
from collections import Counter
acc = [0]
acc.extend(accumulate(A))
c = Counter(ac % M for ac in acc)
print((sum(v * (v - 1) // 2 for v in list(c.values())))) | p03287 |
# coding:utf-8
import sys
from collections import Counter
input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
# Counterを使ったD - Candy Distributionの解法
def solve(N, M, A):
# 累積和(mod M)を求める
S = [0]
for i in range(N):
S.append((S[-1] + A[i]) % M)
del S[0]
# 各要素の個数を数える
C = Counter(S)
ans = 0
for num in C:
if C[num] <= 1:
continue
# C[num]個から2つ選ぶ組み合わせ
ans += C[num] * (C[num] - 1) // 2
# 1箱で条件を満たす(Si = 0, l=r)場合を加算
return ans + C[0]
N, M = inpl()
A = inpl()
print((solve(N, M, A)))
| # coding:utf-8
import sys
from collections import Counter
input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
# Counterを使ったD - Candy Distributionの解法
def solve(N, M, A):
# 累積和S (mod M)を求める
S = [0]
for i in range(N):
S.append((S[-1] + A[i]) % M)
ans = 0
# 各要素の個数を数える
for v in list(Counter(S).values()):
# v個から2個選ぶ組み合わせ
ans += v * (v - 1) // 2
return ans
N, M = inpl()
A = inpl()
print((solve(N, M, A)))
| p03287 |
from collections import Counter
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
ctr = Counter()
ctr[0] = 1
cum = 0
for a in A:
cum = (cum + a) % M
ctr[cum] += 1
ans = 0
for v in list(ctr.values()):
ans += v*(v-1)//2
print(ans) | from collections import Counter
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
cums = [0]
for a in A:
cums.append((cums[-1] + a) % M)
ctr = Counter(cums)
ans = 0
for v in list(ctr.values()):
ans += v*(v-1)//2
print(ans) | p03287 |
from collections import defaultdict
from operator import mul
from functools import reduce
def cmb(n,r):
if n < r:
return 0
r = min(n-r,r)
if r == 0:
return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
sum_A = [0] * (N+1)
for i in range(1,N+1):
sum_A[i] = (sum_A[i-1] + A[i-1]) % M
ans = 0
d = defaultdict(int)
for i in range(N+1):
d[sum_A[i]] += 1
for i,j in list(d.items()):
ans += cmb(j,2)
print(ans)
main() | from itertools import accumulate
from collections import defaultdict
from operator import mul
from functools import reduce
def cmb(n,r):
r = min(n-r, r)
if r == 0:
return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(accumulate(A))
d = defaultdict(int)
for i in range(N):
B[i] %= M
d[B[i]] += 1
cnt = 0
for i, j in list(d.items()):
if i == 0:
cnt += j
if j >= 2:
cnt += cmb(j , 2)
print(cnt)
if __name__ == "__main__":
main() | p03287 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
t = [0]
v = 0
if n > m:
mod = [0] * m
for i in range(len(a)):
v += a[i]
mod[v%m] += 1
ans = mod[0]
for i in range(m):
ans += mod[i] * (mod[i]-1) / 2
print((int(ans)))
else:
ans = 0
for i in range(len(a)):
v += a[i]
t.append(v)
for i in range(len(t)-1):
for j in range(i+1, len(t)):
if (t[j]-t[i]) % m == 0:
ans += 1
print(ans) | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
t = [0]
v = 0
b = {0:1}
for i in range(n):
v = (v + a[i]) % m
if v in list(b.keys()):
b[v] += 1
else:
b[v] = 1
ans = 0
for i in list(b.values()):
ans += i * (i-1) / 2
print((int(ans)))
| p03287 |
import itertools
from math import factorial
from collections import Counter
ans = 0
N, L = list(map(int, input().split()))
x = list(map(int, input().split()))
y = itertools.accumulate(x)
y = [e % L for e in y]
#print(y)
#print(y)
so = set(y)
#print(so)
#print(so)
counter = Counter([0]+y)
#print(counter.values())
#print
for i in list(counter.values()):
#print(ans)
if i>1:ans+=factorial(i) // 2 // factorial(i-2)
print(ans) | import itertools
from math import factorial
from collections import Counter
ans = 0
N, L = list(map(int, input().split()))
x = list(map(int, input().split()))
y = itertools.accumulate(x)
y = [e % L for e in y]
#print(y)
#print(y)
so = set(y)
#print(so)
#print(so)
counter = Counter([0]+y)
#print(counter.values())
#print
for i in list(counter.values()):
#print(ans)
ans+=i * (i - 1) // 2
print(ans) | p03287 |
N, M = list(map(int, input().split()))
A = [ int(x) for x in input().split() ]
B = [0]
sum_v = 0
for a in A:
sum_v += a
sum_v %= M
B += [ sum_v ]
B.sort()
B += [ "@" ]
cur = B[0]
cnt, ans = 1, 0
for i, b in enumerate(B):
if B[i+1] == "@":
ans += cnt*(cnt-1)//2
break
if cur == B[i+1]:
cnt += 1
else:
cur = B[i+1]
ans += cnt*(cnt-1)//2
cnt = 1
print(ans)
| N, M = list(map(int, input().split()))
A = [ int(x) for x in input().split() ]
d = {0:1}
ans, s = 0, 0
for a in A:
s += a
s %= M
ans += d.get(s, 0)
d[s] = d.get(s, 0) + 1
print(ans)
| p03287 |
import os, sys, re, math
N,M = list(map(int,input().split(' ')))
ary = list(map(int,input().split(' ')))
s = [0 for i in range(N+1)]
for i in range(N):
s[i+1] = ary[i] + s[i]
cnt = 0
for j in range(N,0,-1):
for k in range(j,0,-1):
if j == k:
if s[j] % M == 0 and s[j] >= M:
cnt += 1
elif (s[j] - s[k]) % M == 0:
cnt += 1
print(cnt)
| import os, sys, re, math
N,M = list(map(int,input().split(' ')))
ary = list(map(int,input().split(' ')))
s = [0 for i in range(N+1)]
for i in range(N):
s[i+1] = (ary[i] + s[i]) % M
m_map = {}
for j in range(0,N+1):
if s[j] in m_map:
m_map[s[j]] += 1
else:
m_map[s[j]] = 1
ret = 0
for i,v in list(m_map.items()):
if v >= 2:
ret += v * (v-1) // 2
print(ret)
| p03287 |
N , M = list(map(int,input().split()))
A = list(map(int,input().split()))
A = [a for a in A]
partial_sum_list = [0]
partial_sum = 0
res = 0
i = 0
while i < N:
partial_sum += A[i]
partial_sum_list.append(partial_sum)
temp = partial_sum % M
j = 0
while j < len(partial_sum_list)-1:
if temp == (partial_sum_list[j] % M):
res += 1
j += 1
i = i + 1
print(res) | N , M = list(map(int,input().split()))
A = list(map(int,input().split()))
A = [a for a in A]
dic = {}
dic[0] = 0
partial_sum = 0
res = 0
i = 0
while i < N:
partial_sum += A[i]
a = partial_sum % M
if a == 0:
res += 1
if a in dic:
dic[a] += 1
res += dic[a] - 1
else:
dic[a] = 1
res += dic[a] - 1
#res += dic[a]
i = i + 1
print(res) | p03287 |
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = [0 for i in range(n+1)]
for i in range(n):
b[i+1] = b[i]+a[i]
ans = 0
for i in range(n):
for j in range(1,n-i+1):
if (b[i+j] - b[i]) % m == 0:
ans += 1
print(ans) | n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = [0 for i in range(n+1)]
for i in range(n):
b[i+1] = (b[i]+a[i])%m
c = {}
for i in b:
if i in c:
c[i] += 1
else:
c[i] = 1
ans = 0
for i in c:
ans += (c[i]*(c[i]-1)//2)
print(ans) | p03287 |
from collections import defaultdict
from itertools import accumulate
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
acc=list(accumulate(A))
d=[defaultdict(int) for i in range(N+1)]
for i in range(N):
d[i+1][acc[i]%M]+=1
for n,m in list(d[i].items()):
d[i+1][n]+=m
ans=0
for g in range(N):
if acc[g]%M==0:
ans+=d[g+1][acc[g]%M]
else:
ans+=d[g+1][acc[g]%M]-1
print(ans) | from collections import defaultdict
from itertools import accumulate
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
acc=list(accumulate(A))
d=defaultdict(int)
ans=0
for i in range(N):
if acc[i]%M==0:
d[acc[i]%M]+=1
ans+=d[acc[i]%M]
else:
d[acc[i]%M]+=1
ans+=d[acc[i]%M]-1
print(ans) | p03287 |
N,M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
stim_A = [0]
for ind,i in enumerate(A):
stim_A.append((stim_A[-1]+i)%M)
ans = 0
for ind,i in enumerate(stim_A[1:]):
ans += 1 if i==0 else 0
ans += stim_A[1:ind+1].count(i)
print(ans) | N,M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
stim_A = [0]
di = {}
ans = 0
for i in A:
stim_A.append((stim_A[-1]+i)%M)
if(stim_A[-1] in di):
di[stim_A[-1]] += 1
else:
di[stim_A[-1]] = 1
for i in di:
if(i==0):
ans+=di[0]
if(di[i]>1):
ans += (di[i]-1)*di[i]//2
print(ans)
| p03287 |
def cal_comb(n,r):
ret = 1
for i in range(1,n+1):
ret *= i
for i in range(1,n-r+1):
ret //= i
for i in range(1,r+1):
ret //= i
return ret
N,M = list(map(int,input().split()))
L = list(map(int,input().split()))
from itertools import accumulate
accumulated = [0]+list(accumulate(L))
accumulated = [x%M for x in accumulated]
def counter(array):
from collections import Counter
return list(Counter(array).most_common())
c = counter(accumulated)
ans = 0
for x in c:
ans += cal_comb(x[1],2)
print(ans)
|
N,M = list(map(int,input().split()))
L = list(map(int,input().split()))
from itertools import accumulate
accumulated = [0]+list(accumulate(L))
accumulated = [x%M for x in accumulated]
def counter(array):
from collections import Counter
return list(Counter(array).most_common())
c = counter(accumulated)
ans = 0
for x in c:
ans += x[1] * (x[1]-1) //2
print(ans)
| p03287 |
n,m=list(map(int, input().split()))
a=list(map(int,input().split()))
b=[sum(a[0:i]) for i in range(1,n+1)]
c=[b[i]%m for i in range(n)]
ans=0
import collections
k=list(collections.Counter(c).items())
for x in k:
j=True
if x[0]==0:
ans+=x[1]*(x[1]+1)//2
j=False
if x[1]>1 and j:
ans+=(x[1]-1)*x[1]//2
print(ans) | n,m=list(map(int, input().split()))
a=list(map(int,input().split()))
b=[a[0]]
for i in range(1,n):
b.append(b[-1]+a[i])
c=[b[i]%m for i in range(n)]
ans=0
import collections
k=list(collections.Counter(c).items())
for x in k:
j=True
if x[0]==0:
ans+=x[1]*(x[1]+1)//2
j=False
if x[1]>1 and j:
ans+=(x[1]-1)*x[1]//2
print(ans) | p03287 |
def d_candy_distribution(N, M, A):
import itertools
import collections
b = [0] + list(itertools.accumulate(A))
# Aの累積和のうち、Mで割った余りが等しい要素の個数
remainders = collections.defaultdict(int)
for t in b:
remainders[t % M] += 1
ans = 0
for k, v in list(remainders.items()):
if v >= 2:
# 余りが等しい要素が2個以上あるなら、それから2つ選んで要望を満たせる
ans += v * (v - 1) // 2
return ans
N, M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
print((d_candy_distribution(N, M, A))) | def d_candy_distribution(N, M, A):
import itertools
import collections
# Aの累積和のうち、Mで割った余りが等しい要素の個数
remainders = collections.defaultdict(int)
for t in [0] + list(itertools.accumulate(A)):
remainders[t % M] += 1
# 余りが等しい要素が2個以上あるなら、それから2つ選んで要望を満たせる
return sum([v * (v - 1) // 2 for v in list(remainders.values()) if v >= 2])
N, M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
print((d_candy_distribution(N, M, A))) | p03287 |
n, m = list(map(int, input().split()))
lst = list(map(int, input().split()))
imod = []
for i in range(n):
imod = imod + [sum(lst[0:i]) % m]
imod = imod + [sum(lst) % m]
s = 0
for i in range(n):
for j in range(i+1,n+1):
if imod[i] == imod[j]:
s = s + 1
print(s) | n, m = list(map(int, input().split()))
lst = list(map(int, input().split()))
dp = {}
dp[0] = 1
a, s = 0, 0
for i in lst:
a += i
a %= m
if a in dp:
s += dp[a]
dp[a] += 1
else:
dp[a] = 1
print(s) | p03287 |
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
from collections import Counter
c=Counter()
sm=0
c[sm]+=1
for i in range(n):
sm+=a[i]
c[sm%m]+=1
ans=0
for v in list(c.values()):
ans+=v*(v-1)//2
print(ans)
| n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
from collections import Counter
c=Counter()
s=0
c[s]+=1
for i in range(n):
s+=a[i]
c[s%m]+=1
ans=0
for v in list(c.values()):
ans+=v*(v-1)//2
print(ans)
| p03287 |
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
from collections import Counter
c=Counter()
s=0
c[s]+=1
for i in range(n):
s+=a[i]
c[s%m]+=1
ans=0
for v in list(c.values()):
ans+=v*(v-1)//2
print(ans)
| n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
from collections import Counter
c = Counter()
sum_val = 0
c[sum_val] += 1
for i in range(n):
sum_val += a[i]
sum_val %= m
c[sum_val] += 1
ans = 0
for v in list(c.values()):
ans += v*(v-1)//2
print(ans)
| p03287 |
numBox, numnClild = [int(i) for i in input().split()]
numCandies = [int(i) for i in input().split()]
def find(left):
acc = 0
for i in range(left, numBox):
acc += numCandies[i]
if acc % numnClild == 0:
return i + 1
return -1
done_list = []
count = 0
for left in range(0, numBox):
tmp_count = 0
right = left
while right != -1:
right = find(right)
if right != -1:
if right in done_list:
break
else:
done_list.append(right)
tmp_count += 1
count += int(tmp_count * (tmp_count + 1) / 2)
print(count) | numBox, numClild = [int(i) for i in input().split()]
numCandies = [int(i) for i in input().split()]
subsequences = {}
acc = 0
for i in range(0, numBox):
acc += numCandies[i]
if (acc % numClild) in subsequences:
subsequences[acc % numClild].append(i)
else:
subsequences[acc % numClild] = [i]
count = 0
for k, v in list(subsequences.items()):
count += int(len(v) * (len(v) - 1) / 2)
if k == 0:
count += len(v)
print(count) | p03287 |
def main():
N, M = [int(n) for n in input().split()]
A = [int(n) for n in input().split()]
B = [0]*(N+1)
B[0] = 0
d = {}
accum = 0
for i in range(N+1):
B[i] = accum
if i != N:
accum += A[i]
for i, b in enumerate(B):
x = b % M
if x in list(d.keys()):
d[x] += 1
else:
d[x] = 1
# print(B)
print((sum([i * (i - 1)//2 for i in list(d.values())])))
# import os,sys, time
# current = os.path.abspath(__file__ + "/..")+"/"
# fdr = open(current + "d-case1.txt", "r")
# sys.stdin = fdr
# t = time.time()
# main()
# print(time.time() - t)
main()
|
def main():
N, M = [int(n) for n in input().split()]
A = [int(n) for n in input().split()]
B = [0]*(N+1)
B[0] = 0
d = {}
accum = 0
for i in range(N+1):
B[i] = accum
if i != N:
accum += A[i]
for i, b in enumerate(B):
x = b % M
if x in list(d.keys()):
d[x] += 1
else:
d[x] = 1
# print(B)
print((sum([i * (i - 1)//2 for i in list(d.values())])))
# import os,sys, time
# current = os.path.abspath(__file__ + "/..")+"/"
# fdr = open(current + "d-case1.txt", "r")
# sys.stdin = fdr
# t = time.time()
# main()
# print(time.time() - t)
if __name__ == "__main__":
main() | p03287 |
from collections import Counter
n, m = list(map(int, input().split()))
A = [int(i) for i in input().split()]
A[0] %= m
for i in range(n - 1):
A[i + 1] += A[i]
A[i + 1] %= m
C = Counter(A)
ans = 0
for k, v in list(C.items()):
if k == 0:
ans += v
if v >= 2:
ans += v * (v - 1) // 2
print(ans) | from collections import Counter
n, m = list(map(int, input().split()))
A = [int(i) for i in input().split()]
A[0] %= m
for i in range(n-1):
A[i+1] += A[i]
A[i+1] %= m
C = Counter(A)
ans = 0
for k, v in list(C.items()):
if k == 0:
ans += v
if v >= 2:
ans += (v * (v-1)) // 2
print(ans) | p03287 |
from collections import Counter
N, M = list(map(int, input().split()))
A = [0] + [int(i) for i in input().split()]
for i in range(N):
A[i + 1] += A[i]
A[i + 1] %= M
def comb(n, k):
k = min(k, n - k)
result = 1
for i in range(n, n - k, -1):
result *= i
for i in range(1, k + 1):
result //= i
return result
ans = 0
for i in list(Counter(A).values()):
if i > 1:
ans += comb(i, 2)
print(ans) | from collections import Counter
N, M = list(map(int, input().split()))
A = [0] + [int(i) for i in input().split()]
for i in range(N):
A[i + 1] += A[i]
A[i + 1] %= M
ans = 0
for i in list(Counter(A).values()):
if i > 1:
ans += i * (i - 1) // 2
print(ans) | p03287 |
import itertools
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
acc = itertools.accumulate(A)
acc = [e % M for e in acc]
cnt_dict = {}
ans = 0
for e in acc:
if e == 0:
ans += 1
if e in cnt_dict:
cnt_dict[e] += 1
else:
cnt_dict[e] = 0
ans += cnt_dict[e]
print(ans) | def main():
import itertools
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
acc = itertools.accumulate(A)
acc = [e % M for e in acc]
cnt_dict = {}
ans = 0
for e in acc:
if e == 0:
ans += 1
if e in cnt_dict:
cnt_dict[e] += 1
else:
cnt_dict[e] = 0
ans += cnt_dict[e]
print(ans)
main() | p03287 |
n,m,*c=open(0).read().split();d={0:1};r=s=0
for i in c:s+=int(i);s%=int(m);x=d.get(s,0);r+=x;d[s]=x+1
print(r) | n,m,*c=list(map(int,open(0).read().split()));d={0:1};r=s=0
for i in c:s+=i;s%=m;x=d.get(s,0);r+=x;d[s]=x+1
print(r) | p03287 |
N = int(eval(input()))
x = N * 800
y = (N // 15) * 200
print((x-y)) | N = int(eval(input()))
print((N*800-N//15*200)) | p03795 |
meals = int(eval(input()))
print((800 * meals - meals // 15 * 200))
| unit_price = 800
reward_money = 200
meals = int(eval(input()))
print((unit_price * meals - meals // 15 * reward_money))
| p03795 |
n = int(eval(input()))
ans = n * 800 - n//15 * 200
print (ans) | n = int(eval(input()))
x = 800*n
y = int(n/15)
print((x-200*y)) | p03795 |
# A - Restaurant
n = int(eval(input()))
print((800 * n - n // 15 * 200)) | # ABC 055: A – Restaurant
n = int(eval(input()))
print((n * 800 - n // 15 * 200)) | p03795 |
n = int(eval(input()))
x = n * 800
y = (n // 15) * 200
print((x - y)) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
# MOD = 10 ** 9 + 7
# INF = float("inf")
def main():
n = int(eval(input()))
x = n * 800
y = (n // 15) * 200
print((x - y))
if __name__ == '__main__':
main() | p03795 |
x = int(eval(input()))
ans =( 800*x) - ((x//15)*200)
print( ans) | n = int(eval(input()))
x = n*800
y = 200*(n//15)
print((x-y))
| p03795 |
n = int(eval(input()))
if n >= 15:
x = n * 800
y =( n // 15 ) * 200
answer = x - y
print(answer)
else:
answer = n * 800
print(answer) | n = int(eval(input()))
if n >= 15:
x = n * 800
y = ( n // 15 ) * 200
print((x - y))
else:
print((n * 800)) | p03795 |
n = int(eval(input()))
if n >= 15:
x = n * 800
y = ( n // 15 ) * 200
print((x - y))
else:
print((n * 800)) | n = int(eval(input()))
if n >= 15:
print((n * 800 - ( n // 15 ) * 200))
else:
print((n * 800)) | p03795 |
n = int(eval(input()))
x = n * 800
y = (n // 15) * 200
print((x - y)) | def main():
N = int(eval(input()))
prices = N * 800
discount = (N // 15) * 200
print((prices - discount))
if __name__ == '__main__':
main() | p03795 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
def A():
n = I()
print((n*800-200*(n//15)))
#B
def B():
return
#C
def C():
return
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
def J():
return
def K():
return
#Solve
if __name__ == "__main__":
A()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
x = n*800
y = (n//15)*200
print((x-y))
return
#Solve
if __name__ == "__main__":
solve()
| p03795 |
from collections import defaultdict
def main():
n = int(eval(input()))
print((n * 800 - 200 * (n // 15)))
if __name__ == '__main__':
main()
| from collections import defaultdict
def main():
N = int(eval(input()))
print((800 * N - (N // 15) * 200))
if __name__ == '__main__':
main()
| p03795 |
n=int(eval(input()))
print((n*800-200*(n//15))) | n=int(eval(input()))
print((n*800-n//15*200)) | p03795 |
# AtCoder abc055 a
# 入力
n = int(eval(input()))
# 処理
total_pay = n * 800
total_back = (n // 15) * 200
balance = total_pay - total_back
# 出力
print(balance)
| # AtCoder abc055 a
# 入力
n = int(eval(input()))
# 処理
# total_pay = n * 800
# total_back = (n // 15) * 200
# balance = total_pay - total_back
# 出力
print(((n * 800) - ((n // 15) * 200)))
| p03795 |
n=int(eval(input()))
x,y=n*800,n//15*200
print((x-y)) | n=int(eval(input()))
print((n*800-n//15*200)) | p03795 |
N = int(eval(input()))
x = N*800
y = (N//15)*200
print((x-y)) | N = int(eval(input()))
x = 800*N
y = (N//15)*200
print((x-y)) | p03795 |
N = int(eval(input()))
x = 800*N
y = (N//15)*200
print((x-y)) | N = int(eval(input()))
a = N//15
print((N*800-a*200)) | p03795 |
N = int(eval(input()))
print((800 * N - N // 15 * 200)) | print(((lambda N: 800 * N - N // 15 * 200)(int(eval(input()))))) | p03795 |
N = int(eval(input()))
print((800*N-(N//15)*200)) | # coding: utf-8
N = int(eval(input()))
ans = 800*N - N//15*200
print(ans) | p03795 |
n=int(eval(input()));print((n*800-n//15*200)) | n=int(eval(input()));print((int(40/3*(n*59+n%15)))) | p03795 |
a=int(eval(input()))
print((a*800-200*(a//15))) | a=int(eval(input()))
print((a*800-a//15*200))
| p03795 |
import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
# import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def search(pros,tgt,g,d):
tmp = 0
cnt = 0
rest = []
for i in range(d):
if tgt % 2 == 1:
tmp += 100 * (i+1) * pros[i][0] + pros[i][1]
cnt += pros[i][0]
else:
rest.append((i+1,pros[i][0]-1))
tgt //= 2
# print(tmp)
if tmp >= g:
return cnt
for ap, ac in rest[::-1]:
if tmp + 100 * ap * ac >= g:
cnt += math.ceil((g - tmp)/(100 * ap))
return cnt
else:
cnt += ac
tmp += 100 * ac * ap
return INF
def main():
n = getN()
x = 800 * n
y = 200 * (n // 15)
print((x-y))
if __name__ == "__main__":
main()
| import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def nck(n, k, kaijyo):
return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD
def npk(n, k, kaijyo):
if k == 0 or k == n:
return n % MOD
return (kaijyo[n] * divide(kaijyo[n-k])) % MOD
def kaijyo(n):
ret = [1]
for i in range(1, n + 1):
ret.append((ret[-1] * i)% MOD)
return ret
def solve():
n = getN()
x = n * 800
y = (n // 15) * 200
print((x - y))
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve() | p03795 |
N = int(eval(input()))
x = N*800
y = (N//15)*200
print((x-y)) | N = int(eval(input()))
x = 800*N
y = (N//15)*200
print((x-y))
| p03795 |
n = int(eval(input()))
print(((n * 800) - (n // 15 * 200))) | N = int(eval(input()))
print((N * 800 - N // 15 * 200)) | p03795 |
def ii():return int(eval(input()))
def iim():return list(map(int,input().split()))
def iil():return list(map(int,input().split()))
def ism():return list(map(str,input().split()))
def isl():return list(map(str,input().split()))
n = ii()
D = iil()
ans = 0
for i in range(n):
for j in range(i+1,n):
# print(i,j)
ans += D[i]*D[j]
print(ans) | def ii():return int(eval(input()))
def iim():return list(map(int,input().split()))
def iil():return list(map(int,input().split()))
def ism():return list(map(str,input().split()))
def isl():return list(map(str,input().split()))
n = ii()
D = iil()
sumD = sum(D)
ans = 0
for i in range(n):
ans += D[i]*(sum(D)-D[i])
print((ans//2)) | p02886 |
N = int(eval(input()))
d = input().split()
sum = 0
for i in range(len(d)):
for j in range(i+1, len(d)):
sum = sum + int(d[i])*int(d[j])
print(sum) | N = int(eval(input()))
d = list(map(int, input().split()))
sum = 0
for i in range(N):
for j in range(i+1, N):
sum += d[i]*d[j]
print(sum) | p02886 |
#!/usr/bin/env python3
n, *d = list(map(int, open(0).read().split()))
s = sum(d)
print((sum((s - i) * i for i in d)//2))
| n,*d = list(map(int,open(0).read().split()))
print((sum((sum(d)-i)*i for i in d)//2))
| p02886 |
N = int(eval(input()))
d = list(map(int, input().split()))
cal = 0
for i in range(0, N):
for j in range(0 , N):
if i != j:
cal += d[j] * d[i]
print((int(cal / 2))) | N = int(eval(input()))
d = list(map(int, input().split()))
cal = sum([d[j] * d[i] for i in range(N) for j in range(N) if i != j ])
print((int(cal / 2))) | p02886 |
import sys
import itertools
input = lambda: sys.stdin.readline().rstrip()
def solve():
N = int(eval(input()))
d = list(map(int, input().split()))
comb = list(itertools.combinations(list(range(N)), 2))
ans = 0
for c in comb:
i1, i2 = c
ans += d[i1] * d[i2]
print(ans)
if __name__ == '__main__':
solve()
| import sys
import itertools
input = lambda: sys.stdin.readline().rstrip()
def solve():
N = int(eval(input()))
d = list(map(int, input().split()))
ruiseki = list(itertools.accumulate(d))
ans = 0
for i in range(N - 1):
ans += d[i] * (ruiseki[N - 1] - ruiseki[i])
print(ans)
if __name__ == '__main__':
solve()
| p02886 |
n = int(eval(input()))
d = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(n):
if i != j:
ans += d[i] * d[j]
print((ans//2)) | n = int(eval(input()))
d = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(n):
if i > j:
ans += d[i] * d[j]
print(ans) | p02886 |
from itertools import accumulate
n = int(eval(input()))
d = list(map(int, input().split()))
print((sum(a*b for a, b in zip(d[1:], accumulate(d))))) | from itertools import accumulate as Z
n = eval(input())
d = list(map(int,input().split()))
print((sum(a*b for a,b in zip(d[1:],Z(d))))) | p02886 |
import itertools
N = int(eval(input()))
d = list(map(int, input().split()))
ans = 0
for x, y in itertools.combinations(d,2):
ans += x * y
print(ans) | N = int(eval(input()))
d = list(map(int, input().split()))
ans = 0
for i in range(N):
for j in range(i +1,N):
ans += d[i]*d[j]
print(ans) | p02886 |
N = int(eval(input()))
d = list(map(int,input().split()))
ans = 0
for i in range(N-1):
for j in range(i+1,N):
ans+=d[i]*d[j]
print(ans) | N = int(eval(input()))
D = list(map(int,input().split()))
ans = 0
for i in range(N-1):
for j in range(i+1,N):
ans += D[i]*D[j]
print(ans) | p02886 |
A = eval(input())
N = list(map(int,input().split()))
ans = 0
for i in range(len(N)):
for j in range(i,len(N)):
if i != j:
ans += N[i]*N[j]
print(ans) | #abc143_b.py
N = int(eval(input()))
D = list(map(int,input().split()))
ans = 0
for i in range(N):
for j in range(i,N):
if i!=j:
ans += D[i]*D[j]
print(ans) | p02886 |
import itertools
import operator
N = int(eval(input()))
d = list(map(int, input().split()))
n = N * (N - 1) // 2
l = []
c = list(itertools.combinations(d, 2))
for i in range(n):
l.append(operator.mul(c[i][0], c[i][1]))
ans = sum(l)
print(ans) | import itertools
N = int(eval(input()))
d = list(map(int, input().split()))
ans = 0
c = list(itertools.combinations(d, 2))
for x in c:
ans += x[0] * x[1]
print(ans) | p02886 |
N, *D, = [list(map(int, s.split())) for s in open(0)]
N, D = N[0], D[0]
takoyaki_sum = 0
for i in range(N):
for j in range(N):
if i != j:
takoyaki_sum += D[i]*D[j]
print((int(takoyaki_sum/2))) | def main():
_ = int(eval(input()))
a = list(map(int, input().split()))
total = 0
for i in range(len(a)-1):
for j in range(i+1, len(a)):
total += a[i]*a[j]
print(total)
if __name__ == "__main__":
main()
| p02886 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.