code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
L = int(input())
k = L/3
print(k**3)
|
mod = 10**9 + 7
def cmb(n,r,mod):
a=1
b=1
r = min(r,n-r)
for i in range(r):
a = a*(n-i)%mod
b = b*(i+1)%mod
return a*pow(b,mod-2,mod)%mod
X,Y = map(int,input().split())
if (X+Y)%3 != 0:
ans = 0
else:
n = (2*X-Y)//3
m = (2*Y-X)//3
if n < 0 or m < 0:
ans = 0
else:
ans = cmb(n+m,m,mod)
print(ans)
| 0 | null | 98,882,908,340,010 | 191 | 281 |
from collections import defaultdict
dd = defaultdict(int)
n,p=map(int, input().split())
S = list(input().rstrip())
tmp = 0
r=1
su=0
dd[0]=1
if p==2 or p==5:
c=n
for s in S[::-1]:
if int(s)%p==0:
su+=c
c-=1
print(su)
else:
for s in S[::-1]:
tmp+=int(s)*r
tmp%=p
dd[tmp]+=1
r*=10
r%=p
for i in dd.values():
su += (i*(i-1))//2
print(su)
|
import math
n = int(input())
while 1:
flg=1
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
flg=0
break
if flg==1:
print(n)
break
n+=1
| 0 | null | 81,778,779,648,202 | 205 | 250 |
N, K = map(int, input().split())
x = N
pre_x = x
if x // K > 0:
x = abs(x - K * (x // K))
pre_x = x
while True:
pre_x = x
x = abs(x - K)
if pre_x < x:
print(pre_x)
exit()
|
#C - Replacing Intege
N,K = map(int, input().split())
for i in range(N):
if N % K == 0:
N = 0
break
N = N % K
if abs(N-K) < N:
N = abs(N-K)
else :
break
print(N)
| 1 | 39,346,402,333,140 | null | 180 | 180 |
n = int(input())
t = list(map(int,input().split()))
a = min(t)
b = max(t)
c = sum(t)
print(str(a),str(b),str(c))
|
n=input()
lst=[int(x) for x in input().split()]
print(min(lst),max(lst),sum(lst))
| 1 | 725,860,613,828 | null | 48 | 48 |
#!usr/bin/env python3
def main():
while True:
numbers = input()
if int(numbers) == 0:
break
res = 0
for i in numbers:
res += int(i)
print(res)
if __name__ == '__main__':
main()
|
import random,time
def score(D,c,s,t):
v=list()
last=[0]*26
legacy=0
for i in range(D):
minus=0
v.append(legacy)
v[i]+=s[i][t[i]-1]
last[t[i]-1]=i+1
for j in range(26):
minus+=c[j]*(i+1-last[j])
v[i]-=minus
legacy=v[i]
return v[D-1]
time_sta = time.perf_counter()
s=list()
t=list()
D=int(input())
c=list(map(int,input().split()))
for i in range(D):
s.append(list(map(int,input().split())))
t=[random.randint(1,26)]*D
time_end=time.perf_counter()
tim=time_end-time_sta
while tim<1.9:
d=random.randint(1,D)
q=random.randint(1,26)
old=t[d-1]
oldscore=score(D,c,s,t)
t[d-1]=q
if score(D,c,s,t)<oldscore:
t[d-1]=old
time_end=time.perf_counter()
tim=time_end-time_sta
for i in range(D):
print(t[i])
| 0 | null | 5,669,700,914,528 | 62 | 113 |
while 1:
H, W=map(int, raw_input().split())
if H==0 and W==0:
break
for i in range(H):
L=list("#"*W)
if i%2==0:
for j in range(W):
if j%2!=0:
L[j]="."
s="".join(L)
print s
else:
for j in range(W):
if j%2==0:
L[j]="."
s="".join(L)
print s
print ""
|
def draw(h,w):
t = "#." * (w/2)
if w%2 == 0:
s = t
k = t.strip("#") + "#"
else:
s = t + "#"
k = "." + t
for i in range(0,h/2):
print s
print k
if h%2==1:
print s
print
if __name__ == "__main__":
while True:
h,w = map(int, raw_input().split())
if h==0 and w==0:
break
else:
draw(h,w)
| 1 | 868,998,421,340 | null | 51 | 51 |
S = input()
T = input()
def count_diff(s, t):
N = 0
for i, j in zip(s, t):
if i != j:
N += 1
return N
ns = len(S)
nt = len(T)
res = nt
for i in range(ns - nt + 1):
sub = S[i:i+nt]
a = count_diff(sub, T)
if a < res:
res = a
print(res)
|
s = input("")
t = input("")
k = 0
if len(s) == len(t):
s += "?"
for i in range(len(s)-len(t)):
cnt = 0
for j in range(len(t)):
if t[j] == s[i+j]:
cnt += 1
k = max(k, cnt)
print(len(t)-k)
| 1 | 3,680,515,099,052 | null | 82 | 82 |
A,B,C,K=map(int,input().split())
print(1*min(A,K)-1*max(0,K-A-B))
|
a,b,c,k = map(int,input().split())
#l = [1 for i in range(a)] + [0 for i in range(b)] + [-1 for i in range(c)]
#ans = sum(l[:k])
if k <= a:
ans = k
elif (a < k) & (k <= a + b):
ans = a
elif (a + b < k) & (k <= a + b + c):
ans = a - (k - (a + b))
print(ans)
| 1 | 21,664,051,601,920 | null | 148 | 148 |
import sys
def GcdLCM():
for line in sys.stdin:
x,y=map(int,line.split())
if x==None:
break
gcd = Gcd(x,y)
lcm = int(x*y/gcd)
print("{} {}".format(gcd,lcm))
def Gcd(x,y):
while x!=0:
x,y=y%x,x
return y
GcdLCM()
|
def draw(h, w):
for i in range(h):
if i % 2 == 0:
print(("#."*w)[:w])
else:
print((".#"*w)[:w])
print("")
while True:
H, W = map(int, input().split())
if H == W == 0: break
draw(H, W)
| 0 | null | 441,790,640,468 | 5 | 51 |
import math
N, K = (int(a) for a in input().split())
A = [int(a) for a in input().split()]
def isOK(X):
cutcount = 0
for i in range(N):
cutcount += math.ceil(A[i] / X) - 1
if cutcount <= K:
return True
else:
return False
def binary_search():
left = 0
right = max(A) + 1
while (right - left) > 1:
mid = left + (right - left) // 2
if (isOK(mid)):
right = mid;
else:
left = mid;
return right
print(binary_search())
|
while True:
s = raw_input()
if s == '0':
break
n = 0
for i in s:
n += int(i)
print n
| 0 | null | 3,991,274,089,888 | 99 | 62 |
a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if a <= b:
print('YNEOS'[a+v*t < b+w*t::2])
else:
print('YNEOS'[a-v*t > b-w*t::2])
|
count, outrate = map(int, input().split())
if count >= 10:
result = outrate
print(result)
else:
result = outrate + 100 * (10 - count)
print(result)
| 0 | null | 39,385,803,484,390 | 131 | 211 |
import sys
import numpy as np
from numba import njit,i8
R,C,K = map(int,input().split())
item = np.zeros((R,C),np.int64)
for _ in range(K):
r,c,v = map(int,input().split())
item[r-1][c-1] = v
@njit(i8(i8[:,:],i8,i8), cache = True)
def solve(item,R,C):
dp = np.zeros((R+1,C+1,4),np.int64)
for ri in range(R):
for ci in range(C):
dp[ri+1][ci+1][0] = max(dp[ri+1][ci][0], dp[ri][ci+1][3])
dp[ri+1][ci+1][1] = max(dp[ri+1][ci][1], dp[ri+1][ci][0]+item[ri][ci], dp[ri][ci+1][3]+item[ri][ci], dp[ri+1][ci+1][0])
dp[ri+1][ci+1][2] = max(dp[ri+1][ci][2], dp[ri+1][ci][1]+item[ri][ci], dp[ri+1][ci+1][1])
dp[ri+1][ci+1][3] = max(dp[ri+1][ci][3], dp[ri+1][ci][2]+item[ri][ci], dp[ri+1][ci+1][2])
return dp[-1][-1][3]
print(solve(item,R,C))
|
R,C,k = map(int,input().split())
dp1 = [[0]*(C+1) for i in range(R+1)]
dp2 = [[0]*(C+1) for i in range(R+1)]
dp3 = [[0]*(C+1) for i in range(R+1)]
item = [[0]*(C+1) for i in range(R+1)]
for i in range(k):
r,c,v = map(int,input().split())
dp1[r][c] = v
for i in range(1,R+1):
for j in range(1,C+1):
a = dp1[i][j]
dp3[i][j] = max(dp2[i][j-1]+a,dp3[i][j-1])
dp2[i][j] = max(dp1[i][j-1]+a,dp2[i][j-1])
dp1[i][j] = max(dp1[i-1][j]+a,dp2[i-1][j]+a,dp3[i-1][j]+a,dp1[i][j-1],a)
print(max(dp1[R][C],dp2[R][C],dp3[R][C]))
| 1 | 5,571,365,254,478 | null | 94 | 94 |
n = int(raw_input())
output = ""
for i in range(1, n + 1):
x = i
if x % 3 == 0:
output += " "
output += str(i)
continue
while True:
if x % 10 == 3:
output += " "
output += str(i)
break
else:
x /= 10
if x == 0:
break
print output
|
mod_val = 10**9+7
n, k = map(int, input().split())
factorials = [1]*(n+1) # values 0 to n
for i in range(2, n+1):
factorials[i] = (factorials[i-1]*i)%mod_val
def mod_binomial(a, b):
numerator = factorials[a]
denominator = (factorials[b]*factorials[a-b])%mod_val
invert = pow(denominator, mod_val-2, mod_val)
return (numerator*invert)%mod_val
partial = 0
# m is number of rooms with no people
for m in range(min(k+1, n)):
# m places within n to place the 'no people' rooms
# put n-(n-m) people in n-m rooms (n-m) must be placed to be non-empty
partial = (partial + (mod_binomial(n, m) * mod_binomial(n-1, m))%mod_val)%mod_val
print(partial)
| 0 | null | 33,935,325,678,846 | 52 | 215 |
dice = {v: k for k, v in enumerate(list(map(int, input().split())))}
adjacent = {k: v for k, v in enumerate(sorted(dice.keys()))}
q = int(input())
p = [(-1,2,4,1,3,-1),(3,-1,0,5,-1,2),(1,5,-1,-1,0,4),(4,0,-1,-1,5,1),(2,-1,5,0,-1,3),(-1,3,1,4,2,-1)]
for _ in range(q):
top, front = map(int, input().split())
x = dice[top]
y = dice[front]
print(adjacent[p[x][y]])
|
import sys
def input(): return sys.stdin.readline().rstrip()
A,B,C,K = map(int,input().split())
point = 0
if A <= K:
point += A
K -= A
else:
point += K
K = 0
if B <= K:
K -= B
else:
K = 0
point -= K
print(point)
| 0 | null | 11,067,526,613,802 | 34 | 148 |
a,b=map(int,input().split());print(a*b)
|
# coding: utf-8
# Here your code !
N=int(input())
dict={}
for i in range(N):
a,b=input().split()
if a=="insert":
dict[b]=i
else:
if b in dict:
print("yes")
else:
print("no")
| 0 | null | 7,946,780,611,000 | 133 | 23 |
import sys
read = sys.stdin.read
INF = 1 << 60
def main():
H, N, *AB = map(int, read().split())
dp = [INF] * (H + 1)
dp[0] = 0
for a, b in zip(*[iter(AB)] * 2):
for i in range(H + 1):
if i >= a:
if dp[i] > dp[i - a] + b:
dp[i] = dp[i - a] + b
else:
if dp[i] > dp[0] + b:
dp[i] = dp[0] + b
print(dp[H])
return
if __name__ == '__main__':
main()
|
S,W = map(int, input().split())
print("suanfsea f e"[S<=W::2])
| 0 | null | 55,032,189,329,930 | 229 | 163 |
def divisor(n):
res = []
i = 1
while i*i <= n:
if not n % i:
res.append(i)
if (i*i != n): res.append(n//i)
i += 1
return res
N = int(input())
ans = 0
for d in divisor(N):
if d == 1: continue
n = N
while not n % d:
n //= d
if n%d == 1: ans += 1
print(ans + len(divisor(N-1))-1)
|
import sys
if __name__ == '__main__':
letter_counts = [0] * 26 # ?????¢????????????????????????????????° [0]???'a'???[25]???'z'??????????????°
for line in sys.stdin:
# ?°?????????¨??§??????????????\????????????
lower_text = line.lower()
# ??¢???????????????????????¨??????????????°???????¨?
for c in lower_text:
if 'a' <= c <= 'z':
letter_counts[ord(c)-ord('a')] += 1
# ????????? 'a : a????????°' ?????¢??§z?????§1????????¨?????????
for i, n in enumerate(letter_counts):
print('{0} : {1}'.format(chr(ord('a')+i), n))
| 0 | null | 21,619,342,947,432 | 183 | 63 |
import math
while True:
try:
a, b = [int(i) for i in input().split()]
gcd = math.gcd(a, b)
lcm = a * b // gcd
print(f'{gcd} {lcm}')
except EOFError:
break
|
import sys
dataset = sys.stdin.readlines()
def gcd(a, b):
if b > a: return gcd(b, a)
if a % b == 0: return b
return gcd(b, a % b)
def lcd(a, b):
return a * b // gcd(a, b)
for item in dataset:
a, b = list(map(int, item.split()))
print(gcd(a, b), lcd(a,b))
| 1 | 685,817,780 | null | 5 | 5 |
import sys
for i in sys.stdin:
a, b = map(int, i.split())
p, q = max(a, b), min(a, b)
while p % q != 0:
p, q = q, p % q
print("{} {}".format(q, int(a * b / q)))
|
x, k, d = map(int, input().split())
x = abs(x)
if x > k*d:
print(x-k*d)
else:
p = x//d
c = k-p
if (c%2 == 0):
print(abs(x-p*d))
else:
print(abs(d-abs(x-p*d)))
| 0 | null | 2,590,797,381,238 | 5 | 92 |
def main():
n, k = map(int, input().split())
a = list(map(int, input().split()))
op = 0
while True:
new = [0 for _ in range(n + 1)]
for i in range(n):
new[max(0, i - a[i])] += 1
new[min(n, i + a[i] + 1)] -= 1
for i in range(1, n + 1):
new[i] += new[i - 1]
a = new[:-1]
op += 1
if op == k or all(aa == n for aa in a):
break
print(" ".join(map(str, a)))
if __name__ == '__main__':
main()
|
n,k=map(int,input().split())
a=list(map(int,input().split()))
for l in range(k):
if a==[n]*n:
break
imos = [0]*(n+1)
for i in range(n):
imos[max(0,i-a[i]) ]+=1
imos[min(n-1,i+a[i])+1 ]-=1
a=[0]*n
a[0]=imos[0]
for i in range(1,n):
a[i] = a[i-1]+imos[i]
print(*a)
| 1 | 15,482,482,673,868 | null | 132 | 132 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N = INT()
AB = [LIST() for _ in range(N)]
A, B = zip(*AB)
A = list(A)
B = list(B)
A.sort()
B.sort()
if N%2:
a = A[N//2]
b = B[N//2]
print(b-a+1)
else:
a = (A[N//2-1]+A[N//2])/2
b = (B[N//2-1]+B[N//2])/2
print(int((b-a)*2+1))
|
n = int(input())
cou = 0
ans = False
for i in range(n):
da, db = map(int, input().split())
if da == db:
cou += 1
else:
cou = 0
if cou == 3:
ans = True
if ans:
print('Yes')
else:
print('No')
| 0 | null | 9,850,777,535,768 | 137 | 72 |
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
mod = 10**9+7
def comb(n, k):
c = 1
for i in range(k):
c *= n - i
c %= mod
d = 1
for i in range(1, k + 1):
d *= i
d %= mod
return (c * pow(d, mod - 2, mod)) % mod
x,y = map(int, input().split())
if (x + y) % 3 != 0:
print(0)
exit()
n = (x + y) // 3
x -= n
y -= n
if x < 0 or y < 0:
print(0)
exit()
print(comb(x + y, x))
|
mod = 10 ** 9 + 7
x, y = map(int, input().split())
if (x + y) % 3 != 0 or x * 2 < y or y * 2 < x:
print(0)
exit()
l = [1]
for i in range(1, (x + y) // 3 + 100):
l.append(l[-1] * i % mod)
def comb(n, r, m):
return l[n] * pow(l[r], m - 2, m) * pow(l[n - r], m - 2, m) % m
a, b = y - (x + y) // 3, x - (x + y) // 3
print(comb(a + b, a, mod) % mod)
| 1 | 150,100,507,245,820 | null | 281 | 281 |
from collections import defaultdict
MOD = 10**9+7
n = int(input())
A = list(map(int, input().split()))
def sieve(n):
n += 1
res = [i for i in range(n)]
for i in range(2, int(n**.5)+1):
if res[i] < i:
continue
for j in range(i**2, n, i):
if res[j] == j:
res[j] = i
return res
U = max(A)+1
min_factor = sieve(U)
def prime_factor(n):
res = defaultdict(lambda: 0)
while 1 < n:
res[min_factor[n]] += 1
n //= min_factor[n]
return res
pf = defaultdict(lambda: 0)
for a in A:
for p, q in prime_factor(a).items():
if pf[p] < q:
pf[p] = q
x = 1
for p, q in pf.items():
x *= pow(p, q, MOD)
x %= MOD
print(sum(x*pow(a, MOD-2, MOD) for a in A) % MOD)
|
N,X,M = map(int,input().split())
ls = [X]
for i in range(M):
Ai = ls[-1]**2 % M
if Ai in ls:
loop = ls[ls.index(Ai):]
lenloop = len(loop)
sumloop = sum(loop)
startls = ls[:ls.index(Ai)]
break
ls.append(Ai)
if N <= len(startls):
ans = sum(startls[:N])
else:
ans = sum(startls) + ((N-len(startls))//lenloop)*sumloop + sum(loop[:(N-len(startls))%lenloop])
print(ans)
| 0 | null | 45,062,241,974,652 | 235 | 75 |
import math
def main():
n, d = map(int, input().split())
ans = 0
for _ in range(n):
x, y = map(int, input().split())
ans += 1 if math.sqrt(x**2 + y**2) <= d else 0
print(ans)
if __name__ == '__main__':
main()
|
n = int(input())
arr = list(map(int,input().split()))
arr.sort(reverse = True)
ans = arr[0]
odd = False
mult = n-2
if mult%2!=0:
mult-=1
odd = True
mult//=2
ans += sum(arr[1:1+mult])*2
if odd:
ans+=arr[1+mult]
print(ans)
"""
Sample:
7
1 2 3 4 5 6 7
2537146
7+6+6+5+5+4
"""
| 0 | null | 7,611,287,963,460 | 96 | 111 |
T=input()
list=[]
for j in range(len(T)):
if T[j]=="?":
list.append(j)
tt=[]
for TT in range(len(T)):
tt.append(T[TT])
for i in list:
tt[i]="D"
answer=""
for p in range(len(T)):
answer+=tt[p]
print(answer)
|
t = list(input())
for i in range(len(t)-1, -1, -1):
if t[i] == '?':
t[i] = 'D'
print(''.join(list(map(str, t))))
| 1 | 18,428,452,946,720 | null | 140 | 140 |
from collections import deque
x,y,a,b,c = map(int,input().split())
ls = []
la = list(map(int,input().split()))
lb = list(map(int,input().split()))
lc = list(map(int,input().split()))
la.sort(reverse=True)
lb.sort(reverse=True)
lc.sort(reverse=True)
for i in range(a):
ls.append([la[i],1])
for j in range(b):
ls.append([lb[j],2])
for l in range(c):
ls.append([lc[l],3])
ls.sort(key=lambda x:x[0],reverse=True)
ls = deque(ls)
s,t,k = 0,0,0
cnt = 0
while True:
now = ls.popleft()
if now[1] == 1:
if s < x:
cnt += now[0]
s += 1
elif now[1] == 2:
if t < y:
cnt += now[0]
t += 1
else:
cnt += now[0]
k += 1
if s + t + k == x + y:
print(cnt)
break
|
import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
# from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
class Combination:
def __init__(self, n, p):
self.n = n
self.p = p
self.note = [1, 1]
self.noteinv = [1, 1]
self.inv = [0, 1]
self.calc()
def calc(self):
for i in range(2, self.n + 1):
self.note.append((self.note[-1] * i) % self.p)
self.inv.append((-self.inv[self.p % i] * (self.p // i)) % self.p)
self.noteinv.append((self.noteinv[-1] * self.inv[-1]) % self.p)
def nCr(self, n, r):
n = self.n
if r < 0 or n < r:
return 0
r = min(r, n - r)
return (self.note[n] * self.noteinv[r] * self.noteinv[n - r]) % self.p
def Main():
n, m, k = read_ints()
# m * _{n-1}C_k * 1^k * (m-1)^{n-1-k}
p = 998244353
modm = [1]
for _ in range(1, n):
modm.append((modm[-1] * (m - 1)) % p)
cmb = Combination(n - 1, p)
ans = 0
for i in range(k + 1):
ans += (cmb.nCr(n - 1, i) * m * modm[n - 1 - i]) % p
ans %= p
print(ans)
if __name__ == '__main__':
Main()
| 0 | null | 34,086,718,471,050 | 188 | 151 |
x = int(input())
dp = [0]*200000
for j in range(6):
dp[100+j] += 1
def max_sum():
global dp
for i in range(x):
if dp[i] > 0:
for j in range(6):
dp[i+100+j] += 1
return
max_sum()
print(min(dp[x], 1))
|
print(sum([i for i in range(1,int(input())+1) if not ((i%3==0 and i%5==0) or i%3==0 or i%5==0)]))
| 0 | null | 80,947,561,056,726 | 266 | 173 |
# -*- coding: utf-8 -*-
def main():
A, B = map(int, input().split())
ans = A * B
print(ans)
if __name__ == "__main__":
main()
|
print(eval(input().strip().replace(' ','*')))
| 1 | 15,767,222,795,270 | null | 133 | 133 |
N, K = map(int, input().split())
MOD = 10 ** 9 + 7
ans = 0
ctr = [0] * (K + 1)
for x in reversed(range(1, K + 1)):
ctr[x] = pow(K // x, N, MOD)
for y in range(2 * x, K + 1, x):
ctr[x] -= ctr[y]
ans = 0
for n in range(1, K + 1):
ans += n * ctr[n]
ans %= MOD
print(ans)
|
MODINT = 10**9+7
n, k = map(int, input().split())
ans = 0
"""
dp[i] = gdc がi となる場合のgcdの総和
"""
dp = [0] * (k+100)
for i in range(k, 0, -1):
dp[i] = pow(k//i, n, MODINT)
for j in range(i*2, k+1, i):
dp[i] -= dp[j]
ans += (dp[i]*i)%MODINT
print(ans%MODINT)
| 1 | 36,670,011,351,260 | null | 176 | 176 |
m,n=map(long,raw_input().split())
print m/n,
print m%n,
print '%.5f' % (float(m)/n)
|
import sys
input = sys.stdin.readline
mod = int(1e9+7)
n,k = map(int,input().split())
L=list(map(int,input().split()))
ans = 1
if k==n:
for i in L:
ans*=i
ans%=mod
print(ans%mod)
sys.exit()
pos = []
neg = []
for i in L:
if i>=0:
pos.append(i)
else:
neg.append(i)
pos.sort(reverse=True)
neg.sort()
if len(pos) == 0 and k%2!=0:
for i in range(1,k+1):
ans*=neg[-i]
ans%=mod
print(ans%mod)
sys.exit()
if k%2!=0:
ans*=pos.pop(0)
k-=1
l=[]
for i in range(1,len(pos),2):
l.append(pos[i]*pos[i-1])
for i in range(1,len(neg),2):
l.append(neg[i]*neg[i-1])
l.sort(reverse = True)
for i in range(k//2):
ans*=l[i]
ans%=mod
print(ans%mod)
| 0 | null | 5,068,909,866,372 | 45 | 112 |
a,b=map(float,input().split())
a=int(a)
b=int(100*b)
print(a*b//100)
|
a, b = map(int,input().split())
def main(x,y):
print(x*y)
main(a,b)
| 1 | 15,796,873,458,940 | null | 133 | 133 |
N, D = map(int, input().split())
D = D*D
count = 0
for i in range(N):
P = list(map(int, input().split()))
dis = P[0]*P[0] + P[1]*P[1]
if dis <= D:
count += 1
print(count)
|
num, max_num = map(int, input().split())
x = []
y = []
count = 0
for i in range(num):
x1,y1 = map(int, input().split())
x.append(x1)
y.append(y1)
for i in range(len(x)):
temp = (x[i]**2 +y[i]**2)**(1/2)
if temp <= max_num:
count += 1
print(count)
| 1 | 5,925,038,733,952 | null | 96 | 96 |
print(input()[1] == "B" and "ARC" or "ABC")
|
# input
n = int(input())
A = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
u, k, *v_list = list(map(int, input().split()))
for v in v_list:
A[u-1][v-1] = 1
# init
d = [0] * n
f = [0] * n
t = 0
# recursive
def dfs(u):
global t
t += 1
d[u] = t
for v in range(n):
if A[u][v] == 1 and d[v] == 0:
dfs(v)
t += 1
f[u] = t
# dfs
for i in range(n):
if d[i] == 0:
dfs(i)
# output
for i in range(n):
print(i+1, d[i], f[i])
| 0 | null | 12,174,769,162,816 | 153 | 8 |
N, R = list(map(int, input().split(' ')))
i = R if N >= 10 else R+100*(10-N)
print(i)
|
# coding: UTF-8
from collections import deque
#入力値の整理
n = int(input())
adj={}
visited={}
d={}
f={}
t=0
visited=set()
for i in range(n):
raw=list(map(int,input().split()))
u = raw.pop(0)
k = raw.pop(0)
raw.sort()
q = deque(raw)
adj[u] = q
d[u] = -1
f[u] = -1
next = 1
v = next
d[next] = t + 1
stack = deque()
visited.add(v)
while True:
t = t+1
clear = True
while adj[v]:
cand = adj[v].popleft()
if cand not in visited:
next = cand
d[next] = t + 1
visited.add(next)
clear = False
break
if clear:
f[v] = t + 1
if stack:
next = stack.pop()
v = next
else:
end = True
for i in range(n):
if i+1 not in visited:
next = i+1
end = False
break
if end:
break
else:
t = t+1
v = next
d[next] = t + 1
visited.add(v)
else:
stack.append(v)
v = next
#print
i = 0
for j in range(n):
i += 1
print(str(i) + " " + str(d[i]) + " " + str(f[i]))
#return d,f
| 0 | null | 31,543,722,779,022 | 211 | 8 |
S = input()
if S == 'ABC':
print('ARC')
elif S == 'ARC':
print('ABC')
else:
print('ABC または ARC を入力してください')
|
down = []
edge = []
pool = []
for i,c in enumerate(input()):
if c == "\\":
down.append(i)
elif c == "/" and down:
left = down.pop()
area = i - left
while edge:
if edge[-1] > left:
edge.pop()
area += pool.pop()
else:
break
edge.append(left)
pool.append(area)
print(sum(pool))
print(" ".join(map(str,[len(pool)]+pool)))
| 0 | null | 12,191,317,427,062 | 153 | 21 |
N = input()
for s in N:
if s == "7":
print('Yes')
break
else:
print('No')
|
n=input()
n=list(n)
if "7" in n:
print("Yes")
else:
print("No")
| 1 | 34,489,033,139,332 | null | 172 | 172 |
N=int(input())
A=list(map(int,input().split()))
s=sum(A)
ans=1
eda=1
if N==0:
if A[0]==1:
print(1)
else:
print(-1)
exit()
if A[0]!=0:
print(-1)
exit()
for i in range(1,N+1):
if eda*2<=s:
eda*=2
else:
eda=s
ans+=eda
eda-=A[i]
s-=A[i]
if eda<=0 and i != N:
print(-1)
exit()
if eda!=0:
print(-1)
exit()
print(ans)
|
n=int(input())
a=list(map(int,input().split()))
if a[0]>=2:
print(-1)
else:
pN=1
s=1
l=[]
S=sum(a)
b=0
z=1
for k in range(len(a)):
b+=a[k]
l.append(b)
for i in range(1,n+1):
if a[i]>2*pN:
print(-1)
z=0
break
else:
pN=min(2*pN-a[i],S-l[i])
s+=pN
s+=S
if n==0:
s=1
if a[0]==1 and n>=1:
print(-1)
z=0
if z:
print(s)
| 1 | 18,826,732,185,338 | null | 141 | 141 |
import sys
n = int(input())
a = [int(x) for x in input().split()]
d = set()
for i in a:
if i in d:
print("NO")
exit()
d.add(i)
print("YES")
|
from collections import Counter as c
N = int(input())
A = list(input().split())
if c(A).most_common()[0][1] == 1: print("YES")
else: print("NO")
| 1 | 73,913,006,355,012 | null | 222 | 222 |
N = int(input())
ans = 0
if N%2 == 1:
print(0)
else:
for i in range(1,len(str(N))+100):
ans += N//(2*5**i)
print(ans)
|
#!python3
import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
def resolve():
K = int(input())
s = input()
ls = len(s) - 1
mod = 10**9+7
N = ls + K
N1 = N + 1
fact = [1] * N1
inv = [1] * N1
for i in range(2, N1):
fact[i] = fact[i-1] * i % mod
inv[N] = pow(fact[N], mod-2, mod)
for i in range(N-1, 1, -1):
inv[i] = inv[i+1]*(i+1) % mod
def cmb(a, b):
return fact[a] * inv[b] % mod * inv[a-b] % mod
ans = 0
p25 = 1
p26 = pow(26, K, mod)
p26inv = 576923081 #pow(26, mod-2, mod)
for i in range(K+1):
ans = (ans + cmb(ls+i, ls) * p25 % mod * p26 % mod) % mod
p25 = p25 * 25 % mod
p26 = p26 * p26inv % mod
print(ans)
if __name__ == "__main__":
resolve()
| 0 | null | 64,696,296,021,172 | 258 | 124 |
input = raw_input()
input = int(input)
ans = input**3
print ans
|
# coding: utf-8
a = input()
print(int(a)*int(a)*int(a))
| 1 | 278,855,252,380 | null | 35 | 35 |
class Dice:
def __init__(self, faces):
self.faces = tuple(faces)
def roll_north(self):
self.faces = (self.faces[1], self.faces[5], self.faces[2],
self.faces[3], self.faces[0], self.faces[4])
def roll_south(self):
self.faces = (self.faces[4], self.faces[0], self.faces[2],
self.faces[3], self.faces[5], self.faces[1])
def roll_west(self):
self.faces = (self.faces[2], self.faces[1], self.faces[5],
self.faces[0], self.faces[4], self.faces[3])
def roll_east(self):
self.faces = (self.faces[3], self.faces[1], self.faces[0],
self.faces[5], self.faces[4], self.faces[2])
def number(self, face_id):
return self.faces[face_id - 1]
dice = Dice(list(map(int, input().split())))
n = int(input())
for i in range(n):
(face1, face2) = map(int, input().split())
if face2 == dice.number(3) or face2 == dice.number(4):
dice.roll_west()
while dice.number(2) != face2:
dice.roll_north()
while dice.number(1) != face1:
dice.roll_west()
print(dice.number(3))
|
s = input()
t = input()
print(sum([1 for a,b in zip(list(s), list(t)) if a != b]))
| 0 | null | 5,357,090,696,270 | 34 | 116 |
#!/usr/bin/python3
import sys
from collections import Counter
input = lambda: sys.stdin.readline().strip()
n = int(input())
a = [int(x) for x in input().split()]
c = Counter(a)
def c2(n):
return n * (n - 1) // 2
ans = sum(c2(v) for v in c.values())
def add(x):
global ans
ans -= c2(c[x])
c[x] += 1
ans += c2(c[x])
def remove(x):
global ans
ans -= c2(c[x])
c[x] -= 1
ans += c2(c[x])
for x in a:
remove(x)
print(ans)
add(x)
|
import collections
N=int(input())
A=list(map(int,input().split()))
c=collections.Counter(A)
#全体の数列について答えを求めるnC2=n(n-1)/2
ALL=0
for i in c.values():
if i>1:
ALL += i*(i-1)//2
#各要素が影響する分を求める
for i in A:
if c[i]>2:
print(ALL-c[i]+1)
elif c[i]==2:
print(ALL-1)
else:
print(ALL)
| 1 | 47,810,851,898,182 | null | 192 | 192 |
n, m = [int(i) for i in input().split()]
C = [int(i) for i in input().split()]
dp = [100000] * (n + 1)
dp[0] = 0
for k in C:
for j in range(k, n + 1):
if dp[j] > dp[j - k] + 1:
dp[j] = dp[j - k] + 1
print(dp[n])
|
#A
n,m=map(int,input().split())
if n<=1:
n_ans=0
else:
n_ans=n*(n-1)/2
if m<=1:
m_ans=0
else:
m_ans=m*(m-1)/2
print(int(n_ans+m_ans))
| 0 | null | 22,956,733,914,410 | 28 | 189 |
# 16-Character-Sum_of_Numbers.py
# ??°?????????
# ?????????????????°???????????????????¨??????????????????°?????????????????????????????????
# Input
# ?????°??????????????????????????\?????¨??????????????????????????????????????????????????????????????´??° x ?????????????????§?????????????????????
# x ??? 1000 ?????\????????´??°??§??????
# x ??? 0 ?????¨?????\?????????????????¨??????????????????????????????????????????????????????????????£????????????????????????
# Output
# ????????????????????????????????????x ???????????????????????????????????????????????????
# Sample Input
# 123
# 55
# 1000
# 0
# Sample Output
# 6
# 10
# 1
data=[]
while 1:
temp = int( input() )
if temp==0:
break;
else:
data.append( temp )
for i in range( len(data) ):
num = list( map(int, list( str( data[i] ) ) ) )
print( sum(num) )
|
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return input().split()
def S(): return 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 = 1e10
#solve
def solve():
n = II()
st = LSR(n)
x = S()
ans = 0
te = 0
for s, t in st:
if te:
ans += int(t)
if s == x:
te = 1
print(ans)
return
#main
if __name__ == '__main__':
solve()
| 0 | null | 49,510,164,201,190 | 62 | 243 |
a,b = map(int,input().split())
# 8% -> [a,a+1)
# 10% -> [b,b+1)
# max(a*100/8, b*10) <= 元の価格 < min((a+1)*100/8, (b+1)*10)
min8 = a*(100/8)
max8 = (a+1)*(100/8)
min10 = b*10
max10 = (b+1)*10
mi = int(max(min8, min10) - 0.001) + 1
ma = int(min(max8, max10) - 0.001)
if mi > ma:
ans = -1
else:
ans = mi
print(ans)
|
A,B = map(int,input().split())
for n in range(10000):
if int(0.08*n)==A and int(0.10*n)==B:
print(n)
exit()
print(-1)
| 1 | 56,266,829,755,980 | null | 203 | 203 |
def main():
N = int(input())
*A, = map(int, input().split())
ans = sum(A[i] & 1 for i in range(0, N, 2))
print(ans)
if __name__ == '__main__':
main()
|
N = int(input())
A = list(map(int, input().split()))
res = 0
for i in range(1, N + 1):
if i % 2 == 1 and A[i-1] % 2 == 1:
res += 1
print(res)
| 1 | 7,741,338,923,108 | null | 105 | 105 |
N = int(input())
A = [int(i) for i in input().split()]
counter = 0
flag = 1 #????????£??\????´?????????¨??????
while flag:
flag = 0
for j in range(N-1, 0, -1):
if A[j] < A[j-1]:
v = A[j]
A[j] = A[j-1]
A[j-1] = v
flag = 1
counter += 1
print(' '.join([str(A[i]) for i in range(0, N)]))
print(counter)
|
def bubble_sort(a, n):
sw_num = 0
is_swapped = True
i = 0
while is_swapped:
is_swapped = False
for j in range(n-1, i, -1):
if a[j] < a[j-1]:
tmp = a[j]
a[j] = a[j-1]
a[j-1] = tmp
is_swapped = True
sw_num += 1
i += 1
return sw_num
n = int(input())
a = [int(i) for i in input().split()]
sw_num = bubble_sort(a, n)
print(' '.join([str(i) for i in a]))
print(sw_num)
| 1 | 17,339,877,210 | null | 14 | 14 |
def comb(n, k):
nu, de = 1, 1
for i in range(k):
de *= n - i
nu *= i + 1
return de // nu
def ans(N, K):
if K == 0:
return 1
N = str(int(N))
if len(N) < K or int(N) == 0:
return 0
ret = sum([9 ** K * comb(max(dig - 1, 1), K - 1)
for dig in range(K, len(N))])
ret += (int(N[0]) - 1) * 9 ** (K - 1) * comb(len(N) - 1, K - 1)
return ret + ans(N[1:], K - 1)
N = input()
K = int(input())
print(ans(N, K))
|
import sys
from functools import lru_cache
N = int(sys.stdin.readline().rstrip())
K = int(sys.stdin.readline().rstrip())
@lru_cache(None)
def F(N, K):
"""(0以上）N以下で、0でないものがちょうどK個"""
assert N >= 0 # Nが非負であることを保証する
if N < 10: # N が一桁
if K == 0: # 使える 0 以外の数がない場合
return 1 #
if K == 1:
return N # 1,2,...,N までのどれか
return 0 # それ以上 K が余っていたら作れない
q, r = divmod(N, 10) # N = 10*q + r と置く
ret = 0
if K >= 1:
# 1の位(r)が nonzero
ret += F(q, K - 1) * r #
ret += F(q - 1, K - 1) * (9 - r)
# 1の位(r)が zero
ret += F(q, K)
return ret
print(F(N, K))
| 1 | 76,008,840,492,900 | null | 224 | 224 |
ans = [1,2,3]
for i in [0,1]:
y = int(input())
ans.remove(y)
print(ans[0])
|
a=input()
b=input()
if (a=="1" and b=="2")or(a=="2" and b=="1"):
print("3")
if (a=="1" and b=="3")or(a=="3" and b=="1"):
print("2")
if (a=="3" and b=="2")or(a=="2" and b=="3"):
print("1")
| 1 | 110,739,452,948,452 | null | 254 | 254 |
def main():
a = int(input())
b = int(input())
print(6 - a - b)
if __name__ == "__main__":
main()
|
N = int(input())
A = [int(a) for a in input().split()]
cum_A = [0] * N
cum_A[0] = A[0]
for i in range(1, N):
cum_A[i] = cum_A[i - 1] + A[i]
ans = 0
for i in range(N - 1):
inner_sum = cum_A[-1] - cum_A[i]
ans += A[i] * inner_sum
print(ans % (10**9 + 7))
| 0 | null | 57,211,770,933,080 | 254 | 83 |
import sys
def input(): return sys.stdin.readline().rstrip()
class mod_comb3:
def __init__(self,mod=10**9+7,n_max=1):
self.mod,self.n_max=mod,n_max
self.fact,self.inv,self.factinv=[1,1],[0,1],[1,1]
if 1<n_max:setup_table(n_max)
def comb(self,n,r):
if r<0 or n<r:return 0
if self.n_max<n:self.setup_table(n)
return self.fact[n]*(self.factinv[r]*self.factinv[n-r]%self.mod)%self.mod
def setup_table(self,t):
for i in range(self.n_max+1,t+1):
self.fact.append(self.fact[-1]*i%self.mod)
self.inv.append(-self.inv[self.mod%i]*(self.mod//i)%self.mod)
self.factinv.append(self.factinv[-1]*self.inv[-1]%self.mod)
self.n_max=t
def main():
n,k=map(int,input().split())
A=list(map(int,input().split()))
com=mod_comb3()
A.sort()
mod=10**9+7
max_a,min_a=0,0
for i in range(n):
max_a=(max_a+A[i]*com.comb(i,k-1))%mod
min_a=(min_a+A[i]*com.comb(n-i-1,k-1))%mod
print((max_a-min_a)%mod)
if __name__=='__main__':
main()
|
from math import factorial
n,k=map(int,input().split())
a=list(map(int,input().split()))
mod=10**9+7
ans=0
a.sort()
x=(factorial(n-1)*pow(factorial(k-1),mod-2,mod)*pow(factorial(n-k),mod-2,mod))%mod
y=1
for i in range(n-k+1):
ans-=a[i]*x
ans%=mod
x=(x*(n-k-i)*pow(n-i-1,mod-2,mod))%mod
for i in range(k-1,n):
ans+=a[i]*y
ans%=mod
y=(y*(i+1)*pow(i-k+2,mod-2,mod))%mod
print(ans)
| 1 | 95,898,338,699,122 | null | 242 | 242 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
S, T = input().split()
A, B = map(int, input().split())
U = input()
if S == U:
A -= 1
if T == U:
B -= 1
print(A, B)
if __name__ == '__main__':
solve()
|
list1=input().split()
S=list1[0]
T=list1[1]
A,B=map(int,input().split())
U=input()
if U==S:
a=A-1
print(f"{a} {B}")
if U==T:
b=B-1
print(f"{A} {b}")
| 1 | 71,661,856,557,890 | null | 220 | 220 |
S = input()
L = S.split()
a = L[0]
a = int(a)
b = L[1]
b = int(b)
if a < b:
print('a < b')
elif a > b:
print('a > b')
elif a == b:
print('a == b')
|
class SmallLargeOrEqual:
def __init__(self, a, b):
if a < b:
print "a < b"
return
elif a > b:
print "a > b"
return
else:
print "a == b"
return
if __name__ == "__main__":
a,b = map(int,raw_input().split())
SmallLargeOrEqual(a,b)
| 1 | 366,032,898,870 | null | 38 | 38 |
# coding=utf-8
def main():
n = input()
s = ''
for i in range(1, n + 1):
x = i
if x % 3 == 0:
s += ' ' + str(i)
continue
while x:
if x % 10 == 3:
s += ' ' + str(i)
break
x /= 10
print s
if __name__ == '__main__':
main()
|
import math
a = [int(s) for s in input().split()]
b = int(max([a[0], a[1]]))
c = int(min([a[0], a[1]]))
d = 0.5 * (a[2] * 60 + a[3])
e = 6 * a[3]
f = abs(d - int(e))
if f >= 180:
f = 360 - f
if f != 0 and f!= 180:
print(math.sqrt(a[0] ** 2 + a[1] ** 2 - 2 * a[0] * a[1] * math.cos(math.radians(f))))
elif f == 0:
print(b-c)
else:
print(b+c)
| 0 | null | 10,530,115,481,326 | 52 | 144 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
vec = list(range(1, 10))
for i in range(K):
tail = vec[i] % 10
n10 = vec[i] * 10
if tail == 0:
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
elif tail == 9:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
else:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
print(vec[K - 1])
return
if __name__ == '__main__':
main()
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
r = int(readline())
print(r ** 2)
| 0 | null | 92,602,511,558,662 | 181 | 278 |
n, m = map(int, input().split())
in_list = input().split()
vote_list = [int(i) for i in in_list]
ans = 0
for ai in vote_list:
if ai >= 1/(4*m)*sum(vote_list):
ans += 1
if ans < m :
print('No')
else:
print('Yes')
|
n,m,k=map(int,input().split())
par = [-1]*n
num = [0]*n
def find(x):
if par[x]<0:
return x
else:
par[x] = find(par[x])
return par[x]
def union(x, y):
p,q=find(x), find(y)
if p==q:
return
if p>q:
p,q = q,p
par[p] += par[q]
par[q] = p
def size(x):
return -par[find(x)]
def same(x,y):
return find(x)==find(y)
for i in range(m):
a,b=map(int,input().split())
a-=1
b-=1
union(a,b)
num[a]+=1
num[b]+=1
for i in range(k):
c,d=map(int,input().split())
c-=1
d-=1
if same(c,d):
num[c]+=1
num[d]+=1
for i in range(n):
print(size(i)-1-num[i], end=" ")
| 0 | null | 50,409,061,202,250 | 179 | 209 |
N,K,S=list(map(int, input().split()))
L=[0]*N
L[:K]=[S]*K
if S==10**9:
L[K:]=[1]*(N-K)
else:
L[K:]=[10**9]*(N-K)
print(*L)
|
N = int(input())
memo = [1]*(N+1)
for i in range(2,N+1):
tmp = i
while tmp <= N:
memo[tmp] += 1
tmp += i
ans = 0
for key,val in enumerate(memo):
ans += key*val
print(ans)
| 0 | null | 51,280,055,165,470 | 238 | 118 |
n=int(input())
sum=0
for i in range(n+1):
if i%3==0 or i%5==0:
sum+=0
else:
sum+=i
print(sum)
|
N = int(input())
ans=0
for n in range(1, N+1):
ans=ans if n%3==0 or n%5==0 else ans+n
print(ans)
| 1 | 34,735,947,023,140 | null | 173 | 173 |
n = int(input())
s = input()
print(['No','Yes'][s[:n//2]==s[n//2:]])
|
n = int(input())
s = input()
res = "No"
if n%2 == 0 and s[:n//2] *2 ==s:res ="Yes"
print(res)
| 1 | 146,557,505,038,582 | null | 279 | 279 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
def is_ok(l):
cnt = 0
for L in a:
cnt += L // l - 1
if L % l != 0:
cnt += 1
return cnt <= k
def meguru_bisect(ng, ok):
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(meguru_bisect(0, max(a)))
|
s = "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"
t = s.split(", ")
k = int(input())
print(t[k-1])
| 0 | null | 28,166,049,244,830 | 99 | 195 |
s = str(input())
array = list(s)
if array.count("R")==3:print(3)
elif s[1]==("R") and array.count("R")==2:print(2)
elif array.count("R")==0:print(0)
else:print(1)
|
from sys import stdin
test = list(stdin.readline().rstrip())
count = [0,0,0]
i=0
before = 'R'
for str in test:
if str=='R':
count[i] += 1
else:
i = i + 1
print(max(count))
| 1 | 4,933,388,707,432 | null | 90 | 90 |
import sys
x=int(input())
n=1
while(100*n<=x):
if(x<=105*n):
print(1)
sys.exit()
n+=1
print(0)
|
N = int(input())
X = N / 1.08
X_down = int(X)
X_up = int(X) + 1
bool_down = int(X_down * 1.08) == N
bool_up = int(X_up * 1.08) == N
if bool_down:
print(X_down)
elif bool_up:
print(X_up)
else:
print(":(")
| 0 | null | 126,180,249,958,822 | 266 | 265 |
from fractions import Decimal
a,b,c=map(int,input().split())
if a+b+2*(a*b)**Decimal('0.5') < c:
print('Yes')
else:
print('No')
|
# !/usr/local/bin/python3
MOD = int(1e9+7)
def nCk(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n]*(finv[n-k]*finv[k]%MOD)%MOD
def solve():
a.sort()
for i in range(2, MAX_N):
fac[i] = fac[i-1]*i%MOD
inv[i] = MOD-(inv[MOD%i])*(MOD//i)%MOD
finv[i] = finv[i-1]*inv[i]%MOD
max_x = 0
for i in range(k-1, n):
max_x = (max_x+a[i]*nCk(i, k-1))%MOD
min_x = 0
for i in range(n-k+1):
min_x = (min_x+a[i]*nCk(n-i-1, k-1))%MOD
return((max_x-min_x)%MOD)
if __name__ == "__main__":
n, k = list(map(int, input().split()))
a = [(lambda x: int(x))(x) for x in input().split()]
MAX_N = n+5
fac = [1, 1]+[0 for _ in range(MAX_N)]
finv = [1, 1]+[0 for _ in range(MAX_N)]
inv = [0, 1]+[0 for _ in range(MAX_N)]
print(solve())
| 0 | null | 73,793,086,959,592 | 197 | 242 |
t = input() * 2
if input() in t:
print('Yes')
else:
print('No')
|
# coding: utf-8
# Your code here!
s = str(input())
p = str(input())
s2 = s*2
if p in s2:
print("Yes")
else:
print("No")
| 1 | 1,709,348,916,340 | null | 64 | 64 |
n = int(input())
print(1000 - n%1000 if n%1000 else 0)
|
S = int(input())
if S % 1000 == 0:
W = 0
else:
W = 1000-(S % 1000)
print(W)
190
| 1 | 8,436,367,437,520 | null | 108 | 108 |
N = int(input())
x = input().strip()
cnt = 0
for i in range(N):
if x[i]=="R":
cnt += 1
if cnt==0 or cnt==N:
print(0)
else:
ans = 0
for i in range(cnt):
if x[i]=="W":
ans += 1
print(ans)
|
N = int(input())
#stones = list(input())
stones = input()
#print(stones)
a = stones.count('W')
b = stones.count('R')
left_side =stones.count('W', 0, b)
print(left_side)
| 1 | 6,269,143,376,260 | null | 98 | 98 |
from collections import deque as D
line, stack = D(input().split()), D()
while line:
hoge = line.popleft()
if hoge.isdigit():
stack.append(hoge)
else:
a, b = int(stack.pop()), int(stack.pop())
if hoge == "*":
stack.append(a*b)
elif hoge == "+":
stack.append(a+b)
elif hoge == "-":
stack.append(b-a)
else:
stack.append(b//a)
print(stack.popleft())
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
????????????
???????????????????¨???????????????????????????????????????????????¨???°????????°??????????????°??????????¨???°???????¨??????§??????
????????°????????¬?????????????¨??????§?¨???°???????????°??? (1+2)*(5+4) ??????
???????????????????¨??????§??? 1 2 + 5 4 + * ??¨?¨???°???????????????
???????????????????¨??????§?????????????¨??????§????????¨????????¬??§???????????§???????????¨????????????????????????????????????
???????????????????¨??????§?????????????????°???????¨????????????????????????????????????????
"""
# ?????????
INP = list(input().strip().split())
TMP = []
res = 0
for i in INP:
if i == "+":
b = TMP.pop()
a = TMP.pop()
TMP.append(a + b)
# print("{} - {} = {}".format(a,b,a+b))
elif i == "-":
b = TMP.pop()
a = TMP.pop()
TMP.append(a - b)
# print("{} - {} = {}".format(a,b,a-b))
elif i == "*":
b = TMP.pop()
a = TMP.pop()
TMP.append(a * b)
# print("{} * {} = {}".format(a,b,a*b))
else:
TMP.append(int(i))
print(TMP.pop())
| 1 | 36,087,163,010 | null | 18 | 18 |
num = input().split()
x = [int(num) for num in num]
for i in range(5):
if x[i] == 0:
print(i+1)
|
n = int(input())
nn = n**2
nnn = n**3
print(n+nn+nnn)
| 0 | null | 11,737,508,487,580 | 126 | 115 |
for a in range(1,10):
for b in range(1,10):
print("%dx%d=%d" % (a,b,a*b))
|
for number1 in range(1, 10) :
for number2 in range(1, 10) :
print(str(number1) + 'x' + str(number2) + '=' + str(number1 * number2))
| 1 | 3,336,928 | null | 1 | 1 |
x = int(input())
print(1 if x-x//100*100 <= x//100*5 else 0)
|
N, K = map(int, input().split())
mod = 10**9 + 7
fact_count = [0 for _ in range(K+1)]
for k in range(1, K+1):
fact_count[k] = K//k
ans = 0
count = [0 for _ in range(K+1)]
for k in range(K, 0, -1):
c = pow(fact_count[k], N, mod)
j = 2*k
l = 2
while(j<=K):
c -= count[j]
l += 1
j = k*l
count[k] = c
c = c*k%mod
ans += c
ans %= mod
print(ans)
| 0 | null | 82,013,461,048,188 | 266 | 176 |
A = input()
print('A') if A.isupper() else print('a')
|
α = input()
if α.isupper() == True:
print('A')
elif α.islower() == True:
print('a')
| 1 | 11,366,234,451,582 | null | 119 | 119 |
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
sys.setrecursionlimit(500000)
mod=10007
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n=int(input())
a=list(map(int,input().split()))
lst=ruiseki(a)
asum=sum(a)
# print(asum)
# print(lst)
cnt=bisect.bisect_left(lst,asum/2)
# print(cnt)
if asum//2==lst[cnt]:
print(0)
else:
if asum%2==0:
print(2*min(asum//2-lst[cnt-1],lst[cnt]-asum//2))
else:
print(min((asum//2-lst[cnt-1])*2+1,(lst[cnt]-asum//2)*2-1))
|
n=int(input())
a=list(map(int,input().split()))
tot=sum(a)
b=0
c=10**10
d=0
for i in range(n):
b+=a[i]
d=abs(tot/2 - b)
if d<c:
c=d
print(int(2*c))
| 1 | 142,415,396,681,288 | null | 276 | 276 |
import sys
from collections import deque
n,m=map(int,input().split())
s=input()
if n<=m:
print(n)
sys.exit()
lst=[0]*(n+1)
for i in range(1,m+1):
if s[i]=="0":
lst[i]=i
left=1
right=m+1
k=0
while left<n:
if s[left]=="0":
while right-left<=m:
if s[right]=="0":
lst[right]=right-left
right+=1
if right==n+1:
k=n
break
left+=1
if left==right or k==n:
break
if lst[n]==0:
print(-1)
else:
ans=deque([])
while k>0:
c=lst[k]
ans.appendleft(c)
k-=c
print(*ans)
|
k=int(input())
a,b=map(int,input().split())
if b//k-(a-1)//k==0 : print("NG")
else : print("OK")
| 0 | null | 82,607,116,064,032 | 274 | 158 |
n = int(input())
a = list(map(int, input().split()))
i = 1
if 0 in a:
i = 0
else:
for j in range(n):
if i >= 0:
i = i * a[j]
if i > 10 ** 18:
i = -1
print(int(i))
|
n = int(input())
mod = 10**18
li = list(map(int, input().split()))
li.sort()
ans = 1
for i in range(n):
ans *= li[i]
if ans > mod:
ans = -1
break
print(ans)
| 1 | 16,144,563,544,160 | null | 134 | 134 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
N = int(input())
adj = [ [] for _ in range(N) ]
for i in range(N-1):
a,b = map(int,input().split())
a -= 1
b -= 1
adj[a].append((b,i))
res = [None] * (N-1)
def dfs(n, c=-1, p=-1):
if c==-1 or c>1:
nc = 1
else:
nc = c+1
for nei,i in adj[n]:
if nei == p: continue
res[i] = nc
dfs(nei, nc, n)
nc += 1
if nc==c: nc += 1
dfs(0)
print(max(res))
for r in res: print(r)
|
def main():
H, W, M = map(int, input().split())
# H, W, M = (3 * 10 ** 5, 3 * 10 ** 5, 3 * 10 ** 5)
row = [0] * (H + 1)
row_set = [set() for _ in range(H+1)]
column = [0] * (W + 1)
column_set = [set() for _ in range(W+1)]
# import random
ms = []
positions = set()
for m in range(M):
h, w = map(int, input().split())
positions.add((h, w))
# h, w = (random.randrange(3*10**5), random.randrange(3*10**5))
row[h] += 1
row_set[h].add(w)
column[w] += 1
column_set[w].add(h)
max_rows = set()
maxR = -1
for i, v in enumerate(row[1:]):
if v > maxR:
max_rows = set()
max_rows.add(i+1)
maxR = v
elif v == maxR:
max_rows.add(i+1)
max_cols = set()
maxC = -1
for i, v in enumerate(column[1:]):
if v > maxC:
max_cols = set()
max_cols.add(i+1)
maxC = v
elif v == maxC:
max_cols.add(i + 1)
for y in max_rows:
for x in max_cols:
if not (y, x) in positions:
print(maxR + maxC)
exit()
print(maxR + maxC - 1)
main()
| 0 | null | 70,130,549,475,758 | 272 | 89 |
from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def main():
s = input()
if s[2] == s[3] and s[4] == s[5]:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
|
from sys import stdin
def main():
s = stdin.readline()[:-1]
print('Yes') if s[2] == s[3] and s[4] == s[5] else print('No')
if __name__ == "__main__":
main()
| 1 | 41,834,850,124,060 | null | 184 | 184 |
n = int(input())
P = list(map(int, input().split()))
minSoFar = 2 * 10**5 + 1
ans = 0
for i in range(n):
if P[i] < minSoFar:
ans += 1
minSoFar = min(minSoFar, P[i])
print(ans)
|
N = int(input())
minP = N
count = 0
for pi in map(int, input().split()):
minP = min(minP, pi)
if pi <= minP:
count += 1
print(count)
| 1 | 85,309,970,309,240 | null | 233 | 233 |
def main():
s = int(input())
if s < 3:
print(0)
else:
total = [0]*(s+1)
total[3] = 1
mod = 10**9+7
for i in range(4, s+1):
total[i] = (total[i-3] + 1) + total[i-1]
total[i] %= mod
print((total[s-3]+1)%mod)
if __name__ == "__main__":
main()
|
max_n=10**5
mod=10**9+7
frac=[1]
for i in range(1,max_n+1):
frac.append((frac[-1]*i)%mod)
inv=[1,1]
inv_frac=[1,1]
for i in range(2,max_n):
inv.append((mod-inv[mod%i]*(mod//i))%mod)
inv_frac.append((inv_frac[-1]*inv[-1])%mod)
def perm(m,n):
if m<n:
return 0
if m==1:
return 1
return (frac[m]*inv_frac[m-n])%mod
def comb(m,n):
if m<n:
return 0
if m==1:
return 1
return (frac[m]*inv_frac[n]*inv_frac[m-n])%mod
s=int(input())
c=0
for i in range(1,s//3+1):
ss=s-i*3
c=(c+comb(ss+i-1,i-1))%mod
print(c)
| 1 | 3,312,930,372,672 | null | 79 | 79 |
S = input()
A = [0]*(len(S)+1)
for i in range(len(S)):
if S[i] == "<":
A[i+1] = A[i]+1
for i in range(len(S)-1, -1, -1):
if S[i] == ">":
A[i] = max(A[i], A[i+1]+1)
print(sum(A))
|
import sys
import copy
import math
import itertools
import numpy as np
S=input()
N = len(S)+1
a = [0]*N
b = [0]*N
for i in range(N-1):
if S[i]=="<":
a[i+1]=a[i]+1
for i in reversed(range(N-1)):
if S[i]==">":
b[i]=b[i+1]+1
for i in range(N):
if a[i] < b[i]:
a[i]=b[i]
print(sum(a))
| 1 | 156,909,952,995,742 | null | 285 | 285 |
m1,d1 = map(int,input().split())
m2,d2 = map(int,input().split())
print(1 if m1!=m2 else 0)
|
m1,d1=map(int,input().split())
m2,d2=map(int,input().split())
if m1!=m2:
print(1)
else:print(0)
| 1 | 124,547,232,206,332 | null | 264 | 264 |
n = int(input())
a = [int(i) for i in input().split()]
a.sort(reverse=True)
i = 1
ans = a[0]
c = 1
while c < n - 1:
k = min(2, n - 1 - c)
c += k
ans += a[i] * k
i += 1
print(ans)
|
n = int(input())
lis = list(map(int,input().split()))
lis = sorted(lis, reverse=True)
ans = lis[0]
res = []
for i in range(1,n):
res.append(lis[i])
res.append(lis[i])
for i in range(n - 2):
ans += res[i]
print(ans)
| 1 | 9,217,378,776,386 | null | 111 | 111 |
def i_miss_you():
# 入力
S = input()
# 初期処理
string = ''
# 処理
for _ in range(len(S)):
string += 'x'
return string
result = i_miss_you()
print(result)
|
s=input('')
t=''
for a in s:
t=t+'x'
print(t)
| 1 | 73,073,137,566,520 | null | 221 | 221 |
def insert_sort():
n = int(input())
A = [int(x) for x in input().split()]
print(*A)
for i in range(1,n):
v = A[i]
j = i - 1
while j >= 0 and A[j] > v:
A[j+1] = A[j]
j -= 1
A[j+1] = v
print(*A)
if __name__ == "__main__":
insert_sort()
|
n=int(input())
a=input().split()
for i in range(n):
k=int(a[i])
j=i-1
while j>=0 and int(a[j])>k:
a[j+1]=a[j]
j-=1
a[j+1]=k
print(*a)
| 1 | 5,565,634,930 | null | 10 | 10 |
n,m = map(int,input().split())
if 0 < n and n < 10 and 0 < m and m < 10:
print(n*m)
else:
print(-1)
|
import sys
a, b = map(int, sys.stdin.readline().split())
if a <= 9 and b <= 9:
print(a*b)
else:
print(-1)
| 1 | 158,437,970,491,680 | null | 286 | 286 |
n = input()
lis = []
bot = 0
for i in xrange(n):
com = raw_input()
if com[0] == 'i':
lis.append(com[7:])
elif com[6] == ' ':
try:
lis.pop(~lis[::-1].index(com[7:]))
except:
pass
elif com[6] == 'F':
lis.pop()
else:
bot += 1
print ' '.join( map(str, reversed(lis[bot:])) )
|
def main():
n = int(input())
x = int(n/1.08)
if int(x * 1.08) == n:
print(x)
elif int((x + 1) * 1.08) == n:
print(x + 1)
elif int((x - 1) * 1.08) == n:
print(x - 1)
else:
print(":(")
if __name__ == "__main__":
main()
| 0 | null | 63,038,371,376,828 | 20 | 265 |
n = int(input())
output = ""
for i in range(1,n+1):
if i % 3 == 0:
output += " %s" % (i,)
continue
elif i % 10 == 3:
output += " %s" % (i,)
continue
x = i
while x > 1:
x = int(x/10)
if x % 10 == 3:
output += " %s" % (i,)
break
print(output)
|
n = int(input())
for i in range(1, n + 1):
if i % 3 == 0 or str(i).find("3") != -1:
print(" {}".format(i), end = '')
print()
| 1 | 923,643,744,558 | null | 52 | 52 |
import sys
input = sys.stdin.readline
from collections import *
N = int(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)
|
def main():
s = list(input())
k = int(input())
lst = []
cnt = 1
flg = 0
ans = 0
prev = s[0]
for i in range(1, len(s)):
if prev == s[i]:
cnt += 1
else:
lst.append(cnt)
cnt = 1
prev = s[i]
flg = 1
lst.append(cnt)
if len(lst) == 1:
ans = len(s) * k // 2
else:
ans += sum(map(lambda x: x // 2, lst[1:len(lst)-1])) * k
# for l in lst[1: len(lst) - 1]:
# ans += l // 2 * k
if s[-1] == s[0]:
ans += (lst[0] + lst[-1]) // 2 * (k - 1)
ans += lst[0] // 2 + lst[-1] // 2
else:
ans += (lst[0] // 2 + lst[-1] // 2) * k
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 171,991,678,788,992 | 292 | 296 |
H,W,K = map(int, input().split())
ans = 0
board =[list(input()) for _ in range(H)]
for paint_H in range(2 ** H): #行の塗りつぶし方の全列挙
for paint_W in range(2 ** W): #列の塗りつぶし方の全列挙
cnt = 0
for i in range(H):
for j in range(W):
if (paint_H>>i)&1==0 and (paint_W>>j)&1==0:
if board[i][j] == '#':
cnt += 1
if cnt == K:
ans += 1
print(ans)
|
coin , mon = map(int,input().split())
if coin*500 >= mon:
print("Yes")
else:
print("No")
| 0 | null | 53,351,092,330,460 | 110 | 244 |
"""D."""
import sys
def input() -> str: # noqa: A001
"""Input."""
return sys.stdin.readline()[:-1]
class UnionFindTree:
"""Union-find."""
def __init__(self, n: int) -> None:
"""Init."""
self.n = n
self.rank = [-1] * n
def find_root(self, x: int) -> int:
"""Find root."""
if self.rank[x] < 0:
return x
self.rank[x] = self.find_root(self.rank[x])
return self.rank[x]
def union(self, x: int, y: int) -> None:
"""Unite two trees."""
x_root = self.find_root(x)
y_root = self.find_root(y)
if x_root == y_root:
return
if x_root > y_root:
x_root, y_root = y_root, x_root
self.rank[x_root] += self.rank[y_root]
self.rank[y_root] = x_root
def get_size(self, x: int) -> int:
"""Get size."""
return self.rank[self.find_root(x)] * -1
def is_same(self, x: int, y: int) -> bool:
"""Is same group."""
return self.find_root(x) == self.find_root(y)
n, m = map(int, input().split(' '))
tree = UnionFindTree(n)
for _ in range(m):
a, b = map(int, input().split(' '))
tree.union(a - 1, b - 1)
ans = 0
for i in range(n):
ans = max(ans, tree.get_size(i))
print(ans)
|
class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
return self.find(x) == self.find(y)
def get_size(self, x):
x = self.find(x)
return self.size[x]
N, M = map(int, input().split())
u = UnionFind(N+1)
for i in range(M):
A, B = map(int, input().split())
u.union(A, B)
print(max([u.get_size(i) for i in range(1, N+1)]))
| 1 | 3,894,075,270,502 | null | 84 | 84 |
a,b,n=map(int,input().split())
if a%n == 0 and b%n == 0:
print((b//n) - (a//n) + 1)
else:
print((b//n) - (a//n))
|
MOD = 10**9 + 7
def xgcd(a, b):
x0, y0, x1, y1 = 1, 0, 0, 1
while b != 0:
q, a, b = a // b, b, a % b
x0, x1 = x1, x0 - q * x1
y0, y1 = y1, y0 - q * y1
return a, x0, y0
def modinv(a, mod):
g, x, y = xgcd(a, mod)
assert g == 1, 'modular inverse does not exist'
return x % mod
factorials = [1]
def factorial(n, mod):
# n! % mod
assert n >= 0, 'Argument Error! n is "0 <= n".'
if len(factorials) < n+1:
for i in range(len(factorials), n+1):
factorials.append(factorials[-1]*i % mod)
return factorials[n]
def comb(n, r, mod):
# nCr % mod
assert n >= 0, 'Argument Error! n is "0 <= n".'
assert n >= r >= 0, 'Argument Error! r is "0 <= r <= n".'
return perm(n, r, mod) * modinv(factorial(r, mod), mod) % mod
def perm(n, r, mod):
# nPr % mod
assert n >= 0, 'Argument Error! n is "0 <= n".'
assert n >= r >= 0, 'Argument Error! r is "0 <= r <= n".'
return factorial(n, mod) * modinv(factorial(n-r, mod), mod) % mod
x, y = sorted(map(int, input().split()))
MOD = 10 ** 9 + 7
q, r = divmod(x+y, 3)
if r != 0:
print(0)
else:
try:
print(comb(q, y - q, MOD))
except AssertionError:
print(0)
| 0 | null | 78,423,644,758,640 | 104 | 281 |
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
S = list(map(int, LS()))
S = S[::-1]
ln = len(S)
mod = 2019
times = 1
for i in range(ln):
S[i] = S[i] * times
times = times * 10 % mod
R = [0] * (ln+1)
memo = {0: 1}
ans = 0
for i in range(1, ln+1):
tmp = (R[i-1] + S[i-1]) % mod
R[i] = tmp
cnt = memo.get(tmp, 0)
ans = ans + cnt
memo[tmp] = cnt + 1
print(ans)
if __name__ == '__main__':
solve()
|
s=input()
ls=len(s)
m=[0]*(2019)
m[0]+=1
cnt = 0
b = 0
for i in range(ls):
a = (b + pow(10,cnt,2019)*int(s[ls - i -1])) % 2019
m[a] += 1
b = a
cnt += 1
ans = 0
for i in m:
if i <= 1:
continue
ans += i*(i-1)//2
print(ans)
| 1 | 30,812,083,255,670 | null | 166 | 166 |
n,a,b = map(int,input().split())
num1 = n%(a+b)
num2 = n//(a+b)
print(num2*a+min(num1,a))
|
#B
N, A, B=map(int, input().split())
quotient=N//(A+B)
remainder=N%(A+B)
quo_bball=quotient*A
if remainder <=A:
rem_bball=remainder
else:
rem_bball=A
print(quo_bball+rem_bball)
| 1 | 55,826,558,887,428 | null | 202 | 202 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations
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():
x = I()
if 599 >= x >= 400:
print(8)
elif 799 >= x >= 600:
print(7)
elif 999 >= x >= 800:
print(6)
elif 1199 >= x >= 1000:
print(5)
elif 1399 >= x >= 1200:
print(4)
elif 1599 >= x >= 1400:
print(3)
elif 1799 >= x >= 1600:
print(2)
elif 1999 >= x >= 1800:
print(1)
return
# Solve
if __name__ == "__main__":
solve()
|
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from functools import reduce
# from math import *
from fractions import *
N, M = map(int, readline().split())
A = list(map(lambda x: int(x) // 2, readline().split()))
def f(n):
cnt = 0
while n % 2 == 0:
n //= 2
cnt += 1
return cnt
t = f(A[0])
for i in range(N):
if f(A[i]) != t:
print(0)
exit(0)
A[i] >>= t
M >>= t
lcm = reduce(lambda a, b: (a * b) // gcd(a, b), A)
if lcm > M:
print(0)
exit(0)
print((M // lcm + 1) // 2)
| 0 | null | 54,198,477,070,748 | 100 | 247 |
import sys
input = sys.stdin.readline
s,t=input().rstrip().split()
a,b=map(int,input().split())
u=input().rstrip()
if u == s:
print(a-1,b)
else:
print(a,b-1)
|
#!/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 solve(S: str, T: str, A: int, B: int, U: str):
return f"{A-(S==U)} {B-(T==U)}"
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
T = next(tokens) # type: str
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
U = next(tokens) # type: str
print(f'{solve(S, T, A, B, U)}')
if __name__ == '__main__':
main()
| 1 | 72,103,389,377,660 | null | 220 | 220 |
x=int(input())
for i in range(3,11):
if x<i*200:
print(11-i)
break
|
import bisect
n = int(input())
L = list(map(int,input().split()))
L.sort()
ans = 0
for a in range(0,n):
for b in range(a+1,n):
p = bisect.bisect_left(L, L[a]+L[b])
ans += max(p-(b+1),0)
print(ans)
| 0 | null | 89,500,513,411,104 | 100 | 294 |
N = int(input())
A = list(map(int,input().split()))
MOD = 1000000007
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
lcma={}
for ai in A:
f=factorization(ai)
for fi in f:
if fi[0] in lcma:
lcma[fi[0]]=max(lcma[fi[0]],fi[1])
else:
lcma[fi[0]]=fi[1]
l=1
for k,v in lcma.items():
l*=pow(k,v,MOD)
l%=MOD
ans=0
for ai in A:
ans+=l*pow(ai,MOD-2,MOD)
ans%=MOD
print(ans)
|
import sys
from functools import reduce
from math import gcd
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
mod = 10 ** 9 + 7
N = int(readline())
A = list(map(int,readline().split()))
lcm = reduce(lambda x,y:x*y//gcd(x,y),A)
ans = 0
coef = sum(pow(x,mod-2,mod) for x in A)
ans = lcm * coef % mod
print(ans)
| 1 | 87,552,624,063,958 | null | 235 | 235 |
k=int(input())
a=7%k
for i in range(k+1):
if a==0:
print(i+1)
break
a=(a*10+7)%k
else:
print(-1)
|
N,X,T=map(int,input().split())
a=N//X
b=N%X
if b!=0:
print((a+1)*T)
else:
print(a*T)
| 0 | null | 5,188,470,820,988 | 97 | 86 |
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return map(list, zip(*read_all))
#################
def floor(a,b):
return a//b
N,X,M = LI()
# 繰り返しの1回目が終わるまで
used = [-1]*M
end_index = -1
A = [X]
sum_ = 0
for i in range(N):
if i == 0:
sum_ += A[0]
else:
val = pow(A[i-1],2,M)
A.append(val)
if used[val] == -1:
used[val] = i
sum_ += val
else:
end_index = i
start_val = val
start_index = used[val]
break
if end_index == -1:
print(sum_)
exit()
else:
ans = sum_
# 繰り返し全体が終わるまで
n = floor(N-start_index,end_index-start_index)
sum_ = 0
A2 = [start_val]
for j in range(end_index-start_index):
if j == 0:
val2 = start_val
sum_ += val2
else:
val2 = pow(A2[j-1],2,M)
A2.append(val2)
sum_ += val2
ans += (n-1)*sum_
# 残りの部分
sum_ = 0
A2 = [start_val]
for j in range(N-n*end_index+(n-1)*start_index):
if j == 0:
val2 = start_val
sum_ += val2
else:
val2 = pow(A2[j-1],2,M)
A2.append(val2)
sum_ += val2
ans += sum_
print(ans)
|
N, X, M = map(int, input().split())
existence = [False] * M
a = []
A = X
for i in range(N):
if existence[A]:
break
existence[A] = True
a.append(A)
A = A * A % M
for i in range(len(a)):
if a[i] == A:
break
loop_start = i
result = sum(a[:loop_start])
a = a[loop_start:]
N -= loop_start
loops = N // len(a)
remainder = N % len(a)
result += sum(a) * loops + sum(a[:remainder])
print(result)
| 1 | 2,825,471,760,998 | null | 75 | 75 |
H1,M1,H2,M2,K = (int(x) for x in input().split())
Wake = 60*H1+M1
Sleep = 60*H2+M2
Activate = Sleep - Wake
CanStudy = Activate - K
print(int(CanStudy))
|
h1, m1, h2, m2, k = map(int, input().split())
H = h2 - h1
if m1 <= m2:
M = m2 - m1
else:
M = 60 - m1 + m2
H -= 1
print(H*60 + M - k)
| 1 | 17,923,966,637,680 | null | 139 | 139 |
n, m = map(int, input().split())
sc = [list(map(int, input().split())) for _ in range(m)]
def f():
if m == 0:
if n == 1:
return 0
elif n == 2:
return 10
elif n == 3:
return 100
else:
for i in range(1000):
x = str(i)
if len(x) == n:
cnt = 0
for j in range(m):
if x[sc[j][0] - 1] == str(sc[j][1]):
cnt += 1
if cnt == m:
return x
elif x[sc[j][0] - 1] != str(sc[j][1]):
break
return -1
print(f())
|
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
n,m=nii()
l=[lnii() for i in range(m)]
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.parents[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
uf=UnionFind(n)
for a,b, in l:
a-=1
b-=1
if uf.same(a,b)==False:
uf.union(a,b)
ans=0
roots=uf.roots()
for i in uf.roots():
ans=max(ans,uf.size(i))
print(ans)
| 0 | null | 32,539,017,214,240 | 208 | 84 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.