code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
import math
while True:
n=int(input())
if n==0:
break
else:
a=list(map(int,input().split()))
m=sum(a)/n
l=0
for i in range(n):
l+=(a[i]-m)**2
b=math.sqrt(l/n)
print("{:.8f}".format(b))
| from itertools import combinations
N = int(input())
L = list(map(int, input().split()))
ans = 0
for a, b, c in combinations(L, 3):
if a == b or b ==c or a == c:
continue
if a + b + c - max(a, b, c) > max(a, b, c):
ans += 1
print(ans) | 0 | null | 2,609,813,376,392 | 31 | 91 |
import queue
K = int(input())
Q = queue.Queue()
for i in range(1, 10):
Q.put(i)
ans = 1
for k in range(K):
ans = Q.get()
ansm = ans % 10
if ans%10 != 0:
Q.put(10 * ans + ansm - 1)
Q.put(10 * ans + ansm)
if ans%10 != 9:
Q.put(10 * ans + ansm + 1)
print(ans) | from collections import deque
k=int(input())
ans=deque([1,2,3,4,5,6,7,8,9])
for i in range(k):
p=ans.popleft()
if i==k-1:
print(p)
q=p%10
if q==0:
ans.append(10*p+0)
ans.append(10*p+1)
elif q==9:
ans.append(10*p+8)
ans.append(10*p+9)
else:
ans.append(10*p+q-1)
ans.append(10*p+q)
ans.append(10*p+q+1)
| 1 | 39,924,430,156,252 | null | 181 | 181 |
H, A = map(int, input().split())
ans = -(-H // A)
print(ans) | h, a = map(int, input().split())
i = 0
while a*i < h:
i = i + 1
print(int(i)) | 1 | 77,009,808,254,400 | null | 225 | 225 |
n, a, b = map(int, input().split())
print((b-a)//2 + min(a-1,n-b) + 1 if (b-a)%2 else (b-a)//2) | import sys
input = sys.stdin.readline
def main():
N, A, B = map(int, input().split())
if (B - A) % 2 == 0:
ans = (B - A) // 2
else:
a = (A - 1) + 1 + ((B - ((A - 1) + 1)) - 1) // 2
b = (N - B) + 1 + (N - (A + ((N - B) + 1))) // 2
ans = min(a, b)
print(ans)
if __name__ == "__main__":
main()
| 1 | 109,484,290,917,440 | null | 253 | 253 |
X = int(input())
if X < 30:
ans = 'No'
else:
ans = 'Yes'
print(ans) | a=int(input())
if a<30:
print("No")
else:
print("Yes") | 1 | 5,693,392,970,030 | null | 95 | 95 |
'''
Created on 2020/08/20
@author: harurun
'''
def main():
import sys
pin=sys.stdin.readline
A,B,M=map(int,pin().split())
a=list(map(int,pin().split()))
b=list(map(int,pin().split()))
ans=min(a)+min(b)
for _ in [0]*M:
x,y,c=map(int,pin().split())
t=a[x-1]+b[y-1]-c
if t<ans:
ans=t
print(ans)
return
main() | A, B, M = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
x = []
y = []
c = []
for _ in range(M):
xt, yt, ct = [int(x) for x in input().split()]
x.append(xt)
y.append(yt)
c.append(ct)
# 割引券を使わない場合の最小値
ret = min(a) + min(b)
# 割引券を使った場合
for i in range(len(x)):
t = a[x[i] - 1] + b[y[i] - 1] - c[i]
if ret > t:
ret = t
print(ret) | 1 | 53,868,047,684,698 | null | 200 | 200 |
def solve(n):
return (n - 1) // 2
assert solve(4) == 1
assert solve(999999) == 499999
n = int(input())
print(solve(n)) | # エラトステネスの篩, フェルマーの小定理
def make_prime_table(N):
sieve = list(range(N + 1))
sieve[0] = -1
sieve[1] = -1
for i in range(2, int(N ** 0.5) + 1):
if sieve[i] != i:
continue
for j in range(i * i, N + 1, i):
if sieve[j] == j:
sieve[j] = i
return sieve
N = int(input())
A = list(map(int, input().split()))
m = 1000000007
prime_table = make_prime_table(1000000)
lcm_factors = {}
for i in range(N):
t = []
a = A[i]
while a != 1:
if len(t) != 0 and t[-1][0] == prime_table[a]:
t[-1][1] += 1
else:
t.append([prime_table[a], 1])
a //= prime_table[a]
for k, v in t:
if k not in lcm_factors or lcm_factors[k] < v:
lcm_factors[k] = v
lcm = 1
for k in lcm_factors:
for i in range(lcm_factors[k]):
lcm *= k
lcm %= m
result = 0
for i in range(N):
result += lcm * pow(A[i], m - 2, m)
result %= m
print(result)
| 0 | null | 120,865,347,343,670 | 283 | 235 |
# D - Sum of Divisors
N = int(input())
ans = (1 + N) * N
for i in range(2, N//2 + 1):
j = 2
while True:
if i * j <= N:
ans += i * j
j += 1
else:
break
print(ans - 1) | N=int(input())
ans = 0
for k in range(1,N+1):
n_ = N // k
ans_ = k*n_*(n_+1)//2
ans+= ans_
print(ans) | 1 | 11,100,888,157,000 | null | 118 | 118 |
import sys
sys.setrecursionlimit(10 ** 8)
n, u, v = map(int, input().split())
to = [[] for _ in range(n + 1)]
for _ in range(n - 1):
a, b = map(int, input().split())
to[a].append(b)
to[b].append(a)
def DFS(s, dist, to, d = 0, p = -1):
dist[s] = d
for v in to[s]:
if v == p:
continue
DFS(v, dist, to, d + 1, s)
def calcDist(s, dist, to):
DFS(s, dist, to)
distU = [0] * (n + 1)
distV = [0] * (n + 1)
calcDist(u, distU, to)
calcDist(v, distV, to)
ans = 0
for i in range(n + 1):
if distU[i] < distV[i]:
ans = max(ans, distV[i])
print(ans - 1)
| nii=lambda:map(int,input().split())
from collections import deque
n,u,v=nii()
u-=1
v-=1
tree=[[] for i in range(n)]
for i in range(n-1):
a,b=nii()
a-=1
b-=1
tree[a].append(b)
tree[b].append(a)
def BFS(s):
dist=[-1 for i in range(n)]
dist[s]=0
que=deque()
que.append(s)
while que:
x=que.popleft()
for i in tree[x]:
if dist[i]==-1:
que.append(i)
dist[i]=dist[x]+1
return dist
dist_t=BFS(u)
dist_a=BFS(v)
ans=0
for i in range(n):
if dist_a[i]>dist_t[i]:
ans=max(ans,dist_a[i]-1)
print(ans) | 1 | 117,446,639,586,820 | null | 259 | 259 |
import numpy as np
from numpy.fft import rfft,irfft
def main():
n,m=map(int,input().split())
A=np.array(list(map(int,input().split())))
F=np.bincount(A)
fft_len=2*10**5+1
Ff=rfft(F,fft_len)
G=np.rint(irfft(Ff*Ff,fft_len)).astype(np.int64)
G_acc=G.cumsum()
remove_cnt=n**2-m
border=np.searchsorted(G_acc,n**2-m)
x=n**2-m-G_acc[border-1]
remove_sum=(G[:border]*np.arange(border)).sum()+border*x
ans=A.sum()*2*n-remove_sum
print(ans)
if __name__=='__main__':
main() | while True:
text = input()
if text == '0':
break
total = 0
for a in range(len(text)):
total += int(text[a])
print(total) | 0 | null | 55,024,820,918,198 | 252 | 62 |
import math
n = int(input())
i = 1
tmp = n-1
while i <= math.sqrt(n):
if n%i == 0:
j = n//i
if i + j < tmp:
tmp = i + j -2
else:
pass
else:
pass
i += 1
print(tmp) | x=int(input())
def 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
max_lower_div=max(divisors(x))
print((max_lower_div-1)+(x//max_lower_div-1)) | 1 | 161,332,825,784,768 | null | 288 | 288 |
def main():
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14,
1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = int(input())
print(A[K-1])
if __name__ == '__main__':
main()
| K = int(input())
ans = 1
num = 0
seven = 7
if not K%2:
print(-1)
else:
for i in range(K):
num = num + seven
seven = seven*10%K
num = num%K
if num == 0:
print(ans)
break
ans += 1
else:
print(-1) | 0 | null | 28,020,748,872,762 | 195 | 97 |
line = input()
for ch in line:
n = ord(ch)
if ord('a') <= n <= ord('z'):
n -= 32
elif ord('A') <= n <= ord('Z'):
n += 32
print(chr(n), end='')
print() | # -*- coding: utf-8 -*-
str = raw_input()
s = []
for c in str:
s.append(c.lower() if c.isupper() else c.upper())
print ''.join(s) | 1 | 1,499,492,075,912 | null | 61 | 61 |
L = int(input())
a = L/3
m = a*a*a
print(m) | L=int(input())
print(pow(L/3,3)) | 1 | 46,802,119,944,772 | null | 191 | 191 |
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
x = [0] * (N + 1)
y = [0] * (M + 1)
for i in range(N):
x[i + 1] = x[i] + A[i]
for i in range(M):
y[i + 1] = y[i] + B[i]
j = M
ans = 0
for i in range(N + 1):
if x[i] > K:
continue
while j >= 0 and x[i] + y[j] > K:
j -= 1
ans = max(ans, i + j)
print(ans)
| import math
R = float(input())
print(2*math.pi*R) | 0 | null | 21,029,853,661,052 | 117 | 167 |
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
k = int(input())
def gcd(a, b):
while b: a, b = b, a % b
return a
ans = 0
for i in range(1, k + 1):
for j in range(1, k + 1):
for m in range(1 , k + 1):
ans += gcd(gcd(i, j), m)
print(ans)
| k = int(input())
if(k%2 == 0 or k%5 == 0):
print('-1')
else:
if(k%7 == 0):
k = k // 7
num = 1
ans = 1
while(True):
if(num%k == 0):
print(ans)
break
else:
num %= k
num *= 10
num += 1
ans += 1
| 0 | null | 20,897,235,177,380 | 174 | 97 |
import itertools
N,X,Y = list(map(int , input().split()))
combi = list(itertools.combinations(range(1,N+1),2))
ansList = [0 for _ in range(N)]
for i,j in combi:
kyori = min(j-i, abs(j-Y) + abs(X-i) + 1)
ansList[kyori] += 1
# print(i,j,ansList)
for ans in ansList[1:]:
print(ans)
| ### ----------------
### ここから
### ----------------
import sys
from io import StringIO
import unittest
def yn(b):
print("Yes" if b==1 else "No")
return
def resolve():
readline=sys.stdin.readline
n,x,y=map(int, readline().rstrip().split())
ans = [0] * (n-1)
for i in range(1,n+1):
for j in range(i+1,n+1):
d1 = abs(i-x) + abs(j-x)
d2 = abs(i-y) + abs(j-y)
d3 = abs(i-x) + abs(j-y) + 1
d4 = abs(i-y) + abs(j-x) + 1
d5 = abs(i-j)
d=min(d1,d2,d3,d4,d5)
ans[d-1]+=1
for a in ans:
print(a)
#arr=list(map(int, readline().rstrip().split()))
#n=int(readline())
#ss=readline().rstrip()
#yn(1)
return
if 'doTest' not in globals():
resolve()
sys.exit()
### ----------------
### ここまで
### ---------------- | 1 | 44,137,317,540,322 | null | 187 | 187 |
n = int(input())
R =[]
for i in range(n):
R.append(int(input()))
maxR = R[1]
minR = R[0]
maxB = R[1] - R[0]
for i in range(1,n):
if R[i] < minR:
minR = R[i]
maxR = R[i] - 1
elif minR <= R[i] and R[i] <= maxR:
continue
else:
maxR = R[i]
if maxR - minR > maxB:
maxB = maxR - minR
print(str(maxB)) | #coding:utf-8
#1_1_D
n = int(input())
prices = [int(input()) for x in range(n)]
maxv = -2 * 10 ** 9
minv = prices[0]
for i in range(1, n):
maxv = max(maxv, prices[i] - minv)
minv = min(minv, prices[i])
print(maxv) | 1 | 14,322,967,230 | null | 13 | 13 |
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()
def main():
h,w=LI()
l=[]
l.append('.'*(w+1))
for _ in range(h):
x='.'
x+=S()
l.append(x)
dp=[[inf]*(w+10) for _ in range(h+10)]
if l[1][1]=='#':
dp[1][1]=1
else:
dp[1][1]=0
for i in range(1,h+1):
for j in range(1,w+1):
if i==1 and j==1:
continue
if l[i][j]=='#':
if l[i-1][j]=='.':
dp[i][j]=min(dp[i][j],dp[i-1][j]+1)
else:
dp[i][j]=min(dp[i][j],dp[i-1][j])
if l[i][j-1]=='.':
dp[i][j]=min(dp[i][j],dp[i][j-1]+1)
else:
dp[i][j]=min(dp[i][j],dp[i][j-1])
else:
dp[i][j]=min(dp[i-1][j],dp[i][j-1])
# print(dp)
return dp[h][w]
# main()
print(main())
| H, W = map(int, input().split())
stage = []
scores = []
for _ in range(H):
stage.append(list(input()))
scores.append([float('inf')] * W)
if stage[0][0] == '#':
scores[0][0] = 1
else:
scores[0][0] = 0
move = [[0, 1], [1, 0]]
for y in range(H):
for x in range(W):
for dx, dy in move:
nx, ny = x + dx, y + dy
if H <= ny or W <= nx:
continue
if stage[ny][nx] == '#' and stage[y][x] == '.':
scores[ny][nx] = min(scores[ny][nx], scores[y][x] + 1)
else:
scores[ny][nx] = min(scores[ny][nx], scores[y][x])
# print(*scores, sep='\n')
print(scores[-1][-1]) | 1 | 49,271,714,368,760 | null | 194 | 194 |
from operator import itemgetter
N,M = map(int,input().split())
PS = [list(map(str,input().split())) for i in range(M)]
for i in range(M) :
PS[i][0] = int(PS[i][0])
submits = [["null"] for i in range(N)]
for i in range(M) :
submits[PS[i][0]-1][0] = PS[i][0]-1
submits[PS[i][0]-1].append(PS[i][1])
ac = 0
pena = 0
for i in range(len(submits)) :
if submits[i][0] == "null" :
continue
flag = False
wabuf1 = 0
for j in range(1,len(submits[i])) :
if submits[i][j] == "AC" :
ac += 1
flag = True
break
else :
wabuf1 += 1
if flag == True :
pena += wabuf1
print(ac,pena) | n,m=map(int,input().split())
ac_cnt = set()
wa_cnt = 0
penalty = [0]*n
for i in range(m):
p,s = input().split()
num = int(p) - 1
if num not in ac_cnt:
if s == "AC":
ac_cnt.add(num)
wa_cnt += penalty[num]
else:
penalty[num] += 1
print(len(set(ac_cnt)),wa_cnt) | 1 | 93,238,151,937,112 | null | 240 | 240 |
import numpy as np
MOD = 10**9 + 7
N,K = map(int, input().split())
k = np.arange(K,N+2)
low = (k-1)*k//2
high = (N-k+1)*k + low + 1
ans = (high-low)%MOD
print(ans.sum()%MOD) | N = int(input())
C = {(i,j):0 for i in range(1,10) for j in range(1,10)}
num = list(range(1,10))
for k in range(1,N+1):
k = str(k)
i = int(k[0])
j = int(k[-1])
if i in num and j in num:
C[(i,j)] += 1
cnt = 0
for i in range(1,10):
for j in range(1,10):
cnt += C[(i,j)]*C[(j,i)]
print(cnt) | 0 | null | 59,917,899,979,200 | 170 | 234 |
n = int(input())
x = 1
y = ""
z = 1
while True:
z = 1
x += 1
if x % 3 == 0:
y += " "
y += str(x)
else:
while True:
b = int(x % 10 ** (z - 1))
a = int((x - b) / 10 ** z)
c = a % 10 ** z
d = a % 10 ** (z - 1)
if a == 3 or b == 3 or c == 3 or d == 3:
y += " "
y += str(x)
break
z += 1
if a < 3 and z > 3:
break
if x >= n:
break
print(y)
| n = int(input())
S = input()
q = int(input())
class BIT:
def __init__(self, n):
"""
初期化
Input:
n: 配列の大きさ
"""
self.n = n
self.bit = [0] * (n+10)
def add(self, x, w):
"""
更新クエリ(add)
Input:
x: インデックス
w: 加える値
Note:
self.bitが更新される
"""
while x <= self.n:
self.bit[x] += w
x += x&-x
def sum(self, x):
"""
部分和算出クエリ
Input:
x: インデックス
Return:
[1,a]の部分和
"""
cnt = 0
while x > 0:
cnt += self.bit[x]
# 次の最下位桁はどこか
x -= x&-x
return cnt
def psum(self, a, b):
"""
区間[a,b)(0-indexed)における和
Input
a,b: 半開区間
Return
[a,b)の和
"""
return self.sum(b-1) - self.sum(a-1)
def str2num(s):
return ord(s)-ord("a")
bits = [BIT(n) for i in range(26)]
# 入力
ans = []
for i, s in enumerate(S):
ind = str2num(s)
bits[ind].add(i+1, 1)
S = list(S)
for _ in range(q):
x,a,b = input().split()
if x == "1":
i = int(a)
# 更新処理
ind_before = str2num(S[i-1])
ind = str2num(b)
bits[ind_before].add(i,-1)
bits[ind].add(i, 1)
S[i-1] = b
else:
l = int(a)
r = int(b)
cnt = 0
for bit in bits:
if bit.psum(l,r+1) > 0:
cnt += 1
ans.append(cnt)
print(*ans)
| 0 | null | 31,852,025,020,150 | 52 | 210 |
from sys import stdin
from math import sqrt
x1, y1, x2, y2 = [float(x) for x in stdin.readline().rstrip().split()]
print(sqrt((x2-x1)**2 + (y2-y1)**2))
| asd=input()
dfg=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
print(dfg[dfg.index(asd)+1]) | 0 | null | 46,354,031,025,400 | 29 | 239 |
n = int(input())
s = input()
r = set([i+1 for i in range(n) if s[i] == "R"])
g = set([i+1 for i in range(n) if s[i] == "G"])
b = set([i+1 for i in range(n) if s[i] == "B"])
ans = len(r)*len(g)*len(b)
def check(s1, s2, s3):
t = 0
for i in range(1, n+1):
if not i in s1:
continue
for j in range(i+1, n+1):
if not j in s2:
continue
if (j+(j-i)) in s3:
t += 1
return t
ans -= check(r, g, b)
ans -= check(r, b, g)
ans -= check(g, b, r)
ans -= check(g, r, b)
ans -= check(b, r, g)
ans -= check(b, g, r)
print(ans)
| N=int(input())
A=list(map(int,input().split()))
result=[0]*N
for a in A:
result[a-1]+=1
print("\n".join(map(str,result)))
| 0 | null | 34,375,076,594,246 | 175 | 169 |
n,u,v = map(int,input().split())
import queue
dist_t = [0] * n
dist_a = [0] * n
elb_t = [0] * n
elb_a = [0] * n
ab = [[] for j in range(n)]
for i in range(n-1):
a,b = map(int,input().split())
ab[a-1].append(b-1)
ab[b-1].append(a-1)
u -= 1
v -= 1
q = queue.Queue()
q.put(u)
elb_t[u] = 1
dist_t[u] = 0
while not q.empty():
tmp = q.get()
for i in range(len(ab[tmp])):
idx = ab[tmp][i]
if elb_t[idx] != 1:
if dist_t[idx] != 0:
dist_t[idx] = min(dist_t[idx], dist_t[tmp] + 1)
else:
dist_t[idx] = dist_t[tmp] + 1
elb_t[idx] = 1
q.put(idx)
q = queue.Queue()
q.put(v)
elb_a[v] = 1
dist_a[v] = 0
while not q.empty():
tmp = q.get()
for i in range(len(ab[tmp])):
idx = ab[tmp][i]
if elb_a[idx] != 1:
dist_a[idx] = dist_a[tmp] + 1
elb_a[idx] = 1
q.put(idx)
ans = 0
for i in range(n):
if dist_a[i] > dist_t[i]:
ans = max(ans,dist_a[i]-1)
print(ans) | n, u, v = map(int, input().split())
u -= 1
v -= 1
g = [[] for _ in range(n)]
for i in range(n-1):
a, b = map(int, input().split())
a, b = a-1, b-1
g[a].append(b)
g[b].append(a)
from collections import deque
q = deque()
q.append(u)
t = [-1]*n
t[u] = 0
while q:
x = q.popleft()
for new_x in g[x]:
if t[new_x] == -1:
t[new_x] = t[x]+1
q.append(new_x)
q = deque()
q.append(v)
a = [-1]*n
a[v] = 0
while q:
x = q.popleft()
for new_x in g[x]:
if a[new_x] == -1:
a[new_x] = a[x]+1
q.append(new_x)
max_ = 0
for i in range(n):
if t[i] < a[i]:
max_ = max(max_, a[i])
print(max_-1) | 1 | 117,043,672,103,358 | null | 259 | 259 |
import math
def main():
X = int(input())
if X == 2: return 2
if X == 3: return 3
if X == 4 or X == 5: return 5
if X == 6 or X == 7: return 7
if X == 8: return 11
while True:
if X % 2 != 0:
for i in range(3, int(math.sqrt(X))+1, 2):
if X % i == 0: break
else: return X
X += 1
ans = main()
print(ans) | from sys import stdin
n = int(input())
dict = {}
for i in range(n):
line = stdin.readline()
if line[0:6] == 'insert':
dict[line[7:]] = 1
else:
if line[5:] in dict:
print('yes')
else:
print('no')
| 0 | null | 52,896,117,427,818 | 250 | 23 |
import math
import collections
def prime_diviation(n):
factors = []
i = 2
while i <= math.floor(math.sqrt(n)):
if n%i == 0:
factors.append(int(i))
n //= i
else:
i += 1
if n > 1:
factors.append(n)
return factors
N = int(input())
if N == 1:
print(0)
exit()
#pr:素因数分解 prs:集合にしたやつ prcnt:counter
pr = prime_diviation(N)
prs = set(pr)
prcnt = collections.Counter(pr)
#print(pr, prs, prcnt)
ans = 0
for a in prs:
i = 1
cnt = 2*prcnt[a]
#2*prcnt >= n(n+1)となる最大のnを探すのが楽そう
# print(cnt)
while cnt >= i*(i+1):
i += 1
ans += i - 1
print(ans) | import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
n = I()
dic = collections.defaultdict(int)
while n != 1:
prime = 0
limit = int(n**(1/2))
for i in range(2,limit+1):
if n%i == 0:
prime = i
break
else:
prime = n
while n%prime == 0:
n //= prime
dic[prime] += 1
ans = 0
for key,value in dic.items():
cnt = 0
while value>=cnt+1:
cnt += 1
value -= cnt
ans += cnt
# print(dic)
print(ans)
main()
| 1 | 16,811,359,372,290 | null | 136 | 136 |
from functools import reduce
from math import gcd
MOD = 10 ** 9 + 7
_ = int(input())
la = list(map(int, input().split()))
def inv(a):
return pow(a, MOD - 2, MOD)
def lcm(a, b):
return a * b // gcd(a, b)
def addmod(a, b):
return (a + b) % MOD
l = reduce(lcm, la) % MOD
answer = reduce(addmod, (l * inv(a) for a in la), 0)
print(answer)
| import sys
def input(): return sys.stdin.readline().rstrip()
class Sieve: #区間[2,n]の値の素因数分解 前処理O(nloglogn)素因数分解O(logn)
def __init__(self,n=1):
self.primes=[]
self.f=[0]*(n+1) #ふるい（素数ならその値）
self.f[0]=self.f[1]=-1
for i in range(2,n+1): #素数リスト作成
if self.f[i]: continue
self.primes.append(i)
self.f[i]=i
for j in range(i*i,n+1,i):
if not self.f[j]:
self.f[j]=i #最小の素因数を代入
def is_prime(self, x):
return self.f[x]==x
def prime_fact(self,x): #素因数分解 {2:p,3:q,5:r,...}
fact_dict=dict()
while x!=1:
p=self.f[x]
fact_dict[p]=fact_dict.get(p,0)+1
x//=self.f[x]
return fact_dict
class Sieve2: #√nまでの素因数で試し割り 前処理O(√nloglogn+√n/logn)
def __init__(self,n):
self.primes=[]
self.f=[0]*(int(n**0.5)+1) #ふるい（素数ならその値）
self.f[0]=self.f[1]=-1
for i in range(2,int(n**0.5)+1): #素数リスト作成
if self.f[i]: continue
self.primes.append(i)
self.f[i]=i
for j in range(i*i,int(n**0.5)+1,i):
if not self.f[j]:
self.f[j]=i #最小の素因数を代入
def prime_fact(self,x): #素因数分解 {2:p,3:q,5:r,...}
fact_dict=dict()
for p in self.primes:
if p*p>x:break
while x%p==0:
x//=p
fact_dict[p]=fact_dict.get(p,0)+1
if x>1:fact_dict[x]=fact_dict.get(x,0)+1
return fact_dict
def main():
n=int(input())
A=list(map(int,input().split()))
mod=10**9+7
p_lis={}
Prime=Sieve2(10**6+5)
for a in A:
f=Prime.prime_fact(a)
for key in f:
p_lis[key]=max(p_lis.get(key,0),f[key])
lcm=1
for key in p_lis:
lcm=(lcm*pow(key,p_lis[key],mod))%mod
ans=0
for a in A:
b=lcm*pow(a,mod-2,mod)%mod
ans=(ans+b)%mod
print(ans)
if __name__ == '__main__':
main()
| 1 | 88,127,312,643,648 | null | 235 | 235 |
import math
r = float(input())
S = math.pi * r * r
L = 2 * math.pi * r
print("{0:.10f}".format(S),end=" ")
print("{0:.10f}".format(L)) | n = int(input())
a = list(map(int,input().split()))
lst = [0]*(max(a)+1)
for i in a:
lst[i] += 1
num_lst = [0]*(max(a)+1)
for i in range(1,max(a)+1):
if not lst[i] in [0,1]:
num_lst[i] = lst[i]*(lst[i]-1)//2
ans = sum(num_lst)
for i in a:
if lst[i] in [0,1]:
print(ans)
else:
print(ans-num_lst[i]+((lst[i]-1)*(lst[i]-2)//2)) | 0 | null | 24,302,009,491,968 | 46 | 192 |
n = int(input())
tscore = 0
hscore = 0
for i in range(n):
wlist = []
t,h = map(str, input().split())
wlist.append(t)
wlist.append(h)
order = sorted(wlist, key = str.lower)
if (t.lower() == h.lower()):
tscore += 1
hscore += 1
elif (order[1] == t):
tscore += 3
elif (order[1] ==h ):
hscore += 3
print(tscore, hscore)
| n,k = map(int, input().split())
lag = []
for l in range(n):
lag.append(int(input()))
w_max = 100000*100000
w_min = 0
while w_min < w_max:
w_mid = (w_max + w_min) // 2
tracks = 0
current = 0
for i in range(n):
if lag[i] > w_mid:
tracks = k
break
elif lag[i] + current > w_mid:
tracks += 1
current = lag[i]
else:
current += lag[i]
if tracks < k:
w_max = w_mid
else:
w_min = w_mid + 1
print(w_max) | 0 | null | 1,025,909,058,752 | 67 | 24 |
ans = []
for i, x in enumerate(open(0).readlines()):
ans.append("Case %d: %s" % (i+1, x))
open(1,'w').writelines(ans[:-1])
| data = input()
counter=1
while data != 0:
print("Case %d: %d" % (counter, data))
data = input()
counter+=1 | 1 | 485,888,932,912 | null | 42 | 42 |
from sys import stdin
w = input()
n = 0
for line in stdin:
line = line.rstrip()
if 'END_OF_TEXT' == line:
break
n += len(list(filter(lambda x: w.lower() == x.lower(), line.split(' '))))
print(n) | # AOJ ITP1_9_A
# ※大文字と小文字を区別しないので注意！！！！
# 全部大文字にしちゃえ。
def main():
W = input().upper() # 大文字にする
line = ""
count = 0
while True:
line = input().split(" ")
if line[0] == "END_OF_TEXT": break
for i in range(len(line)):
word = line[i].upper()
if W == word: count += 1
print(count)
if __name__ == "__main__":
main()
# Accepted.
| 1 | 1,811,012,454,988 | null | 65 | 65 |
s = list(input())
f1 = s == list(reversed(s))
f2 = s[:(len(s)-1)//2] == list(reversed(s[:(len(s)-1)//2]))
f3 = s[(len(s)+2)//2:] == list(reversed(s[(len(s)+2)//2:]))
print("Yes" if all([f1, f2, f3]) else "No") | while True:
h, w = map(int, input().split())
if h == 0 and w == 0:
break
width = ''
for j in range(h):
if j == 0 or j == h - 1:
for i in range(w):
width += '#'
else:
for i in range(w):
if i == 0 or i == w - 1:
width += '#'
else:
width += '.'
print(width)
width = ''
print('')
| 0 | null | 23,510,550,842,912 | 190 | 50 |
r,c=map(int, input().split())
total=[0]*(c+1)
for i in range(r):
a=list(map(int, input().split()))
a.append(sum(a))
print(*a)
for j in range(c+1):
total[j]+=a[j]
print(*total)
| r, c = map(int, input().split())
tabl = [list(map(int, input().split())) for i in range(r)]
for i in range(r):
print(" ".join(map(str, tabl[i])) + " " + str(sum(tabl[i])))
ss = ""
for i in range(c):
ans = 0
for j in range(r):
ans += tabl[j][i]
ss += str(ans) + " "
print(ss+str(sum([int(i) for i in ss.split()]))) | 1 | 1,355,849,977,340 | null | 59 | 59 |
a=input().split()
operator={
'+':(lambda x,y:x+y),
'-':(lambda x,y:x-y),
'*':(lambda x,y:x*y),
'/':(lambda x,y:float(x)/y)
}
stack=[]
for i,j in enumerate(a):
if j not in operator.keys():
stack.append(int(j))
continue
y=stack.pop()
x=stack.pop()
stack.append(operator[j](x,y))
print(stack[0])
| import sys
sys.setrecursionlimit(10000)
ERROR_INPUT = 'input is invalid'
OPECODE = ['+', '-', '*']
BUF = []
def main():
stack = get_input()
ans = calc_stack(stack=stack)
print(ans)
def calc_stack(stack):
if stack[-1] in OPECODE:
BUF.append(stack[-1])
stack.pop()
return calc_stack(stack=stack)
else:
right_num = int(stack[-1])
stack.pop()
if stack[-1] in OPECODE:
BUF.append(right_num)
BUF.append(stack[-1])
stack.pop()
return calc_stack(stack=stack)
else:
left_num = int(stack[-1])
stack.pop()
stack.append(calc(left_num, right_num, BUF[-1]))
BUF.pop()
stack.extend(reversed(BUF))
BUF.clear()
if len(stack) == 1:
return stack[0]
else:
return calc_stack(stack=stack)
def calc(left, right, ope):
if ope == '+':
return left + right
elif ope == '-':
return left - right
elif ope == '*':
return left * right
def get_input():
inp = input().split(' ')
opecode_count = 0
OPECODE_count = 0
for i in inp:
if i in OPECODE:
opecode_count += 1
elif int(i) < 0 or int(i) > 10**6:
print(ERROR_INPUT)
sys.exit(1)
else:
OPECODE_count += 1
if opecode_count < 1 or opecode_count > 100:
print(ERROR_INPUT)
sys.exit(1)
if OPECODE_count < 2 or OPECODE_count > 100:
print(ERROR_INPUT)
sys.exit(1)
return inp
main() | 1 | 36,570,295,388 | null | 18 | 18 |
N = int(input())
S = [int(x) for x in input().split()]
T = int(input())
Q = [int(x) for x in input().split()]
c = set()
for s in S:
for q in Q:
if s == q:
c.add(s)
print(len(c))
|
n = int(input())
s = [int(i) for i in input().split()]
q = int(input())
t = [int(i) for i in input().split()]
ans = 0
for si in set(s):
if si in t:
ans += 1
print(ans)
| 1 | 65,775,504,958 | null | 22 | 22 |
a, b = map(int, input().split())
c = list(map(int,input().split()[:a]))
d = 0
for i in c:
if i>=b:
d+=1
print(d) | n,k=map(int,input().split())
L=list(map(int,input().split()))
ans=0
for i in L:
if i>=k:
ans+=1
print(ans) | 1 | 179,331,542,870,790 | null | 298 | 298 |
n=int(input())
result=0
for i in range(n+1):
if (i%3)!=0 and (i%5)!=0:
result+=i
print(result) | N = int(input())
A = list(map(int, input().split()))
S = [0]
for i in range(N):
S.append(A[i] + S[i])
ans = float('inf')
for i in range(1, N):
ans = min(ans, abs((S[i] - S[0]) - (S[N] - S[i])))
print(ans)
| 0 | null | 88,403,078,692,640 | 173 | 276 |
def main():
N, M = list(map(lambda n: int(n), input().split(" ")))
if M == 0:
print("0 0")
return 0
AC = [0] * N
WA = [0] * N
for i in range(M):
tmp = input().split(" ")
No = int(tmp[0]) - 1
if tmp[1] == "AC":
AC[No - 1] = 1
if tmp[1] == "WA" and AC[No - 1] == 0:
WA[No - 1] += 1
totAC = sum(AC)
totWA = sum([AC[i] * WA[i] for i in range(len(AC))])
print(totAC, end=" ")
print(totWA)
main()
| n,m = map(int,input().split())
ans_list = [False for _ in range(n+1)]
pe_list = [0 for _ in range(n+1)]
ac=0
pe=0
for _ in range(m):
p,s = input().split()
if not ans_list[int(p)]:
if s == 'AC':
ac+=1
pe+=pe_list[int(p)]
ans_list[int(p)]=True
else:
pe_list[int(p)]+=1
print(ac,pe) | 1 | 93,331,778,459,440 | null | 240 | 240 |
import itertools
n = int(input())
s = list(map(int, input().split(' ')))
t = list(map(int, input().split(' ')))
hoge = list(itertools.permutations(range(1, n+1)))
p = 0
q = 0
for i in range(len(hoge)):
if list(hoge[i]) == s:
p = i
if list(hoge[i]) == t:
q = i
print(abs(p - q)) | import math
(a, b, C) = [float(i) for i in input().split()]
S = 0.5 * a * b * math.sin(math.radians(C))
c = math.sqrt(a * a + b * b - 2 * a * b * math.cos(math.radians(C)))
print("%8f" %(S))
print("%8f" %(a + b + c))
print("%8f" %(S / a * 2)) | 0 | null | 50,563,601,395,872 | 246 | 30 |
a, b = map(int, input().split())
x = int(a*(a-1)/2)
y = int(b*(b-1)/2)
print(x+y) | #!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def nPr(n: int, r: int) -> int:
return math.factorial(n) // math.factorial(n - r)
def nCr(n: int, r: int) -> int:
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def solve(N: int, M: int):
return (nCr(N, 2)if N > 1 else 0) + (nCr(M, 2) if M > 1 else 0)
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
print(f'{solve(N, M)}')
if __name__ == '__main__':
main()
| 1 | 45,638,701,869,152 | null | 189 | 189 |
r = input()
suq = int(r) * int(r)
print(suq) | def main():
r = int(input())
print(int(r * r))
if __name__ == '__main__':
main()
| 1 | 145,211,613,907,200 | null | 278 | 278 |
def main():
n = int(input())
inlis = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(n):
if i < j:
ans += inlis[i] * inlis[j]
print(ans)
if __name__ == "__main__":
main()
| n=int(input())
l=list(map(int,input().split()))
prod=0
for i in range(n):
for j in range(i+1,n):
prod=prod+(l[i]*l[j])
print(prod)
| 1 | 168,412,542,514,870 | null | 292 | 292 |
import math
a, b, c = map(int, input().split())
PI = 3.1415926535897932384
c = math.radians(c)
print('{:.5f}'.format(a * b * math.sin(c) / 2))
A = a - b * math.cos(c)
B = b * math.sin(c)
print('{:.5f}'.format(math.sqrt(A * A + B * B) + a + b))
print('{:.5f}'.format(B))
| import math
def triangle(a, b, deg):
result = {}
rad = math.radians(deg)
c = math.sqrt(a*a+b*b-(2*a*b*math.cos(rad)))
s = (a+b+c)/2
result['area'] = math.sqrt(s*(s-a)*(s-b)*(s-c))
result['perimeter'] = a+b+c
result['height'] = result['area'] * 2 / a
return result
if __name__ == '__main__':
a, b, deg = map(int, input().split())
triangle = triangle(a, b, deg)
print(triangle['area'])
print(triangle['perimeter'])
print(triangle['height'])
| 1 | 173,216,049,984 | null | 30 | 30 |
from functools import reduce
from collections import deque
def operate(dq, op):
if op[0] == 'i':
dq.appendleft(int(op[7:]))
else:
k = op[6]
if k == 'F':
dq.popleft()
elif k == 'L':
dq.pop()
else:
try:
dq.remove(int(op[7:]))
except ValueError:
pass
return dq
n = int(input())
print(*reduce(operate, [input() for _ in range(n)], deque())) | from collections import deque
d = deque()
for _ in range(int(input())):
a = input()
if "i" == a[0]: d.appendleft(int(a[7:]))
elif "F" == a[6]: d.popleft()
elif "L" == a[6]: d.pop()
else:
try: d.remove(int(a[7:]))
except: pass
print(*d)
| 1 | 52,228,792,300 | null | 20 | 20 |
N = int(input())
A = list(map(int, input().split()))
ans = 1000
for i in range(N - 1):
a = A[i]
if a < A[i + 1]:
units = ans // a
ans = (ans - units * a) + units * A[i + 1]
# print(i, ans)
print(ans)
| # Problem D - Road to Millionaire
# input
N = int(input())
a_nums = list(map(int, input().split()))
# initialization
max_list = [0] * N
max_list[0] = 1000
# max calc
for i in range(1, N):
for j in range(0, i):
a_remain = max_list[j] % a_nums[j]
a_count = max_list[j] // a_nums[j]
max_list[i] = max(max_list[j], a_nums[i]*a_count+a_remain)
# output
print(max_list[N-1])
| 1 | 7,388,853,792,942 | null | 103 | 103 |
NK = input().split()
n = int(NK[0])
k = int(NK[1])
arr = list(map(int, input().split()))
arr.sort()
print(sum(arr[0:k]))
| import math
def main():
K = int(input())
s = 0
for i in range(K):
for j in range(K):
tmp = math.gcd(i+1, j+1)
for k in range(K):
s += math.gcd(tmp, k+1)
print(s)
if __name__=="__main__":
main()
| 0 | null | 23,699,926,617,848 | 120 | 174 |
text = raw_input()
t = list(text)
for i in range(len(t)):
if t[i].isupper():
t[i] = t[i].lower()
elif t[i].islower():
t[i] = t[i].upper()
print "".join(t) | if __name__ == "__main__":
from decimal import Decimal
r = Decimal(raw_input())
pi = Decimal("3.14159265358979")
print "{0:.6f} {1:.6f}".format( r * r * pi, 2 * r * pi) | 0 | null | 1,077,013,412,070 | 61 | 46 |
n = float(input())
print(n * n * n / 27) | n=int(input())
print((n*n*n)/27) | 1 | 46,873,518,323,180 | null | 191 | 191 |
h, a = map(int, input().split())
print(int((a + h - 1) / a)) | h,a = [int(i) for i in input().split()]
cont=0
while h > 0:
h-=a
cont+=1
print(cont)
| 1 | 76,658,063,672,200 | null | 225 | 225 |
n = int(input())
count = [0 for i in range(n+1)]
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
f = x ** 2 + y ** 2 + z ** 2 + x*y + y*z + z*x
if f <= n:
count[f] += 1
for i in count[1:]:
print(i) | from operator import itemgetter
n=int(input())
XL=[list(map(int,input().split())) for _ in range(n)]
for i in range(n):
XL[i].append(XL[i][0]+XL[i][1])
XL.sort(key=itemgetter(2))
cnt=1
choice=0
for i in range(n):
if XL[choice][2]<=XL[i][0]-XL[i][1]:
choice=i
cnt+=1
print(cnt) | 0 | null | 48,786,643,787,482 | 106 | 237 |
#coding:utf-8
n = input()
l = map(int, raw_input(). split())
print("{0} {1} {2}". format(min(l), max(l), sum(l))) | n = int(input())
num = [int(i) for i in input().split()]
print("{0} {1} {2}".format(min(num),max(num),sum(num)))
| 1 | 721,158,110,790 | null | 48 | 48 |
N, M = map(int, input().split())
ac = wa = 0
ac_lis = [False] * N
wa_cnt = [0] * N
for _ in range(M):
p, s = input().split()
p = int(p) - 1
if s == "AC":
if not ac_lis[p]:
ac += 1
wa += wa_cnt[p]
ac_lis[p] = True
else:
if not ac_lis[p]:
wa_cnt[p] += 1
print(ac, wa)
| n,m = map(int,input().split())
ans_list = [False for _ in range(n+1)]
pe_list = [0 for _ in range(n+1)]
ac=0
pe=0
for _ in range(m):
p,s = input().split()
if not ans_list[int(p)]:
if s == 'AC':
ac+=1
pe+=pe_list[int(p)]
ans_list[int(p)]=True
else:
pe_list[int(p)]+=1
print(ac,pe) | 1 | 93,351,181,217,330 | null | 240 | 240 |
import math
def main(n: int, x: int, t: int):
print(math.ceil(n / x) * t)
if __name__ == '__main__':
n, x, t = map(int, input().split())
main(n, x, t)
| x=int(input())
print(0 if x//100*5<x%100 else 1) | 0 | null | 65,708,180,577,920 | 86 | 266 |
x, y = map(int,input().split())
while True:
if x >= y:
x %= y
else:
y %= x
if x == 0 or y == 0:
print(x+y)
break | #ALDS 1-B: Greatest Common Divisor
x = input().split()
a = int(x[0])
b = int(x[1])
while(a % b != 0):
c = b
b = a % b
a = c
print(b)
| 1 | 8,177,439,008 | null | 11 | 11 |
n, m, k = map(int, input().split(" "))
a = [0]+list(map(int, input().split(" ")))
b = [0]+list(map(int, input().split(" ")))
for i in range(1, n+1):
a[i] += a[i - 1]
for i in range(1, m+1):
b[i] += b[i - 1]
j,mx= m,0
for i in range(n+1):
if a[i]>k:
break
while(b[j]>k-a[i]):
j-=1
if (i+j>mx):
mx=i+j
print(mx) | MOD = 10**9 + 7
INT_MAX = (1 << 63) - 1
if __name__ == "__main__":
# test_case_num = int(input())
# for _ in range(test_case_num):
m, n = map(int, input().split())
grid = [input().strip() for _ in range(m)]
dp = [float('inf')] * n
for i, row in enumerate(grid):
for j, val in enumerate(row):
if i == 0 and j == 0:
dp[j] = grid[0][0] == '#'
else:
temp = INT_MAX
if i > 0:
temp = min(dp[j] + (val == '#' != grid[i-1][j]), temp)
if j > 0:
temp = min(dp[j-1] + (val == '#' != grid[i][j-1]), temp)
dp[j] = temp
# print(dp)
print(dp[-1])
| 0 | null | 29,992,680,649,990 | 117 | 194 |
# C gacha
N = int(input())
goods = set()
cnt = 0
for i in range(N):
S = input()
if S not in goods:
goods.add(S)
cnt += 1
print(cnt) | import math
x1,y1,x2,y2 = map(float,raw_input().split())
a = math.sqrt((x1-x2)**2+(y1-y2)**2)
print '%f'%a | 0 | null | 15,155,112,332,442 | 165 | 29 |
import os
import sys
from atexit import register
from io import BytesIO
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
raw_input = lambda: sys.stdin.readline().rstrip('\r\n')
x = int(input())
print(int(x!=1)) | x, y = map(int, input().split())
a = max(x, y)
b = min(x, y)
while a%b != 0:
temp = a
a = b
b = temp%b
print(b) | 0 | null | 1,454,559,128,452 | 76 | 11 |
def shuffle():
h = int(input())
for i in range(h):
s.append(s[0])
del s[0]
while True:
s = list(input())
if s == ['-']:
break
m = int(input())
for i in range(m):
shuffle()
print(''.join(s))
| import sys
import itertools
import fractions
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
def frac2(p):
return p//2
N,M=nm()
A=nl()
A=list(map(frac2,A))
min_bai=A[0]
for i in range(1,N):
min_bai=min_bai*A[i]//fractions.gcd(min_bai,A[i])
for i in range(N):
if((min_bai//A[i])%2==0):
print(0)
sys.exit(0)
tmp=M//min_bai
if(tmp%2==0):
tmp-=1
print((tmp+1)//2) | 0 | null | 52,150,521,767,878 | 66 | 247 |
d,t,s = map(int,input().split())
if d <= t*s:
result = "Yes"
else:
result = "No"
print(result) | X, Y, A, B, C = map(int, input().split())
*p, = map(int, input().split())
*q, = map(int, input().split())
*r, = map(int, input().split())
p.sort(key=lambda x: -x)
q.sort(key=lambda x: -x)
p = p[:X]
q = q[:Y]
pqr = p+q+r
pqr.sort(key=lambda x: -x)
print(sum(pqr[:X+Y])) | 0 | null | 24,053,523,264,868 | 81 | 188 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
mod = 10 ** 9 + 7
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
ans = 0
def comb(n, r):
if n >= r:
return fac[n] * ( finv[r] * finv[n-r] % mod ) % mod
else:
return 0
for i in range(2, N + 1):
fac.append( ( fac[-1] * i ) % mod )
inv.append( mod - ( inv[mod % i] * (mod // i) % mod ) )
finv.append( finv[-1] * inv[-1] % mod )
if K == 1:
print(0)
else:
for i, x in enumerate(A):
cnt = x * ( comb(i, K-1) - comb(N-1-i, K-1) ) % mod
ans += cnt
ans %= mod
print(ans) | from collections import Counter
N = int(input())
S = input()
c = Counter(S)
ans = c['R'] * c['G'] * c['B']
for s in range(N-2):
for d in range(1, (N-1-s)//2+1):
t = s + d
u = t + d
if S[s] != S[t] and S[t] != S[u] and S[u] != S[s]:
ans -= 1
print(ans)
| 0 | null | 66,159,704,541,644 | 242 | 175 |
import sys
while True:
h, w = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
if 0 ==h and 0 == w:
break
for i in range( h ):
if 0 == i or h-1 == i:
print( "#"*w )
else:
print( "#"+"."*(w -2)+"#" )
print( "" ) | turn=int(input())
ten=[0,0]
for _ in range(turn):
hikaku = input().split()
if hikaku[0] < hikaku[1]:
ten[1] +=3
elif hikaku[0] > hikaku[1]:
ten[0] +=3
else:
ten[0]+=1
ten[1]+=1
print(" ".join(map(str,ten))) | 0 | null | 1,403,523,354,950 | 50 | 67 |
"""
○ 角速度 = θ / t [rad/s]
・時針
ω = θ / t
= math.radians(360) / (12 * 60 * 60) [rad/s]
・分針
ω = θ / t
= math.radians(360) / (60 * 60) [rad/s]
"""
import math
def colon():
# 入力
A, B, H, M = map(int, input().split())
# 時針と分針の角速度
angular_velocity_h = math.radians(360) / (12 * 60 * 60)
angular_velocity_m = math.radians(360) / (60 * 60)
# 0時を基準に時針が何度傾いたか
radian_h = angular_velocity_h * ((H * 60 * 60) + (M * 60))
# 0時を基準に分針が何度傾いたか
radian_m = angular_velocity_m * (M * 60)
# 時針と分針の間の角度
radian_hm = abs(radian_h - radian_m)
if radian_hm > math.pi:
radian_hm = 2 * math.pi - radian_hm
elif radian_hm == math.pi:
return A + B
elif math.pi > radian_hm:
pass
# 端点の距離
distance = math.sqrt((A**2 + B**2) - (2 * A * B * math.cos(radian_hm)))
# 戻り値
return distance
result = colon()
print(result) | import sys
input=sys.stdin.readline #文字列入力はするな！！
n=int(input())
a=list(map(int,input().split()))
def f(x):
z=[0]*40
i=1
while x>0:
z[-i]=x%2
x=x//2
i+=1
return z
for i in range(n):
a[i]=f(a[i])
y=[0]*40
for i in range(40):
y[i]=sum(a[j][i] for j in range(n))%2
ans=[]
for i in range(n):
p=0
for j in range(40):
if y[-j-1]!=a[i][-j-1]:
p+=2**j
ans.append(p)
for i in range(n):
print(ans[i], end=" ")
| 0 | null | 16,347,521,082,580 | 144 | 123 |
for i in range(3000):
list = map(int, raw_input().split())
x = list[0]
y = list[1]
if ((x == 0) and (y == 0)):
break
else:
if x <= y:
print '%d %d'%(x, y)
else:
print '%d %d'%(y, x) | nums = []
while True:
in_line = raw_input().split()
if int(in_line[0]) == 0 and int(in_line[1]) == 0:
break
nums.append([int(in_line[0]),int(in_line[1])])
for n in nums:
n.sort()
print n[0],
print n[1] | 1 | 521,956,766,252 | null | 43 | 43 |
import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inl = lambda: [int(x) for x in sys.stdin.readline().split()]
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
def solve():
n = ini()
a = inl()
cur = 1
for x in a:
if x == cur:
cur += 1
if cur == 1:
return -1
return n + 1 - cur
print(solve())
| hp1, atk1, hp2, atk2 = map(int, input().split())
print("Yes" if hp2 / atk1 <= -(-hp1 // atk2) else "No") | 0 | null | 72,456,351,439,680 | 257 | 164 |
a, b = map(int, input().split())
if a < b:
print('a < b')
elif a == b:
print('a == b')
else:
print('a > b')
| class findroop:
def __init__(self, n, nex):
self.n = n
self.next = nex
#遷移start回でループに入る、end回でループする
#A->B->C->D->B: return=(1, 4)
#C->D->B->C : return=(0, 3)
#O(n)
def findroop(self, start):
roopstart = -1
roopend = -1
visited = [False for i in range(self.n)]
visitlist = []
now = start
for i in range(self.n):
if visited[now]:
roopend = i
break
else:
visited[now] = True
visitlist.append(now)
now = self.next(now)
for i in range(len(visitlist)):
if visitlist[i] == now:
roopstart = i
return (roopstart, roopend)
N,X,M = list(map(int, input().split()))
fr = findroop(M, lambda x: x**2 % M)
roopstart, roopend = fr.findroop(X)
ans = 0
if N <= roopstart:
for i in range(N):
ans += X
X = (X**2)%M
else:
for i in range(roopstart):
ans += X
X = (X**2)%M
N -= roopstart
roopsum = 0
for i in range(roopend-roopstart):
roopsum += X
X = (X**2) % M
ans += (N // (roopend-roopstart)) * roopsum
N = N % (roopend-roopstart)
for i in range(N):
ans += X
X = (X**2) % M
print(ans) | 0 | null | 1,565,366,784,660 | 38 | 75 |
a,b = map(int,input().split())
ans = ""
k = min(a,b)
l = max(a,b)
for i in range(l):
ans += str(k)
print(ans) | n = int(input())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
# 解説AC
ans, num = 0,1
for i in range(60):
cnt = sum((ai & num) == num for ai in a)
ans += (cnt * (n - cnt) * num) % mod
num <<= 1
print(ans % mod)
| 0 | null | 103,921,085,196,960 | 232 | 263 |
N = int(input())
ans = N//2 + N%2
print(ans) | ans = (int(input()) - 1) // 2 + 1
print(ans) | 1 | 59,133,424,481,440 | null | 206 | 206 |
hp1, atk1, hp2, atk2 = map(int, input().split())
print("Yes" if hp2 / atk1 <= -(-hp1 // atk2) else "No") | import sys
s = input()
if s[2] == s[3] and s[4] == s[5]:
print("Yes")
sys.exit()
print("No") | 0 | null | 35,798,175,031,348 | 164 | 184 |
from collections import defaultdict
N=int(input())
*A,=map(int,input().split())
mod = 10**9+7
count = defaultdict(int)
count[0] = 3
ans = 1
for i in range(N):
ans *= count[A[i]]
ans %= mod
count[A[i]] -= 1
count[A[i]+1] += 1
print(ans) | import sys
n=int(input())
A=list(map(int,input().split()))
p=10**9+7
status=[1,0,0]
ans=3
if A[0]!=0:
print(0)
sys.exit()
for i in range(1,n):
count=status.count(A[i])
if count==0:
print(0)
sys.exit()
ans=(ans*count)%p
status[status.index(A[i])]+=1
print(ans) | 1 | 130,323,166,432,158 | null | 268 | 268 |
n,m = map(int,input().split())
A = list(map(int,input().split()))
judge = sum(A) / (4 * m)
ans = []
for i in range(n):
if A[i] < judge :
continue
else:
ans.append(A[i])
print("Yes") if len(ans) >= m else print("No") | N, M = map(int, input().split())
A = list(map(int, input().split()))
cnt = 0
thr = -(-sum(A)//(4*M))
for a in A:
if a >= thr:
cnt += 1
if cnt >= M:
print("Yes")
else:
print("No")
| 1 | 38,424,460,319,612 | null | 179 | 179 |
a = list(map(int,input().split()))
if a[0] == a[1]:print("Yes")
else:print("No") | a,b=map(int,input().split())
total=b-a
if(total==0):
print("Yes")
else:
print("No") | 1 | 82,854,274,432,600 | null | 231 | 231 |
import math
from functools import reduce
n, m = input().split()
a = list(map(int, input().split()))
b =[0]*int(n)
for i in range(len(a)):
b[i] = a[i]//2
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
c = 0
x = lcm_list(b)
for i in range(int(n)):
if (x // b[i]) % 2 == 0:
c = -1
break
else:
continue
if c == -1:
print(0)
else:
print(math.floor(((int(m)/x)+1)/2))
| def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def two(val):
ret = 0
tmp = val
while True:
if tmp != 0 and tmp % 2 == 0:
ret += 1
tmp = tmp // 2
else:
break
return ret
n, m = map(int, input().split())
a_list = list(map(int, input().split()))
b_list = []
for item in a_list:
b_list.append(item // 2)
cnt = -1
for item in b_list:
ret = two(item)
if cnt == -1:
cnt = ret
elif cnt != ret:
print(0)
exit()
val = b_list[0]
for item in b_list:
val = lcm(item, val)
ret = m // val
tmp1 = ret // 2
tmp2 = ret % 2
print(tmp1 + tmp2)
| 1 | 102,228,805,753,280 | null | 247 | 247 |
class dice:
men = [0] * 7
def __init__(self, li):
self.men = [0] + li
def move(self, h):
if h == "N":
t = self.men[1]
self.men[1] = self.men[2]
self.men[2] = self.men[6]
self.men[6] = self.men[5]
self.men[5] = t
elif h == "S":
t = self.men[1]
self.men[1] = self.men[5]
self.men[5] = self.men[6]
self.men[6] = self.men[2]
self.men[2] = t
elif h == "W":
t = self.men[1]
self.men[1] = self.men[3]
self.men[3] = self.men[6]
self.men[6] = self.men[4]
self.men[4] = t
elif h == "E":
t = self.men[1]
self.men[1] = self.men[4]
self.men[4] = self.men[6]
self.men[6] = self.men[3]
self.men[3] = t
saikoro = dice(list(map(int, input().split())))
for s in input():
saikoro.move(s)
print(saikoro.men[1])
| import sys
input = sys.stdin.readline
def south(dice):
f, u, d, b = [dice["front"], dice["up"], dice["down"], dice["back"]]
dice["front"] = u
dice["up"] = b
dice["down"] = f
dice["back"] = d
return dice
def north(dice):
f, u, d, b = [dice["front"], dice["up"], dice["down"], dice["back"]]
dice["front"] = d
dice["up"] = f
dice["down"] = b
dice["back"] = u
return dice
def west(dice):
d, l, r, u = [dice["down"], dice["left"], dice["right"], dice["up"]]
dice["down"] = l
dice["left"] = u
dice["right"] = d
dice["up"] = r
return dice
def east(dice):
d, l, r, u = [dice["down"], dice["left"], dice["right"], dice["up"]]
dice["down"] = r
dice["left"] = d
dice["right"] = u
dice["up"] = l
return dice
def show(dice):
print(" ", dice["up"], " ")
print(dice["left"], dice["front"], dice["right"], dice["back"])
print(" ", dice["down"], " ")
print()
def init_dice(dice_data):
return {
"front": dice_data[1], "back": dice_data[4],
"up": dice_data[0], "right": dice_data[2], "down": dice_data[5], "left": dice_data[3]
}
def main():
pos = list(map(int, input().split()))
move = input().rstrip()
dice = init_dice(pos)
for i in move:
if i == "W":
dice = west(dice)
elif i == "S":
dice = south(dice)
elif i == "N":
dice = north(dice)
elif i == "E":
dice = east(dice)
print(dice["up"])
if __name__ == "__main__":
main()
| 1 | 231,939,935,682 | null | 33 | 33 |
n, k = map(int, input().split())
a = n % k
if (a <= int(k/2)):
print(a)
else:
print(k-a)
| def gcd(a, b):
if b == 0: return a
else: return gcd(b, a % b)
def lcm(a, b):
return a * b / gcd(a, b)
while True:
try:
a, b = map(int, input().split())
print(int(gcd(a, b)), int(lcm(a, b)))
except EOFError:
break | 0 | null | 19,803,916,047,510 | 180 | 5 |
N=int(input())
DMY=10**9
mmax=None
mmin=None
dmax=None
dmin=None
for i in range(N):
x,y = map(int, input().split())
if not mmax:
mmax=(x,y,x+y)
mmin=(x,y,x+y)
dmax=(x,y,x+DMY-y)
dmin=(x,y,x+DMY-y)
continue
if x+y > mmax[2]:
mmax=(x,y,x+y)
elif x+y < mmin[2]:
mmin=(x,y,x+y)
if x+DMY-y > dmax[2]:
dmax=(x,y,x+DMY-y)
elif x+DMY-y < dmin[2]:
dmin=(x,y,x+DMY-y)
print(max(mmax[2]-mmin[2],dmax[2]-dmin[2]))
| n = int(input())
xy = [list(map(int,input().split())) for i in range(n)]
cheby = []
for i in range(n):
l = [xy[i][0]-xy[i][1],xy[i][0]+xy[i][1]]
cheby.append(l)
xmax = -10**10
xmin = 10**10
ymax = -10**10
ymin = 10**10
for i in range(n):
if cheby[i][0] > xmax :
xmax = cheby[i][0]
xa = i
if cheby[i][0] < xmin :
xmin = cheby[i][0]
xi = i
if cheby[i][1] > ymax :
ymax = cheby[i][1]
ya = i
if cheby[i][1] < ymin :
ymin = cheby[i][1]
yi = i
if abs(xmax-xmin) > abs(ymax-ymin):
print(abs(xy[xa][0]-xy[xi][0])+abs(xy[xa][1]-xy[xi][1]))
else :
print(abs(xy[ya][0]-xy[yi][0])+abs(xy[ya][1]-xy[yi][1]))
| 1 | 3,396,840,696,444 | null | 80 | 80 |
import sys
K = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip('\n')
# ## COMBINATION (MOD) ###
N_MAX = 10**6 # 問題サイズに合わせて変えておく
MOD = 10**9 + 7
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N_MAX + 2):
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
# K 文字追加
ans = 0
ln = len(S)
p1 = 1
p2 = 1
s2 = pow(26, K, MOD)
for i in range(1, K + 2):
ans += (p1 * p2 * s2) % MOD
ans %= MOD
# print(p1, p2, s2)
# pre
p1 = (p1 * (ln + i - 1) * inv[i]) % MOD
p2 = (p2 * 25) % MOD
# suf
s2 = (s2 * inv[26]) % MOD
print(ans)
| import sys
input = sys.stdin.readline
K = int(input())
S = list(input())[: -1]
N = len(S)
mod = 10 ** 9 + 7
class Factorial:
def __init__(self, n, mod):
self.f = [1]
for i in range(1, n + 1):
self.f.append(self.f[-1] * i % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for i in range(1, n + 1)[: : -1]:
self.i.append(self.i[-1] * i % mod)
self.i.reverse()
def factorial(self, i):
return self.f[i]
def ifactorial(self, i):
return self.i[i]
def combi(self, n, k):
return self.f[n] * self.i[n - k] % mod * self.i[k] % mod
f = Factorial(N + K + 1, mod)
res = 0
for l in range(K + 1):
r = K - l
res += f.combi(l + N - 1, l) * pow(25, l, mod) % mod * pow(26, r, mod) % mod
res %= mod
print(res) | 1 | 12,848,180,514,120 | null | 124 | 124 |
n = int(input())
for i in range(1, 10):
tmp = (n / i)
if tmp.is_integer() and 1<=tmp and tmp <=9:
print("Yes")
exit()
print("No") | N = int(input())
# A*B=Nとなるような1以上9以下の整数(A, B)が存在するかどうか全探索を行う
ans = 'No'
for i in range(1, 10):
for j in range(1, 10):
if i*j == N:
ans = 'Yes'
break
print(ans) | 1 | 159,780,947,653,756 | null | 287 | 287 |
n, k = map(int, input().split())
a = list(map(lambda x: int(x) - 1, input().split()))
table = [[0] * n for _ in [0] * 64]
table[0] = a
for i in range(61):
for j in range(n):
table[i + 1][j] = table[i][table[i][j]]
ans = 0
for i in range(61, -1, -1):
if k >> i & 1:
ans = table[i][ans]
print(ans + 1)
| n, k = map(int,input().split())
a = list(map(int, input().split()))
flg = [True] * n
dst = [1]
twn = 0
for _ in range(k):
if flg[twn]:
dst.append(a[twn])
flg[twn] = False
twn = a[twn] - 1
else:
index = dst.index(a[twn])
ld = len(dst[:index])
cyc = len(dst[index:])
print(dst[(ld - 1) + (k + 1 - ld) % cyc] if (k + 1 - ld) % cyc != 0 else dst[-1])
exit()
print(dst[-1]) | 1 | 22,617,689,633,568 | null | 150 | 150 |
from copy import deepcopy
d=int(input())
c=list(map(int,input().split()))
s=[]
for i in range(d):
a=list(map(int,input().split()))
s.append(a)
def score_calculator(l):
score=0
las=[0]*26
for i in range(d):
for j in range(26):
las[j]+=1
las[l[i]]=0
for j in range(26):
score-=las[j]*c[j]
score+=s[i][l[i]]
return score
highest_sum_score=-1000000000000
for i in range(1,26):
last=[0]*26
temp_ans_lst=[]
for j in range(d):
daily_highest_score=-10000000000000
for k in range(26):
temp_score=s[j][k]
temp_last=deepcopy(last)
for p in range(26):
temp_last[p]+=1
temp_last[k]=0
for p in range(26):
down=temp_last[p]
for q in range(i):
qdown=down+i+1
down+=qdown
temp_score-=down*c[p]
if temp_score>daily_highest_score:
daily_highest_score=temp_score
daily_choice=k
for k in range(26):
last[k]+=1
last[daily_choice]=0
temp_ans_lst.append(daily_choice)
if score_calculator(temp_ans_lst)>highest_sum_score:
ans_lst=deepcopy(temp_ans_lst)
highest_sum_score=score_calculator(temp_ans_lst)
for i in ans_lst:
print(i+1) | N,K=map(int,input().split())
a=N%K
b=abs(N%K-K)
print(min(a,b)) | 0 | null | 24,697,753,799,312 | 113 | 180 |
import numpy as np
n,k = map(int,input().split())
h = np.array(list(map(int,input().split())))
print(len(h[k<=h])) | n, quantum = list(map(int, input().split()))
queue = []
sumOfTime = 0
for _ in range(n):
name, time = input().split()
queue.append([name, int(time)])
while len(queue) > 0:
name, time = queue.pop(0)
if time > quantum:
sumOfTime += quantum
queue.append([name, time - quantum])
else:
sumOfTime += time
print(name, sumOfTime)
| 0 | null | 89,762,750,627,914 | 298 | 19 |
K,X = map(int, open(0).read().split())
if 500 * K >= X:
print('Yes')
else:
print('No') | N, K = map(int, input().split())
A = list(map(int, input().split()))
for i in range(N):
A[i] -= 1
judge = N*[0]
pos = 0
freq = 0
while judge[pos]==0 and K > 0:
judge[pos] = 1
pos = A[pos]
K -= 1
freq+=1
tmp = pos
pos = 0
while pos!=tmp:
pos = A[pos]
freq -= 1
#print(freq)
if K==0:
print(pos+1)
else:
K %= freq
pos = tmp
for i in range(K):
pos = A[pos]
print(pos+1)
| 0 | null | 60,637,238,390,720 | 244 | 150 |
from collections import deque
import sys
n = int(input())
if n == 1:
print('a')
sys.exit()
q = deque([])
q.append((1, 'a', '1'))
cur = 1
while cur != n:
num = len(q)
j = 0
while j < num:
a, b, c = q.popleft()
for i in range(1, max(map(int, list(c)))+2):
q.append((i, b + chr(96+i), c + str(i)))
j += 1
cur += 1
for i in range(len(q)):
a, b, c = q.popleft()
print(b)
| def solve():
N = int(input())
dfs("", 0, N)
def dfs(cur, n_type, N):
if len(cur) == N:
print(cur)
return
for offset in range(n_type+1):
next_chr = chr(ord('a') + offset)
next_n_type = n_type + 1 if offset==n_type else n_type
dfs(cur+next_chr, next_n_type, N)
return
if __name__ == '__main__':
solve() | 1 | 52,523,697,894,240 | null | 198 | 198 |
word1 = input()
word2 = input()
if word1 == word2[:-1]:
print('Yes')
else:
print('No') | n,a,b = map(int, input().split())
ans = (b-a)//2
if (b-a)%2 == 1:
ans += 1 + min(a-1,n-b)
print(ans) | 0 | null | 65,811,815,719,736 | 147 | 253 |
X = int(input())
money = 100
answer = 0
while money < X:
money += (money//100)
answer += 1
print(answer) | c = input()
alpha = [chr(i) for i in range(97, 97+26)]
number = alpha.index(c)
print(alpha[number + 1])
| 0 | null | 59,599,597,935,962 | 159 | 239 |
print(6-sum([int(input()) for i in range(2)])) | a = int(input())
b = int(input())
l = [a, b]
if not 1 in l:
print('1')
elif not 2 in l:
print('2')
else:
print('3') | 1 | 110,909,093,389,600 | null | 254 | 254 |
if(str(input()).islower()):
print("a")
else:
print("A") | A = input()
if(A.isupper()):
print("A")
else:
print("a") | 1 | 11,318,803,842,098 | null | 119 | 119 |
N,M = map(int, input().split())
A = list(map(int, input().split()))
total = sum(A)
A.sort(reverse=True)
if A[M-1] >= total / (4*M):
print('Yes')
else:
print('No') | N, M = map(int, input().split())
A = list(map(int, input().split()))
D = sum(A)
cnt = 0
for i in range(N):
if A[i] * 4 * M >= D:
cnt += 1
if cnt >= M:
print('Yes')
else:
print('No') | 1 | 38,622,778,890,300 | null | 179 | 179 |
def CheckNum(n, x, i):
x = i
if x % 3 == 0:
print(" %d"%(i), end="")
return 2, i, x
return 1, i, x
def Include3(n, x, i):
if x % 10 == 3:
print(" %d"%(i), end="")
return 2, i, x
x = int(x/10)
if x != 0:
return 1, i, x
return 2, i, x
def EndCheckNum(n, x, i):
i += 1
if i <= n:
return 0, i, x
print("")
return 3, i, x
def call(n):
counter = 0
i = 1
x = 1
func = [CheckNum, Include3, EndCheckNum]
while counter != 3:
counter, i, x = func[counter](n, x, i)
n = int(input())
call(n) | from collections import deque
n = int(input())
d = deque()
for i in range(n):
c = input()
if ' ' in c:
c, num = c.split()
if c == 'insert':
d.appendleft(num)
elif c == 'delete' and num in d:
d.remove(num)
else:
if c == 'deleteFirst' and d:
d.popleft()
elif c == 'deleteLast' and d:
d.pop()
print(' '.join(d))
| 0 | null | 484,171,362,410 | 52 | 20 |
W,H,x,y,r = map(int,input().split())
if x-r<0 or W<x+r or y-r<0 or H<y+r: print('No')
else: print('Yes')
| W, H, x, y, r = map(int, input().split())
if x - r < 0 or x + r > W or y - r < 0 or y + r > H:
print('No')
else:
print('Yes')
| 1 | 459,004,657,660 | null | 41 | 41 |
n,m=map(int,input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
a[i]+=[sum(a[i])]
print(*a[i])
a=list(zip(*a[::-1]))
for i in range(m):print(sum(a[i]),end=' ')
print(sum(a[m]))
| r, c = map(int, input().split())
table = [cc + [sum(cc)] for cc in (list(map(int, input().split())) for _ in range(r))]
table.append(list(map(sum, zip(*table))))
for line in table:
print(*line) | 1 | 1,327,708,220,758 | null | 59 | 59 |
X = int(input())
ROTATION = 360
K = 1
while K * X % 360 != 0:
K += 1
print(K)
| S = list(input())
if S[2]==S[3]:
if S[4] == S[5]:
print("Yes")
else:
print("No")
else:
print("No") | 0 | null | 27,631,387,563,068 | 125 | 184 |
n = int(input())
a = list(map(int, input().split()))
first_half = 0
latter_half = sum(a)
min_diff = latter_half
for i in range(n):
first_half += a[i]
latter_half -= a[i]
diff = abs(first_half - latter_half)
min_diff = min(min_diff, diff)
print(min_diff)
| import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def debug(*args):
if debugmode:
print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]
debugmode = True
n = INT()
a = LIST()
arr = [0 for _ in range(n)]
arr[0] = a[0]
for i in range(1, n):
arr[i] = arr[i - 1] + a[i]
s = arr[-1]
mn = inf
for i in range(n):
mn = min(mn, abs(s / 2 - arr[i]))
print(int(mn * 2)) | 1 | 141,751,412,498,192 | null | 276 | 276 |
N,K=map(int,input().split())
L=[0]*K
R=[0]*K
for i in range(K):
L[i],R[i]=map(int,input().split())
MOD=998244353
dp=[0]*(N+1)
dpsum=[0]*(N+1)
dp[1]=1
dpsum[1]=1
for i in range(2,N+1):
for j in range(K):
Li=i-R[j]
Ri=i-L[j]
if Ri<0:
continue
else:
Li=max(Li,1)
dp[i]=(dp[i]+dpsum[Ri]-dpsum[Li-1])%MOD
dpsum[i]=dpsum[i-1]+dp[i]
print(dp[N]) |
def main(a, b, c, d):
ans = -float('inf')
for x in [a, b]:
for y in [c, d]:
z = x * y
if ans < z:
ans = z
return ans
if __name__ == '__main__':
a, b, c, d = map(int, input().split())
ans = main(a, b, c, d)
print(ans)
| 0 | null | 2,854,337,396,950 | 74 | 77 |
#a(n) = 2^ceiling(log_2(n+1))-1
import math
print(2**(math.ceil(math.log2(int(input())+1)))-1) | def solve():
H = int(input())
cnt = 0
ans = 0
while H > 0:
ans += 2**cnt
if H == 1:
break
H = H // 2
cnt += 1
print(ans)
if __name__ == "__main__":
solve() | 1 | 79,947,320,540,032 | null | 228 | 228 |
N = int(input())
flag = 0
ans = "No"
for i in range(N):
A,B = input().split()
if A == B:
flag += 1
else:
flag = 0
if flag == 3:
ans = "Yes"
break
print(ans) | a,b,k=map(int,input().split())
s=k-a
t=k-a-b
if s>=0:
if t>=0:
print(0,0)
else:
print(0,a+b-k)
else:
print(a-k,b) | 0 | null | 53,283,798,305,668 | 72 | 249 |
N, K=map(int, input().split())
A=list(map(int, input().split()))
F=list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
l=-1
r=10**12+10
while l+1<r:
mid=(l+r)//2
s=0
for i in range(N):
s+=max(0, A[i]-mid//F[i])
if s<=K:
r=mid
else:
l=mid
print(r)
| import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
from itertools import accumulate
N = int(readline())
A = list(map(int, readline().split()))
acc = list(accumulate(A))
S = sum(A)
ans = INF
for first in acc:
second = S - first
ans = min(ans, abs(first - second))
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 153,681,478,609,572 | 290 | 276 |
w=raw_input().lower()
c=0
while 1:
t=map(str,raw_input().split())
if t[0]=="END_OF_TEXT":
break
for i in range(len(t)):
if t[i].lower()==w:
c+=1
print c | N, K, S = map(int, input().split())
ans = []
n = N-K
for i in range(K):
ans.append(S)
for i in range(n):
if S == 10**9:
ans.append(S-1)
else:
ans.append(S+1)
ans=[str(a) for a in ans]
ans=" ".join(ans)
print(ans) | 0 | null | 46,429,917,346,650 | 65 | 238 |
n = input()
s = input().split()
q = input()
t = input().split()
ans = 0
for c1 in t:
for c2 in s:
if c1 == c2:
ans += 1
break
print(ans) | import math
x1,y1,x2,y2 = map(float,input().split())
ans = math.sqrt((x2-x1)**2+(y2-y1)**2)
print(round(ans,8))
| 0 | null | 111,770,670,970 | 22 | 29 |
if __name__ == '__main__':
n = int(input())
a = input().split()
a = [int(x) for x in a]
ans = 1
if 0 in a:
print(0)
else:
for i in a:
ans = ans*i
if ans > 10**18:
ans = -1
break
print(ans) | N = int(input())
A = list(map(int,input().split()))
ans = 1
if 0 in A:
print(0)
else:
for i in A:
ans = ans * i
if ans > 10**18:
ans = -1
break
print(ans) | 1 | 16,323,774,189,760 | null | 134 | 134 |