code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
# エラトステネスの篩
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
def f(X):
t = []
a = X
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]
result = 1
for _, n in t:
result *= n + 1
return result
N = int(input())
prime_table = make_prime_table(N)
result = 0
for K in range(1, N + 1):
result += K * f(K)
print(result)
| N, M = map(int, input().split())
pena= 0
ac = [0]*(10**5)
for _ in range(M):
tmp = input().split()
if ac[int(tmp[0])-1] < 1:
if tmp[1] == "AC":
pena -= ac[int(tmp[0])-1]
ac[int(tmp[0])-1] = 1
else: ac[int(tmp[0])-1] -= 1 #penalty
print(ac.count(1), pena) | 0 | null | 51,967,858,486,220 | 118 | 240 |
def bubble_sort(numbers, n):
"""bubble sort method
Args:
numbers: a list of numbers to be sorted by bubble sort
n: len(list)
Returns:
sorted list
"""
flag = True
counter = 0
while flag:
flag = False
for index in range(n - 1, 0, -1):
if numbers[index] < numbers[index - 1]:
numbers[index], numbers[index - 1] = numbers[index - 1], numbers[index]
flag = True
counter += 1
return numbers, counter
n = int(raw_input())
numbers = [int(x) for x in raw_input().split()]
numbers, swapped_numbers = bubble_sort(numbers, n)
print(" ".join([str(x) for x in numbers]))
print(swapped_numbers) | import sys
def lower(word):
Word = ''
str = list(word)
for i in range(len(str)):
if str[i].isupper(): Word += str[i].lower()
else: Word += str[i]
return Word
a = []
for line in sys.stdin:
a.extend(list(line))
count = [0] * 26
for i in range(len(a)):
a[i] = lower(a[i])
if 97 <= ord(a[i]) and ord(a[i]) < 123:
count[ord(a[i]) - 97] += 1
for i in range(26):
print(chr(i + 97) + ' : ' + str(count[i]))
| 0 | null | 827,239,215,400 | 14 | 63 |
import sys
from operator import mul
from functools import reduce
from collections import Counter
n = int(input())
s = input()
c = Counter(s)
if len(c) != 3:
print(0)
sys.exit()
ans = reduce(mul, c.values())
for i in range(n - 1):
x, y, z = i, i + 1, i + 2
while z <= n - 1:
if s[x] != s[y] and s[x] != s[z] and s[y] != s[z]:
ans -= 1
y += 1
z += 2
print(ans) | print(input().translate(str.maketrans('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')))
| 0 | null | 18,715,159,718,710 | 175 | 61 |
def f(x, m):
return (x**2) % m
N, X, M = map(int, input().split())
A = [X]
S = {X}
while True:
X = f(X, M)
if X in S:
break
else:
A.append(X)
S.add(X)
start = A.index(X)
l = len(A) - start
ans = sum(A[:start])
N -= start
ans += sum(A[start:]) * (N//l)
N %= l
ans += sum(A[start:start+N])
print(ans) | n = int(raw_input())
minv = int(raw_input())
maxv = -1*10**9
for j in range(n-1):
a = int(raw_input())
b = a- minv
if maxv < b:
maxv = b
if minv > a:
minv = a
print maxv | 0 | null | 1,427,201,367,920 | 75 | 13 |
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def make4(initial, L, M, N, O):
return [[[[initial for i in range(O)]
for n in range(N)]
for m in range(M)]
for l in range(L)]
def make3(initial, L, M, N):
return [[[initial for n in range(N)]
for m in range(M)]
for l in range(L)]
def debug(table, *args):
ret = []
for name, val in table.items():
if val in args:
ret.append('{}: {}'.format(name, val))
print(' | '.join(ret), file=sys.stderr)
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
N = I()
A = LI()
dp_use = [-IINF] * 3
dp_not_use = [-IINF] * 3
dp_not_use[0] = 0
for i in range(N):
dp_use_next = [-IINF] * 3
dp_not_use_next = [-IINF] * 3
for j in range(3):
if j - 1 >= 0:
dp_not_use_next[j] = max(dp_use[j], dp_not_use[j-1])
else:
dp_not_use_next[j] = dp_use[j]
dp_use_next[j] = dp_not_use[j] + A[i]
# print('dp_use ', *[a if a > -10**10 else '-IINF' for a in dp_use_next])
# print('dp_not_use', *[a if a > -10**10 else '-IINF' for a in dp_not_use_next])
dp_use = dp_use_next
dp_not_use = dp_not_use_next
if N % 2 == 0:
print(max(dp_use[1], dp_not_use[0]))
else:
print(max(dp_use[2], dp_not_use[1]))
if __name__ == '__main__':
main()
| n=int(input());l=list(map(int,input().split()));p=[0]*n;d=[0]*n
for i in range(n):p[i]=l[i]+p[i-2];d[i]=max(p[i-1]if i&1else d[i-1],l[i]+d[i-2])
print(d[-1]) | 1 | 37,487,463,327,108 | null | 177 | 177 |
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7
a, v = MAP()
b, w = MAP()
t = INT()
if a == b:
YES()
exit()
if w >= v:
NO()
exit()
diff = v - w
dist = abs(a-b)
if diff*t >= dist:
YES()
else:
NO()
| a,v = map(int,input().split())
b,m = map(int,input().split())
n = int(input())
dis = abs(a-b)
a_move = n*v
b_move = n*m
if dis+b_move - a_move <= 0:
print('YES')
else:
print('NO') | 1 | 15,135,558,352,540 | null | 131 | 131 |
N, K = map(int, input().split())
x = 10
y = 10 + N
ans = 0
a = x
b = y
for i in range(1, N + 2):
if i >= K:
ans += b - a + 1
a += (x + i)
b += (y - i)
print(ans % (10 ** 9 + 7))
| pai = 3.141592653589793
r = float(input())
s = pai * r ** 2
l = 2 * pai * r
print(s, l)
| 0 | null | 16,772,849,804,308 | 170 | 46 |
N, K, C = list(map(int, input().split(" ")))
S = input()
F_list = []
B_list = []
f_count = 0
b_count = 0
f_rest = 0
b_rest = 0
S_len = len(S)
# o
for i in range(S_len):
if f_count == K and b_count == K:
break
if f_count < K:
if S[i] == "o" and f_rest == 0:
f_rest += C
f_count += 1
F_list.append(i+1)
else:
if f_rest > 0:
f_rest -= 1
if b_count < K:
if S[-(i+1)] == "o" and b_rest == 0:
b_rest += C
b_count += 1
B_list.append(S_len-i)
else:
if b_rest > 0:
b_rest -= 1
for i in range(K):
if F_list[i] == B_list[-(i+1)]:
print(F_list[i])
| N,K,C = map(int,input().split())
S = input()
left, right = [], []
d = 0
while d < N and len(left) < K:
if S[d] == 'o':
left.append(d)
d += C + 1
else:
d += 1
d = N - 1
while d >= 0 and len(right) < K:
if S[d] == 'o':
right.append(d)
d -= C + 1
else:
d -= 1
right.sort()
ans = []
for i in range(K):
if left[i] == right[i]:
ans.append(left[i])
for c in ans:
print(c+1) | 1 | 40,722,292,676,000 | null | 182 | 182 |
m=[0]*50
f=[0]*50
r=[0]*50
result=[""]*50
num=0
while True:
a,b,c=map(int,input().split())
if a == b == c ==-1:
break
else:
m[num],f[num],r[num]=a,b,c
num+=1
for i in range(num):
if m[i] == -1 or f[i]==-1:
result[i]="F"
elif m[i]+f[i]>=80:
result[i]="A"
elif m[i]+f[i]>=65:
result[i]="B"
elif m[i]+f[i]>=50:
result[i]="C"
elif m[i]+f[i]>=30:
if r[i] >=50:
result[i]="C"
else:
result[i]="D"
else:
result[i]="F"
for i in range(num):
print(result[i])
| while True:
m, f, r = map(int, (input().split()))
score = m + f
if m == f == r == -1:
break
else:
if m == -1 or f == -1:
print("F")
elif score >= 80:
print("A")
elif 80 > score >= 65:
print("B")
elif 65 > score >= 50:
print("C")
elif 50 > score >= 30 and r >= 50:
print("C")
elif 50 > score >= 30 and r < 50:
print("D")
else:
print("F") | 1 | 1,214,452,581,728 | null | 57 | 57 |
S = input()
N = len(S)
K = int(input())
dp = [[[0 for _ in range(5)] for _ in range(2)] for _ in range(N+5)]
dp[1][0][1] = 1
dp[1][1][0] = 1
dp[1][1][1] = int(S[0])-1
for i in range(1, N):
n = int(S[i])
ok = 0 if n == 0 else 1
for j in range(4):
dp[i+1][0][j+ok] += dp[i][0][j]
if n > 0:
dp[i+1][1][j] += dp[i][0][j]
dp[i+1][1][j+1] += (n-1)*dp[i][0][j]
dp[i+1][1][j] += dp[i][1][j]
dp[i+1][1][j+1] += 9*dp[i][1][j]
print(dp[N][0][K]+dp[N][1][K]) | import math
n=int(input())
print(int(360/math.gcd(n,360))) | 0 | null | 44,459,819,179,792 | 224 | 125 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
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():
t = LI()
a = LI()
b = LI()
a[0] -= b[0]
a[1] -= b[1]
if t[0]*a[0] == -t[1]*a[1]:
print("infinity")
return
if a[0] < 0:
a[0] *= -1
a[1] *= -1
if t[0]*a[0]+t[1]*a[1] > 0:
print(0)
return
A = t[0]*a[0]+t[1]*a[1]
k = t[0]*a[0]
l = 0
r = 10**20
while r-l > 1:
x = (l+r) >> 1
if A*x+k > 0:
l = x
else:
r = x
ans = 2*l+1
if A*r+k == 0:
ans += 1
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| import sys
input = sys.stdin.readline
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
T=LI()
A=LI()
B=LI()
d1=(A[0]-B[0])*T[0]
d2=(A[1]-B[1])*T[1]
if d1>=0:
#最初は必ず正の方向へいかないように調整
d1*=-1
d2*=-1
if d1+d2==0:
print("infinity")
elif d1==0:#d1=0のパターンを排除した
print(0)
elif d1+d2<=0:
print(0)
else:
cnt=(-1*d1)//(d1+d2)
ans=cnt*2+1
if cnt*(d1+d2)==-1*d1:
ans-=1
print(ans)
main()
| 1 | 131,443,744,749,148 | null | 269 | 269 |
from collections import Counter
n = int(input())
d = list(input() for _ in range(n))
D = Counter(d)
m = max(D.values())
l = []
for i,j in D.most_common():
if m != j:
break
l.append(i)
l.sort()
for i in l:
print(i) | while 1:
H, W = map(int, input().split())
if (H == 0 and W == 0) : break
for i in range(H):
x = ""
for j in range(W):
x += "#"
print(x)
print("") | 0 | null | 35,413,875,405,952 | 218 | 49 |
n = int(input())
list_ = [0]*n
joshi_list = list(map(int, input().split()))[::-1]
for i,num in enumerate(joshi_list):
list_[num-1]+=1
for num in list_:
print(num) | n = int(input())
minv = int(input())
maxv = (10**9)*(-1)
for j in range(1,n):
r = int(input())
if maxv < (r - minv):
maxv = r - minv
if minv > r:
minv = r
print(maxv) | 0 | null | 16,341,121,621,440 | 169 | 13 |
import sys
if sys.argv[-1] == 'ONLINE_JUDGE':
import os
import re
with open(__file__) as f:
source = f.read().split('###''nbacl')
for s in source[1:]:
s = re.sub("'''.*", '', s)
sp = s.split(maxsplit=1)
if os.path.dirname(sp[0]):
os.makedirs(os.path.dirname(sp[0]), exist_ok=True)
with open(sp[0], 'w') as f:
f.write(sp[1])
from nbmodule import cc
cc.compile()
import numpy as np
from numpy import int64
from nbmodule import solve
f = open(0)
N, M = [int(x) for x in f.readline().split()]
AB = np.fromstring(f.read(), dtype=int64, sep=' ').reshape((-1, 2))
ans = solve(N, AB)
print(ans)
'''
###nbacl nbmodule.py
import numpy as np
from numpy import int64
from numba import njit
from numba.types import i8
from numba.pycc import CC
import nbacl.dsu as dsu
cc = CC('nbmodule')
@cc.export('solve', (i8, i8[:, ::1]))
def solve(N, AB):
t = np.full(N, -1, dtype=int64)
for i in range(AB.shape[0]):
dsu.merge(t, AB[i, 0] - 1, AB[i, 1] - 1)
ret = 0
for _ in dsu.groups(t):
ret += 1
return ret - 1
if __name__ == '__main__':
cc.compile()
###nbacl nbacl/dsu.py
import numpy as np
from numpy import int64
from numba import njit
@njit
def dsu(t):
t = -1
@njit
def merge(t, x, y):
u = leader(t, x)
v = leader(t, y)
if u == v:
return u
if -t[u] < -t[v]:
u, v = v, u
t[u] += t[v]
t[v] = u
return u
@njit
def same(t, x, y):
return leader(t, x) == leader(t, y)
@njit
def leader(t, x):
if t[x] < 0:
return x
t[x] = leader(t, t[x])
return t[x]
@njit
def size(t, x):
return -t[leader(t, x)]
@njit
def groups(t):
for i in range(t.shape[0]):
if t[i] < 0:
yield i
''' | # Connect Cities
# Union Findデータ構造（素集合データ構造）
#入力:N,M(int:整数)
def input2():
return map(int,input().split())
#入力:[n1,n2,...nk](int:整数配列)
def input_array():
return list(map(int,input().split()))
class UnionFind():
"""docstring for UnionFind"""
def __init__(self, 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[y]=x
n,m=input2()
AB=[input_array() for _ in range(m)]
uf = UnionFind(n)
for ab in AB:
a=ab[0]
b=ab[1]
uf.union(a-1,b-1)
ans=0
for i in uf.parents:
if i < 0:
ans+=1
print(ans-1) | 1 | 2,318,252,012,958 | null | 70 | 70 |
class Dice(object):
def __init__(self, num):
self.num = num
def rotate_S(self):
self.num = [self.num[4], self.num[0], self.num[2], self.num[3], self.num[5], self.num[1]]
def rotate_N(self):
self.num = [self.num[1], self.num[5], self.num[2], self.num[3], self.num[0], self.num[4]]
def rotate_W(self):
self.num = [self.num[2], self.num[1], self.num[5], self.num[0], self.num[4], self.num[3]]
def rotate_E(self):
self.num = [self.num[3], self.num[1], self.num[0], self.num[5], self.num[4], self.num[2]]
dice = Dice(map(int, raw_input().split()))
order = raw_input()
for i in range(len(order)):
if order[i] == 'S':
dice.rotate_S()
elif order[i] == 'N':
dice.rotate_N()
elif order[i] == 'W':
dice.rotate_W()
elif order[i] == 'E':
dice.rotate_E()
print dice.num[0] | n=int(input())
x=input()
p=x.count('1')
#愚直に解く関数を定義
def solve(n):
count=0
while n:
popcount=bin(n).count('1')
n%=popcount
count+=1
return count+1
#popcount(x)が0,1だった場合に対応
if p==0:
for i in range(n):
print(1)
exit()
elif p==1:
z=x.index('1')
t=pow(2,n-z-1,p+1)
for i in range(n):
if i==z:
print(0)
else:
tmp=(t+pow(2,n-i-1,p+1))%(p+1)
print(solve(tmp))
exit()
#2^i mod(p+1),2^i mod(p-1)のリストを作成
a,b=[],[]
for i in range(n):
a.append(pow(2,i,p+1))
b.append(pow(2,i,p-1))
#x mod(p+1),x mod(p-1)を計算
a1,b1=0,0
for i in range(n):
if x[-1-i]=='1':
a1+=a[i]
b1+=b[i]
#本計算
for i in range(n):
if x[i]=='1':
tmp=(b1-b[-1-i])%(p-1)
else:
tmp=(a1+a[-1-i])%(p+1)
print(solve(tmp)) | 0 | null | 4,282,348,113,472 | 33 | 107 |
N = int(input())
D = [input().split() for i in range(N)]
cnt=0
for i in range(N):
if D[i][0] == D[i][1]:
cnt+=1
if cnt == 3:
print("Yes")
exit()
else:
cnt=0
print("No") | N=int(input())
A=[]
for i in range(N):
D=list(map(int,input().split()))
A.append(D)
for i in range(N-2):
if A[i][0]==A[i][1] and A[i+1][0]==A[i+1][1] and A[i+2][0]==A[i+2][1]:
print('Yes')
break
else:
print('No') | 1 | 2,502,731,366,448 | null | 72 | 72 |
def solve(N, S):
ans = 0
R, G, B = 0, 0, 0
for i in range(N):
if S[i] == "R":
R += 1
elif S[i] == "G":
G += 1
else:
B += 1
# print(R, G, B, R*G*B)
ans = R * G * B
dif = 1
while dif <= N//2+1:
idx = 0
while idx + dif + dif < N:
if S[idx] != S[idx + dif] and S[idx+dif] != S[idx+2*dif] and S[idx+2*dif] != S[idx]:
ans -= 1
idx += 1
dif += 1
print(ans)
if __name__ == '__main__':
# N = 4000
# S = 'RGBR' * 1000
N = int(input())
S = input()
solve(N, S)
| n=int(input())
s=list(input())
r=[]
g=[]
b=[]
for i in range(n):
if s[i]=='R':
r.append(i)
elif s[i]=='G':
g.append(i)
else:
b.append(i)
import bisect
def binary_search(a, x):
# 数列aのなかにxと等しいものがあるか返す
i = bisect.bisect_left(a, x)
if i != len(a) and a[i] == x:
return True
else:
return False
ans=0
for i in range(len(r)):
for j in range(len(g)):
p=0
if r[i]<g[j]:
if binary_search(b,g[j]-r[i]+g[j]):
p+=1
if binary_search(b,r[i]+(g[j]-r[i])/2):
p+=1
if binary_search(b,r[i]-(g[j]-r[i])):
p+=1
else:
if binary_search(b,r[i]-g[j]+r[i]):
p+=1
if binary_search(b,g[j]+(r[i]-g[j])/2):
p+=1
if binary_search(b,g[j]-(r[i]-g[j])):
p+=1
ans+=len(b)-p
print(ans)
| 1 | 36,116,064,352,982 | null | 175 | 175 |
N, M = map(int, input().split())
Pajew = [i for i in range(N)]
import sys
sys.setrecursionlimit(1000000)
def find(x, Pajew):
if Pajew[x] == x:
return x
else:
a = find(Pajew[x], Pajew)
Pajew[x] =a
return a
def unite(x, y):
x = find(x, Pajew)
y = find(y, Pajew)
if x != y:
Pajew[x] = y
for _ in range(M):
a, b = map(int, input().split())
unite(a-1, b-1)
grou = 0
for i in range(N):
if i == Pajew[i]:
grou +=1
print(grou-1) | from collections import deque
N,M = map(int,input().split())
l = [[] for _ in range(N+1)]
for _ in range(M):
a,b = map(int,input().split())
l[a].append(b)
l[b].append(a)
check = [0]*(N+1)
cnt = 0
for i in range(1,N+1):
if check[i] == 1:
continue
st = deque([i])
check[i] = 1
while st:
s = st.popleft()
for t in l[s]:
if check[t] == 0:
check[t] = 1
st.append(t)
continue
cnt += 1
print(cnt-1) | 1 | 2,302,046,211,040 | null | 70 | 70 |
def resolve():
INF = 10 ** 18
N, M, L = map(int, input().split())
G = [[INF] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
G[a][b] = G[b][a] = c
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j] = min(G[i][j], G[i][k] + G[k][j])
Cost = [[INF] * N for _ in range(N)]
for i in range(N):
for j in range(N):
if G[i][j] <= L:
Cost[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
Cost[i][j] = min(Cost[i][j], Cost[i][k] + Cost[k][j])
Q = int(input())
for _ in range(Q):
a, b = map(lambda x: int(x) - 1, input().split())
if Cost[a][b] == INF:
print(-1)
else:
print(Cost[a][b] - 1)
if __name__ == "__main__":
resolve()
| import sys
input = sys.stdin.readline
N = int(input())
S = [input()[:-1] for _ in range(N)]
high = []
low = []
for i in range(N):
cnt = 0
m = 0
for j in range(len(S[i])):
if S[i][j] == "(":
cnt += 1
else:
cnt -= 1
m = min(m, cnt)
if cnt > 0:
high.append([m, cnt])
else:
low.append([m-cnt, -cnt])
high.sort(reverse=True)
low.sort(reverse=True)
h = 0
for m, up in high:
if h+m < 0:
print("No")
sys.exit()
h += up
p = 0
for m, down in low:
if p+m < 0:
print("No")
sys.exit()
p += down
if h == p:
print("Yes")
else:
print("No")
| 0 | null | 98,190,027,623,698 | 295 | 152 |
r=input().split()
A=int(r[0])
B=int(r[1])
K=int(r[2])
if K>=A+B:
print("0 0")
elif K>=A:
print("0 "+str(B-K+A))
else:
print(str(A-K)+" "+str(B)) | #!/usr/bin/env python
n = int(input())
x_plus_y = [0 for _ in range(n)]
x_minus_y = [0 for _ in range(n)]
for i in range(n):
x, y = map(int, input().split())
x_plus_y[i] = x+y
x_minus_y[i] = x-y
ans = max(max(x_plus_y)-min(x_plus_y), max(x_minus_y)-min(x_minus_y))
print(ans)
| 0 | null | 54,161,625,709,852 | 249 | 80 |
import math
a, b, deg = map(float, raw_input().split(" "))
c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(deg)))
L = a + b + c
s = (a + b + c) / 2.0
S = math.sqrt(s*(s-a)*(s-b)*(s-c))
h = 2 * S / a
print(str(S) + " " + str(L) + " " + str(h)) | import math
data = map(int, raw_input().split())
a = data[0]
b = data[1]
deg = math.radians(data[2])
c = (a**2 + b**2 - 2*a*b*math.cos(deg))**0.5
L = a + b + c
h = b * math.sin(deg)
S = a * h * 0.5
print S
print L
print h | 1 | 167,252,574,212 | null | 30 | 30 |
N, M=map(int, input().split())
s_row = [0 for x in range(M+1)]
for n in range(N):
arr = list(map(int, input().split()))
arr.append(sum(arr))
s_row = [x+y for x,y in zip(s_row, arr)]
print(" ".join([str(x) for x in arr]))
print(" ".join([str(x) for x in s_row])) | from sys import stdin
s = list(stdin.readline())
for i in range(len(s)):
if s[i].islower():
s[i] = s[i].upper()
elif s[i].isupper():
s[i] = s[i].lower()
print(*s, sep="", end="")
| 0 | null | 1,447,923,532,704 | 59 | 61 |
N, M = map(int, input().split())
S = input()
ans = []
now_pos = N
while now_pos > 0:
next_pos = max(0, now_pos - M)
for i in range(M):
if S[next_pos + i] == "0":
ans.append(now_pos - (next_pos + i))
now_pos = next_pos + i
break
else:
print(-1)
exit()
print(" ".join(map(str, ans[::-1])))
| def main():
N, M = map( int, input().split())
S = [ int(s) for s in input()][::-1]
ANS = []
t = 0
while t < N:
for i in range( min(M, N-t),0,-1):
if S[t+i] == 0:
ANS.append(i)
t += i
break
else:
print(-1)
return
if sum(ANS) == N:
print( " ".join( map( str,ANS[::-1])))
else:
print(-1)
if __name__ == '__main__':
main()
| 1 | 138,949,376,770,958 | null | 274 | 274 |
a, b, c = map(int,input().split(' '))
k = int(input())
while k > 0:
if c <= b:
c *= 2
elif b <= a:
b *= 2
k -= 1
if a < b and b < c:
print('Yes')
break
else:
print('No')
| import sys
while True:
try:
a,b = raw_input().split()
c = int(a) + int(b)
for i in range(10):
if c / (10**i) == 0:
print (i)
break
except EOFError:
break | 0 | null | 3,488,329,255,764 | 101 | 3 |
N, X, M = map(int, input().split())
pt = [[0] * (M+100) for i in range(70)]
to = [[0] * (M+100) for i in range(70)]
for i in range(M+1):
to[0][i] = (i*i) % M
pt[0][i] = i
for i in range(65):
for j in range(M+1):
to[i+1][j] = to[i][to[i][j]]
pt[i+1][j] = pt[i][j] + pt[i][to[i][j]]
ans = 0
for i in range(60):
if (N>>i)&1:
ans += pt[i][X]
X = to[i][X]
print(ans)
| # -*- coding: utf-8 -*-
import sys
from collections import defaultdict
H,W,K=map(int, sys.stdin.readline().split())
S=[ sys.stdin.readline().strip() for _ in range(H) ]
#print H,W,K
#print S
ans=float("inf")
for bit in range(2**H):
cnt=0
group_num=0
GROUP={}
for i,s in enumerate(S):
if i==0:
GROUP[i]=group_num
else:
if bit>>i-1&1==1:
cnt+=1 #境目のカウントに+1
group_num+=1
GROUP[i]=group_num
#print "GROUP :: ",GROUP
ok=None
VALUE=defaultdict(lambda: 0)
w=0
for w in range(W):
for h in range(H):
VALUE[GROUP[h]]+=int(S[h][w])
#現在の値がKを超えていないか
for v in VALUE.values():
if v<=K:
pass
else:
#print "NG!",w
if ok is None: #okに値がない場合は、このパターンは成り立たない
#print "IMPOSSIBLE!"
cnt=float("inf") #不可能なパターンなのでカウントに無限大を代入
else: #以前の列で成り立たっていた場合
cnt+=1 #境目のカウントに+1
VALUE=defaultdict(lambda: 0) #NGの場合は値を初期化して入れなおし
for h in range(H):
VALUE[GROUP[h]]+=int(S[h][w])
break
else:
ok=w
#print "w,ok,cnt,VALUE :: ",w,ok,cnt,VALUE
ans=min(ans,cnt)
print ans | 0 | null | 25,698,570,057,534 | 75 | 193 |
n = int(input())
a_ls = list(map(int, input().split()))
def isOK(a,b,c):
return abs(a-b) < c < a+b
a_ls.sort()
ans = 0
for i in range(n):
short = a_ls[i]
r = i+1
num = 0
for l in range(i+1,n-1):
while r+1 < n and isOK(short, a_ls[l], a_ls[r+1]):
r += 1
num += r - l
if l == r:
r += 1
ans += num
print(ans) | n=int(input())
R=[int(input()) for i in range(n)]
mini=10**10
maxi=-10**10
for r in R:
maxi=max([maxi,r-mini])
mini=min([mini,r])
print(maxi)
| 0 | null | 85,761,171,886,280 | 294 | 13 |
def main():
L, R, d = map(int, input().split(' '))
X = 0
if L % d == 0:
X = int(L / d) - 1
else:
X = int(L / d)
print(int(R / d) - X)
main() | L, R, d = map(int, input().split())
count = 0
for l in list(range(L, R + 1)):
if l % d == 0:
count += 1
print(count)
| 1 | 7,499,772,202,880 | null | 104 | 104 |
n = int(input())
d = {}
for i in range(n):
s = input()
if s not in d:
d[s] = 1
else:
d[s] += 1
m = max(d.values())
ans = [_ for _ in d if d[_] == m]
ans.sort()
[print(_) for _ in ans]
| s=input()
s_list=list(s)
s_list.append('0')
for i in range(len(s)):
if s_list[i]=='?':
if s_list[i+1]=='D':
if s_list[i-1]=='P':
s_list[i]='D'
else:
s_list[i]='P'
elif s_list[i+1]=='?':
if s_list[i-1]=='P':
s_list[i]='D'
else :
s_list[i]='P'
else :
s_list[i]='D'
s_list.pop()
a="".join(s_list)
print(a) | 0 | null | 43,973,942,154,560 | 218 | 140 |
N, K = map(int, input().split())
p_list = list(map(int, input().split()))
p_list_E = []
p_list_E_temp = [1, 1.5, 2, 2.5, 3, 3.5]
for i in range(len(p_list)):
p_list_E.append((p_list[i]+1)*0.5)
#print(p_list_E)
p_list_sum = [0]
for i in range(0,N):
p_list_sum.append(p_list_sum[i]+p_list_E[i])
#print(p_list_sum)
ans = 0
for i in range(K,N+1):
ans = max(ans, p_list_sum[i]-p_list_sum[i-K])
print(ans) | if __name__ == "__main__":
x1, x2 , x3, x4, x5 = map(int, input().split())
X = [x1, x2 , x3, x4, x5]
for i in range(5):
if X[i] == 0:
print(i+1) | 0 | null | 44,059,421,830,838 | 223 | 126 |
n = int(input())
a = list(map(int, input().split()))
a.sort()
n_sum = a[0]
sum = 0
for i in range(1,n):
sum += a[i] * n_sum
n_sum += a[i]
print(sum % (10**9 + 7))
|
dic = {}
for b in range(1,5):
for f in range(1,4):
for r in range(1,11):
dic[(b,f,r)] = 0
n = int(raw_input())
for k in range(n):
b,f,r,v = map(int,raw_input().split())
dic[(b,f,r)] += v
j = 0
for b in range(1,5):
for f in range(1,4):
ls = []
for r in range(1,11):
ls.append(dic[(b,f,r)])
print ' ' + ' '.join(map(str,ls))
else:
if j < 3:
print '#'*20
j +=1 | 0 | null | 2,438,557,148,580 | 83 | 55 |
N, K, S = map(int, input().split())
S2 = S-1 if S == 1000000000 else S+1
As = [S]*K+[S2]*(N-K)
print(" ".join(map(str, As)))
| n, k, s = map(int, input().split())
ai = s
ls1 = [ai] * k
for aj in reversed(range(10 ** 9 + 1)):
if aj != ai:
ls2 = [aj] * (n - k)
break
print(" ".join(map(str, (ls1 + ls2)))) | 1 | 90,769,439,939,820 | null | 238 | 238 |
def decide_hand2(T, hand, i, K, N):
if T[i] == "r":
if i <= K - 1:
hand[i] = "p"
else:
if hand[i - K] == "p":
hand[i] = "-"
else:
hand[i] = "p"
elif T[i] == "p":
if i <= K - 1:
hand[i] = "s"
else:
if hand[i - K] == "s":
hand[i] = "-"
else:
hand[i] = "s"
elif T[i] == "s":
if i <= K - 1:
hand[i] = "r"
else:
if hand[i - K] == "r":
hand[i] = "-"
else:
hand[i] = "r"
def main():
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
hand = ["" for _ in range(N)]
for i in range(N):
decide_hand2(T, hand, i, K, N)
ans = 0
for i in range(N):
if hand[i] == "r":
ans += R
elif hand[i] == "s":
ans += S
elif hand[i] == "p":
ans += P
print(ans)
if __name__ == "__main__":
main() | N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
point = [0]*K
flag = ["a"]*K
k = -1
#K本のリストを用意する 剰余系の中で、同じ手が連続するとき、１、３、５、...は別の手に変える
for i in range(N):
k = (k+1)%K #mod
if T[i] == "r":
if flag[k] == "r":
flag[k] = "a"
else:
flag[k] = "r"
point[k] += P
elif T[i] == "s":
if flag[k] == "s":
flag[k] = "a"
else:
flag[k] = "s"
point[k] += R
if T[i] == "p":
if flag[k] == "p":
flag[k] = "a"
else:
flag[k] = "p"
point[k] += S
print(sum(point)) | 1 | 107,127,149,648,408 | null | 251 | 251 |
s = input()
ans = 0
if 'RRR' in s:
ans = 3
elif 'RR' in s:
ans = 2
elif 'R' in s:
ans = 1
print(ans) | n = int(input())
for i in range(1,n+1):
if i % 3 == 0:
print(" {0}".format(i), end="")
else:
x = i
while x != 0:
if x % 10 == 3:
print(" {0}".format(i), end="")
break;
x //= 10;
print("")
| 0 | null | 2,917,152,460,768 | 90 | 52 |
n=int(input())
x,y=[],[]
for i in range(n):
x1,y1=map(int,input().split())
x.append(x1)
y.append(y1)
s=0
for i in range(n):
for j in range(n):
if i!=j:
s+=((x[i]-x[j])**2+(y[i]-y[j])**2)**(1/2)
print(s/n) | P = [1 for _ in range(10**6)]
P[0]=0
P[1]=0
for i in range(2,10**3):
for j in range(i*i,10**6,i):
P[j] = 0
Q = []
for i in range(2,10**6):
if P[i]==1:
Q.append(i)
N = int(input())
C = {}
for q in Q:
if N%q==0:
C[q] = 0
while N%q==0:
N = N//q
C[q] += 1
if N>1:
C[N] = 1
cnt = 0
for q in C:
k = C[q]
n = 1
while k>(n*(n+1))//2:
n += 1
if k==(n*(n+1))//2:
cnt += n
else:
cnt += n-1
print(cnt)
| 0 | null | 82,694,202,743,980 | 280 | 136 |
from itertools import product
H, W, K = map(int, input().split())
choco = [list(input()) for _ in range(H)]
def cnt(array):
count = [0] * H
split_cnt = 0
for w in range(W):
for h in range(H):
if choco[h][w] == "1":
count[array[h]] += 1
if any(i > K for i in count):
split_cnt += 1
count = [0] * H
for h in range(H):
if choco[h][w] == "1":
count[array[h]] += 1
if any(i > K for i in count):
return 10 ** 20
return split_cnt
def get_array(array):
l = len(array)
ret = [0] * l
for i in range(1, l):
ret[i] = ret[i-1] + array[i]
return ret
ans = 10 ** 20
for p in product(range(2), repeat=H-1):
p = get_array([0]+list(p))
ans = min(ans, cnt(p)+max(p))
print(ans)
| N = int(input())
A_lis = list(map(int,input().split()))
ls = [0] * N
for i in range(N-1):
ls[A_lis[i]-1] += 1
for a in ls:
print(a) | 0 | null | 40,665,800,434,048 | 193 | 169 |
#
# abc145 c
#
import sys
from io import StringIO
import unittest
import math
import itertools
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """3
0 0
1 0
0 1"""
output = """2.2761423749"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2
-879 981
-866 890"""
output = """91.9238815543"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """8
-406 10
512 859
494 362
-955 -475
128 553
-986 -885
763 77
449 310"""
output = """7641.9817824387"""
self.assertIO(input, output)
def resolve():
N = int(input())
P = [list(map(int, input().split())) for _ in range(N)]
R = itertools.permutations(range(N))
all = 0
for r in R:
for pi in range(1, len(r)):
all += math.sqrt((P[r[pi]][0]-P[r[pi-1]][0])**2 +
(P[r[pi]][1]-P[r[pi-1]][1])**2)
n = 1
for i in range(1, N+1):
n *= i
print(f"{all/n:.10f}")
if __name__ == "__main__":
# unittest.main()
resolve()
| s = input()
if s[-1] == "s":
x = "es"
else:
x = "s"
print(s, x, sep = "") | 0 | null | 75,681,470,065,460 | 280 | 71 |
N=int(input())
A=list(map(int,input().split()))
mod=10**9+7
buf=0
s=0
for k in range(N-1):
buf=(buf+A[N-1-k])%mod
s=(s+A[N-2-k]*buf)%mod
print(s)
| N = int(input())
al = list(map(int,input().split()))
sss=0
pss=0
for i in range(1,N):
pss+=al[i-1]
sss+=al[i]*pss
print(sss%1000000007) | 1 | 3,771,895,830,430 | null | 83 | 83 |
N = int(input())
A = list(map(int, input().split()))
B = [0 for i in range(N)]
for i in range(N):
B[A[i]-1] = i
for b in B:
print(b+1) | n=int(input());a=list(map(int,input().split()));dict={i+1:a[i] for i in range(n)}
print(*[i[0] for i in sorted(dict.items(),key=lambda x:x[1])],sep=' ') | 1 | 180,771,802,380,892 | null | 299 | 299 |
N, M = map(int, input().split())
flgs = [0] * N
penas = [0] * N
ac = 0
pena = 0
for _ in range(M):
p, s = input().split()
p = int(p)
s = (s=='AC')
if flgs[p - 1]:
continue
elif s:
ac += 1
flgs[p - 1] = 1
pena += penas[p-1]
else:
penas[p - 1] += 1
print(ac, pena)
| import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
# N =I()
N,M= LI()
if M==0:
print(0,0)
exit()
pS = [LS() for _ in range(M)]
# print(pS)
_p,S = zip(*pS)
p = list(map(int,_p))
WA = np.zeros(N+1)
AC = np.full(N+1,False, dtype=bool)
penalty = 0
for i in range(M):
if AC[p[i]]:
continue
if S[i]=='WA':
WA[p[i]] += + 1
else:
AC[p[i]]=True
penalty += WA[p[i]]
AC_count = np.count_nonzero(AC)
# space output
print(AC_count,int(penalty))
#Ap = np.array(A)
# if ans:
# print('Yes')
# else:
# print('No') | 1 | 93,576,711,896,320 | null | 240 | 240 |
n=int(input())
ls=[]
for i in range(n):
s=input()
ls.append(s)
setl=set(ls)
print(len(setl)) | nums = input().split()
a = int(nums[0])
b = int(nums[1])
if a < b:
print('a < b')
elif a > b:
print('a > b')
else:
print('a == b') | 0 | null | 15,445,566,726,852 | 165 | 38 |
n = int(input())
result = [input() for i in range(n)]
print('AC x ' + str(result.count("AC")))
print('WA x ' + str(result.count("WA")))
print('TLE x ' + str(result.count("TLE")))
print('RE x ' + str(result.count("RE"))) | f,l,n=map(int,input().split())
ctr=0
for i in range(f,l+1):
if i%n==0:
ctr+=1
print(ctr) | 0 | null | 8,086,209,334,240 | 109 | 104 |
a1,a2,a3=map(int,input().split())
if a1+a2+a3<=21 :
print("win")
else :
print("bust") | A = map(int,input().split())
if sum(A)>=22:
print("bust")
else:
print("win") | 1 | 119,090,418,982,962 | null | 260 | 260 |
n = int(input())
l = [list(map(int, input().split())) for i in range(n)]
#print(l[0][0])
#print(l[0][1])
ans = n-2
ans1 = 0
for m in range(ans):
if l[m][0] == l[m][1] and l[m+1][0] == l[m+1][1] and l[m+2][0] == l[m+2][1]:
ans1 += 1
if ans1 >= 1:
print("Yes")
else:
print("No") | # coding: utf-8
# input
n = int(input())
s = list(map(int,input().split()))
q = int(input())
t = list(map(int,input().split()))
cnt = 0
for i in t:
if i in s:
cnt += 1
print(cnt) | 0 | null | 1,262,575,299,100 | 72 | 22 |
N=int(input())
a=int(N/100)
b=int((N-100*a)/10)
c=N-100*a-10*b
if a==7 or b==7 or c==7:
print("Yes")
else:
print("No") | import sys
import itertools
def resolve(in_):
N = int(next(in_))
xy = (tuple(map(int, line.split())) for line in itertools.islice(in_, N))
zw = tuple((x + y, x - y) for x, y in xy)
zmax = zmin = zw[0][0]
wmax = wmin = zw[0][1]
for z, w in zw[1:]:
zmax = max(zmax, z)
zmin = min(zmin, z)
wmax = max(wmax, w)
wmin = min(wmin, w)
ans = max(zmax - zmin, wmax - wmin)
return ans
def main():
answer = resolve(sys.stdin.buffer)
print(answer)
if __name__ == '__main__':
main()
| 0 | null | 18,884,713,647,592 | 172 | 80 |
def insertionSort(A, n, g):
for i in range(g,n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
global cnt
cnt += 1
A[j+g] = v
def shellSort(A, n):
global cnt
cnt = 0
G =[]
g = 0
for h in range(100):
g = 3*g + 1
if g <= n:
G.insert(0,g)
m = len(G)
for i in range(m):
insertionSort(A, n, G[i])
print(m)
print(*G)
print(cnt)
print(*A,sep="\n")
n = int(input())
A = [int(input()) for i in range(n)]
shellSort(A, n)
| N, M, X = map(int, input().split())
C = []
A = []
for i in range(N):
tmp = list(map(int, input().split()))
C.append(tmp[0])
A.append(tmp[1:])
ans = -1
for i in range(1, 1 << N):
price = 0
skill = [0] * M
b = len(bin(i)) - 2
for j in range(b):
price += C[j] * (i >> j & 1)
for k in range(M):
skill[k] += A[j][k] * (i >> j & 1)
if min(skill) >= X and (price < ans or ans < 0):
ans = price
print(ans)
| 0 | null | 11,147,992,746,582 | 17 | 149 |
N, K = map(int, input().split())
li = [0]*(K+1)
out = 0
mod = 10**9+7
for i in range(K, 0, -1):
li[i] = pow(K//i, N, mod)
for j in range(i*2, K+1, i):
li[i] -= li[j]
out += li[i] * i
print(out%mod) | n, k = map(int, input().split())
prime_mod = 10**9+7
countgcd = [0]*k
for idx in range(k, 0, -1):
num_multiples = k//idx
num_sequences = pow(num_multiples, n, prime_mod)
overcount = sum(countgcd[j*idx-1] for j in range(2, num_multiples+1))
overcount = overcount%prime_mod
countgcd[idx-1] = (num_sequences-overcount)%prime_mod
# print(idx, num_multiples, num_sequences, overcount, num_sequences-overcount)
final_sum = 0
for idx in range(1, k+1):
final_sum = (final_sum + idx*countgcd[idx-1])%prime_mod
print(final_sum) | 1 | 36,935,562,988,360 | null | 176 | 176 |
N=input()
i=0
while i<len(N):
print("x" ,end='')
i+=1 | s=list(input())
for i in range(len(s)):
if s[i]!="x":
s[i]="x"
print("".join(s))
| 1 | 72,776,184,886,900 | null | 221 | 221 |
def main():
k = int(input())
r = 'ACL'
print(r*k)
if __name__ == "__main__":
main()
| N = int(input())
for X in range(1, N+1):
if X*108//100==N:
print(X)
break
else:
print(':(') | 0 | null | 64,310,013,766,948 | 69 | 265 |
#from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7
#R = 998244353
def ddprint(x):
if DBG:
print(x)
# # # # unionfind.py # # # #
# usage: uf = Unionfind(n) ; x = uf.root(y); uf.conn(a,b)
class Unionfind:
def __init__(s,n):
s.sz = [1] * n
s.ances = [i for i in range(n)]
def root(s,x):
a = []
y = x
while s.ances[y] != y:
a.append(y)
y = s.ances[y]
for z in a:
s.ances[z] = y
return y
def conn(s,x,y):
i = s.root(x)
j = s.root(y)
if i==j:
return
#k = [i,j].min
k = j if (s.sz[i]<s.sz[j]) else i
if k==j:
s.ances[i] = j
else:
s.ances[j] = i
s.sz[k] = s.sz[i] + s.sz[j]
# # # # end unionfind.py # # # #
n,m = inm()
uf = Unionfind(n)
for i in range(m):
a,b = inm()
uf.conn(a-1,b-1)
h = {}
x = 0
for i in range(n):
r = uf.root(i)
if r not in h:
h[r] = 1
else:
h[r] += 1
x = max(x,h[r])
print(x)
| import sys
#import time
from collections import deque, Counter, defaultdict
#from fractions import gcd
import bisect
import heapq
#import math
import itertools
import numpy as np
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**18
MOD = 1000000007
ri = lambda : int(input())
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def same(self, x, y):
return self.find(x) == self.find(y)
# ノードxが属する木のサイズを返す
def size(self, x):
return -self.root[self.find(x)]
n,m = rl()
uf = UnionFind(n)
for i in range(m):
a,b = rl()
uf.unite(a,b)
print(-min(uf.root)) | 1 | 3,940,625,675,446 | null | 84 | 84 |
num = input()
num1,num2 = num.split(' ')
num1 = int(num1)
num2 = int(num2)
if num1 > 9 or num2 > 9:
print('-1')
else:
print (num1 * num2) | a,b=map(int,input().split())
if a<=9:
if b<=9:
print(a*b)
else:
print("-1")
else:
print("-1") | 1 | 158,427,361,204,622 | null | 286 | 286 |
import math
import itertools
n = int(input())
k = int(input())
f = len(str(n))
if f < k:
print(0)
else:
#f-1桁以内に収まる数
en = 1
for i in range(k):
en *= f-1-i
de = math.factorial(k)
s = en // de * pow(9, k)
#f桁目によって絞る
kami = int(str(n)[0])
en = 1
for i in range(k-1):
en *= f-1-i
de = math.factorial(k-1)
s += (en // de * pow(9, k-1)) * (kami-1)
#以下上1桁は同じ数字
keta = list(range(f-1))
num = list(range(1,10))
b = kami * pow(10, f-1)
m = 0
if k == 1:
m = b
if m <= n:
s += 1
else:
for d in itertools.product(num, repeat=k-1):
for c in itertools.combinations(keta, k-1):
m = b
for i in range(k-1):
m += d[i] * pow(10, c[i])
if m <= n:
s += 1
print(s)
| #!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
def resolve():
N=input()
K,=pin()
#degit DP
#dp_table["index"][smaller][cond]=cond:=ちょうどK個の数がある を満たす総数
rb=(0,1)
dp_table=[[[0 for cnd in range(K+1)]for sml in rb]for ind in range(len(N)+1)]
dp_table[0][0][0]=1
#print(dp_table)
#print("degit,sml,k,prove,l,x<n,dp_table[degit-1][sml][k]")#
for degit in range(len(N)+1):
n=int(N[degit-1])
for sml in rb:
t=10 if sml else int(N[degit-1])+1
for k in range(K+1):
for prove in range(t):
x=prove
try:#Indexerror
#print(degit,sml,k,prove,"l",x<n,dp_table[degit-1][sml][k])
#if sml==False and x==n:print(n,":")
dp_table[degit][sml or x<n][k+(x!=0)]+=dp_table[degit-1][sml][k]
except :pass
print(dp_table[-1][0][K]+dp_table[-1][1][K])
#print(dp_table)
#%%submit!
resolve()
| 1 | 76,032,416,637,632 | null | 224 | 224 |
from functools import reduce
from math import gcd
N=int(input())
A=list(map(int, input().split()))
c=max(A)+1
C=[0]*c
f=1
for i in A:
C[i]+=1
for i in range(2,c):
cnt=0
for j in range(i,c,i):
cnt+=C[j]
if cnt>1:
f=0
if f==1:
print('pairwise coprime')
elif reduce(gcd, A) == 1:
print('setwise coprime')
else:
print('not coprime') | H = int(input())
W = int(input())
N = int(input())
p = -1
if H > W:
p = H
else:
p = W
count = 1
result = 1
while True:
result = count * p
if result >= N:
print(count)
break
else:
count += 1
| 0 | null | 46,449,691,023,722 | 85 | 236 |
W, H, x, y, r = map(int, raw_input().split())
if x-r<0 or y-r<0:
print"No"
elif x+r <= W and y+r <= H:
print"Yes"
else:
print"No" | a = input()
b = a.split(' ')
W = int(b[0])
H = int(b[1])
x = int(b[2])
y = int(b[3])
r = int(b[4])
if -100 <= x < 0:
print('No')
elif -100 <= y < 0:
print('No')
elif W >= x + r and H >= y + r:
print('Yes')
else:
print('No') | 1 | 450,733,973,898 | null | 41 | 41 |
n = int(input())
b = 0
while b < n:
b += 1000
print(b-n) | from decimal import Decimal, getcontext
getcontext().prec = 10000
def f(x):
return Decimal(x).sqrt()
a, b, c = map(int, input().split())
eps = Decimal(10) ** (-1000)
if f(a) + f(b) + eps < f(c):
ans = "Yes"
else:
ans = "No"
print(ans)
| 0 | null | 30,012,055,583,918 | 108 | 197 |
import sys
heights = [int(i) for i in sys.stdin.read().split()]
heights.sort(reverse=True)
print("\n".join(map(str, heights[:3]))) | a=[]
for i in range(10):a.append(int(input()))
a.sort()
print(a[9],a[8],a[7],sep='\n'); | 1 | 30,709,630 | null | 2 | 2 |
h, w, m = map(int, input().split())
a_list = []
b_list = []
h_list = [0 for _ in range(h)]
w_list = [0 for _ in range(w)]
for i in range(m):
a, b = map(int, input().split())
a_list.append([a,b])
h_list[a - 1] += 1
w_list[b - 1] += 1
h_max = max(h_list)
w_max = max(w_list)
w_flag = [0 for _ in range(w)]
for i in range(w):
if w_list[i] == w_max:
w_flag[i] = 1
h_flag = [0 for _ in range(h)]
for i in range(h):
if h_list[i] == h_max:
h_flag[i] = 1
flag = 0
for i in range(m):
if h_flag[a_list[i][0] - 1] == 1 and w_flag[a_list[i][1] - 1] == 1:
flag += 1
s = sum(h_flag) * sum(w_flag)
print(h_max + w_max - 1 if flag == s else h_max + w_max)
|
def main():
n = int(input())
ans=''
while(n):
n -= 1
ans += chr(ord('a') + n%26)
n //= 26
print(ans[::-1])
if __name__ == "__main__":
main() | 0 | null | 8,256,224,169,038 | 89 | 121 |
n, m = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(m)]
ans = [-1]*n
flag = False
for s, c in X:
if ans[s-1] >= 0 and ans[s-1] != c:
flag = True
if n > 1 and s == 1 and c == 0:
flag = True
else:
ans[s-1] = c
if flag:
print(-1)
exit(0)
for i in range(n):
if ans[i] == -1:
if n > 1 and i == 0:
ans[i] = 1
else:
ans[i] = 0
print(*ans, sep="") | a=str(input())
if a[-1]=="s":
print(a+"es")
else:
print(a+"s") | 0 | null | 31,474,575,782,990 | 208 | 71 |
#UnionFind
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 size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m,k = map(int,input().split())
V = [[] for i in range(n+1)]
W = [0]*(n+1)
uf = UnionFind(n+1)
for _ in range(m):
a,b = map(int,input().split())
V[a].append(b)
V[b].append(a)
uf.union(a,b)
for _ in range(k):
c,d = map(int,input().split())
if uf.find(d) == uf.find(c):
W[c] += 1
W[d] += 1
for i in range(1,n+1):
ans = uf.size(i) - len(V[i]) - W[i] - 1
print(ans,end="")
print(" ",end="")
print() | a, b = map(int, raw_input().split())
for i in xrange(10000) :
print str(min(a, b)) + ' ' + str(max(a, b))
a, b = map(int, raw_input().split())
if a == 0 and b == 0 :
break | 0 | null | 31,104,550,923,068 | 209 | 43 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect# lower_bound etc
#import numpy as np
#from copy import deepcopy
#from collections import deque
def sum_count(arr):
mem = arr[:]
while True:
if len(mem) == 1:break
tmp = []
while True:
if len(mem) == 1:
tmp.append(mem[-1])
mem = tmp[:]
break
if len(mem) == 0:
mem = tmp[:]
break
x1, x2 = mem.pop(), mem.pop()
tmp.append(int(x1) + int(x2))
return int(mem[0])
def run():
N = int(input())
X = list(input())[::-1]
lis_bf = []
lis_af = []
count1 = sum_count(X)
sum_val_bf, sum_val_af = 0, 0
if count1 <= 1:
for i in range(N):
tmp_af = 0
if int(X[i]):
tmp_af = pow(2, i, count1 + 1)
lis_af.append(tmp_af)
sum_val_af += tmp_af
sum_val_af %= count1 + 1
for i in list(range(N))[::-1]:
ans = 0
if X[i] == '1':
print(0)
continue
else:
next_val = (sum_val_af + pow(2, i, count1 + 1)) % (count1 + 1)
# print(next_val)
ans += 1
# print(f'i : {i}, next_val : {next_val}')
while True:
if next_val == 0: break
val = next_val
count_n = sum_count(list(bin(val)[2:]))
next_val = val % count_n
ans += 1
# print(f'next_val : {next_val}')
print(ans)
return None
for i in range(N):
tmp_bf, tmp_af = 0,0
if int(X[i]):
tmp_bf = pow(2, i , count1-1)
tmp_af = pow(2, i, count1+1)
lis_bf.append(tmp_bf)
lis_af.append(tmp_af)
sum_val_bf += tmp_bf
sum_val_bf %= count1-1
sum_val_af += tmp_af
sum_val_af %= count1 + 1
for i in list(range(N))[::-1]:
ans = 0
if X[i] == '1':
next_val = (sum_val_bf - lis_bf[i]) % (count1-1)
else:
next_val = (sum_val_af + pow(2, i, count1+1)) % (count1+1)
#print(next_val)
ans += 1
#print(f'i : {i}, next_val : {next_val}')
while True:
if next_val == 0:break
val = next_val
count_n = sum_count(list(bin(val)[2:]))
next_val = val % count_n
ans += 1
#print(f'next_val : {next_val}')
print(ans)
if __name__ == "__main__":
run()
| N=int(input())
X=input()
c=X.count('1')
r1=int(X,2)%(c-1) if c>1 else 0
r2=int(X,2)%(c+1)
d=[0]*(N+1)
for i in range(N):
d[i+1]=d[(i+1)%bin(i+1).count('1')]+1
for i in range(N):
if X[i]=='0':
n=(r2+pow(2,N-i-1,c+1))%(c+1)
else:
if c==1:
print(0)
continue
n=(r1-pow(2,N-i-1,c-1))%(c-1)
print(d[n]+1) | 1 | 8,196,014,059,130 | null | 107 | 107 |
from collections import Counter
n = int(input())
c = list(input())
count = Counter(c)
ans = float('inf')
w = 0
r = 0
if count.get('R'):
r = count['R']
ans = max(w, r)
for i in range(n):
if c[i]=='W':
w += 1
else:
r -= 1
ans =min(max(w,r), ans)
print(ans) | import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return map(int,input().split())
def onem(): #Nとかの取得
return int(input())
def s(x): #圧縮
a = []
if len(x) == 0:
return []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(map(max,x))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
def pow_k(x, n):
ans = 1
while n:
if n % 2:
ans *= x
x *= x
n >>= 1
return ans
"""
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if (ここに評価入れる):
rr = mid
else:
ll = mid+1
"""
n = onem()
S = input()[:-1]
po = [0 for i in range(n)]
for i in range(n-1,-1,-1):
if i == n-1:
if S[i] == "R":
po[i] += 1
else:
if S[i] == "R":
po[i] += po[i+1]+1
else:
po[i] += po[i+1]
co = 0
for i in range(n):
if po[i] - co > 0 and S[i] != "R":
co += 1
print(co)
| 1 | 6,345,305,229,756 | null | 98 | 98 |
import sys
from collections import Counter
from itertools import combinations
def input():
return sys.stdin.readline().strip()
sys.setrecursionlimit(20000000)
MOD = 10 ** 9 + 7
INF = float("inf")
def main():
N = int(input())
L = list(map(int, input().split()))
count = Counter(L)
key = count.keys()
set_list = combinations(key, 3)
answer = 0
for s in set_list:
a = s[0]
b = s[1]
c = s[2]
if (a + b) > c and (b + c) > a and (c + a) > b:
answer += count[a] * count[b] * count[c]
print(answer)
if __name__ == "__main__":
main()
| n=int(input())
if n<3:
print(0)
else:
L=[int(i) for i in input().split()]
x=0
for i in range(0,n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
if L[i]==L[j] or L[j]==L[k] or L[k]==L[i]:
pass
elif L[i]+L[j]>L[k] and L[i]+L[k]>L[j] and L[j]+L[k]>L[i]:
x+=1
else:
pass
print(x) | 1 | 5,018,715,842,660 | null | 91 | 91 |
N=int(input())
C=[0]*4
S=['AC','WA','TLE','RE']
for _ in range(N):
s=input()
if s==S[0]:
C[0]+=1
elif s==S[1]:
C[1]+=1
elif s==S[2]:
C[2]+=1
else:
C[3]+=1
for i in range(4):
print(S[i],'x',C[i]) | results = {'AC': 0, 'WA': 0, 'TLE': 0, 'RE': 0}
N = int(input())
for _ in range(N):
S = input()
results[S] = results[S] + 1
for k, v in results.items():
print(k, 'x', v) | 1 | 8,714,210,756,668 | null | 109 | 109 |
def main():
from math import ceil
debt = 100000
n = int(input())
for _ in range(n):
debt *= 1.05
debt = ceil(debt/1000)*1000
print(debt)
if __name__ == '__main__':
main() | n = input()
cnt = 0
for i in n:
cnt += int(i)
if cnt % 9 == 0:
print('Yes')
else:
print('No') | 0 | null | 2,187,033,258,438 | 6 | 87 |
K=int(input())
ans = False
M,N = map(int,input().rstrip().split(" "))
#print(K,M,N)
for number in range(M,N+1):
if number%K==0:
ans = True
if ans:
print("OK")
else:
print("NG") | from collections import deque
s = deque(input())
q = int(input())
flag = 0
for _ in range(q):
query = list(map(str, input().split()))
if query[0] == "1": flag = 1 - flag
else:
if query[1] == "1":
if flag == 0: s.appendleft(query[2])
else: s.append(query[2])
else:
if flag == 0: s.append(query[2])
else: s.appendleft(query[2])
if flag == 1: s.reverse()
print(*s, sep="") | 0 | null | 41,983,825,157,670 | 158 | 204 |
n=int(input())
s=input().split("ABC")
print(len(s)-1) | n = int(input())
a = set(input().split())
print('YES' if (len(a) == n) else 'NO') | 0 | null | 86,632,558,618,188 | 245 | 222 |
import sys
input = sys.stdin.readline
n = int(input())
A = tuple(int(x) for x in input().split())
_ = int(input())
M = tuple(int(x) for x in input().split())
S = set()
def Check(i, s):
if i == n:
S.add(s)
return
Check(i + 1, s + A[i])
Check(i + 1, s)
Check(0, 0)
for m in M:
if m in S:
print('yes')
else:
print('no')
| n=int(input())
s=input()
ans=s.count("R")*s.count("G")*s.count("B")
for i in range(n-2):
for j in range(i+1,n-1):
if 2*j-i>n-1:
break
if s[i]!=s[j] and s[j]!=s[2*j-i] and s[i]!=s[2*j-i]:
ans-=1
print(ans) | 0 | null | 18,060,420,300,992 | 25 | 175 |
import math
ans = 0
N,D = map(int,input().split())
for i in range(N):
x,y = map(int,input().split())
if math.sqrt(abs(x)**2 + abs(y)**2) <= D:
ans += 1
print(ans) | n, d = map(int, input().split())
import math
count = 0
for i in range(n):
x, y = map(int, input().split())
distance = math.sqrt(x**2+y**2)
if distance <= d:
count += 1
print(count) | 1 | 5,924,612,038,802 | null | 96 | 96 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from math import ceil
def main():
n, k, *a = map(int, read().split())
def isOK(x):
kaisu = 0
for ae in a:
kaisu += ceil(ae / x) - 1
if kaisu <= k:
return True
else:
return False
ng = 0
ok = max(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if isOK(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
| N, K = map(int, input().split())
p=list(map(int,input().split()))
for i in range(N):
p[i]=(1+p[i])/2
ans=[0]*(N-K+1)
ans[0]=sum(p[:K])
for i in range(1, N-K+1):
ans[i]=ans[i-1]-p[i-1]+p[i+K-1]
print(max(ans)) | 0 | null | 40,703,794,522,944 | 99 | 223 |
#!/usr/bin/env python
# coding: utf-8
# In[86]:
# ans = [0]*(len(S)+1)
# for i in range(len(S)):
# count_left = 0
# count_right = 0
# for j in range(i):
# if S[i-j-1] == "<":
# count_left += 1
# else:
# j -= 1
# break
# for k in range(i,len(S)):
# if S[k] == ">":
# count_right += 1
# else:
# k -= 1
# break
# ans[i] = max(count_left, count_right)
# # print(count_left, count_right)
# # print(S[i-j-1:i], S[i:k+1])
# # print(ans)
# print(sum(ans))
# In[87]:
from collections import deque
S = input()
left = deque([0])
right = deque([0])
cnt = 0
for s in S:
if s == '<':
cnt += 1
else:
cnt = 0
left.append(cnt)
cnt = 0
for s in S[::-1]:
if s == '>':
cnt += 1
else:
cnt = 0
right.appendleft(cnt)
ans = 0
for l, r in zip(left, right):
ans += max(l, r)
print(ans)
# In[ ]:
| X = int(input())
for a in range(121):
for b in range(121):
if a ** 5 - b ** 5 == X:
print(a, b)
break
elif a ** 5 + b ** 5 == X:
print(a, -b)
break
else:
continue
break
| 0 | null | 91,015,077,081,458 | 285 | 156 |
A,B = list(map(int, input().split()))
list_A = []
list_B = []
for i in range(A):
a = list(map(int, input().split()))
list_A.append(a)
for i in range(B):
b = int(input())
list_B.append(b)
for i in list_A:
output = []
for (y,z) in zip(i,list_B):
op = y*z
output.append(op)
sum_op = sum(output)
print(sum_op) | # 不親切な人の証言は、正しかろうが間違っていようが検証できないので無視する
# bit全探索で正直者を仮定・固定して、証言に矛盾が出なければ人数を数えて記録する
from itertools import product
n = int(input())
Ev = [[] for _ in range(n)]
for i in range(n):
A = int(input())
for a in range(A):
x, y = map(int, input().split())
Ev[i].append((x - 1, y))
bit = list(product([1, 0], repeat=n))
ans = 0
for b in bit:
for i, v in enumerate(b): # v == 1 or 0
if v == 1:
for x, y in Ev[i]: # 証言１つ１つを取り出して検証
if b[x] != y: # bitで仮定している正直者リストと矛盾する証言を正直者が行ったらアウト
break
else:
continue
break
else:
ans = max(b.count(1), ans)
print(ans) | 0 | null | 61,037,928,972,580 | 56 | 262 |
n,k=map(int,input().split())
A=[0]*k
mod=10**9+7
def power(a,x): #a**xの計算
T=[a]
while 2**(len(T))<mod: #a**1,a**2.a**4,a**8,...を計算しておく
T.append(T[-1]**2%mod)
b=bin(x) #xを2進数表記にする
ans=1
for i in range(len(b)-2):
if int(b[-i-1])==1:
ans=ans*T[i]%mod
return ans
for i in range(k):
cnt=power(k//(k-i),n)
now=(k-i)*2
while now<=k:
cnt-=A[now-1]
now+=k-i
A[k-i-1]=cnt
ans=0
for i in range(k):
ans+=(i+1)*A[i]%mod
ans%=mod
print(ans) | N,K = map(int,input().split())
gcddic = {}
mod_n = (10**9+7)
for i in range(K,0,-1):
x = pow((K//i),N,mod_n)
ll=2
while(ll*i<=K):
x -= gcddic[ll*(i)]
ll += 1
gcddic[i] = x
sumnation = 0
for i,l in gcddic.items():
sumnation += i*l
print(sumnation%mod_n) | 1 | 36,659,687,877,190 | null | 176 | 176 |
#設定
import sys
input = sys.stdin.buffer.readline
#ライブラリインポート
from collections import defaultdict
con = 10 ** 9 + 7
#入力受け取り
def getlist():
return list(map(int, input().split()))
class Combination(object):
def __init__(self, N, con):
self.fac = [0] * (N + 1)
self.inv = [0] * (N + 1)
self.finv = [0] * (N + 1)
self.fac[0], self.fac[1] = 1, 1
self.inv[1] = 1
self.finv[0], self.finv[1] = 1, 1
# 前計算
for i in range(2, N + 1):
self.fac[i] = self.fac[i - 1] * i % con
self.inv[i] = self.inv[con % i] * (con - (con // i)) % con
self.finv[i] = self.finv[i - 1] * self.inv[i] % con
def com(self, N, k):
return (self.fac[N] * self.finv[k] * self.finv[N - k]) % con
#処理内容
def main():
N, K = getlist()
if K >= N:
Com = Combination(2 * N - 1, con)
ans = Com.com(2 * N - 1, N)
print(ans)
else:
Com1 = Combination(N, con)
Com2 = Combination(N - 1, con)
ans = 0
for i in range(1, K + 1):
ans += Com1.com(N, i) * Com2.com(N - 1, i)
ans %= con
ans = (ans + 1) % con
print(ans)
if __name__ == '__main__':
main() | N,K=map(int, raw_input().split())
mod=10**9+7
fact, inv_fact = [1], [1]
fact_tmp = 1
for i in range(1,N+1):
fact_tmp *= i
fact_tmp %= mod
fact.append(fact_tmp)
inv_fact.append(pow(fact_tmp, mod-2, mod))
def ncr(n,r):
if n < 0 or r < 0 or n < r: return 0
else: return (fact[n] * inv_fact[r] * inv_fact[n-r]) %mod
can_zero_num=min(N-1,K)
ans=0
for zero_num in range(can_zero_num+1):
ans+=ncr(N,zero_num)*ncr(N-1,N-zero_num-1)
print ans%mod | 1 | 66,909,626,473,340 | null | 215 | 215 |
n=int(input())
a=list(map(int,input().split()))
a.sort()
am=max(a)
dp=[[True,0] for _ in range(am+1)]
count=0
for i in a:
if dp[i][0]==False:
continue
else:
if dp[i][1]==1:
dp[i][0]=False
count-=1
else:
dp[i][1]=1
count+=1
for j in range(2*i,am+1,i):
dp[j][0]=False
print(count) | def main():
n = int(input())
a = sorted(map(int,input().split()))
fld = [-1 for i in range(a[-1]+1)]
flg = []
for i in range(n):
if fld[a[i]]==-1:
fld[a[i]]=1
for j in range(2,a[-1]//a[i]+1):
fld[a[i]*j] = 0
elif fld[a[i]]==1:
flg.append(a[i])
for i in range(len(flg)):
fld[flg[i]] = 0
ans = 0
for i in range(len(fld)):
if fld[i] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| 1 | 14,392,845,545,430 | null | 129 | 129 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N = input()
s = 0
for i in range(len(N)):
s += int(N[i])
if s%9 == 0:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| while 1:
x, y = map(int, input().split())
if x == 0 and y == 0:
break
if x >= y:
print("{0} {1}".format(y, x))
else:
print("{0} {1}".format(x, y)) | 0 | null | 2,442,459,211,580 | 87 | 43 |
# -*- coding: utf-8 -*-
def solve():
S = input()
return S[:3]
if __name__ == '__main__':
print(solve())
|
def soinsu(n):
insu = []
tmp = n
if n == 1:
insu.append([1,0])
return insu
for i in range(2,int(n**0.5)+1):
cnt = 0
if tmp % i == 0:
while(tmp % i == 0):
tmp //= i
cnt += 1
insu.append([i,cnt])
if tmp != 1:
insu.append([tmp,1])
if len(insu) == 0:
insu.append([n,1])
return insu
n = int(input())
a = [0]*(int(n**0.5)+1)
cnt=1
for i in range(1,len(a)):
for j in range(cnt,cnt+i+1):
if j < len(a):
a[j] = i
cnt += 1
else:
break
sum = 0
insu = soinsu(n)
for i in range(len(insu)):
sum += a[insu[i][1]]
print(sum) | 0 | null | 15,879,304,078,722 | 130 | 136 |
a,b,m=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
C=[list(map(int,input().split())) for i in range(m)]
lis=[min(A)+min(B)]
for i in range(m):
lis.append(A[C[i][0]-1]+B[C[i][1]-1]-C[i][2])
print(min(lis))
| A,B,M=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
List=[list(map(int,input().split())) for i in range(M)]
minn=min(a)+min(b)
for i in range(M):
minn=min(minn,a[List[i][0]-1]+b[List[i][1]-1]-List[i][2])
print(minn) | 1 | 54,024,430,129,152 | null | 200 | 200 |
import math
from decimal import Decimal, ROUND_HALF_UP
def resolve():
a, b, C = map(int, input().split())
x = math.radians(C)
h = b * math.sin(x)
S = Decimal((a * h) / 2).quantize(Decimal('0.00000001'), rounding=ROUND_HALF_UP)
c = Decimal(math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(x))).quantize(Decimal('0.00000001'),
rounding=ROUND_HALF_UP)
L = Decimal(a + b + c).quantize(Decimal('0.00000001'), rounding=ROUND_HALF_UP)
print(S, L, h, sep="\n")
resolve()
| #coding = utf-8
import math
a, b, c = map(float, raw_input().split())
h = b * math.sin(math.pi*c/180)
s = a * h / 2
x = math.sqrt(h**2 + (a-b*math.sin(math.pi*(90-c)/180))**2)
l = a + b + x
#print "%.8f, %.8f, %.8f" % (s, l, h)
print "\n".join([str(s), str(l), str(h)])
#print "%.1f, %.1f, %.1f" % (s, l, h) | 1 | 180,080,458,308 | null | 30 | 30 |
i = int(input())
h = i // 3600
i -= h * 3600
m = i // 60
i -= m * 60
s = i
print("{}:{}:{}".format(h, m, s))
| S=input()
h=int(S)/3600
m=(int(S)%3600)/60
s=((int(S)%3600)%60)/1
print(int(h),':',int(m),':',int(s),sep='')
| 1 | 338,878,733,550 | null | 37 | 37 |
def kton(S):
r = 0
m = 0
for s in S:
r += 1 if s == '(' else -1
m = min(m, r)
return r, m
def main():
N = int(input())
RM = [kton(input()) for _ in range(N)]
pos = 0
negp = []
negn = []
posn = []
for r, m in RM:
if m < 0:
if r >= 0:
negp.append((-m, r))
else:
negn.append((-(r-m), -r, m))
else:
pos += r
negp.sort()
for m, r in negp:
if pos - m < 0:
return False
pos += r
negn.sort()
for _, r, m in negn:
if pos + m < 0:
return False
pos -= r
return pos == 0
print('Yes' if main() else 'No') | import sys
inp = [int(x) for x in sys.stdin.read().split()]; ii = 0
class SegmentTree:
def __init__(self, data, default=0, func=max):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
"""func of data[start, stop)"""
start += self._size
stop += self._size
res_left = res_right = self._default
while start < stop:
if start & 1:
res_left = self._func(res_left, self.data[start])
start += 1
if stop & 1:
stop -= 1
res_right = self._func(self.data[stop], res_right)
start >>= 1
stop >>= 1
return self._func(res_left, res_right)
def __repr__(self):
return "SegmentTree({0})".format(self.data)
shift = int(10**9 + 1)
rows, cols, k = inp[ii:ii+3]; ii += 3
items = [[] for _ in range(rows+1)]
best = [0]*(cols+1)
for _ in range(k):
r, c, v = inp[ii:ii+3]; ii += 3
items[r].append(c*shift+v)
for i in range(rows+1):
items[i].sort()
S = SegmentTree(best)
ans = 0
for r in range(1, rows+1):
dp = []
best1, best2 = 0, 0
Row = items[r]
for X in Row:
c, v = X//shift, X%shift
v1 = S.query(1, c+1) + v
v2 = best1 + v
v3 = best2 + v
V = v1
if V < v2:
V = v2
if V < v3:
V = v3
dp.append(V)
if v1 > best1:
best1 = v1
if v2 > best2:
best2 = v2
if ans < V:
ans = V
for j in range(len(dp)):
c = Row[j]//shift
if S[c] < dp[j]:
S[c] = dp[j]
print(ans)
| 0 | null | 14,560,241,347,204 | 152 | 94 |
# -*- coding: utf-8 -*-
"""
B - TAKOYAKI FESTIVAL 2019
https://atcoder.jp/contests/abc143/tasks/abc143_b
"""
import sys
from itertools import combinations
def solve(takoyaki):
return sum(x * y for x, y in combinations(takoyaki, 2))
def main(args):
_ = input()
takoyaki = map(int, input().split())
ans = solve(takoyaki)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| N = int(input())
D = list(map(int,input().split()))
cnt = 0
for i in range(N):
cnt += D[i]**2
tot = 0
for i in range(N):
tot += D[i]
tot = tot**2
tot -= cnt
print(tot//2) | 1 | 168,522,027,811,698 | null | 292 | 292 |
from math import gcd
def main():
ans = 0
k = int(input())
for i in range(1,1+k):
for j in range(1,1+k):
for l in range(1,1+k):
ans += gcd(i,gcd(j,l))
print(ans)
if __name__ == "__main__":
main() |
from math import gcd as g
k = int(input())
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
temp = g(a, b)
for c in range(1, k+1):
ans += g(temp, c)
print(ans)
| 1 | 35,446,898,036,260 | null | 174 | 174 |
# 1
# a,b=map(int,input().split())
# if a+b==15:
# ans='+'
# elif a*b==15:
# ans='*'
# else:
# ans='x'
# print(ans)
# 2
X=int(input())
print(8-(X-400)//200) | # coding: utf-8
import sys
from operator import itemgetter
sysread = sys.stdin.readline
read = sys.stdin.read
from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import combinations, product
#import bisect# lower_bound etc
#import numpy as np
#import queue# queue,get(), queue.put()
def run():
N = int(input())
current = 0
ways = []
dic = {'(': 1, ')': -1}
SS = read().split()
for S in SS:
path = [0]
for s in S:
path.append(path[-1]+ dic[s])
ways.append((path[-1], min(path)))
ways_pos = sorted([(a,b) for a,b in ways if a >= 0], key = lambda x:(x[1], x[0]), reverse=True)
ways_neg = sorted([(a,b) for a,b in ways if a < 0], key = lambda x:(x[1] - x[0], -x[0]))
for i in range(len(ways_pos)):
go, max_depth = ways_pos[i]
if current + max_depth >= 0:
current += go
else:
print("No")
return None
for i in range(len(ways_neg)):
go, max_depth = ways_neg[i]
if current + max_depth >= 0:
current += go
else:
print("No")
return None
if current == 0:
print('Yes')
else:
print('No')
if __name__ == "__main__":
run() | 0 | null | 15,252,454,514,732 | 100 | 152 |
#coding:utf-8
class Combination:
def __init__(self,N,P=10**9+7):
if N > 10**7:
self.fact = lambda x: x * self.fact(x-1) % P if x > 2 else 2
self.perm = lambda x, r: x * self.perm(x-1,r-1) % P if r > 0 else 1
self.cmb = lambda n,r: (self.perm(n,min(n-r,r)) * pow(self.fact(min(n-r,r)) ,P-2 ,P) % P) if r > 0 else 1
else:
self.__fact = [1] * (N+1)
self.__inv = [1] * (N+1)
self.__inv_fact = [1] * (N+1)
for i in range(2,N+1):
self.__fact[i] = self.__fact[i-1] * i % P
self.__inv[i] = - self.__inv[P%i] * (P//i) % P
self.__inv_fact[i] = self.__inv_fact[i-1] * self.__inv[i] % P
self.fact = lambda n: self.__fact[n]
self.perm = lambda n,r: self.__fact[n] * self.__inv_fact[n-r] % P
self.cmb = lambda n,r: (self.__fact[n] * self.__inv_fact[n-r] * self.__inv_fact[r] % P) if r > 0 else 1
import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
input = lambda: given().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
XLMIIS = lambda x: [LMIIS() for _ in range(x)]
YN = lambda c : print('Yes') if c else print('No')
MOD = 10**9+7
from collections import deque
n,k = LMIIS()
cmb = Combination(2*n)
ans = 1
for i in range(1,min(n,k+1)):
ans = (ans + cmb.cmb(n,i) * cmb.cmb(n-1,i)) % MOD
print(ans)
if __name__ == '__main__':
main() | a = [int(str) for str in input().split()]
b = [int(str) for str in input().split()]
if a[0] == b[0]:
print(0)
else:
print(1) | 0 | null | 95,985,899,648,244 | 215 | 264 |
import sys
def solve():
a = [int(input()) for i in range(10)]
a.sort(reverse=True)
print(*a[:3], sep='\n')
if __name__ == '__main__':
solve() | n=int(input())
dp=[0]*(n+1)
dp[0]=1
dp[1]=1
def rec(x):
if dp[x]>0:
return dp[x]
res=rec(x-1)+rec(x-2)
dp[x]=res
return dp[x]
print(rec(n))
| 0 | null | 934,289,614 | 2 | 7 |
case_num = 1
while True:
tmp_num = int(input())
if tmp_num == 0:
break
else:
print("Case %d: %d" % (case_num,tmp_num))
case_num += 1
| N = int(input())
D = N % 10
if D in [2, 4, 5, 7, 9]:
print("hon")
if D in [0, 1, 6, 8]:
print("pon")
if D == 3:
print("bon") | 0 | null | 9,921,099,518,202 | 42 | 142 |
#coding:utf-8
from copy import deepcopy
n = int(input())
A = list(input().split())
B = deepcopy(A)
def BubbleSort(A,N):
for i in range(N):
for j in range(N-1,i,-1):
if A[j][1] < A[j-1][1]:
A[j], A[j-1] = A[j-1], A[j]
def SelectionSort(A,N):
for i in range(N):
minj = i
for j in range(i,N):
if A[j][1] < A[minj][1]:
minj = j
A[i], A[minj] = A[minj], A[i]
BubbleSort(A,n)
SelectionSort(B,n)
A = " ".join([data for data in A])
B = " ".join([data for data in B])
print(A)
print("Stable")
print(B)
if A == B:
print("Stable")
else:
print("Not stable")
| import math
cnt = 0
for i in range(int(input())):
x = int(input())
flg = False # なんらかの数で割り切れるかどうか
if x == 1:
continue
if x == 2:
cnt += 1
continue
for k in range(2, math.floor(math.sqrt(x))+1):
if not(x % k):
flg = True
break
if not flg:
cnt += 1
print(cnt)
| 0 | null | 18,013,004,698 | 16 | 12 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
N, R = map(int, input().split())
if N < 10:
ans = R + 100 * (10 - N)
else:
ans = R
print(ans)
if __name__ == '__main__':
solve()
| N, R = [int(i) for i in input().split(' ')]
N = min(10,N)
print(R + 100*(10-N)) | 1 | 63,490,216,476,720 | null | 211 | 211 |
K=int(input())
import math
l=[]
for i in range(1,K+1):
for j in range(1,K+1):
for k in range(1,K+1):
x=math.gcd(i,math.gcd(j,k))
l.append(x)
print(sum(l)) | from math import gcd
K = int(input())
ans = 0
for i in range(1, K+1):
for j in range(i+1, K+1):
for k in range(j+1, K+1):
ans += gcd(gcd(i, j), k)*6
for i in range(1, K+1):
for j in range(i+1, K+1):
ans += gcd(i, j)*6
ans += K*(K+1)//2
print(ans)
| 1 | 35,455,071,611,118 | null | 174 | 174 |
s = input()
n = len(s)
dp = [0]*(n+1)
t = 0
for e,i in enumerate(s,1):
if i=='<' :
dp[e]=dp[e-1]+1
# print(dp)
t = 0
for e in range(n-1,-1,-1):
i = s[e]
# print(t)
if i=='>' :
dp[e]=max(dp[e],dp[e+1]+1)
# print(dp)
print(sum(dp)) | S = input()
ans = [0] * (len(S) + 1)
for i in range(len(S)):
if S[i] == '<':
ans[i + 1] = ans[i] + 1
for i in range(len(S) - 1, -1, -1):
if S[i] == '>':
ans[i] = max(ans[i], ans[i + 1] + 1)
print(sum(ans)) | 1 | 156,943,126,476,250 | null | 285 | 285 |
import sys
n = int(input())
a = dict()
for x in map(int, input().split()):
if a.get(x) == 1:
print('NO')
sys.exit()
a[x] = 1
print('YES')
| A = []
for _ in range(12):
A.append([0]*10)
n = int(input())
for _ in range(n):
b, f, r, v = map(int, input().split())
A[3*b-(3-f)-1][r-1] += v
for i in range(12):
print(' ', end='')
print(' '.join(map(str, A[i])))
if i in [2, 5, 8]:
print('#'*20)
| 0 | null | 37,714,918,592,068 | 222 | 55 |
A,B=map(int,input().split())
if 10>A>0 and 10>B>0:
print(A*B)
else:
print(-1)
| #!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
def resolve():
A,B=pin()
if A>9 or B>9:print(-1);return
print(A*B)
#%%submit!
resolve() | 1 | 158,515,704,721,660 | null | 286 | 286 |
import sys
input = sys.stdin.buffer.readline
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
n, k = MAP()
h = LIST()
h.sort(reverse=True)
if k >= n:
print(0)
else:
print(sum(h[k:]))
| def solve():
N,K = [int(i) for i in input().split()]
H = [int(i) for i in input().split()]
if K >= len(H):
print('0')
else:
sorted_H = sorted(H)
alived = N - K
print(sum(sorted_H[:alived]))
if __name__ == "__main__":
solve() | 1 | 79,349,004,447,052 | null | 227 | 227 |
n,k = map(int,input().split())
person = [0]*n
for i in range(k):
d = int(input())
A = list(map(int,input().split()))
for j in range(len(A)):
person[A[j]-1] = 1
print(person.count(0))
| n = int(input())
a =[[[0 for i in range(10)]for j in range(3)]for k in range(4)]
for i in range(n):
b, f, r, v = map(int, input().split())
a[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
for k in range(10):
print("", a[i][j][k], end='')
print()
if i != 3:
print("#" * 20) | 0 | null | 12,841,163,466,880 | 154 | 55 |
n,x,y=map(int,input().split())
l=[]
for i in range(n-1):
for j in range(i+1,n):
d1=j-i
d2=abs((x-1)-i)+abs(j-(y-1))+1
d=min(d1,d2)
l.append(d)
import collections
c=collections.Counter(l)
for kk in range(1,n):
print(c[kk]) | N,K = map(int,input().split())
li = []
count = 0
for i in range(K):
d = int(input())
a = list(map(int,input().split()))
for j in range(d):
li.append(a[j])
for i in range(N):
if i+1 not in li:
count += 1
print(count) | 0 | null | 34,279,444,226,690 | 187 | 154 |
import sys
from collections import deque
def test():
EleList = deque()
sublist = []
output = []
areas_from_left = list(sys.stdin.readline())
sum = 0
depth = 0
for element in areas_from_left:
if element == '\\':
depth += 1
EleList.append(element)
elif element == '_':
if EleList:
EleList.append(element)
elif element == '/':
depth -= 1
if EleList:
for pop_count in range(len(EleList)):
pop_ele = EleList.pop()
if pop_ele == '\\' and EleList:
for i in range(pop_count+2):
EleList.append('_')
break
lake = pop_count + 1
sum += lake
if len(EleList) == 0:
if len(sublist) == 0:
output.append(lake)
else:
tmp = 0
for i in sublist:
tmp += i[0]
output.append(tmp + lake)
sublist.clear()
else:
if not sublist or sublist[len(sublist)-1][1] < depth:
sublist_element = [0,0]
sublist_element[0] = lake
sublist_element[1] = depth
sublist.append(sublist_element)
else:
sublist_element = [lake,depth]
while True:
if not sublist:
break
tmp = sublist.pop()
if tmp[1] > depth:
sublist_element[0] += tmp[0]
else:
sublist.append(tmp)
break
sublist.append(sublist_element)
#print(f"{output}{sublist}")
output_sublist = []
for tmp in sublist:
output_sublist.append(tmp[0])
output = output + output_sublist
length = len(output)
print(sum)
if length != 0:
print(f"{length} ",end='')
else:
print(length)
for i in range(length - 1):
print(f"{output[i]} ",end='')
if output:
print(output[length-1])
if __name__ == "__main__":
test()
| s = input()
i = 0
S1 = []
S2 = []
water = []
wtot = 0
while i < len(s):
if s[i] == "\\":
S1.append(i)
elif s[i] == '/' and len(S1) != 0:
w0 = (i - S1[-1])
wtot += w0
if len(S2) == 0:
S2.append((S1[-1], w0))
else:
while len(S2) != 0 and S2[-1][0] > S1[-1]:
w0 += S2[-1][1]
S2.pop()
S2.append((S1[-1], w0))
S1.pop()
i += 1
ans = str(wtot) + '\n' + str(len(S2))
for p in S2:
ans += ' ' + str(p[1])
print(ans)
| 1 | 61,451,669,088 | null | 21 | 21 |
a = {x:0 for x in range(ord('a'), ord('z') + 1)}
while True:
try:
text = input()
for x in text:
if ord('a') <= ord(x) <= ord('z') or ord('A') <= ord(x) <= ord('Z'):
a[ord(x.lower())] += 1
except EOFError:
break
for x in range(ord('a'), ord('z') + 1):
print(chr(x), ':', a[x]) | tmp = "abcdefghijklmnopqrstuvwxyz"
alph = list(tmp)
alphcount = [0]*26
while True:
try:
letter = input()
letterarray = list(letter.lower())
# print(letterarray)
except:
break
for x in letterarray:
for i in range(26) :
if (x == alph[i]):
alphcount[i] += 1
else :
continue
for i in range(26):
print(str(alph[i])+" : "+str(alphcount[i]))
| 1 | 1,663,850,080,530 | null | 63 | 63 |
l = len(input())
print('x'*l) | import math
def main():
n = int(input())
r = 2 * math.pi * n
print(round(r,2))
main() | 0 | null | 52,262,306,239,390 | 221 | 167 |
num = int(input())
if num >= 30:
print("Yes")
else:
print("No") | n = int(input())
print("Yes") if n >= 30 else print("No") | 1 | 5,777,545,218,388 | null | 95 | 95 |
from math import gcd as g
k = int(input())
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
temp = g(a, b)
for c in range(1, k+1):
ans += g(temp, c)
print(ans)
| from math import gcd
K = int(input())
ans = 0
for i in range(1, K+1):
for j in range(i+1, K+1):
for k in range(j+1, K+1):
ans += gcd(gcd(i, j), k)*6
for i in range(1, K+1):
for j in range(i+1, K+1):
ans += gcd(i, j)*6
ans += K*(K+1)//2
print(ans)
| 1 | 35,501,972,508,928 | null | 174 | 174 |
h = int(input())
i =1
while h>1:
h //=2
i += 1
print(2**i-1) | s = input()
n = len(s)
t = input()
m = len(t)
c_max = 0
for i in range(n - m + 1):
c = 0
for j in range(m):
if s[i + j] == t[j]:
c += 1
if c > c_max:
c_max = c
print(m - c_max) | 0 | null | 42,053,134,286,108 | 228 | 82 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.