code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
from collections import defaultdict
d = defaultdict(lambda: 0)
N = int(input())
for _ in range(N):
ord, str = input().split()
if ord == 'insert':
d[str] = 1
else:
if str in d:
print('yes')
else:
print('no')
|
N = int(input())
d = {}
for i in [None]*N:
a, b = input().split()
if a == "insert":
d[b] = 1
else:
print("yes" if b in d else "no")
| 1 | 77,196,512,628 | null | 23 | 23 |
s=input()
a,b=s.split()
a=int(a)
b=int(b)
print("%d %d"%(a*b,2*a+2*b))
|
n = int(input())
fib = []
fib.append(1)
fib.append(1)
for _ in range(n - 1):
fib.append(fib[-2] + fib[-1])
print(fib[-1])
| 0 | null | 154,729,371,082 | 36 | 7 |
#dpでできないかな？
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,cos,radians,sqrt
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7
n,a,b=MI()
l=b-a
if l%2==0:
ans=l//2
print(ans)
else:
edge=min(n-b,a-1)
#print(edge)
ans=edge
ans+=1
l-=1
ans+=l//2
print(ans)
|
N,A,B=map(int,input().split())
ans=0
if (B-A)%2==0:
ans=(B-A)//2
else:
if A-1<N-B:
if B-A==1:
ans=B-1
else:
ans=A+(B-A-1)//2
else:
if B-A==1:
ans=N-A
else:
ans=N-B+1+(N-(A+N-B+1))//2
print(ans)
| 1 | 109,480,518,324,798 | null | 253 | 253 |
from itertools import permutations
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
l=[i+1 for i in range(n)]
perm = permutations(l)
perm=list(perm)
p=[]
for i in perm:
k=(''.join(map(str,i)))
p.append(int(k))
a=''.join(map(str,a))
b=''.join(map(str,b))
idx1=p.index(int(a))
idx2=p.index(int(b))
print(abs(idx1-idx2))
|
# -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
# 標準入力を取得
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
return N, P, Q
def main(N: int, P: tuple, Q: tuple) -> None:
"""
メイン処理.
Args:\n
N (int): 数列の大きさ
P (tuple): 順列
Q (tuple): 順列
"""
# 求解処理
p = 0
q = 0
order = 1
for t in itertools.permutations(range(1, N + 1), N):
if t == P:
p = order
if t == Q:
q = order
order += 1
ans = abs(p - q)
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, P, Q = get_input()
# メイン処理
main(N, P, Q)
| 1 | 100,180,796,312,400 | null | 246 | 246 |
from queue import LifoQueue
MAP = input()
que = LifoQueue()
res = LifoQueue()
for i, m in enumerate(MAP):
if m=='\\':
que.put(i)
elif m=='/':
if not que.empty():
j = que.get(False)
v = i - j
t = (j, v)
while not res.empty():
pre = res.get(False)
if (pre[0] > j):
t = (t[0], t[1] + pre[1])
else:
res.put(pre)
res.put(t)
break
else:
res.put(t)
summaly = 0
lakes = []
while not res.empty():
v = res.get()
lakes.append(v[1])
summaly += v[1]
print(summaly)
print(len(lakes), *(reversed(lakes)))
|
from collections import deque
x = input()
A = 0
S1 = deque()
S2 = deque()
for i in range(len(x)):
if x[i] == "\\":
S1.append(i)
elif x[i] == "/" and len(S1) > 0 :
j = S1.pop()
A += i - j
a = i - j
while len(S2) > 0 and S2[-1][0] > j:
a += S2[-1][1]
S2.pop()
S2.append([j,a])
print(A)
if len(S2)== 0:
print(0)
else:
print(len(S2),"",end="")
for i in range(len(S2)):
if i == len(S2) - 1:
print(S2[i][1])
else:
print(S2[i][1],"",end="")
| 1 | 58,432,391,562 | null | 21 | 21 |
s, t = map(str, input().split())
print(str(t)+str(s))
|
n, k = map(int, input().split())
lp = list(map(int, input().split()))
le = [(p + 1) / 2 for p in lp]
e = sum(le[:k])
m = e
for i in range(n - k):
e -= le[i]
e += le[k + i]
m = max(m, e)
print(m)
| 0 | null | 89,275,000,318,530 | 248 | 223 |
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
L = dict(Counter([i+A[i] for i in range(N)]))
R = dict(Counter([i-A[i] for i in range(N)]))
cnt = 0
for x in L:
cnt += L[x]*R.get(x, 0)
print(cnt)
|
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
A1 = []
A2 = []
for i in range(1,N+1):
A1.append(i + A[i-1])
A2.append(i - A[i-1])
c1 = Counter(A1)
c2 = Counter(A2)
result = 0
for k in set(c1).intersection(c2):
result += c1[k] * c2[k]
print(result)
| 1 | 26,188,391,724,260 | null | 157 | 157 |
n = int(input().rstrip())
r = int(n / 2) + (n % 2)
print(r / n)
|
N = int(input())
if N%2 == 0:
print(0.5000000000)
else:
odd = N//2 + 1
print(odd/N)
| 1 | 177,170,649,584,212 | null | 297 | 297 |
import math
r = float(input())
s = r * r * math.pi
l = r * 2 * math.pi
print('{:f} {:f}'.format(s, l))
|
def calc_circle(r):
pi = 3.14159265359
area = round(r*r*pi, 6)
circ = round(2*r*pi, 6)
return (area, circ)
if __name__ == "__main__":
r = float(input())
area, circ = calc_circle(r)
print(f"{area:.6f} {circ:.6f}")
| 1 | 635,580,536,000 | null | 46 | 46 |
def main():
S = input()
print("x"*len(S))
if __name__ == "__main__":
main()
|
s=input('')
t=''
for a in s:
t=t+'x'
print(t)
| 1 | 73,109,442,496,808 | null | 221 | 221 |
MOD = 998244353
n = int(input())
d = list(map(int, input().split()))
dist_map = [0]*n
for dist in d:
dist_map[dist] += 1
ans = 1
if d[0] != 0 or dist_map[0] > 1:
print(0)
exit()
for i in range(1, n):
ans *= pow(dist_map[i-1], dist_map[i], MOD)
ans %= MOD
print(ans)
|
def main():
a = input()
print('A' if a.isupper() else 'a')
if __name__ == '__main__':
main()
| 0 | null | 83,424,084,220,860 | 284 | 119 |
#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)
s = ins()
t = ins()
ls = len(s)
lt = len(t)
mn = BIG
for i in range(ls-lt+1):
x = 0
for j in range(lt):
if s[i+j]!=t[j]:
x += 1
mn = min(mn,x)
print(mn)
|
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
import bisect
import heapq
import itertools
import math
import numpy as np
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
bunshi=1
bunbo=1
for i in range(r):
bunbo = bunbo*(i+1)%mod
bunshi = bunshi*(n-i)%mod
return (bunshi*pow(bunbo,mod-2,mod))%mod
mod = 10**9+7
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return [list(map(int, input().split())) for _ in range(n)]
n,m = MI()
graph = [[] for _ in range(n+1)]
for i in range(m):
a,b = MI()
graph[a].append(b)
graph[b].append(a)
dist = [-1]*(n+1)
dist[0] = 0
dist[1] = 0
d = deque()
d.append(1)
ans = [0]*(n+1)
while d:
v = d.popleft()
for i in graph[v]:
if dist[i] != -1:
continue
ans[i] = v
dist[i] = 0
d.append(i)
print("Yes")
for i in ans[2:]:
print(i)
| 0 | null | 11,978,341,838,260 | 82 | 145 |
#!/usr/bin/env python3
from sys import stdin, stdout
def solve():
n = int(stdin.readline().strip())
seqA = []
seqB = []
for i in range(n):
a,b = map(int, stdin.readline().split())
seqA.append(a)
seqB.append(b)
seqA = sorted(seqA)
seqB = sorted(seqB)
mA = seqA[n//2]
mB = seqB[n//2]
if n%2==0:
mA += seqA[n//2-1]
mB += seqB[n//2-1]
print(mB-mA+1)
solve()
|
n = int(input())
a, b = [0] * n, [0] * n
for i in range(n):
a[i], b[i] = map(int, input().split())
a.sort()
b.sort()
if n % 2:
min_m, max_m = a[n // 2], b[n // 2]
ans = max_m - (min_m - 1)
else:
min_m2 = a[n // 2] + a[n // 2 - 1]
max_m2 = b[n // 2] + b[n // 2 - 1]
ans = max_m2 - min_m2 + 1
print(ans)
| 1 | 17,388,335,882,750 | null | 137 | 137 |
def main():
N = int(input())
A = list(map(int, input().split()))
for i in range(N):
if A[i] % 2 == 0 and (A[i] % 3 != 0 and A[i] % 5 != 0):
return "DENIED"
return "APPROVED"
if __name__ == '__main__':
print(main())
|
N=int(input())
S=[int(s) for s in input().split()]
for i in range(N):
if S[i]%2==0 and S[i]%5!=0 and S[i]%3!=0:
print("DENIED")
break
elif i==N-1:
print("APPROVED")
| 1 | 69,081,914,383,460 | null | 217 | 217 |
N, K, C = map(int, input().split())
S = input()
must = set()
i = len(S)+C
for j in range(K):
i = S.rindex("o", 0, i-C)
must.add(i)
if i<=C or "o" not in S[:i-C]:
i = -C-1
for j in range(K):
i = S.index("o", i+C+1)
if i in must:
print(i+1)
|
nkc=input().split()
K=int(nkc[1])
C=int(nkc[2])
s=input()
workday_list=[]
for i,youso in enumerate(s) :
if youso=='o' :
workday_list.append(i+1)
s=1
current_num=0
current_num1=1
list1=[]
list1.append(workday_list[0])
while(s<K) :
if current_num1>=len(workday_list):
break
elif workday_list[current_num1]-workday_list[current_num]>C :
current_num=current_num1
list1.append(workday_list[current_num1])
s+=1
else :
current_num1=current_num1+1
m=1
current_num2=len(workday_list)-1
current_num3=len(workday_list)-2
list2=[]
list2.append(workday_list[-1])
while(m<K) :
if current_num3<0:
break
elif workday_list[current_num2]-workday_list[current_num3]>C :
current_num2=current_num3
list2.append(workday_list[current_num3])
m+=1
else :
current_num3=current_num3-1
list2.reverse()
flag=True
for i in range(len(list1)) :
if list1[i]==list2[i] :
flag=False
print(list1[i])
if flag :
print()
| 1 | 40,556,983,170,832 | null | 182 | 182 |
residence = [[[0 for r in range(10)] for f in range(3)] for b in range(4)]
n = int(input())
sep = "#"*20
s = ""
for i in range(n):
b,f,r,v = map(int,input().split())
residence[b-1][f-1][r-1] += v
for i in residence:
for j in i:
s += " "+" ".join(map(str,j)) + "\n"
s += sep+"\n"
print(s.rstrip(sep+"\n"))
|
import sys
n = int(raw_input())
building_a = [[0 for j in range(11)] for i in range(4)]
building_b = [[0 for j in range(11)] for i in range(4)]
building_c = [[0 for j in range(11)] for i in range(4)]
building_d = [[0 for j in range(11)] for i in range(4)]
for i in range(n):
b, f, r, v = map(int, raw_input().split())
if b == 1:
building_a[f][r] += v
elif b == 2:
building_b[f][r] += v
elif b == 3:
building_c[f][r] += v
elif b == 4:
building_d[f][r] += v
for i in range(1, 4):
print "",
for j in range(1, 11):
print building_a[i][j],
print
for i in range(20):
sys.stdout.write("#")
print
for i in range(1, 4):
print "",
for j in range(1, 11):
print building_b[i][j],
print
for i in range(20):
sys.stdout.write ("#")
print
for i in range(1, 4):
print "",
for j in range(1, 11):
print building_c[i][j],
print
for i in range(20):
sys.stdout.write("#")
print
for i in range(1, 4):
print "",
for j in range(1, 11):
print building_d[i][j],
print
| 1 | 1,115,542,263,910 | null | 55 | 55 |
n,q = map(int,input().split())
name = []
time = []
for i in range(n):
a = input().split()
name.append(a[0])
time.append(int(a[1]))
s = 0
while name:
if time[0]> q:
time[0] -= q
time.append(time.pop(0))
name.append(name.pop(0))
s += q
else:
s += time[0]
time.pop(0)
print(name.pop(0),s)
|
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
input = sys.stdin.readline
INF = float("inf")
MOD = 1000000007
# 処理内容
def main():
N = int(input())
a = 1
for _ in range(N):
a = a * 10 % MOD
b = 1
for _ in range(N):
b = b * 9 % MOD
c = 1
for _ in range(N):
c = c * 8 % MOD
ans = (a - 2*b + c) % MOD
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 1,576,397,779,200 | 19 | 78 |
n,a,b = map(int,input().split())
answer = 0
answer = a*(n//(a+b))
n = n%(a+b)
answer += min(a,n)
print(answer)
|
n, a, b = map(int, input().split())
div, mod = divmod(n, a + b)
print(div * a + min(a, mod))
| 1 | 55,583,983,000,072 | null | 202 | 202 |
H,W,K = map(int,input().split())
S = [input() for i in range(H)]
ans = [[None]*W for _ in range(H)]
v = 0
for i,row in enumerate(S):
sp = row.split('#')
if len(sp)==1: continue
if len(sp)==2:
v += 1
for j in range(W):
ans[i][j] = v
continue
j = 0
for k,a in enumerate(sp):
if k==len(sp)-1:
for _ in range(len(a)):
ans[i][j] = v
j += 1
else:
v += 1
for _ in range(len(a)+1):
ans[i][j] = v
j += 1
i = 0
while ans[i][0] is None:
i += 1
for ii in range(i):
for j in range(W):
ans[ii][j] = ans[i][j]
for i in range(1,H):
if ans[i][0] is None:
for j in range(W):
ans[i][j] = ans[i-1][j]
for row in ans:
print(*row)
|
import sys
from collections import deque
input = sys.stdin.readline
def main():
h, w, k = map(int, input().split())
board = [input().strip() for i in range(h)]
group = [[0 for i in range(w)] for j in range(h)]
state = 0 # 0:not found, 1:one strawberry
num = 1
stock = 1
pre = -1
for i in range(h):
if "#" not in board[i]:
stock += 1
continue
for j in range(w):
if board[i][j] == "#":
if state == 0:
state = 1
else:
num += 1
group[i][j] = num
else:
group[i][j] = num
for k in range(stock):
for j in range(w):
print(group[i][j], end=" ")
print()
num += 1
state = 0
stock = 1
pre = i
for k in range(h-pre-1):
for j in range(w):
print(group[pre][j], end=" ")
print()
if __name__ == "__main__":
main()
| 1 | 143,785,608,152,770 | null | 277 | 277 |
MOD = 998244353
N, M, K = map(int, input().split())
fac = [1] * N
for i in range(1, N):
fac[i] = (fac[i - 1] * i) % MOD
pow_mmm = [1] * N
for i in range(1, N):
pow_mmm[i] = (pow_mmm[i - 1] * (M - 1)) % MOD
ans = 0
for i in range(K + 1):
t = (M * pow_mmm[N - 1 - i]) % MOD
comb = (fac[N - 1] * pow(fac[N - 1 - i], MOD - 2, MOD) * pow(fac[i], MOD - 2, MOD)) % MOD
t = (t * comb) % MOD
ans = (ans + t) % MOD
print(ans)
|
import sys
n, m, k = map(int, input().split())
prime_mod = 998244353
def prime_cycle_division(a, b):
inverted = pow(b, prime_mod-2, prime_mod)
return (a*inverted)%prime_mod
def gen_mod_combs(places):
k = 0
x = 1
while True:
yield x
factor = prime_cycle_division(places-k, k+1)
x = (x*factor)%prime_mod
k += 1
def combos(j):
ans = (m*next(gen))%prime_mod
ans = (ans*pow(m-1, n-1-j, prime_mod))%prime_mod
return ans
total = 0
gen = gen_mod_combs(n-1)
for j in range(k+1):
total = (total + combos(j))%prime_mod
print(total)
| 1 | 23,037,357,178,176 | null | 151 | 151 |
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
n = int(input())
aa = []
bb = []
for i in range(n):
a , b = list(map(int, input().split()))
aa.append(a)
bb.append(b)
aa.sort()
bb.sort()
if n % 2 == 0:
m_a = (aa[n // 2 - 1] + aa[n // 2])
m_b = (bb[n // 2 - 1] + bb[n // 2])
print(m_b - m_a+1)
sys.exit()
else:
median_a = aa[n // 2]
median_b = bb[n // 2]
print(median_b-median_a+1)
sys.exit()
|
import sys
N=int(sys.stdin.readline().strip())
A=[]
B=[]
for _ in range(N):
a,b=map(int, sys.stdin.readline().split())
A.append(a)
B.append(b)
A.sort()
B.sort()
if N%2==0:
A_med=float(A[N/2]+A[N/2-1])/2
B_med=float(B[N/2]+B[N/2-1])/2
print int((B_med-A_med)*2+1)
else:
A_med=A[N/2]
B_med=B[N/2]
print B_med-A_med+1
| 1 | 17,265,599,278,980 | null | 137 | 137 |
r = int(input()) % 1000
print((1000 - r) % 1000)
|
N = int(input())
print(-(N%-1000))
| 1 | 8,467,709,037,570 | null | 108 | 108 |
n,m=map(int,input().split(" "))
l=max(n,m)
s=min(n,m)
while s!=0:
tmp = s
s = l % s
l = tmp
print(n*m // l)
|
n = int(input())
lr1, lr2 = [], []
res = 0
for _ in range(n):
s = input()
m = len(s)
l, r = 0, 0
tmp = 0
for i in range(m):
if s[i] == ')':
tmp += 1
else:
tmp -= 1
l = max(l, tmp)
tmp = 0
for i in range(m):
if s[m-1-i] == '(':
tmp += 1
else:
tmp -= 1
r = max(r, tmp)
res += r - l
if r - l >= 0:
lr1.append((l, r))
else:
lr2.append((l, r))
if res != 0:
print('No')
exit()
lr1.sort(key=lambda x: x[0])
lr2.sort(key=lambda x: x[1])
flg1, flg2 = True, True
n1, n2 = len(lr1), len(lr2)
tmp = 0
for i in range(n1):
l, r = lr1[i]
tmp -= l
if tmp < 0:
flg1 = False
tmp += r
tmp = 0
for i in range(n2):
l, r = lr2[i]
tmp -= r
if tmp < 0:
flg2 = False
tmp += l
if flg1 and flg2:
print('Yes')
else:
print('No')
| 0 | null | 68,850,037,406,460 | 256 | 152 |
S = input()
s_rev = S[::-1]
r_list = [0] * 2019
r_list[0] = 1
num, d = 0, 1
for i in range(len(S)):
num += d*int(s_rev[i])
num %= 2019
r_list[num] += 1
d *= 10
d %= 2019
ans = 0
for i in range(2019):
ans += r_list[i]*(r_list[i]-1)//2
print(ans)
|
from collections import Counter
N = int(input())
Alist = list(map(int,input().split()))
numcntlist = [0] * N
numCounter = Counter(Alist)
for i in range(1,N+1):
numcntlist[i-1] = numCounter[i]
sumcomb = 0
for i in numcntlist:
sumcomb += int(i*(i-1)/2)
for i in Alist:
ans = sumcomb -(numCounter[i] - 1)
print(ans)
| 0 | null | 39,532,070,218,080 | 166 | 192 |
from sys import setrecursionlimit, exit
setrecursionlimit(1000000000)
def main():
n = int(input())
a = [(int(v), i) for i, v in enumerate(input().split())]
a.sort(reverse=True)
dp = [[0] * (n + 1) for _ in range(n + 1)]
dp[0][0] = a[0][0] * (n - 1 - a[0][1])
dp[0][1] = a[0][0] * a[0][1]
for i, v in enumerate(a[1:]):
dp[i+1][0] = dp[i][0] + v[0] * abs(n - 1 - (i + 1) - v[1])
dp[i+1][i+2] = dp[i][i+1] + v[0] * abs(v[1] - (i + 1))
for j in range(1, i + 2):
dp[i+1][j] = max(
dp[i][j] + v[0] * abs(n - 1 - (i + 1) + j - v[1]),
dp[i][j-1] + v[0] * abs(v[1] - (j - 1)))
ans = -float('inf')
for i in dp[n-1]:
ans = max(ans, i)
print(ans)
main()
|
N=int(input());A=sorted((int(x),i)for i,x in enumerate(input().split()));t=[0]*N**2
for w in range(N):
a,j=A[w]
for l in range(N-w):
r=l+w;p=a*abs(j-l);t[l*N+r]=max(p+t[(l+1)*N+r],a*abs(j-r)+t[l*N+r-1])if w else p
print(t[N-1])
| 1 | 33,655,328,224,018 | null | 171 | 171 |
a, b = map(int, raw_input().split())
print(str(a*b) + " " + str(2*(a+b)))
|
# coding: utf-8
input_nums = raw_input().rstrip().split()
a, b = [int(x) for x in input_nums]
menseki = a * b
syutyo = 2 * (a + b)
print menseki, syutyo
| 1 | 307,064,104,558 | null | 36 | 36 |
n = int(input().rstrip())
ans = [0 for x in range(10000)]
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
f = ((x+y)**2 + (y+z)**2 + (z+x)**2)//2
if f <= 10000:
ans[f-1] += 1
for i in range(n):
print(ans[i])
|
from collections import defaultdict
N = int(input())
d = defaultdict(int)
for x in range(1,100):
for y in range(x,100):
for z in range(y,100):
n = x**2+y**2+z**2+x*y+y*z+z*x
if x == y == z:
d[n] += 1
elif x == y or y == z or z == x:
d[n] += 3
else:
d[n] += 6
if n > N:
break
for i in range(1,N+1):
print(d[i])
| 1 | 8,059,897,169,490 | null | 106 | 106 |
def main():
S = input()
print("x"*len(S))
if __name__ == "__main__":
main()
|
S = input()
arr = [0]*(len(S) + 1)
cn = 0
for i in range(len(S)):
if S[i] == "<":
cn += 1
else:
cn = 0
arr[i+1] = cn
cn = 0
for i in range(len(S)-1, -1, -1):
if S[i] == ">":
cn += 1
else:
cn = 0
arr[i] = max(arr[i], cn)
# print(arr)
print(sum(arr))
| 0 | null | 114,812,334,903,748 | 221 | 285 |
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))
n, a, b = map(int, input().split())
if (a == 0):
print (0)
exit()
ans = n // (a+b) * a
amari = n % (a+b)
if (amari <= a):
ans += amari
else:
ans +=a
print (ans)
|
n, t = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
dp = [[0] * t for _ in range(n + 1)]
ans = 0
for i, (a, b) in enumerate(ab):
for j in range(t):
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
if j + a <= t - 1:
dp[i+1][j+a] = max(dp[i+1][j+a], dp[i][j] + b)
else:
ans = max(ans, dp[i][j] + b)
print(ans)
| 0 | null | 103,941,716,816,302 | 202 | 282 |
t1, t2 = map(int,input().split())
a1, a2 = map(int,input().split())
b1, b2 = map(int,input().split())
a1 = t1*a1
a2 = t2*a2
b1 = t1*b1
b2 = t2*b2
if (a1 + a2) == (b1 + b2):
print('infinity')
exit(0)
elif (a1 + a2) > (b1 + b2):
a1, b1 = b1, a1
a2, b2 = b2, a2
if b1 > a1:
print(0)
exit(0)
tmp00 = a1 - b1
tmp01 = b1 + b2 - a1 - a2
ans = tmp00 // tmp01 * 2 + 1
if tmp00 % tmp01 == 0:
ans -= 1
print(ans)
|
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
INF = -1
def main(T1, T2, A1, A2, B1, B2):
D1 = T1 * (A1 - B1)
D2 = D1 + T2 * (A2 - B2)
if D1 * D2 > 0:
return 0
if abs(D1) == abs(D2) or D2 == 0:
return INF
d, m = divmod(abs(D1), abs(D2))
return (1 if m else 0) + 2 * d
if __name__ == '__main__':
input = sys.stdin.readline
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
ans = main(T1, T2, A1, A2, B1, B2)
print(ans if ans >= 0 else 'infinity')
| 1 | 131,668,488,855,288 | null | 269 | 269 |
ans=[]
while True:
try:
k,l=list(map(int,input().split(" ")))
init_k=k
init_l=l
#
while True:
if k%l==0:
gcd=l
tmp_1=init_k/gcd
tmp_2=init_l/gcd
lcm=gcd*tmp_1*tmp_2
break
else:
tmp=k%l
k=l
l=tmp
gcd=int(gcd)
lcm=int(lcm)
ans.append(str(gcd)+" "+str(lcm))
except:
break
for i in ans:
print(i)
|
def gcd(a, b):
"""Return greatest common divisor using Euclid's Algorithm."""
while b:
a, b = b, a % b
return a
def lcm(a, b):
"""Return lowest common multiple."""
return a * b // gcd(a, b)
try:
while True:
a, b = map(int, raw_input().split(' '))
print gcd(a, b), lcm(a, b)
except EOFError:
pass
| 1 | 592,416,324 | null | 5 | 5 |
a, b, c, k = map(int,input().split())
if k <= a:
print(k)
elif a < k <= a + b:
print(a)
elif a + b <= k:
print(a*2 - k + b)
|
H, W = map(int, input().split())
S = [[i for i in input()] for j in range(H)]
dp = [[0 for i in range(W)] for j in range(H)]
if S[0][0] == "#":
dp[0][0] = 1
for i in range(1, H):
if S[i-1][0] == "." and S[i][0] == "#":
dp[i][0] = dp[i-1][0] + 1
else:
dp[i][0] = dp[i-1][0]
for j in range(1, W):
if S[0][j-1] == "." and S[0][j] == "#":
dp[0][j] = dp[0][j-1] + 1
else:
dp[0][j] = dp[0][j-1]
for h in range(1, H):
for w in range(1, W):
if S[h][w] == "#":
if S[h-1][w] == ".":
c1 = dp[h-1][w] + 1
else:
c1 = dp[h-1][w]
if S[h][w-1] == ".":
c2 = dp[h][w-1] + 1
else:
c2 = dp[h][w-1]
dp[h][w] = min(c1, c2)
else:
dp[h][w] = min(dp[h-1][w], dp[h][w-1])
print(dp[H-1][W-1])
| 0 | null | 35,600,637,770,930 | 148 | 194 |
def main2():
h,w,k = map(int,input().split())
G = []
for _ in range(h):
c = list(input())
G.append(c)
ans = 0
for ib in range(1<<h):
for jb in range(1<<w):
ct = 0
for i in range(h):
for j in range(w):
if (ib>>i)&1 and (jb>>j)&1 and G[i][j]=="#":
ct+=1
if ct == k:
ans+=1
print(ans)
main2()
|
from itertools import product
h, w, k = map(int, input().split())
c = [[1 if j == '#' else 0 for j in input()] for i in range(h)]
cnt = 0
for br in product([0, 1], repeat=h):
for bc in product([0, 1], repeat=w):
if sum(c[i][j]*br[i]*bc[j] for i, j in product(range(h), range(w))) == k:
cnt += 1
print(cnt)
| 1 | 8,954,150,211,202 | null | 110 | 110 |
print(1-int(input()))
|
print(int(not(int(input()))))
| 1 | 2,972,472,524,712 | null | 76 | 76 |
n, m, l = map(int, input().split(" "))
A = []
for i in range(n):
A.append(list())
X = list(map(int, input().split(" ")))
for j in range(m):
A[i].append(list())
A[i][j] = X[j]
B = []
for i in range(m):
B.append(list())
X = list(map(int, input().split(" ")))
for j in range(l):
B[i].append(list())
B[i][j] = X[j]
C = []
for i in range(n):
C.append(list())
for j in range(l):
C[i].append(list())
C[i][j] = 0
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
print(" ".join([str(x) for x in C[i]]))
|
#!/usr/bin/env python3
def main():
import sys
import numpy as np
input = sys.stdin.readline
A, B, H, M = map(int, input().split())
pi = np.pi
time = 60 * H + M
theta_H = (time * 2 * pi) / (12 * 60)
theta_M = (M * 2 * pi) / 60
res = abs(theta_H - theta_M)
theta = min(res, 2 * pi - res)
ans = np.sqrt(A ** 2 + B ** 2 - 2 * A * B * np.cos(theta))
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 10,813,301,720,562 | 60 | 144 |
res = []
n = int(input())
for i in range(n):
r = input()
res.append(r)
ac = res.count("AC")
wa = res.count("WA")
tle = res.count("TLE")
re = res.count("RE")
print("AC x "+str(ac))
print("WA x "+str(wa))
print("TLE x "+str(tle))
print("RE x "+str(re))
|
N = int(input())
C_0 = 0
C_1 = 0
C_2 = 0
C_3 = 0
for _ in range(N):
S = input()
if S == 'AC':
C_0 += 1
elif S == 'WA':
C_1 += 1
elif S == 'TLE':
C_2 += 1
else:
C_3 += 1
print('AC x {}'.format(C_0))
print('WA x {}'.format(C_1))
print('TLE x {}'.format(C_2))
print('RE x {}'.format(C_3))
| 1 | 8,643,185,128,428 | null | 109 | 109 |
def linearSearch(A, key):
i = 0
A.append(key)
while A[i] != key:
i += 1
if i == len(A)-1:
A.pop()
return 'Not_found'
A.pop()
return i
if __name__ == '__main__':
c = 0
n = int(input())
hoge1 = [int(x) for x in input().split()]
q = int(input())
for key in (int(x) for x in input().split()):
if linearSearch(hoge1, key) == 'Not_found':
continue
else:
c += 1
print (c)
|
# coding=utf-8
from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop, heapify
import copy
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)
def lcm(a, b): return a * b / gcd(a, b)
# 1 2 3
# a, b, c = LI()
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
# a = I()
def I(): return int(sys.stdin.buffer.readline())
# abc def
# a, b = LS()
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
# a = S()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
# 2
# 1
# 2
# [1, 2]
def IR(n): return [I() for i in range(n)]
# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]
def LIR(n): return [LI() for i in range(n)]
# 2
# abc
# def
# [abc, def]
def SR(n): return [S() for i in range(n)]
# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]
def LSR(n): return [LS() for i in range(n)]
# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]
def SRL(n): return [list(S()) for i in range(n)]
n = I()
ans = 0
for a in range(1, n):
ans += (n-1)//a
print(ans)
| 0 | null | 1,357,654,418,400 | 22 | 73 |
S = input()
N = len(S)
def palindrome(string):
return 0 if string==string[::-1] else 1
ls1 = S[0:int((N-1)/2)]
ls2 = S[int((N+3)/2-1):N]
#print(ls1)
#print(ls2)
if palindrome(S) == palindrome(ls1) == palindrome(ls2) == 0:
print('Yes')
else:
print('No')
|
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
N, K = map(int, input().split())
K = min(K, N)
MOD = 10**9 + 7
comb = Combination(N + 100)
ans = 0
for k in range(K + 1):
ans += comb.ncr(N, k) * comb.nhr(N - k, k)
ans %= MOD
print(ans)
| 0 | null | 56,457,953,849,710 | 190 | 215 |
X, K, D = map(int, input().split())
X = abs(X)
if X >= K * D:
ans = X - K * D
else:
n, d = divmod(X, D)
ans = d
if (K - n) % 2:
ans = D - d
print(ans)
|
X, K, D = map(int, input().split())
value = abs(X)
if (value / D) >= K:
print(value - D * K)
else:
min_count = value // D
mod_value = K - min_count
if mod_value % 2 == 0:
print(value % D)
else:
print(abs(value % D - D))
| 1 | 5,201,076,653,290 | null | 92 | 92 |
N, M = map(int, input().split())
diffs = [False] * N
a = 1
b = N
for _ in range(M):
while True:
diff0 = b-a
diff1 = (N+a-b)
if not diffs[diff0] and not diffs[diff1]:
break
b-=1
diffs[diff0] = True
diffs[diff1] = True
print(str(a) + ' ' + str(b))
a += 1
b -= 1
if b-a == (N+a-b):
b-=1
|
# -*-coding:utf-8-*-
def get_input():
while True:
try:
yield "".join(input())
except EOFError:
break
if __name__=="__main__":
array = list(get_input())
for i in range(len(array)):
temp = array[i].split()
a = int(temp[0])
b = int(temp[1])
ans = a + b
print(len(str(ans)))
| 0 | null | 14,235,859,375,260 | 162 | 3 |
a5=[]
while True:
x=int(input())
if x==0:
break
a5.append(x)
j = 0
for i in a5:
print("Case " + str(j+1)+": "+ str(i))
j=j+1
|
s = input()
n = int(input())
ans = ''
i = 0
while i < n:
order = list(map(str, input().split(' ')))
if order[0] == 'print':
ans += s[int(order[1]):int(order[2])+1] + '\n'
elif order[0] == 'reverse':
i1 = int(order[1])
i2 = int(order[2])
s0 = s[:i1]
j = 0
while j < (i2 - i1 + 1):
s0 += s[i2 - j]
j += 1
s0 += s[i2+1:]
s = s0
else:
i1 = int(order[1])
i2 = int(order[2])
s = s[:i1] + order[3] + s[i2+1:]
i += 1
print(ans[:-1])
| 0 | null | 1,289,568,873,486 | 42 | 68 |
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()
|
H, W = map(int, raw_input().split())
while H | W != 0:
for i in range(H):
s = ''
for j in range(W):
s += '#' if (j + i) % 2 == 0 else '.'
print s
print ''
H, W = map(int, raw_input().split())
| 0 | null | 450,896,333,272 | 5 | 51 |
n = int(input())
A = list(map(int, input().split()))
l = A[0]
r = sum(A[1:])
x = abs(l-r)
for a in A[1:]:
l += a
r -= a
if x > abs(l-r): x = abs(l-r)
print(x)
|
a_len = int(input())
a = {n for n in input().split(" ")}
b_len = int(input())
b = {n for n in input().split(" ")}
print(len(a & b))
| 0 | null | 70,991,642,311,630 | 276 | 22 |
s=input()
d_in={'/':1,'\\':-1,'_':0}
stack_h=[]
pairs_x=[]
for i in range(len(s)):
if d_in[s[i]]==-1:
stack_h.append(i)
elif d_in[s[i]]==1:
if len(stack_h)!=0:
pairs_x.append([stack_h.pop(),i+1])
stack_ans=[]
for i in range(len(pairs_x)):
pair_i=pairs_x.pop()
if len(stack_ans)==0:
stack_ans.append(pair_i)
elif pair_i[1]<=stack_ans[-1][0]:
stack_ans.append(pair_i)
area=[0]*len(stack_ans)
sum_area=0
for i in range(len(stack_ans)):
p=stack_ans.pop()
h=0
for j in range(p[0],p[1]):
area[i]+=h
h-=d_in[s[j]]
sum_area+=area[i]
print(sum_area)
if len(area)==0:
print(0)
else:
print(len(area),end=' ')
print(' '.join(map(str,area)))
|
cross_section = input()
visited = {0: -1}
height = 0
pools = []
for i, c in enumerate(cross_section):
if c == '\\':
height -= 1
elif c == '/':
height += 1
if height in visited:
width = i - visited[height]
sm = 0
while pools and pools[-1][0] > visited[height]:
_, volume = pools.pop()
sm += volume
pools.append((i, sm + width - 1))
visited[height] = i
print(sum(v for _, v in pools))
print(len(pools), *(v for _, v in pools))
| 1 | 57,514,050,968 | null | 21 | 21 |
row, col, num = map(int, input().split())
tmp_l = []
board = []
for i in range(row):
str = input()
for j in range(col):
if str[j] == '.':
tmp_l.append(0)
if str[j] == '#':
tmp_l.append(1)
board.append(tmp_l)
tmp_l = []
onoff = []
bi = [32, 16, 8, 4, 2, 1]
for i in range(64):
tmp = i
for j in bi:
tmp_l.insert(0, int(tmp / j))
tmp %= j
onoff.append(tmp_l)
tmp_l = []
count = 0
ans = 0
for i in range(2**row):
for j in range(2**col):
for k in range(row):
if onoff[i][k] == 1:
for l in range(col):
if onoff[j][l] == 1:
if board[k][l] == 1:
count += 1
if count == num:
ans += 1
count = 0
print(ans)
|
h,w,k = map(int,input().split())
ls = [str(input()) for _ in range(h)]
a = [[] for _ in range(2**h)]
b = [[] for _ in range(2**w)]
for i in range(2**h):
for j in range(h):
if (i>>j)&1:
a[i].append(j)
for s in range(2**w):
for l in range(w):
if (s>>l)&1:
b[s].append(l)
p = 0
for e in range(2**h):
for f in range(2**w):
cnt = 0
for g in range(len(ls)):
if g not in a[e]:
di = list(ls[g])
for t in range(len(di)):
if t not in b[f]:
if di[t] == "#":
cnt += 1
if cnt == k:
p += 1
print(p)
| 1 | 8,939,419,053,070 | null | 110 | 110 |
N, *X = map(int, open(0).read().split())
ans = float("inf")
for x in range(min(X), max(X) + 1):
cur = 0
for j in range(N):
cur += (X[j] - x) ** 2
ans = min(ans, cur)
print(ans)
|
import os, sys, re, math
N = int(input())
X = [int(n) for n in input().split()]
d = [i ** 2 for i in range(101)]
min_v = 100 ** 2 * 100
for i in range(1, 101):
min_v = min(min_v, sum(d[abs(x - i)] for x in X))
print(min_v)
| 1 | 65,168,388,884,840 | null | 213 | 213 |
import sys
sys.setrecursionlimit(10**7)
def dfs(f):
if vis[f] == 1: return
vis[f] = 1
for t in V[f]:
dfs(t)
n, m = map(int, input().split())
E = [[*map(lambda x: int(x)-1, input().split())] for _ in range(m)]
V = [[] for _ in range(n)]
for a, b in E: V[a].append(b); V[b].append(a)
ans = 0
vis = [0]*n
for a in range(n):
if vis[a]==1:
continue
ans+=1
dfs(a)
print(ans-1)
|
code = r"""
# distutils: language=c++
# distutils: include_dirs=/opt/ac-library
from libcpp cimport bool
from libcpp.vector cimport vector
cdef extern from "<atcoder/dsu>" namespace "atcoder":
cdef cppclass dsu:
dsu(int n)
int merge(int a, int b)
bool same(int a, int b)
int leader(int a)
int size(int a)
vector[vector[int]] groups()
from libc.stdio cimport getchar, printf
cdef inline int read() nogil:
cdef int b, c = 0
while 1:
b = getchar() - 48
if b < 0: return c
c = c * 10 + b
cdef int n = read(), i
cdef dsu *u = new dsu(n)
for i in range(read()): u.merge(read() - 1, read() - 1)
printf('%lu\n', u.groups().size() - 1)
"""
import os, sys
if sys.argv[-1] == 'ONLINE_JUDGE':
open('solve.pyx', 'w').write(code)
os.system('cythonize -i -3 -b solve.pyx')
import solve
| 1 | 2,267,643,065,320 | null | 70 | 70 |
x,n=map(int, input().split())
a=list(map(int, input().split()))
for y in range(x+1):
for b in[-1,1]:
c=x+y*b
if a.count(c)==0:
print(c)
exit(0)
|
N = int(input())
A = [int(i) for i in input().split()]
d = {}
for i in range(1, N+1):
d[i] = 0
for i in range(N-1):
d[A[i]] += 1
for i in range(1, N+1):
print(d[i])
| 0 | null | 23,188,407,212,308 | 128 | 169 |
x = input().split()
for i in range(5):
if x[i] == '0':
print(i+1)
|
mod = 998244353
n,k = map(int,input().split())
lr = [[int(i) for i in input().split()] for j in range(k)]
dp = [0]*(n+1)
dp_rui = [0]*(n+1)
dp[1] = 1
dp_rui[1] = 1
for i in range(2,n+1):
for j in range(k):
lft = i - lr[j][1]
rht = i - lr[j][0]
#print(i,lft,rht)
if rht <= 0:
continue
lft = max(1,lft)
dp[i] += dp_rui[rht] - dp_rui[lft-1]
#print(dp_rui[rht],dp_rui[lft-1])
dp[i] %= mod
#print(dp)
#print(dp_rui)
dp_rui[i] = dp_rui[i-1] + dp[i]
dp_rui[i] %= mod
print(dp[n]%mod)
| 0 | null | 8,153,290,944,250 | 126 | 74 |
S = list(input())
print("".join(S[0:3]))
|
s = str(input())
print(s[0]+s[1]+s[2])
| 1 | 14,769,800,082,248 | null | 130 | 130 |
inputs = input().split(' ')
inputs = list(map(int,inputs))
W = inputs[0]
H = inputs[1]
x = inputs[2]
y = inputs[3]
r = inputs[4]
if r <= x and x <= W-r and r <= y and y <= H-r :
print('Yes')
else :
print('No')
|
#ALDS1_1_D
N = int(input())
min,dif = 10000000000, -10000000000
for i in range(N):
a = int(input())
if (a - min) > dif:
dif = a - min
if a < min:
min = a
print(dif)
| 0 | null | 225,225,560,868 | 41 | 13 |
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import itertools
import math
import sys
INF = float('inf')
def solve(x: "List[int]"):
return x.index(0) + 1
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
x = [int(next(tokens)) for _ in range(5)] # type: "List[int]"
print(solve(x))
if __name__ == '__main__':
main()
|
lst = [int(i) for i in input().split()]
for i in range(5):
if lst[i] == 0:
print(i + 1)
break
| 1 | 13,463,000,192,422 | null | 126 | 126 |
from sys import stdin
readline = stdin.readline
def i_input(): return int(readline().rstrip())
def i_map(): return map(int, readline().rstrip().split())
def i_list(): return list(i_map())
def main():
A, B, C, D = i_map()
print(max([A * C, A * D, B * C, B * D]))
if __name__ == "__main__":
main()
|
L=list(map(int,input().split()))
a=L[0]
b=L[1]
c=L[2]
d=L[3]
print(max(a*c,b*d,a*d,b*c))
| 1 | 3,028,699,630,600 | null | 77 | 77 |
# -*- coding: utf-8 -*-
import sys
from math import ceil
for line in sys.stdin.readlines():
List = map(int, line.strip().split())
n = List[0]
yen = 100000
for i in xrange(n):
yen *= 1.05
yen = int(ceil(yen/1000)) * 1000
print yen
|
a=100000
n=int(input())
for i in range(n):
a=a*1.05
if a%1000 !=0:
a=a-(a%1000)+1000
print(int(a))
| 1 | 1,291,113,216 | null | 6 | 6 |
N, M = map(int, input().split())
An = [int(i) for i in input().split()]
total = sum(An)
if total > N:
print('-1')
else:
print(N - total)
|
x=input()
s=x*2
y=input()
if y in s:
print("Yes")
else:
print("No")
| 0 | null | 16,728,799,526,790 | 168 | 64 |
a=[]
for i in range(10):
inp=input()
a.append(inp)
if i>=3:
a.sort()
del a[0]
print a[2]
print a[1]
print a[0]
|
N = int(input())
alphabet = list("abcdefghijklmnopqrstuvwxyz")
res = ""
while (N > 0):
N -= 1
num = int(N % 26)
res += alphabet[num]
N /= 26
N = N // 1
print(res[::-1])
| 0 | null | 5,950,420,028,932 | 2 | 121 |
li1 = []
li2 = []
ans = 0
for i, s in enumerate(input()):
if s == "\\":
li1.append(i)
elif s == "/" and li1:
j = li1.pop()
c = i - j
ans += c
while li2 and li2[-1][0] > j:
c += li2[-1][1]
li2.pop()
li2.append((j, c))
print(ans)
if li2:
print(len(li2), *list(zip(*li2))[1])
else:
print(0)
|
K = int(input())
[A,B] = list(map(int,input().split()))
flag=0
for i in range(A,B+1):
if i%K==0:
flag=1
if flag==1:
print('OK')
else:
print('NG')
| 0 | null | 13,235,679,191,580 | 21 | 158 |
import sys
def input(): return sys.stdin.readline().rstrip()
from bisect import bisect_left,bisect
def main():
h, w, m = map(int,input().split())
h_lis = [0] * (h+1)
w_lis = [0] * (w+1)
bombs = set([tuple(map(int,input().split())) for i in range(m)])
for hh, ww in bombs:
h_lis[hh] += 1
w_lis[ww] += 1
max_h = max(h_lis)
max_w = max(w_lis)
h_max_index = [i for i, h in enumerate(h_lis) if h == max_h]
w_max_index = [i for i, w in enumerate(w_lis) if w == max_w]
for h_i in h_max_index:
for w_i in w_max_index:
if not (h_i, w_i) in bombs:
print(h_lis[h_i] + w_lis[w_i])
sys.exit()
else:
print(h_lis[h_i] + w_lis[w_i] - 1)
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 | 12,439,492,884,548 | 89 | 144 |
from collections import deque
def init_tree(x, par):
for i in range(x + 1):
par[i] = i
def find(x, par):
q = deque()
q.append(x)
while len(q) > 0:
v = q.pop()
if v == par[v]:
return v
q.append(par[v])
def union(x, y, par, rank):
px, py = find(x, par), find(y, par)
if px == py:
return
if rank[px] < rank[py]:
par[px] = py
return
elif rank[px] == rank[py]:
rank[px] += 1
par[py] = px
n, m, k = map(int, input().split())
par = [0] * (n + 1)
rank = [0] * (n + 1)
init_tree(n, par)
eg = [[] for _ in range(n + 1)]
for _ in range(m):
a, b = map(int, input().split())
union(a, b, par, rank)
eg[a].append(b)
eg[b].append(a)
for _ in range(k):
a, b = map(int, input().split())
eg[a].append(b)
eg[b].append(a)
xs = [0] * (n + 1)
ys = [0] * (n + 1)
for i in range(1, n + 1):
p = find(i, par)
xs[p] += 1
for v in eg[i]:
if p == find(v, par):
ys[i] += 1
ans = [-1] * (n + 1)
for i in range(1, n + 1):
ans[i] += xs[find(i, par)] - ys[i]
ans = [-1] * (n + 1)
for i in range(1, n + 1):
ans[i] += xs[find(i, par)] - ys[i]
print(*ans[1:])
|
# AC: 753 msec(Python3)
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.size = [1] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.find(self.par[x])
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.size[x] < self.size[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
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):
return self.size[self.find(x)]
def main():
N,M,K,*uv = map(int, read().split())
ab, cd = uv[:2*M], uv[2*M:]
uf = UnionFind(N)
friend = [[] for _ in range(N+1)]
for a, b in zip(*[iter(ab)]*2):
uf.unite(a, b)
friend[a].append(b)
friend[b].append(a)
ans = [uf.get_size(i) - 1 - len(friend[i]) for i in range(N+1)]
for c, d in zip(*[iter(cd)]*2):
if uf.is_same(c, d):
ans[c] -= 1
ans[d] -= 1
print(*ans[1:])
if __name__ == "__main__":
main()
| 1 | 61,859,161,354,540 | null | 209 | 209 |
def main():
N, K = map(int, input().split())
mod = 10**9 + 7
r = 0
D = [0] * (K + 1)
for i in reversed(range(1, K + 1)):
D[i] = pow(K // i, N, mod) - sum(D[::i])
return sum(i * j for i, j in enumerate(D)) % mod
print(main())
|
N, P = map(int, input().split())
S = input()
XX = 0
if P == 2:
for i in range(N):
if int(S[i]) % 2 == 0:
XX += i + 1
print(XX)
elif P == 5:
for i in range(N):
if int(S[i]) % 5 == 0:
XX += i + 1
print(XX)
else:
base = 1
X = [0 for i in range(N)]
X[-1] = int(S[-1])
for i in range(N, 0, -1):
X[i-1] = (base * int(S[i-1])) % P
base *= 10
base %= P
for i in range(1, N):
X[i] += X[i-1]
X[i] %= P
D = {i: 0 for i in range(P)}
D[0] = 1
for i in range(N):
D[X[i]] += 1
XX = 0
for i in D:
XX += (D[i] * (D[i] - 1)) // 2
print(XX)
| 0 | null | 47,272,870,011,520 | 176 | 205 |
_, s, _, t = [[*map(int, o.split())] for o in open(0)]
print(sum(i in s for i in t))
|
n = int(input())
str = input().split(" ")
S = [int(str[i]) for i in range(n)]
q = int(input())
str = input().split(" ")
T = [int(str[i]) for i in range(q)]
S_set = set(S)
S = list(S_set)
T.sort()
result = 0
for s in S:
for t in T:
if s == t:
result += 1
break
print(result)
| 1 | 67,498,413,894 | null | 22 | 22 |
def sample(n):
return n * n * n
n = input()
x = sample(n)
print x
|
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 | 701,347,406,080 | 35 | 55 |
money=100000
n=int(input())
for day in range(n):
money+=money*0.05
money=-(-money//1000)*1000
print(int(money))
|
n=int(input())
syakkin=100000
for i in range(n):
syakkin*=1.05
if syakkin%1000!=0:
syakkin=syakkin-syakkin%1000+1000
print(int(syakkin))
| 1 | 1,160,689,476 | null | 6 | 6 |
N, K, C = list(map(int,input().split()))
s = list(str(input()))
L = [] # i+1日目に働くのはL[i]日目以降
R = [] # i+1日目に働くのはL[i]日目以前
for i in range(N):
if len(L) >= K:
break
if s[i] == 'o' and (L == [] or (i + 1) - L[-1] > C):
# 出勤可能('o') 且 (Lが空又はi日目時点の最終出勤からc日経過)
# ならばLにi+1を追加
L.append(i + 1)
for i in range(N - 1, -1, -1):
if len(R) >= K:
break
if s[i] == 'o' and (R == [] or R[-1] - (i + 1) > C):
R.append(i + 1)
R.reverse()
ans = []
for i in range(K):
if L[i] == R[i]:
print(L[i])
|
def Judge(a):
col=[]
diag1=0
diag2=0
for i in range(3):
if(a[i].count(0)==3):
return 1
break
if(a[i][0]==0):
col.append(0)
if(a[i][1]==0):
col.append(1)
if(a[i][2]==0):
col.append(2)
if(a[i][i]==0):
diag1+=1
if(a[i][-(i+1)]==0):
diag2+=1
if(diag1==3 or diag2==3):
return 1
if(col.count(0)==3 or col.count(1)==3 or col.count(2)==3):
return 1
return 0
a=[]
for i in range(3):
a.append(list(map(int,input().split())))
n=int(input())
for i in range(n):
b=int(input())
for j in range(3):
for k in range(3):
if(b==a[j][k]):
a[j][k]=0
judge=Judge(a)
if(judge==1):
print("Yes")
else:
print("No")
| 0 | null | 50,049,425,434,208 | 182 | 207 |
# import sys
# import math #sqrt,gcd,pi
# import decimal
# import queue # queue
import bisect
# import heapq # priolity-queue
# from time import time
# from itertools import product,permutations,\
# combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce
# mod = int(1e9+7)
mod = 998244353
INF = 1<<50
def readInt():
return list(map(int,input().split()))
def main():
n,k = readInt()
l = []
r = []
for i in range(k):
a,b = readInt()
l.append(a)
r.append(b)
dp = [0 for i in range(n+1)]
dp[1] = 1
dpsum = [0 for i in range(n+1)]
dpsum[1] = 1
for i in range(2,n+1):
for j in range(k):
lj = max(1,i - r[j])
rj = i - l[j]
if rj<1:
continue
dp[i] += dpsum[rj] - dpsum[lj-1]
dp[i] %= mod
dpsum[i] = dpsum[i-1] + dp[i]
print(dp[n])
return
if __name__=='__main__':
main()
|
# 累積和を用いたdpの高速か
n, k = map(int, input().split())
mod = 998244353
lr_list = [list(map(int, input().split())) for _ in range(k)]
dp = [0] * (n + 1)
dp[1] = 1
sdp = [0] * (n + 1)
sdp[1] = 1
for i in range(2, n + 1):
for j in range(k):
right = max(0, i - lr_list[j][0])
left = max(0, i - lr_list[j][1] - 1)
dp[i] = (dp[i] + sdp[right] - sdp[left]) % mod
sdp[i] = sdp[i - 1] + dp[i]
print(dp[n])
| 1 | 2,750,446,876,492 | null | 74 | 74 |
ret = []
while True:
m, f, r = map(int, raw_input().split())
if (m,f,r) == (-1, -1, -1):
break
if m == -1 or f == -1:
ret += 'F'
elif 80 <= m + f:
ret += ['A']
elif 65 <= m + f < 80:
ret += ['B']
elif 50 <= m + f < 65:
ret += ['C']
elif 30 <= m + f < 50 and 50 <= r:
ret += ['C']
elif 30 <= m + f < 50 and r < 50:
ret += ['D']
elif m + f < 30:
ret += ['F']
for i in ret:
print i
|
result = []
while True:
(m, f, r) = [int(i) for i in input().split()]
sum = m + f
if m == f == r == -1:
break
if m == -1 or f == -1:
result.append('F')
elif sum >= 80:
result.append('A')
elif sum >= 65:
result.append('B')
elif sum >= 50:
result.append('C')
elif sum >= 30:
if r >= 50:
result.append('C')
else:
result.append('D')
else:
result.append('F')
[print(result[i]) for i in range(len(result))]
| 1 | 1,225,433,312,850 | null | 57 | 57 |
class Combination:
def __init__(self, max_n, _mod):
self.mod = _mod
self.fac = [0 for _ in range(max_n + 10)]
self.finv = [0 for _ in range(max_n + 10)]
self.inv = [0 for _ in range(max_n + 10)]
self.fac[0], self.fac[1] = 1, 1
self.finv[0], self.finv[1] = 1, 1
self.inv[1] = 1
for i in range(2, max_n + 10):
self.fac[i] = self.fac[i - 1] * i % self.mod
self.inv[i] = self.mod
self.inv[i] -= self.inv[self.mod % i] * (self.mod // i) % self.mod
self.finv[i] = self.finv[i - 1] * self.inv[i] % self.mod
def mod_comb(self, n, k):
if n < k or n < 0 or k < 0:
return 0
res = self.fac[n] * (self.finv[k] * self.finv[n - k] % self.mod)
res %= self.mod
return res
def main():
mod = 998244353
N, M, K = map(int, input().split())
comb = Combination(N, mod)
ans = 0
for i in range(K + 1):
add_v = M * pow(M - 1, N - i - 1, mod) % mod
add_v = (add_v * comb.mod_comb(N - 1, i)) % mod
ans = (ans + add_v) % mod
print(ans)
main()
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
class UnionFind:
def __init__(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def makeSet(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def find(self, x):
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parents[x] = y
self.length[y] += self.length[x]
else:
self.parents[y] = x
self.length[x] += self.length[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getLength(self, x):
x = self.find(x)
return self.length[x]
def isSameGroup(self, x, y):
return self.find(x) == self.find(y)
def main():
N, M, K = map(int, readline().split())
friend = [set() for _ in range(N)]
block = [set() for _ in range(N)]
uf = UnionFind(N)
for _ in range(M):
a, b = map(int, readline().split())
a-=1
b-=1
friend[a].add(b)
friend[b].add(a)
uf.unite(a, b)
for _ in range(K):
c, d = map(int, readline().split())
c-=1
d-=1
block[c].add(d)
block[d].add(c)
for i in range(N):
cnt = 0
for blk in block[i]:
if uf.isSameGroup(i, blk):
cnt += 1
ans = uf.getLength(i)-cnt-len(friend[i])-1
if i == N-1:
print(ans)
else:
print(ans, end=" ")
if __name__ == '__main__':
main()
| 0 | null | 42,519,248,043,232 | 151 | 209 |
import math
import fractions
import collections
import itertools
import pprint
N,M=map(int,input().split())
#rotateすれば他の部屋で同じ組み合わせが出てしまう<=>他の部屋の2数の数字の差が同じになってしまう
#前半分を偶数差、後ろ半分を奇数差と言った感じで上から詰めれば良い
#部屋数をMとして、1,2,...,Mの差を考える
l=[]
maemin=1
usiromax=N
for i in range(M,0,-1):
if i%2==0:
l.append([maemin,maemin+i])
maemin=maemin+1
else:
l.append([usiromax-i,usiromax])
usiromax=usiromax-1
#print(l)
for i in range(M):
print(*l[i],sep=" ")
|
import os, sys, re, math
A = [int(n) for n in input().split()]
print('win' if sum(A) <= 21 else 'bust')
| 0 | null | 73,645,005,469,658 | 162 | 260 |
import math
n = int(input())
x, y = [int(e) for e in input().split()], [int(e) for e in input().split()]
D1 = D2 = D3 = 0; D4 = []
for x1, y1 in zip(x, y):
D1 += abs(x1-y1)
D2 += abs(x1-y1)**2
D3 += abs(x1-y1)**3
D4.append(abs(x1-y1))
print('{0:.6f}'.format(D1))
print('{0:.6f}'.format(math.sqrt(D2)))
print('{0:.6f}'.format(math.pow(D3, (1/3))))
print('{0:.6f}'.format(max(D4)))
|
import math
n = int(input())
x = list(map(float, input().split()))
y = list(map(float, input().split()))
for p in [1.0, 2.0, 3.0]:
a = 0
for i in range(n):
a += abs(x[i] - y[i]) ** p
D = a ** (1/p)
print(D)
inf_D = float("-inf")
for i in range(n):
if abs(x[i] - y[i]) > inf_D:
inf_D = abs(x[i] - y[i])
print(inf_D)
| 1 | 210,509,248,432 | null | 32 | 32 |
import math
def isprime(n):
if n==1:
return False
elif n==2:
return True
k=int(math.sqrt(n))+1
for i in range(2,k+1):
if n%i==0:
return False
return True
N=int(input())
ans=0
for i in range(N):
if isprime(int(input())):
ans+=1
print(ans)
|
n = int(input()) - 1 # n=n-1
print(sum([(n//x - x)*2 + 1 for x in range(1, int(n**0.5) + 1)]))
| 0 | null | 1,285,321,261,140 | 12 | 73 |
from collections import deque
n, m = map(int, input().split())
links = [[] for _ in range(n)]
for _ in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
links[a].append(b)
links[b].append(a)
ans = [-1] * n
ans[0] = 0
q = deque([(0, 0)])
while q:
room, prev = q.popleft()
for next_ in links[room]:
if ans[next_] < 0:
ans[next_] = room
q.append((next_, room))
print('Yes')
for i in range(1, n):
print(ans[i] + 1)
|
from collections import deque
N, M = map(int,input().split())
P = [list(map(int,input().split())) for i in range(M)]
A = [ [] for _ in range(N)]
#node_info = [{'node':d,'connect':[],'depth':-1,'dir':-1} for d in range(N)]
for path in P:
A[path[1]-1].append(path[0]-1)
A[path[0]-1].append(path[1]-1)
#print(A)
previous = [-1 for i in range(N)]
previous[0]=0
que = deque([0])
while len(que) != 0:
v = que.popleft()
for v_i in A[v]:
if previous[v_i] != -1:
continue
else:
que.append(v_i)
previous[v_i] = v
for i in range(N):
if previous[i] == -1:
print('No')
exit()
print('Yes')
for i in range(1,N):
print(previous[i]+1)
| 1 | 20,549,990,140,640 | null | 145 | 145 |
def execute(N, A):
dst = 0
s = sum(A)
for v in A:
s -= v
dst += v * s
return dst % (10**9+7)
if __name__ == '__main__':
N = int(input())
A = list(map(int, input().split()))
print(execute(N, A))
|
N = int(input())
A = list(map(int, input().split()))
ans = 0
now = 1
for i in range(N):
if A[i] == now:
now += 1
continue
else:
ans += 1
if now == 1 and ans == N:
print(-1)
else:
print(ans)
| 0 | null | 59,056,630,629,682 | 83 | 257 |
# -*- coding:utf-8 -*-
import sys
def cross_section_diagram(diagram):
stack = []
area = []
for i, ch in enumerate(diagram):
if ch == "\\":
stack.append(i)
elif ch == "/":
if stack:
point = stack.pop()
area.insert(0, (point, i - point))
else:
pass
result = []
if area:
p1, cnt1 = area.pop(0)
for p2, cnt2 in area:
if p1 < p2:
cnt1 += cnt2
else:
result.insert(0, cnt1)
p1 = p2
cnt1 = cnt2
result.insert(0, cnt1)
print(sum(result))
result.insert(0, len(result))
print(" ".join([str(n)for n in result]))
return result
if __name__ == "__main__":
diagram = [val for val in sys.stdin.read().splitlines()]
cross_section_diagram(diagram[0])
|
import sys
def read_heights():
current = 0
heights = [current]
for c in sys.stdin.read().strip():
current += {
'/': 1,
'\\': -1,
'_': 0
}[c]
heights.append(current)
return heights
heights = read_heights()
height_index = {}
for i, h in enumerate(heights):
height_index.setdefault(h, []).append(i)
flooded = [False] * len(heights)
floods = []
# search from highest points
for h in sorted(height_index.keys(), reverse=True):
indexes = height_index[h]
for i in range(len(indexes) - 1):
start = indexes[i]
stop = indexes[i + 1]
if start + 1 == stop or flooded[start] or flooded[stop]:
continue
if any(heights[j] >= h for j in range(start + 1, stop)):
continue
# flood in (start..stop)
floods.append((start, stop))
for j in range(start, stop):
flooded[j] = True
floods.sort()
areas = []
for start, stop in floods:
area = 0
top = heights[start]
for i in range(start + 1, stop + 1):
h = heights[i]
area += top - h + (heights[i - 1] - h) * 0.5
areas.append(int(area))
print(sum(areas))
print(' '.join([str(v) for v in [len(areas)] + areas]))
| 1 | 61,043,431,250 | null | 21 | 21 |
def solve(string):
x, k, d = map(int, string.split())
if k % 2:
x = min(x - d, x + d, key=abs)
k -= 1
x, k, d = abs(x), k // 2, d * 2
return str(min(x % d, abs((x % d) - d))) if x < k * d else str(x - k * d)
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
|
import datetime
from sys import stdin
h1, m1, h2, m2, k = [int(x) for x in stdin.readline().rstrip().split()]
d1 = datetime.datetime(year=2018, month=1, day=7, hour=h1, minute=m1, second=0, microsecond=0)
d2 = datetime.datetime(year=2018, month=1, day=7, hour=h2, minute=m2, second=0, microsecond=0)
delta = d2 - d1
dt2 = delta.seconds / 60
dt2 -= k
if dt2 < 0 :
dt2 = 0
print(int(dt2))
| 0 | null | 11,563,706,679,938 | 92 | 139 |
S,T = open(0).read().split()
print(T+S)
|
S, T = map(str, input().split())
print("{}{}".format(T, S))
| 1 | 102,609,388,947,648 | null | 248 | 248 |
x = list(map(int, input().split()))
count = 1
for i in x:
if i == 0:
print(count)
break
count += 1
|
from math import pi
r = float(input())
S = r * r * pi
L = 2 * r * pi
print(f'{(S):.6f} {(L):.6f}')
| 0 | null | 7,041,968,948,580 | 126 | 46 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def inp():
return int(input())
def inps():
return input().rstrip()
def inpl():
return list(map(int, input().split()))
def _debug(obj):
print(obj, file=sys.stderr)
# import decimal
# from decimal import Decimal
# decimal.getcontext().prec = 10
# from heapq import heappush, heappop, heapify
# import math
# from math import gcd
# import itertools as it
# import collections
# from collections import deque
# ---------------------------------------
s = inps()
print("ARC" if s == "ABC" else "ABC")
|
N = int(input())
A = list(map(int, input().split())) # <- note that this has (N - 1) elements
#print(A)
A_0 = [x - 1 for x in A]
#print(A_0)
ans = [0] * N # <- represents number of immediate subordinates of each person
for i in range(0, N - 1):
ans[A_0[i]] += 1
for i in range(0, N):
print(ans[i])
| 0 | null | 28,296,655,017,478 | 153 | 169 |
N, K = map(int, input().split())
A = list(map(lambda x: int(x)-1, input().split()))
sa = [0]
for a in A:
sa.append((sa[-1] + a) % K)
d = {0: 1}
ans = 0
for i in range(1, N+1):
if i >= K:
d[sa[i-K]] -= 1
v = d.get(sa[i], 0)
ans += v
d[sa[i]] = v + 1
print(ans)
|
N, K = map(int,input().split())
H = list(map(int,input().split()))
s = 0
for i in H:
if K <= i:
s += 1
print(s)
| 0 | null | 158,578,719,583,948 | 273 | 298 |
import numpy as np
from collections import Counter
from math import sqrt
from time import time
def main():
N = int(input())
np_a_o = list([int(x) for x in input().split()])
np_a = Counter(np_a_o)
np_a_keys = set(np_a.keys())
div_list = set()
key_max = max(np_a_keys)
c = 0
for key in np_a_keys:
for div in range(key*2, key_max+1, key):
div_list.add(div)
r = np_a_keys - div_list
u, count = np.unique(np.array(np_a_o), return_counts=True)
r -= set(u[count > 1])
print(len(r))
if __name__ == '__main__':
main()
|
import math
from math import gcd
INF = float("inf")
import sys
input=sys.stdin.readline
import itertools
from collections import Counter
def main():
n = int(input())
a = list(map(int, input().split()))
c = Counter(a)
p = [True] * (10**6 + 1)
s = list(set(a))
for x in s:
t = x * 2
while t <= 10**6:
p[t] = False
t += x
ans = 0
for x in a:
if c[x] == 1 and p[x] == True:
ans += 1
print(ans)
if __name__=="__main__":
main()
| 1 | 14,520,553,880,040 | null | 129 | 129 |
N=int(input())
ans=N*2-2
for n in range(1,int(N**.5)+1):
if N%n==0:
ans=min(ans,N//n+n-2)
print(ans)
|
def make_divisors(n):
'''
nの約数の配列を返す
'''
lower_divisors, upper_divisors = [], []
i = 1
while i * i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n // i)
i += 1
return lower_divisors + upper_divisors[::-1]
def solve():
N = int(input())
D = make_divisors(N)
ans = N - 1
for d in D:
ans = min(ans, N // d - 1 + d - 1)
print(ans)
if __name__ == "__main__":
solve()
| 1 | 161,187,529,607,620 | null | 288 | 288 |
def main():
from collections import Counter
s = input()
l = [0]
t = 1
for i, x in enumerate(s[::-1]):
t = t * 10 % 2019
y = (l[-1] + int(x) * t) % 2019
l.append(y)
c = Counter(l)
ans = sum([v * (v - 1) // 2 for v in c.values()])
print(ans)
if __name__ == '__main__':
main()
|
s=list(map(int,input()))
c=0
cnt=[0]*2019
cnt[0]+=1
for k in range(len(s)-1,-1,-1):
c=(c+s[k]*pow(10,len(s)-1-k,2019))%2019
cnt[c]+=1
print(sum(x*(x-1)//2 for x in cnt))
| 1 | 31,066,631,522,268 | null | 166 | 166 |
import sys
r=sys.stdin.readline
N,M=map(int,r().split())
city=[[] for _ in range(N+1)]
for _ in range(M):
a,b=map(int,r().split())
city[a].append(b)
city[b].append(a)
check=[True]+[False]*(N)
def dfs(v):
stack=[v]
while stack:
cur=stack.pop()
check[cur]=True
for v in city[cur]:
if not check[v]:
stack.append(v)
cnt=0
for i in range(1,N+1):
if not check[i]:
dfs(i)
cnt+=1
print(cnt-1)
|
def main():
while True:
n, x = map(int, input().split())
if n == x == 0:
break
number = 0
for i in range(n):
j = i + 1
if x - j > n*2 - 1:
continue
elif x - j <= j:
break
else:
for k in range(x - j):
m = k + 1
if k < j:
continue
elif (x - j - m) > m and x - j - m <= n:
number += 1
print(number)
return
if __name__ == '__main__':
main()
| 0 | null | 1,807,419,823,304 | 70 | 58 |
def main():
s = input()
for _ in range(len(s)):
print("x",end= "")
print()
if __name__ == "__main__":
main()
|
def merge(A, left, mid, right, c):
global counter
n1 = mid - left
n2 = right - mid
L = [0] * (n1+1)
R = [0] * (n2+1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = 1000000000
R[n2] = 1000000000
i = 0
j = 0
for k in range(left,right):
c += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else :
A[k] = R[j]
j += 1
L.pop()
R.pop()
return c
def mergeSort(A, left, right, c):
if left+1 < right:
mid = int((left + right)/2)
c = mergeSort(A, left, mid, c)
c = mergeSort(A, mid, right, c)
c = merge(A, left, mid, right, c)
return c
if __name__ == '__main__':
num = int(input())
m = list(map(int,input().split()))
c = 0
c = mergeSort(m, 0, num, c)
print(' '.join(map(str,m)))
print(str(c))
| 0 | null | 36,300,280,003,438 | 221 | 26 |
import sys
def euc(n,m):
if max(n,m)%min(n,m) == 0:
return min(n,m)
else:
return euc(min(n,m), max(n,m)%min(n,m))
for line in sys.stdin:
a,b = [int(i) for i in line.split()]
print(euc(a,b),int(a*b/euc(a,b)))
|
import sys
def gcd(a,b):
r= b % a
while r != 0:
a,b = r,a
r = b % a
return a
def lcm(a,b):
return int(a*b/gcd(a,b))
for line in sys.stdin:
a,b = sorted(map(int, line.rstrip().split(' ')))
print("{} {}".format(gcd(a,b),lcm(a,b)))
| 1 | 710,402,952 | null | 5 | 5 |
K = int(input())
S = input()
n = len(S)
MOD = 10 ** 9 + 7
MAX = 2 * 10 ** 6 + 5
fac = [0] * MAX
finv = [0] * MAX
inv = [0] * MAX
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def nCk(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
A = 0
for i in range(K + 1):
A1 = pow(26, K - i, MOD)
A2 = (pow(25, i, MOD) * nCk(i + n - 1, n - 1)) % MOD
A = (A + (A1 * A2) % MOD) % MOD
print(A % MOD)
|
n = int(input())
a = [int(x) for x in input().split()]
q = int(input())
bc=[]
for i in range(q):
bc.append([int(x) for x in input().split()])
a_cnt=[0]*(10**5+1)
for i in range(len(a)):
a_cnt[a[i]]+=1
a_goukei=sum(a)
for gyou in range(q):
a_goukei+=(bc[gyou][1]-bc[gyou][0])*a_cnt[bc[gyou][0]]
print(a_goukei)
a_cnt[bc[gyou][1]]+=a_cnt[bc[gyou][0]]
a_cnt[bc[gyou][0]]=0
| 0 | null | 12,404,598,983,602 | 124 | 122 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
from collections import Counter
n = int(readline())
count = Counter()
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
a = x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x
count[a] += 1
for i in range(1, n + 1):
print(count[i])
if __name__ == '__main__':
main()
|
import math
N = int(input())
ans = [0]*(N+1)
owari = math.sqrt(N)
owari = math.ceil(owari)
for x in range(1, owari):
a = x*x
for y in range(1, owari):
b = y*y
c = x*y
for z in range(1, owari):
hantei = z*(z+x+y)+a+b+c
if hantei > N:
break
ans[hantei] += 1
for i in range(1, N+1):
print(ans[i])
| 1 | 8,031,025,077,572 | null | 106 | 106 |
from collections import deque
h,w = map(int, input().split())
hw = [input() for _ in range(h)]
def bfs(s):
que = deque([s])
m = [[-1]*w for _ in range(h)]
sh, sw = s
m[sh][sw] = 0
ret = 0
while que:
now_h, now_w = que.popleft()
for dh, dw in [(1,0), (-1,0), (0,-1), (0,1)]:
nh = now_h + dh
nw = now_w + dw
if not (0<=nh<h and 0<=nw<w) or m[nh][nw] != -1 or hw[nh][nw] == '#':
continue
m[nh][nw] = m[now_h][now_w] + 1
que.append((nh,nw))
ret = max(ret, m[now_h][now_w] + 1)
return ret
ans = 0
for y in range(h):
for x in range(w):
if hw[y][x] == '#':
continue
s = (y, x)
ans = max(bfs(s), ans)
print(ans)
|
H,W = list(map(int,input().split()))
N=H*W
#壁のノード
wall=[]
for h in range(H):
for w_idx,w in enumerate(list(input())):
if w == '#':
wall.append(W*h+w_idx+1)
#道のノード
path=[_ for _ in range(1,N+1) if _ not in wall]
#隣接リスト
ad = {}
for n in range(N):
ad[n+1]=[]
for n in range(N):
n=n+1
if n not in wall:
up = n-W
if up > 0 and up not in wall:
ad[n].append(up)
down = n+W
if down <= N and down not in wall:
ad[n].append(down)
left = n-1
if n % W != 1 and left not in wall and left > 0:
ad[n].append(left)
right = n+1
if n % W != 0 and right not in wall:
ad[n].append(right)
from collections import deque
def BFS(start):
que = deque([start])
visit = deque([])
color = {}
for n in range(N):
color[n+1] = -1
color[start] = 0
depth = {}
for n in range(N):
depth[n+1] = -1
depth[start] = 0
while len(que) > 0:
start = que[0]
for v in ad[start]:
if color[v] == -1:
que.append(v)
color[v] = 0
depth[v] = depth[start]+1
color[start] = 1
visit.append(que.popleft())
return depth[start]
ans=-1
for start in path:
ans_=BFS(start)
if ans < BFS(start):
ans = ans_
# print(start,ans_)
print(ans)
| 1 | 94,448,291,984,490 | null | 241 | 241 |
import sys
input = sys.stdin.readline
def main():
print(1 - int(input()))
main()
|
# B - Digits
N,K = map(int,input().split())
i = 1
while K**i-1<N:
i += 1
print(i)
| 0 | null | 33,514,632,513,648 | 76 | 212 |
from sys import stdin
inf = 10**9 + 1
def solve():
n = int(stdin.readline())
R = [int(stdin.readline()) for i in range(n)]
ans = max_profit(n, R)
print(ans)
def max_profit(n, R):
max_d = -inf
min_v = R[0]
for i in range(1, n):
max_d = max(max_d, R[i] - min_v)
min_v = min(min_v, R[i])
return max_d
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
if __name__ == '__main__':
solve()
|
#ALDS_1_1_D Maximum Profit
N=int(input())
A=[]
for i in range(N):
A.append(int(input()))
MIN= A[0]
MAX= A[1]-A[0]
for i in range(1,N):
MAX=max(MAX,A[i]-MIN)
MIN=min(MIN,A[i])
print(MAX)
| 1 | 13,764,667,488 | null | 13 | 13 |
n = int(input())
s,t = input().split()
res = ""
for i in range(0,n):
res += s[i]
res += t[i]
print(res)
|
n,k=map(int,input().split())
a=list(map(int,input().split()))
data=[0]*(n+1)
data[1]=1
ans=[1]
res=0
for i in range(n):
p=a[res]
if data[p]==0:
data[p]=1
ans.append(p)
res=p-1
else:
res=ans.index(p)
break
if len(ans)>k:
print(ans[k])
else:
m=len(ans)-res
k-=res
d=k%m
print(ans[res+d])
| 0 | null | 67,573,099,861,632 | 255 | 150 |
def readInt():
return list(map(int, input().split()))
n = int(input())
a = readInt()
b = 0
ans = 0
for i in a:
b += i ** 2
# print(sum(a))
ans = ((sum(a) ** 2 - b) // 2) % (10 ** 9 + 7)
print(ans)
|
a = [int(s) for s in input().split()]
b = int(a[0] // (a[1] + a[2]))
c = int(a[0] % (a[1] + a[2]))
d = b * a[1]
if c >= a[1]:
d = d + a[1]
else:
d = d + c
print(d)
| 0 | null | 29,613,547,607,488 | 83 | 202 |
n,m,k = map(int,input().split())
def cmb(n, r, mod):#コンビネーションの高速計算
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 998244353 #出力の制限
N = n #Nの最大値
g1 = [0]*(N+1) #元テーブル(p(n,r))
g1[0] = g1[1] = 1
g2 = [0]*(N+1) #逆元テーブル
g2[0] = g2[1] = 1
inverse = [0]*(N+1) #逆元テーブル計算用テーブル
inverse[0],inverse[1] = 0,1
for i in range(2,N+1):
g1[i] = (g1[i-1] * i) % mod
inverse[i] = (-inverse[mod % i] * (mod//i)) % mod
g2[i] = (g2[i-1] * inverse[i]) % mod
# i組 -> m * (n-1)Ci * (m-1)^(n-1-i)
ans = 0
for i in range(k+1):
ans += m * cmb(n-1,i,mod) * pow(m-1,n-1-i,mod)
ans %= mod
print(ans)
|
n,m,k = map(int,input().split())
ans = 0
mod = 998244353
p = [0 for i in range(n)]
p[0] = 1
for i in range(n-1):
p[i+1] = p[i]*(i+2)%mod
p.append(1)
for i in range(k+1):
u = pow(m-1,n-1-i,mod)
s = p[n-2]*pow(p[i-1],mod-2,mod)*pow(p[n-i-2],mod-2,mod)
ans = (ans + m*u*s)%mod
print(ans)
| 1 | 23,095,560,507,460 | null | 151 | 151 |
def main():
A = [list(map(int, input().split())) for _ in range(3)]
N = int(input())
b = [int(input()) for _ in range(N)]
for bb in b:
for i in range(3):
for j in range(3):
if bb == A[i][j]:
A[i][j] = 0
for i in range(3):
if A[i][0] == 0 and A[i][1] == 0 and A[i][2] == 0:
print('Yes')
exit()
for i in range(3):
if A[0][i] == 0 and A[1][i] == 0 and A[2][i] == 0:
print('Yes')
exit()
if A[0][0] == 0 and A[1][1] == 0 and A[2][2] == 0:
print('Yes')
exit()
if A[2][0] == 0 and A[1][1] == 0 and A[0][2] == 0:
print('Yes')
exit()
print('No')
if __name__ == "__main__":
main()
|
N = int(input())
a = []
typ = ["S ", "H ", "C ", "D "]
for i in range(N):
a.append(input())
for i in range(4):
for j in range(1, 14):
if typ[i] + str(j) not in a:
print(typ[i] + str(j))
| 0 | null | 30,313,284,422,498 | 207 | 54 |
x = int(input())
h500 = x // 500
h5 = (x%500) //5
print(h500 * 1000 + h5* 5)
|
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():
K = II()
A, B = MI()
for i in range(A, B+1):
if i % K == 0:
print('OK')
return
print('NG')
if __name__ == '__main__':
solve()
| 0 | null | 34,588,596,331,818 | 185 | 158 |
a,b = map(int,input().split())
c="入力が間違っています。"
d="鶴が"
e="匹で、亀が"
f="匹です。"
k=b//2-a
t=2*a-b//2
if k<0 or t<0 or b%2!=0:
print('No')
else:
print('Yes')
|
X,Y = map(int,input().split())
turtle_leg = 4
crane_leg = 2
for i in range(X+1):
if Y == turtle_leg*i+crane_leg*(X-i):
print ("Yes")
break
if i==X:
print ("No")
break
| 1 | 13,757,025,442,132 | null | 127 | 127 |
import itertools
#再帰関数のときのRE予防
import sys
sys.setrecursionlimit(312467)
N = int(input())
List = []
def dfs(S):
List.append(S)
if len(S) < N:
for i in range(ord("a"), ord(max(S))+2):
dfs(S+[chr(i)])
return
dfs(["a"])
for i in List:
if len(i) == N:
print("".join(i))
elif len(i) > N:
break
|
n=int(input())
def make(floor,kind,name): #floor=何階層目か,kind=何種類使ってるか
if floor==n+1:
print(name)
return
num=min(floor,kind+1)
for i in range(num):
use=0 #新しい文字使ってるか
if kind-1<i:
use=1
make(floor+1,kind+use,name+chr(i+97))
make(1,0,"")
| 1 | 52,412,624,808,612 | null | 198 | 198 |
X = int(input())
while True:
a = []
for i in range(2,X):
if X % i == 0:
a.append(0)
break
else:
a.append(1)
if 0 in a:
X += 1
else:
break
print(X)
|
while True:
num = input()
if int(num) == 0:
break
sum = 0
for i in num:
a = int(i)
sum += a
print(sum)
| 0 | null | 53,392,573,762,020 | 250 | 62 |
import sys
sys.setrecursionlimit(10**6)
a,b = map(int, input().split())
if a < 10 and b < 10:
print(a*b)
else:
print(-1)
|
h,a = [int(i) for i in input().split()]
cont=0
while h > 0:
h-=a
cont+=1
print(cont)
| 0 | null | 117,301,551,813,290 | 286 | 225 |
while True:
n,x = map(int,input().split())
if n==0 and x==0:
break
count=0
for a in range(1,n-1):
for b in range(a+1,n):
for c in range(b+1,n+1):
if a+b+c == x:
count += 1
print(count)
|
while True:
n,x = map(int,input().split(" "))
if n == 0 and x == 0:
break
#データリスト作成
data = [m for m in range(1,n+1)]
data_list = []
cnt = 0
#n種類の数字があって、xになる組み合わせは？
for i in range(1,n+1):
for j in range(1+i,n+1):
for k in range(1+j,n+1):
if i+j+k == x:
cnt += 1
print(cnt)
| 1 | 1,287,959,229,378 | null | 58 | 58 |
h, w = map(int, input().split())
if h == 1 or w == 1:
print(1)
else:
print((-(-w//2)) * (-(-h//2)) + (w//2) * (h//2))
|
x, y = map(int, input().split())
if x == 1 or y == 1:
print(1)
elif (x * y) % 2 == 0:
print((x * y) // 2)
else:
print((x * y + 1) // 2)
| 1 | 50,863,920,014,970 | null | 196 | 196 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.