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
|
---|---|---|---|---|---|---|
import math
import itertools
def distance(p1, p2):
return math.sqrt((p1[0]-p2[0])**2 + (p1[1] - p2[1])**2)
n = int(input())
adj = {}
for i in range(1, n+1):
x, y = map(int, input().split())
adj[i] = (x, y)
dd = {}
ans = 0
for i in range(1, n):
for j in range(i+1, n+1):
dist = distance(adj[i], adj[j])
ans += dist
print(format((2 * ans) / n, '.10f'))
|
N = int(input())
A = [tuple(map(int, input().split())) for _ in range(N)]
ans = []
import numpy as np
for i in range(len(A)-1):
for k in range(i+1,len(A)):
ans.append(np.sqrt(((A[i][0]-A[k][0])**2)+(A[i][1]-A[k][1])**2))
print(sum(ans)*2/N)
| 1 | 148,626,278,502,740 | null | 280 | 280 |
N, K = (int(x) for x in input().split())
ans=0
while(N>=1):
N = int(N/K)
ans+=1
print(ans)
|
N, K = map(int, input().split())
c = 1
while N//K != 0:
N = N//K
c += 1
print(c)
| 1 | 64,108,920,432,620 | null | 212 | 212 |
data = list(map(int, list(input().split())))
row = data[0]
column = data[1]
matrix = [[0 for i in range(column)] for j in range(row)]
vector = [[0] for k in range(column)]
vector_multi = [[0] for l in range(row)]
for i in range(row):
data_row = list(map(int, list(input().split())))
for j in range(column):
matrix[i][j] = data_row[j]
for i in range(column):
vector[i] = int(input())
for i in range(row):
element = 0
for j in range(column):
element += matrix[i][j] * vector[j]
vector_multi[i][0] = element
for i in vector_multi:
print(i[0])
|
N = int(input())
matrix = [[0,0,0,0,0,0,0,0,0,0] for _ in range(10)]
for i in range(1,N+1):
first = int(str(i)[0])
last = int(str(i)[-1])
matrix[first][last] += 1
ans = 0
for i in range(10):
for l in range(10):
ans += matrix[i][l]*matrix[l][i]
print(ans)
| 0 | null | 44,035,409,032,088 | 56 | 234 |
N = int(input())
XYS = [list(map(int, input().split())) for _ in range(N)]
s = 0
def perm(ns):
acc = []
def fill(ms, remains):
if remains:
for m in remains:
fill(ms + [m], [x for x in remains if x != m])
else:
acc.append(ms)
fill([], ns)
return acc
s = 0
for indexes in perm(list(range(N))):
xys = [XYS[i] for i in indexes]
x0, y0 = xys[0]
for x1, y1 in xys:
s += ((x0 - x1)**2 + (y0 - y1)**2) ** 0.5
x0 = x1
y0 = y1
nf = 1
for i in range(1, N+1):
nf *= i
ans = s / nf
print(ans)
|
s = input()
ans = chk = 0
ans = [-1] * (len(s)+1)
if s[0] == "<":
ans[0] = 0
if s[-1] == ">":
ans[-1] = 0
for i in range(len(s) - 1):
if s[i] == ">" and s[i+1] == "<":
ans[i+1] = 0
for i in range(len(s)):
if s[i] == "<":
ans[i+1] = ans[i] + 1
for i in range(-1, -len(s)-1,-1):
if s[i] == ">":
ans[i-1] = max(ans[i-1], ans[i]+1)
print(sum(ans))
| 0 | null | 152,098,472,517,248 | 280 | 285 |
n,k=[int(i) for i in input().split()]
p=[(int(i)+1)/2 for i in input().split()]
ans=0
sum_num=sum(p[:k])
for i in range(n-k+1):
if i==0:
sum_num = sum(p[:k])
else:
sum_num+=p[i+k-1]-p[i-1]
ans=max(ans,sum_num)
print(ans)
|
n = list(map(int, input()[::-1])) + [0]
s = 0
res = 0
for i, ni in enumerate(n[:-1]):
k = ni + s
if k < 5 or (k == 5 and int(n[i + 1]) < 5):
res += k
s = 0
else:
res += 10 - k
s = 1
res += s
print(res)
| 0 | null | 73,202,904,536,422 | 223 | 219 |
N, M = map(int, input().split())
pairs = [[] for _ in range(N + 1)] # pairs[i]:iと直接つながっている部屋のリスト
for _ in range(M):
input_list = list(map(int, input().split()))
pairs[input_list[0]].append(input_list[1])
pairs[input_list[1]].append(input_list[0])
ans = [0 for _ in range(N + 1)]
n_ans = 0 # ansを埋めた回数 -> N-1になったら終了
done = [False for _ in range(N + 1)] # 探索済リスト
todo = [1]
while n_ans < N - 1:
for n in todo:
for m in pairs[n]:
if not done[m]:
done[m] = True
ans[m] = n
n_ans += 1
todo.append(m)
print('Yes')
for i in range(2, N + 1):
print(ans[i])
|
x = int(input())
def sanjo(x):
return x**3
print(sanjo(x))
| 0 | null | 10,408,440,857,680 | 145 | 35 |
N_str, q_str = raw_input().split()
N = int(N_str)
q = int(q_str)
A =[]
B =[]
total =0
for i in range(N):
t = raw_input().split()
A.append([t[0],int(t[1])])
while A:
name, time = A.pop(0)
if time <= q:
total += time
B.append(name+" "+ str(total))
else:
time -= q
total += q
A.append([name, time])
print '\n'.join(B)
|
# -*- coding: utf-8 -*-
N, X, M = map(int, input().split())
mod_check_list = [False for _ in range(M)]
mod_list = [(X ** 2) % M]
counter = 1
mod_sum = (X ** 2) % M
last_mod = 0
for i in range(M):
now_mod = (mod_list[-1] ** 2) % M
if mod_check_list[now_mod]:
last_mod = now_mod
break
mod_check_list[now_mod] = True
mod_list.append(now_mod)
counter += 1
mod_sum += now_mod
loop_start_idx = 0
for i in range(counter):
if last_mod == mod_list[i]:
loop_start_idx = i
break
loop_list = mod_list[loop_start_idx:]
loop_num = counter - loop_start_idx
ans = 0
if mod_list[-1] == 0:
ans = X + sum(mod_list[:min(counter, N - 1)])
else:
if (N - 1) <= counter:
ans = X + sum(mod_list[:N - 1])
else:
ans += X + mod_sum
N -= (counter + 1)
ans += sum(loop_list) * (N // loop_num) + sum(loop_list[:N % loop_num])
print(ans)
| 0 | null | 1,450,649,955,460 | 19 | 75 |
class dice:
value = [0] * 6
def __init__(self, list):
self.value = list
def dice_roll(self,dir):
if dir == "S":
prev = self.value
self.value = [prev[4],prev[0],prev[2],prev[3],prev[5],prev[1]]
elif dir == "N":
prev = self.value
self.value = [prev[1],prev[5],prev[2],prev[3],prev[0],prev[4]]
elif dir == "W":
prev = self.value
self.value = [prev[2],prev[1],prev[5],prev[0],prev[4],prev[3]]
elif dir == "E":
prev = self.value
self.value = [prev[3],prev[1],prev[0],prev[5],prev[4],prev[2]]
mydice = dice(list(map(int, input().split())))
x = str(input())
for i in x:
mydice.dice_roll(i)
print(mydice.value[0])
|
class Dice:
def __init__(self, labels):
self.labels = labels
def north(self):
self.change([2, 6, 3, 4, 1, 5])
def south(self):
self.change([5, 1, 3, 4, 6, 2])
def east(self):
self.change([4, 2, 1, 6, 5, 3])
def west(self):
self.change([3, 2, 6, 1, 5, 4])
def change(self, convert):
result = []
for i in range(6):
result.append(self.labels[convert[i] - 1])
self.labels = result
dice = Dice(list(map(int, input().split())))
for direction in input():
if direction == 'N':
dice.north()
if direction == 'S':
dice.south()
if direction == 'E':
dice.east()
if direction == 'W':
dice.west()
print(dice.labels[0])
| 1 | 234,148,848,608 | null | 33 | 33 |
import numpy as np
from fractions import gcd
def lcm(a,b):
return a*b//gcd(a,b)
N,M=map(int,input().split())
a=[i//2 for i in map(int,input().split())]
b=np.array(a)
cnt=0
while all(b%2==0):
b//=2
if any(b%2==0):
print(0)
exit()
ans=1
for i in a:
ans=lcm(ans,i)
print((M//ans-1)//2+1)
|
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def two(val):
ret = 0
tmp = val
while True:
if tmp != 0 and tmp % 2 == 0:
ret += 1
tmp = tmp // 2
else:
break
return ret
n, m = map(int, input().split())
a_list = list(map(int, input().split()))
b_list = []
for item in a_list:
b_list.append(item // 2)
cnt = -1
for item in b_list:
ret = two(item)
if cnt == -1:
cnt = ret
elif cnt != ret:
print(0)
exit()
val = b_list[0]
for item in b_list:
val = lcm(item, val)
ret = m // val
tmp1 = ret // 2
tmp2 = ret % 2
print(tmp1 + tmp2)
| 1 | 101,845,811,217,578 | null | 247 | 247 |
n, a, b = map(int, input().split())
MOD = 10**9 + 7
def comb(n, r, mod):
if r > n-r:
r = n - r
res_X = 1
for i in range(n-r+1, n+1):
res_X = (res_X * i)%mod
res_Y = 1
for i in range(1, r+1):
res_Y = (res_Y * i)%mod
return (res_X * pow(res_Y, mod-2, mod))%mod
base = (pow(2, n, MOD) - 1)%MOD
a = comb(n, a, MOD)
b = comb(n, b, MOD)
print((base - a - b)%MOD)
|
s = input()
t = input()
print("Yes" if s == t[:len(t) - 1] else "No")
| 0 | null | 44,072,058,139,758 | 214 | 147 |
A, B, H, M = list(map(int, input().split()))
m = 360/60 * M
h = 360/12 * (H + M/60)
deg = abs(h-m)
if deg>180: deg = 360-deg
import math
Csq = A**2 + B**2 - 2*A*B*math.cos(math.radians(deg))
print('{:.10f}'.format(math.sqrt(Csq)))
|
while True:
H,W = list(map(int, input().split()))
if (H == 0 and W == 0):
break
else:
for n in range(H):
s = ""
for m in range(W):
s += "#"
print(s)
print("")
| 0 | null | 10,407,074,654,360 | 144 | 49 |
n = int(input())
l = list(map(int, input().split()))
l.sort(reverse=True)
ans = 0
c = n - 1
for a in range(n - 2):
c = n - 1
for b in range(a + 1, n - 1):
# 各a,bに対してのcを尺取法で探索
while l[a] >= l[b] + l[c]:
c -= 1
if c <= b:
break
else:
# print(l[a], l[b], l[c])
ans += c - b
continue
break
print(ans)
|
from bisect import bisect_left
n = int(input())
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n):
for j in range(i + 1, n):
k = l[i] + l[j]
pos = bisect_left(l, k)
ans += max(0, pos - j - 1)
print(ans)
| 1 | 171,737,076,188,230 | null | 294 | 294 |
S = str(input())
N = len(S)
half = (N+1) // 2
ans = 0
for i in range(half):
if S[i] != S[N-1-i]:
ans += 1
print(ans)
|
N=int(input())
if N%2==1:
print(int(float(N-1)/2))
else:
print(int(float(N-2)/2))
| 0 | null | 136,609,719,638,000 | 261 | 283 |
n = int(input())
mod = 10**9+7
ans = 0
ans += pow(10, n, mod)
ans -= pow(9, n, mod)
ans -= pow(9, n, mod)
ans += pow(8, n, mod)
ans %= mod
print(ans)
|
import math
N = int(input())
MOD_VALUE = math.pow(10, 9) + 7
def pow_mod(value, pow):
ret = 1
for _ in range(pow):
ret = ret * value % MOD_VALUE
return ret
result = pow_mod(10, N) - pow_mod(9, N) * 2 + pow_mod(8, N)
print(int(result % MOD_VALUE))
| 1 | 3,145,752,816,078 | null | 78 | 78 |
a = int(input())
S =""
l =['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
num = a % 26
while a >0:
if a%26 !=0:
S =l[(a%26)-1] + S
a = (a-a%26)//26
else:
S = l[(a%26)-1] + S
a = (a-26)//26
print(S)
|
N = int(input())
def numalpha(num):
if num <= 26:
return chr(64+num)
elif num % 26 == 0:
return numalpha(num//26-1)+chr(90)
else:
return numalpha(num//26)+chr(64+num%26)
print(numalpha(N).lower())
| 1 | 11,880,270,384,232 | null | 121 | 121 |
n,m = map(int,input().split())
graph = [[] for _ in range(n)]
h = list(map(int,input().split()))
for _ in range(m):
a,b = map(int,input().split())
graph[a-1].append(b-1)
graph[b-1].append(a-1)
cnt = 0
for i in range(n):
if graph[i] == []:
cnt += 1
continue
if max([h[j] for j in graph[i]]) < h[i] : cnt += 1
print(cnt)
|
k = int(input())
if(k%2 == 0 or k%5 == 0):
print('-1')
else:
if(k%7 == 0):
k = k // 7
num = 1
ans = 1
while(True):
if(num%k == 0):
print(ans)
break
else:
num %= k
num *= 10
num += 1
ans += 1
| 0 | null | 15,590,529,219,088 | 155 | 97 |
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 10**9
for i in range(M):
x, y, c = map(int, input().split())
if ans > a[x-1] + b[y-1] - c:
ans = a[x-1] + b[y-1] - c
if min(a) + min(b) < ans:
ans = min(a) + min(b)
print(ans)
|
import math
r = input()
r = float(r)
area = math.pi * (r ** 2)
length = 2 * math.pi * r
print("{0:.5f} {1:.5f}".format(area, length))
| 0 | null | 27,408,568,942,902 | 200 | 46 |
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
n = ini()
ans = n % 1000
print(0 if ans == 0 else 1000 - ans)
|
def get_ints():
return map(int, input().split())
def get_list():
return list(map(int, input().split()))
l, r, d = get_ints()
c = 0
for i in range(l, r + 1):
if i % d == 0:
c += 1
print(c)
| 0 | null | 8,057,629,276,450 | 108 | 104 |
from bisect import bisect_left
import string
dic={c:[] for c in string.ascii_lowercase}
N=int(input())
S=list(input())
Q=int(input())
for i in range(len(S)):
dic[S[i]].append(i+1)
for i in range(Q):
a,b,c=map(str,input().split())
if a=='1':
if S[int(b)-1]==c:
continue
b=int(b)
f=S[b-1]
d=bisect_left(dic[f],b)
e=bisect_left(dic[c],b)
dic[f].pop(d)
dic[c].insert(e,b)
S[b-1]=c
else:
ans=0
b,c=int(b),int(c)
for j in string.ascii_lowercase:
d=bisect_left(dic[j],b)
if d<len(dic[j]):
if dic[j][d]<=c:
ans+=1
print(ans)
|
#1indexed
class BIT():
def __init__(self, n):
self.size = n
self.bit = [0] * (n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += i & -i
n = int(input())
s = input()
q = int(input())
bit = [BIT(n+1) for i in range(26)]
for i in range(n):
bit[ord(s[i])-97].add(i+1, 1)
s = list(s)
for _ in range(q):
query, a, b = input().split()
if query == "1":
i = int(a)
c = ord(b)-97
bit[c].add(i, 1)
bit[ord(s[i-1])-97].add(i, -1)
s[i-1] = b
else:
ans = 0
for k in range(26):
if bit[k].sum(int(b))-bit[k].sum(int(a)-1) >= 1:
ans += 1
print(ans)
| 1 | 62,282,849,839,196 | null | 210 | 210 |
N = int(input())
p = dict()
for i in range(N):
s = input()
if not s in p:
p[s] = 0
p[s] += 1
m = max(p.values())
ans = [k for k in p.keys() if p[k] == m]
ans = sorted(ans)
for j in range(len(ans)):
print(ans[j])
|
def resolve():
N = int(input())
print(1000 * ((1000 + (N-1)) // 1000) - N)
resolve()
| 0 | null | 39,332,348,905,860 | 218 | 108 |
hitsuji, okami = map(int, input().split())
if hitsuji <= okami:
print('unsafe')
else:
print('safe')
|
def main():
n, k = map(int, input().split())
cnt = 0
i = 1
# nが大きい
while n >= i:
i *= k
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
| 0 | null | 46,707,433,392,288 | 163 | 212 |
def main():
n = int(input())
al = []
bl = []
for _ in range(n):
a, b = map(int, input().split())
al.append(a)
bl.append(b)
als = list(sorted(al))
bls = list(sorted(bl))
if n%2:
print(bls[n//2]-als[n//2]+1)
else:
print(bls[n//2-1]+bls[n//2]-als[n//2]-als[n//2-1]+1)
if __name__ == "__main__":
main()
|
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
N = INT()
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = MAP()
A.sort()
B.sort()
if N % 2 == 0:
mn = (A[N//2-1]+A[N//2]) / 2
mx = (B[N//2-1]+B[N//2]) / 2
ans = int((mx-mn)*2) + 1
else:
mn = A[N//2]
mx = B[N//2]
ans = (mx-mn) + 1
print(ans)
| 1 | 17,321,186,622,784 | null | 137 | 137 |
"""dfs"""
import sys
sys.setrecursionlimit(10**6)
n = int(input())
to = [[] for _ in range(n)]
eid = [[] for _ in range(n)]
ans = [0]*(n-1)
def dfs(v, c=-1, p=-1): # v:これから見るnode、c:pとvを繋ぐedgeの色、p:親node
k = 1
for i in range(len(to[v])):
u = to[v][i]
ei = eid[v][i]
if u == p: continue # 親nodeは確認済みなので見ない
if k == c: k += 1 # 親nodeとの間のedgeの色と同じではいけないのでインクリメントする
ans[ei] = k
k += 1
dfs(u,ans[ei],v)
for i in range(n-1):
a,b = map(int, input().split())
a -= 1; b -= 1
to[a].append(b); eid[a].append(i) # to:nodeの繋がり、eid:edgeの色
to[b].append(a); eid[b].append(i)
dfs(0)
mx = 0
for i in range(n):
mx = max(mx, len(to[i]))
print(mx)
for i in range(n-1):
print(ans[i])
|
n=int(input())
nextlist=[[] for _ in range(n)]
ablist=[]
for i in range(n-1):
a,b=map(int,input().split())
ablist.append((a,b))
nextlist[a-1].append(b)
nextlist[b-1].append(a)
nc=0
for i, next in enumerate(nextlist):
tmp=len(next)
if tmp>nc:
nc=tmp
nci=i+1
print(nc)
linedic={}
seen=set()
todo=[[[nci,0]],[]]
seen.add(nci)
i=0
while todo[i] != []:
if i ==0:
x=1
else:
x=0
todo[x]=[]
for to in todo[i]:
tmp=to[1]
k=1
for next in nextlist[to[0]-1]:
if not next in seen:
if k == tmp:
k +=1
seen.add(next)
todo[x].append([next,k])
linedic[(min(to[0],next),max(to[0],next))]=k
k += 1
i=x
for ab in ablist:
print(linedic[ab])
| 1 | 135,710,072,818,450 | null | 272 | 272 |
def main():
M1, D1 = map(int, input().split())
M2, D2 = map(int, input().split())
if D2 == 1:
print(1)
else:
print(0)
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
import sys
from collections import deque, defaultdict
from math import sqrt, factorial, gcd, ceil
# def input(): return sys.stdin.readline()[:-1] # warning not \n
# def input(): return sys.stdin.buffer.readline().strip() # warning bytes
# def input(): return sys.stdin.buffer.readline().decode('utf-8')
import string
# string.ascii_lowercase
from bisect import bisect_left
def solve():
n = int(input())
l = [int(x) for x in input().split()]
l.sort()
ans = 0
for i in range(n):
for j in range(i + 1, n):
r = bisect_left(l, l[i] + l[j])
if r > j:
ans += r - j - 1
print(ans)
t = 1
# t = int(input())
for case in range(1,t+1):
ans = solve()
"""
azyxwvutsrqponmlkjihgfedcb
"""
| 0 | null | 148,505,430,923,172 | 264 | 294 |
N = int(input())
a_num = 97
def dfs(s, n): #s: 現在の文字列, n: 残りの文字数, cnt: 現在の文字列の最大の値
if n == 0:
print(s)
return
for i in range(ord("a"), ord(max(s))+2):
dfs(s+chr(i), n-1)
dfs("a", N-1)
|
def II(): return int(input())
def MI(): return map(int, input().split())
A,B,N=MI()
def f(x):
return A*x//B-A*(x//B)
if B-1<=N:
ans=f(B-1)
else:
ans=f(N)
print(ans)
| 0 | null | 40,304,123,318,568 | 198 | 161 |
"""bfs"""
import sys
sys.setrecursionlimit(10**6)
n = int(input())
to = [[] for _ in range(n)]
eid = [[] for _ in range(n)]
ans = [0]*(n-1)
for i in range(n-1):
a,b = map(int, input().split())
a -= 1; b -= 1
to[a].append(b); eid[a].append(i) # to:nodeの繋がり、eid:edgeの色
to[b].append(a); eid[b].append(i)
import queue
q = queue.Queue()
used = [0]*n
q.put(0)
used[0] = 1
while not q.empty():
v = q.get()
c = -1
for i in range(len(to[v])):
u = to[v][i]; ei = eid[v][i]
if used[u]: c = ans[ei]
k = 1
for i in range(len(to[v])):
u = to[v][i]; ei = eid[v][i]
if used[u]: continue
if k == c: k += 1
ans[ei] = k
k += 1
q.put(u)
used[u] = 1
mx = 0
for i in range(n):
mx = max(mx, len(to[i]))
print(mx)
for i in range(n-1):
print(ans[i])
|
from collections import deque
import sys
sys.setrecursionlimit(10**9)
N = int(input())
to = [[] for _ in range(N)]
order = []
for _ in range(N - 1):
a, b = list(map(lambda x:int(x) - 1, input().split()))
to[a].append(b)
to[b].append(a)
order.append(b)
def solve():
dist = [-1] * N
# 頂点iに向かう辺をiとする
color = [0] * N
dist[0] = 0
color[0] = 0
que = deque([0])
while que:
v = que.popleft()
used_color = [color[v]]
next_color = 1
for nv in to[v]:
if dist[nv] == -1:
dist[nv] = dist[v] + 1
while next_color in used_color:
next_color += 1
color[nv] = next_color
used_color.append(next_color)
que.append(nv)
print(len(set(color[1:])))
for i in range(N - 1):
print(color[order[i]])
if __name__ == "__main__":
solve()
| 1 | 136,204,776,223,138 | null | 272 | 272 |
# BFS
from collections import deque
h, w = map(int, input().split())
s = [input() for _ in range(h)]
ans = 0
for i in range(h):
for j in range(w):
if s[i][j] == '#': continue
q = deque([(i, j)])
dist = [[-1]*w for _ in range(h)]
dist[i][j] = 0
while q:
x, y = q.popleft()
for k, l in [[-1, 0], [1, 0], [0, -1], [0, 1]]:
if 0 <= x+k < h and 0 <= y+l < w and dist[x+k][y+l] < 0 and s[x+k][y+l] == '.':
dist[x+k][y+l] = dist[x][y] + 1
ans = max(ans, dist[x+k][y+l])
q.append((x+k, y+l))
print(ans)
|
from collections import deque
import numpy as np
H,W = map(int,input().split())
Maze=[list(input()) for i in range(H)]
ans=0
for hi in range(0,H):
for wi in range(0,W):
if Maze[hi][wi]=="#":
continue
maze1=[[0]*W for _ in range(H)]
stack=deque([[hi,wi]])
while stack:
h,w=stack.popleft()
for i,j in [[1,0],[-1,0],[0,1],[0,-1]]:
new_h,new_w=h+i,w+j
if new_h <0 or new_w <0 or new_h >=H or new_w >=W:
continue
elif Maze[new_h][new_w]!="#" and maze1[new_h][new_w]==0:
maze1[new_h][new_w]=maze1[h][w]+1
stack.append([new_h,new_w])
maze1[hi][wi]=0
ans=max(ans,np.max(maze1))
print(ans)
| 1 | 94,695,513,124,188 | null | 241 | 241 |
s=input()
a=[0]*(len(s)+1)
for i in range(len(s)):
if s[i]=="<":
a[i+1]=a[i]+1
for i in range(len(s)-1,-1,-1):
if s[i]==">":
a[i]=max(a[i],a[i+1]+1)
print(sum(a))
|
s = input()
n = len(s) + 1
t = [0]*n
for i in range(n-1):
if s[i] == '<':
t[i+1] = t[i] + 1
for i in range(n-2,-1,-1):
if s[i] == '>':
t[i] = max(t[i],t[i+1]+1)
print(sum(t))
| 1 | 156,822,455,084,666 | null | 285 | 285 |
R,G,B=map(int,input().split())
K=int(input())
for i in range (K+1):
if R < G < B:
print ('Yes')
exit()
else:
pass
if G < B:
pass
else:
B*=2
continue
if R < G:
pass
else:
G*=2
continue
print('No')
|
#!/usr/bin/env python3
def main():
N, K = map(int, input().split())
A = [int(x) - 1 for x in input().split()]
way = []
seen = [False for _ in [0] * (2 * 10 ** 5 + 1)]
now = 0
for _ in range(K):
if seen[now]:
loop_start = way.index(now)
loop = way[loop_start:]
K -= len(way[:loop_start])
now = loop[K % len(loop)]
break
way.append(now)
seen[now] = True
now = A[now]
print(now + 1)
if __name__ == '__main__':
main()
| 0 | null | 14,910,973,014,282 | 101 | 150 |
x = input()
n = int(x)*int(x)*int(x)
print(n)
|
# coding:utf-8
n = int(input())
ans = [0] * n
for i in range(1, 101):
for j in range(1, 101):
for k in range(1, 101):
tmp = i**2 + j**2 + k**2 + i * j + j * k + k * i
if tmp <= n:
ans[tmp - 1] += 1
for item in ans:
print(item)
| 0 | null | 4,141,686,728,982 | 35 | 106 |
def resolve():
N,K = map(int,input().split())
A = list(map(int,input().split()))
F= list(map(int,input().split()))
A.sort()
F.sort(reverse = True)
AF = list(zip(A,F))
if sum(A)<=K:
print(0)
return
l = 0
r = max([i*j for i,j in AF])
center =0
while l < r-1:
center = (l+r)//2
score =sum([max(0,a-center//f) for a,f in AF])
if score > K:
l = center
else:
r = center
print(r)
if __name__ == "__main__":
resolve()
|
import sys
def input():
return sys.stdin.readline().rstrip('\n')
##### main
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
AxF = [A[i]*F[i] for i in range(N)]
AxFmax = max(AxF)
def is_possible(x):
_sum = 0
for i in range(N):
_sum += max(0, A[i] - x//F[i])
#print(x,_sum,K)
return _sum <= K
left = 0
right = AxFmax
while(left != right):
x = (left+right)//2
if is_possible(x):
right = x
else:
left = x+1
#print('main', left, right, x)
print(left)
| 1 | 164,819,295,609,788 | null | 290 | 290 |
M1,D1 = map(int,input().split())
M2,D2 = map(int,input().split())
if M1<M2:print(1)
else:print(0)
|
M,D=map(int,input().split())
MM,DD=map(int,input().split())
if D>DD:
print(1)
else:
print(0)
| 1 | 123,963,282,267,350 | null | 264 | 264 |
# 素因数分解
N=int(input())
cand=[]
def check(N0,K0):
if N0%K0==0:
return check(int(N0/K0),K0)
elif N0%K0==1:
return 1
else:
return 0
def check0(N0,K0):
while N0%K0==0:
N0=int(N0/K0)
if N0%K0==1:
return 1
else:
return 0
# N-1の約数の数
for i in range(2,int((N-1)**0.5)+1):#O(N**0.5)
if (N-1)%i==0:
cand.append(i)
if i!=int((N-1)/i):
cand.append(int((N-1)/i))
if N>2:
cand.append(N-1)
# Nの約数
for i in range(2,int(N**0.5)+1):#O(N**0.5)
if N%i==0:
cand.append(i)
if i!=int(N/i):
cand.append(int(N/i))
cand.append(N)
#print(cand)
count=0
for i in range(len(cand)):
if check(N,cand[i]):
count+=1
print(count)
|
import sys
def input():
return sys.stdin.readline()[:-1]
def main():
N = int(input())
P = []
for k in range(1,1+int((N-1)**(1/2))):
if (N-1)%k == 0:
P.append((N-1)//k)
P.append(k)
P = set(P)
ans = len(P)
for k in range(2,1+int(N**(1/2))):
if N%k == 0:
t = N//k
while t%k == 0:
t //= k
if t%k == 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 1 | 41,548,494,640,480 | null | 183 | 183 |
n = int(input())
s_taro,s_hanako = 0,0
for trial in range(n):
taro,hanako = list(map(str, input().split()))
if taro > hanako:
s_taro += 3
elif taro < hanako:
s_hanako += 3
else:
s_taro += 1
s_hanako += 1
print(s_taro, s_hanako)
|
# Five Variables
print([i + 1 for i, n in enumerate(input().split()) if n == '0'][0])
| 0 | null | 7,698,864,713,248 | 67 | 126 |
#!/usr/bin/env python3
from networkx.utils import UnionFind
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n,m=map(int, input().split())
uf = UnionFind()
for i in range(1,n+1):
_=uf[i]
for _ in range(m):
a,b=map(int, input().split())
uf.union(a, b) # aとbをマージ
print(len(list(uf.to_sets()))-1)
#for group in uf.to_sets(): # すべてのグループのリストを返す
#print(group)
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
def resolve(T,v):
lv = v
while lv != T[lv]:
lv = T[lv]
T[v] = lv
return lv
def solve():
N, M = map(int, input().split())
T = list(range(N+1))
for i in range(M):
u, v = map(int, input().split())
lu = resolve(T,u)
lv = resolve(T,v)
if lv == lu:
continue
T[lv] = lu
#print(f'===round{i}===')
#print(T)
#print([resolve(T,v) for v in range(N+1)])
return len(set(resolve(T,v) for v in range(1,N+1)))-1
if __name__ == '__main__':
print(solve())
| 1 | 2,284,773,827,040 | null | 70 | 70 |
n = int(input())
a = list(map(int, input().split()))
l = [0] * n
for i in range(n - 1):
if a[i] > 0:
l[a[i] - 1] += 1
for i in range(n):
print(l[i])
|
n=int(input());l=list(map(int,input().split()));p=[0]*n;d=[0]*n;p[0]=l[0]
for i in range(1,n):p[i]=l[i]+(p[i-2]if i>1else 0);d[i]=max(p[i-1]if(i&1)else d[i-1],l[i]+(d[i-2]if i>1else 0))
print(d[-1])
| 0 | null | 34,785,083,557,670 | 169 | 177 |
import math
x1,y1,x2,y2=map(float,input().split(' '))
res=math.sqrt((x1-x2)**2+(y1-y2)**2)
print(res)
|
import math
import sys
input = sys.stdin.readline
def main():
a, b, x = map(int, input().split())
x /= a
h = x / a
if h < b/2:
t = 2 * x / b
ans = math.degrees(math.atan(b/t))
else:
ans = math.degrees(math.atan(2*(b-h)/a))
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 81,947,936,642,532 | 29 | 289 |
S = input()
list_S = list(S)
T = input()
list_T = list(T)
count = 0
for i in range(len(list_S)):
if S[i] != T[i]:
count +=1
print(count)
|
N=list(input())
M=list(input())
ans=0
number=len(N)
for i in range(number):
if N[i]==M[i]:
ans+=1
print(number-ans)
| 1 | 10,525,170,070,272 | null | 116 | 116 |
import math
print((int)(math.ceil((int)(input())/2)))
|
N,A,B=map(int,input().split())
if A==0:
print("0")
elif B==0:
print(N)
elif N%(A+B)>A:
print(A*int(N/(A+B))+A)
else:
print(A*int(N/(A+B))+N%(A+B))
| 0 | null | 57,574,692,660,962 | 206 | 202 |
while True:
s = input()
if s == '-':
break
for n in range(int(input())):
h = int(input())
s = s[h:]+s[:h]
print(s)
|
A,B=map(int,input().split())
if B < A:
A,B=B,A
for i in range(B):
print(A, end="")
print()
| 0 | null | 43,380,230,513,500 | 66 | 232 |
N,M= map(int, input().split())
num = list(range(1,N+1))
ans = []
if M % 2 == 0:
for i in range(M // 2):
ans.append([i+1,M+1-i])
for i in range(M // 2):
ans.append([i+2+M,2*M+1-i])
if M % 2 != 0:
for i in range(M // 2):
ans.append([i+1,M-i])
for i in range(M - M//2):
ans.append([i+1+M,2*M+1-i])
for an in ans:
print(an[0],an[1])
|
xin = []
while True:
x = raw_input()
if x == '0':
break
xin += [x]
for i in xin:
print sum(map(int , list(i)))
| 0 | null | 15,176,243,147,080 | 162 | 62 |
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))
from math import gcd
mod = int(1e9+7)
n = ii()
cnd = {}
azero = 0
bzero = 0
allzero = 0
for _ in range(n):
a,b = iim()
if a*b == 0:
if a == 0 and b != 0:
azero += 1
elif a != 0 and b == 0:
bzero += 1
else:
allzero += 1
else:
g = gcd(a,b)
a //= g
b //= g
if a<0:
a *= -1
b *= -1
before = cnd.get((a,b),False)
if b > 0:
check = cnd.get((b,-a),False)
else:
check = cnd.get((-b,a),False)
if before:
cnd[(a,b)] = [before[0]+1,before[1]]
elif check:
if b > 0:
cnd[(b,-a)] = [check[0],check[1]+1]
else:
cnd[(-b,a)] = [check[0],check[1]+1]
else:
cnd[(a,b)] = [1,0]
cnd[0] = [azero,bzero]
noreg = 0
ans = 1
#print(cnd)
for item in cnd.values():
if item[0] == 0 or item[1] == 0:
noreg += max(item[0],item[1])
else:
ans *= (2**item[0]+2**item[1]-1)
ans %= mod
print((ans*((2**noreg)%mod)-1+allzero)%mod)
|
from collections import deque
def bfs(s):
color[s] = 'GRAY'
d[s] = 0
Q.append(0)
while len(Q) != 0:
u = Q.popleft()
for v in range(n):
if M[u][v] and color[v] == 'WHITE':
color[v] = 'GRAY'
d[v] = d[u] + 1
Q.append(v)
color[u] = 'BLACK'
n = int(input())
M = [[0] * n for _ in range(n)]
color = ['WHITE'] * n
d = [-1] * n
Q = deque()
for _ in range(n):
a = list(map(int, input().split()))
u = a[0]
v = a[2:]
for j in v:
M[u - 1][j - 1] = 1
bfs(0)
for i in range(n):
out = ''
out += '{} {}'.format(i + 1, d[i])
print(out)
| 0 | null | 10,419,462,679,120 | 146 | 9 |
# import math
# import statistics
a=int(input())
#b,c=int(input()),int(input())
# c=[]
# for i in a:
# c.append(i)
# e1,e2 = map(int,input().split())
f = list(map(int,input().split()))
#g = [input() for _ in range(a)]
f.sort()
count=1
ans=[0 for i in range(a)]
for i in range(len(f)-1):
if f[i]==f[i+1]:
count+=1
else:
ans[f[i]-1]=count
count=1
if count>=1:
ans[f[-1]-1]=count
for i in ans:
print(i)
|
x = int(input())
a = x // 500
b = (x - (a * 500)) // 5
c = (a * 1000) + (b * 5)
print(c)
| 0 | null | 37,720,328,446,820 | 169 | 185 |
n,m = map(int,input().split())
if n % 2 == 1:
ans = [[1+i,n-i] for i in range(n//2)]
else:
ans = [[1+i,n-i] for i in range(n//4)]+[[n//2+1+i,n//2-1-i] for i in range(n//2-n//4-1)]
for i in range(m):
print(ans[i][0],ans[i][1])
|
S = input()
S_inv = S[-1::-1]
counter = 0
for i in range(len(S)//2):
if S[i]!=S_inv[i]:
counter +=1
print(counter)
| 0 | null | 74,186,345,669,010 | 162 | 261 |
S,T=input().split()
num1,num2=map(int,input().split())
throw=input()
if throw==S:
num1-=1
else:
num2-=1
print(num1,num2)
|
#12716015
n, m = map(int, input().split())
h = list(map(int, input().split()))
ans = [1]*n
for i in range(m):
a, b= map(int, input().split())
a -= 1
b -= 1
if h[a] > h[b]:
ans[b] = 0
elif h[a] < h[b]:
ans[a] = 0
if h[a] == h[b]:
ans[a] = 0
ans[b] = 0
print(ans.count(1))
| 0 | null | 48,485,147,122,510 | 220 | 155 |
A,B = list(map(int,input().split()))
N={1:300000,2:200000,3:100000}
if A ==1 and B==1:
print(1000000)
else:
try:
A=N[A]
except KeyError:
A=0
try:
B=N[B]
except KeyError:
B=0
print(A+B)
|
import numpy as np
n = int(input())
a = list(map(int,input().split()))
dp = np.zeros((n+1,2), int)
dp[1],dp[2] = [0,a[0]], [0,max(a[0], a[1])]
for i in range(3,n+1):
if(i%2 == 0):
dp[i][0] = max(dp[i-1][0],dp[i-2][0]+a[i-1],dp[i-2][1])
dp[i][1] = max(dp[i-1][1],dp[i-2][1]+a[i-1])
else:
dp[i][0] = max(dp[i-1][1],dp[i-2][1],dp[i-2][0]+a[i-1])
dp[i][1] = dp[i-2][1]+a[i-1]
print(dp[n][(n+1)%2])
| 0 | null | 88,780,671,872,760 | 275 | 177 |
chs = 'abcdefghijklmnopqrstuvwxyz'
s = input()
for i,c in enumerate(chs):
if s == c:
print(chs[i+1])
break
|
from collections import defaultdict
N,K = map(int,input().split())
N_List = list(map(int,input().split()))
N_Dict = defaultdict(int)
N_Dict[1] = 1
Pos = N_List[0]
for i in range(N):
N_Dict[Pos] += 1
if N_Dict[Pos] == 2:
break
else:
Pos = N_List[Pos - 1]
##ループ始点がPosに入っている状態
##ループがどのくらいの長さか知りたい
CPos = Pos
flg = 0
Loop_List = [CPos]
while flg == 0:
CPos = N_List[CPos-1]
if CPos != Pos:
Loop_List.append(CPos)
else:
flg = 1
##ループの始点に至るまでの長さを求める
FL = len(N_Dict) - len(Loop_List)
if FL <= K:
ans = Loop_List[(K - FL) % len(Loop_List)]
else:
ans =list(N_Dict.keys())[K]
print(ans)
| 0 | null | 57,477,665,875,140 | 239 | 150 |
num = int(input())
K = "1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51"
l = K.split(',')
print(l[num-1])
|
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# 二分探索
N, K = lr()
A = np.array(lr())
F = np.array(lr())
A.sort()
F = np.sort(F)[::-1]
def check(x):
count = np.maximum(0, (A - (x // F))).sum()
return count <= K
left = 10 ** 12 # 可能
right = -1 # 不可能
while left > right + 1:
mid = (left+right) // 2
if check(mid):
left = mid
else:
right = mid
print(left)
# 51
| 0 | null | 107,662,419,967,168 | 195 | 290 |
import numpy as np
CARD_SIZE = 3
def solve(card, called_numbers):
checked_card = np.vectorize(lambda n: n in called_numbers)(card)
for l in checked_card:
if all(l):
return True
for l in zip(*checked_card):
if all(l):
return True
if all([checked_card[n][n] for n in range(CARD_SIZE)]):
return True
if all([checked_card[n][CARD_SIZE - n - 1] for n in range(CARD_SIZE)]):
return True
return False
def resolve():
card = [[int(row) for row in input().split()] for _ in range(CARD_SIZE)]
N = int(input())
called_numbers = {int(input()) for n in range(N)}
ret = solve(card, called_numbers)
print("Yes" if ret else "No")
if __name__ == '__main__':
resolve()
|
n = int(input())
x, y = [list(map(float,input().split()))for i in range(2)]
print("%.6f"%sum([abs(x[i]-y[i])for i in range(n)]))
print("%.6f"%pow(sum([abs(x[i]-y[i])**2 for i in range(n)]), 1/2))
print("%.6f"%pow(sum([abs(x[i]-y[i])**3 for i in range(n)]), 1/3))
print(*max([abs(x[i]-y[i])] for i in range(n)))
| 0 | null | 30,190,892,170,302 | 207 | 32 |
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])
|
import sys
from operator import itemgetter
input = sys.stdin.readline
def nibun_right(a, x):
lo, hi = 0, len(a)
while lo < hi:
mid = (lo+hi)//2
if x < a[mid][0]: hi = mid
else: lo = mid+1
return lo
N,D,A=map(int,input().split())
lst=[0]*N
for i in range(N):
lst[i]=list(map(int,input().split()))
lst[i][1]=int((lst[i][1]-1)/A)+1
lst.sort(key=itemgetter(0))
DMG=[0]*(N+1)
ans=0
for i in range(N):
renji=nibun_right(lst,lst[i][0]+2*D)
Z=max(lst[i][1]-DMG[i],0)
DMG[i]+=Z
DMG[renji]-=Z
ans+=Z
DMG[i+1]+=DMG[i]
print(ans)
| 0 | null | 57,368,339,311,898 | 169 | 230 |
n = int(input())
branch = [[] for _ in range(n)]
a, b, inda, indb = [], [], [], []
for _ in range(n-1):
i, j = map(int, input().split())
i -= 1
j -= 1
branch[i].append(j)
branch[j].append(i)
a.append(i)
b.append(j)
inda.append(len(branch[i])-1)
indb.append(len(branch[j])-1)
kind = max([len(i) for i in branch])
print(kind)
# DFS
color = [0 for _ in range(n)]
todo = [0]
color[0] = 1
while len(todo) > 0:
num = todo.pop(-1)
col = color[num]
if col == kind:
col = 1
else:
col = col + 1
for i in range(len(branch[num])):
if color[branch[num][i]] == 0:
color[branch[num][i]] = col
todo.append(branch[num][i])
branch[num][i] = -col
if col == kind:
col = 1
else:
col = col + 1
for i in range(n-1):
if branch[a[i]][inda[i]] < 0:
print(-branch[a[i]][inda[i]])
else:
print(-branch[b[i]][indb[i]])
|
from itertools import accumulate as acc
from bisect import bisect_right
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A_acc = [0] + list(acc(A))
B_acc = [0] + list(acc(B))
max_num = 0
for i in range(min(K+1, N+1)):
# Aからi冊読む
count_a = i
time = A_acc[i]
# Bから読めるだけ読む
count_b = bisect_right(B_acc, K-time)-1
time += B_acc[count_b]
# print(time, count_a, count_b)
count = count_a + count_b
if time <= K:
max_num = max(max_num, count)
print(max_num)
| 0 | null | 73,538,747,611,446 | 272 | 117 |
h, a = map(int, input().split())
ans = 0
while True:
if h > 0:
h = h - a
ans += 1
else:
print(ans)
exit()
|
import math
H, A = list(map(int, input().split()))
if H % A == 0:
print(H // A)
else:
print(math.ceil(H / A))
| 1 | 76,699,211,137,570 | null | 225 | 225 |
N, K, C = map(int, input().split())
S = input()
L, R = [], []
i = 0
while len(L) < K:
if S[i] == "o":
L.append(i)
i += C+1
else:
i += 1
i = N-1
while len(R) < K:
if S[i] == "o":
R.append(i)
i -= C+1
else:
i -= 1
R = R[::-1]
for i in range(K):
if L[i] == R[i]:
print (L[i]+1)
|
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, K, C = mapint()
S = list(input())
r_S = S[::-1]
pos = [10**18]*N
neg = [10**18]*N
ok = 0
cnt = 0
for i in range(N):
if S[i]=='o':
if ok<=i:
pos[i] = cnt + 1
cnt += 1
ok = i + C + 1
else:
pass
ok = 0
cnt = 0
for i in range(N):
if r_S[i]=='o':
if ok<=i:
neg[i] = cnt + 1
cnt += 1
ok = i + C + 1
else:
pass
ans = []
neg = neg[::-1]
for i in range(N):
if pos[i]+neg[i]-1==K:
ans.append(i)
for a in ans:
print(a+1)
| 1 | 40,717,676,421,358 | null | 182 | 182 |
print(str((lambda x:x**3)(int(input()))))
|
#!/usr/bin/env python3
import sys
def cube(x):
if not isinstance(x,int):
x = int(x)
return x*x*x
if __name__ == '__main__':
i = sys.stdin.readline()
print('{}'.format( cube( int(i) ) ))
| 1 | 274,671,082,532 | null | 35 | 35 |
s=str("ACL")
n=int(input())
print(s*n)
|
n,m = map(int,input().split())
A = [list(map(int,input().split())) for _ in [None]*n]
b = [int(input()) for _ in [None]*m]
for a in A:print(sum(i*j for i,j in zip(a,b)))
| 0 | null | 1,659,548,503,808 | 69 | 56 |
from typing import Dict
def main():
n: int = int(input())
d: Dict[str, bool] = {}
for _ in range(n):
command = input().split()
if command[0] == "insert":
d[f"{command[1]}"] = True
else:
if command[1] in d:
print("yes")
else:
print("no")
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return input().rstrip().decode()
def II(): return int(input())
def FI(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
import bisect
def main():
n,a,b=MI()
if abs(b-a)%2==0:
ans=abs(b-a)//2
else:
if b<a:
a,b=b,a
ans=min(a-1,n-b)+1+(b-a-1)//2
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 54,598,349,394,240 | 23 | 253 |
import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : map(int, input().split())
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
#a = int(input())
n, k, c_yutori = tin()
if n == 1:
return 1
s = input()
can_work = [0]*n
can_work[0] = 1 if s[0]=='o' else 0
yn = c_yutori if s[0]=='o' else 0
for i, c in enumerate( list(s)[1:],1):
if yn == 0 and c == 'o':
can_work[i] = can_work[i-1]+1
yn = c_yutori
else:
can_work[i] = can_work[i-1]
yn = max(0, yn - 1)
need_to_work = [k]*n
if s[-1]=='o':
need_to_work[-1] = k-1
yn = c_yutori
else:
need_to_work[-1]=k
yn=0
for i, c in enumerate(list(s)[-2::-1],1):
pos = n-i-1
if yn == 0 and c == 'o':
need_to_work[pos] = need_to_work[pos+1]-1
yn = c_yutori
else:
need_to_work[pos]=need_to_work[pos+1]
yn = max(0, yn-1)
#pa(can_work)
#pa(need_to_work)
if need_to_work[1] == 1:
print(1)
for i in range(1, n-1):
if can_work[i-1] < need_to_work[i+1]:
print(i+1)
if can_work[-2]==k-1:
print(n)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
|
import math
def isPrime(n):
for i in range(2, int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
N = int(input())
nums = [int(input()) for i in range(N)]
print(sum([isPrime(n) for n in nums]))
| 0 | null | 20,467,983,445,238 | 182 | 12 |
N=int(input())
arr=[list(map(int,input().split())) for i in range(N)]
za,wa=-10**10,-10**10
zi,wi=10**10,10**10
for i in range(N):
z=arr[i][0]+arr[i][1]
w=arr[i][0]-arr[i][1]
za=max(z,za)
zi=min(z,zi)
wa=max(w,wa)
wi=min(w,wi)
print(max(za-zi,wa-wi))
|
def resolve():
N, K = list(map(int, input().split()))
cnt = 1
while N >= K**cnt:
cnt += 1
print(cnt)
if '__main__' == __name__:
resolve()
| 0 | null | 33,873,730,726,134 | 80 | 212 |
h, n = map(int, input().split())
items = [tuple(map(int, input().split())) for _ in range(n)]
#dp[i][j] := i番目までの物でjの価値を実現するのに必要な最小コスト
dp = [[0] * (h+1) for _ in range(n+1)]
for j in range(1, h+1):
dp[0][j] = float("inf")
for i in range(n):
for j in range(h+1):
if j < items[i][0]:
dp[i+1][j] = min(dp[i][j], items[i][1])
else:
dp[i+1][j] = min(dp[i][j], dp[i+1][j-items[i][0]] + items[i][1])
print(dp[n][h])
|
h, n = map(int,input().split())
a = [0 for i in range(n)]
b = [0 for i in range(n)]
for i in range(n):
ai ,bi = map(int,input().split())
a[i] = ai
b[i] = bi
mh = [0 for i in range(10003)]
for i in range(1,h+1):
mb = 10**9
for j in range(n):
if mb > mh[i-a[j]] + b[j]:
mb = mh[i-a[j]] + b[j]
mh[i] = mb
print(mh[h])
| 1 | 80,894,775,251,810 | null | 229 | 229 |
import sys
n = int(input())
r0 = int(input())
r1 = int(input())
mx = r1-r0
mn = min(r1,r0)
for i in map(int,sys.stdin.readlines()):
if mx < i - mn:
mx = i - mn
if 0 > i-mn:
mn = i
elif mn > i:
mn = i
print(mx)
|
h,*s=open(0)
h,w,k,*m=map(int,h.split())
b=w
while b:
b-=1;r=t=j=0;d=[0]*h
while w-j:
i=c=0;j+=1
while h-i:
d[c]+=s[i][~j]>'0'
if d[c]>k:d=[0]*h;f=t<j;r-=h*w*~-f-1;t=j;j-=f;break
c+=b>>i&1;i+=1
m+=r+c,
print(min(m))
| 0 | null | 24,302,703,172,860 | 13 | 193 |
list = []
x = 1
while x > 0:
x = input()
if x > 0:
list.append(x)
for i,j in enumerate(list):
print "Case " + str(i+1) + ": " + str(j)
|
a = input()
for i in xrange(10000) :
print "Case " + str(i+1) + ": " + str(a)
a = input()
if (a == 0) :
break
| 1 | 492,757,567,940 | null | 42 | 42 |
alpha = input()
print('A' if alpha.isupper() else 'a')
|
alpha = input()
print("a" if alpha.islower() else "A")
| 1 | 11,227,312,159,670 | null | 119 | 119 |
import math
N=int(input())
M =int(math.sqrt(N))
for i in range(M):
if N%(M-i)==0:
K=N//(M-i)
L=M-i
break
print(L+K-2)
|
from collections import deque
infinity=10**6
import sys
input = sys.stdin.readline
N,u,v = map(int,input().split())
u -= 1
v -= 1
G=[[] for i in range(N)]
for i in range(N-1):
A,B = map(int,input().split())
A -= 1
B -= 1
G[A].append(B)
G[B].append(A)
ends = []
for i in range(N):
if len(G[i]) == 1:
ends.append(i)
#幅優先探索
def BFS (s):
queue = deque()
d = [infinity]*N
queue.append(s)
d[s]= 0
while len(queue)!=0:
u = queue.popleft()
for v in G[u]:
if d[v] == infinity:
d[v] = d[u]+1
queue.append(v)
return d
d_nigeru = BFS(u)
d_oni = BFS(v)
ans=0
for u in ends:
if d_nigeru[u] < d_oni[u]:
ans = max(ans,d_oni[u]-1)
print(ans)
| 0 | null | 139,163,820,372,512 | 288 | 259 |
(a, b, c) = (int(i) for i in input().split())
count = 0
for i in range(a, (b + 1)):
if c % i == 0:
count = count + 1
print(count)
|
n,m=map(int,input().split())
ans=[0]*n
num1=[[] for _ in range(n)]
def ap(num01,num02):
num1[num01-1].append(num02)
num1[num02-1].append(num01)
for i in range(m):
a,b=map(int,input().split())
ap(a,b)
queue=[1]
def apq(num01):
queue.append(num01)
def qp():
return queue.pop(0)
for i in range(n):
if len(queue)==0:
break
num=qp()
for j in range(len(num1[num-1])):
if ans[num1[num-1][j]-1]==0:
apq(num1[num-1][j])
ans[num1[num-1][j]-1]=num
if ans.count(0)!=0:
print("No")
else:
print("Yes")
for i in range(1,n):
print(ans[i])
| 0 | null | 10,473,456,965,020 | 44 | 145 |
import itertools
H,W,N=[int(s) for s in input().split()]
hls=[0 for _ in range(H+1)]
wls=[0 for _ in range(W+1)]
bombs=[set() for _ in range(H+1)]
for _ in range(N):
h,w=[int(s) for s in input().split()]
hls[h]+=1
wls[w]+=1
bombs[h].add(w)
hmax=max(hls)
wmax=max(wls)
hmaxls=[i for i in range(H+1) if hls[i]==hmax]
wmaxls=[i for i in range(W+1) if wls[i]==wmax]
for h,w in itertools.product(hmaxls,wmaxls):
if not(w in bombs[h]):
print(hmax+wmax)
exit()
else:
print(hmax+wmax-1)
|
h,w,m=map(int,input().split())
hl=[0]*(h)
wl=[0]*(w)
bom=[]
for i in range(m):
h1,w1=map(int,input().split())
bom.append([h1-1,w1-1])
hl[h1-1]+=1
wl[w1-1]+=1
mh=max(hl)
mw=max(wl)
ans=mh+mw
mhl=set()
mwl=set()
for i in range(h):
if mh==hl[i]:
mhl.add(i)
for i in range(w):
if mw==wl[i]:
mwl.add(i)
count=len(mhl)*len(mwl)
for i in range(len(bom)):
if bom[i][0] in mhl and bom[i][1] in mwl:
count-=1
if count>0:
print(ans)
else:
print(ans-1)
| 1 | 4,735,270,387,232 | null | 89 | 89 |
N = int(input())
A = list(map(int, input().split()))
cnt = [0] * (100001)
ans = sum(A)
for a in A:
cnt[a] += 1
Q = int(input())
for _ in range(Q):
B, C = map(int, input().split())
cnt[C] += cnt[B]
ans += cnt[B] * (C-B)
cnt[B] = 0
print(ans)
|
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
n = I()
suuretu = LI()
q = I()
dic = collections.Counter(suuretu)
nowsum = sum(suuretu)
for _ in range(q):
b,c = LI()
cnt = dic[b]
nowsum += (c-b)*cnt
print(nowsum)
dic[b] = 0
dic[c] += cnt
main()
| 1 | 12,123,854,995,264 | null | 122 | 122 |
# ALDS1_5_B Merge Sort
import sys
count = 0
def merge(A, left, mid, right):
global count
l = A[left: mid]
r = A[mid: right]
l.append(float('inf'))
r.append(float('inf'))
i = 0
j = 0
for k in range(left, right, 1):
count += 1
if l[i] <= r[j]:
A[k] = l[i]
i += 1
else:
A[k] = r[j]
j += 1
def merge_sort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
n = int(input())
S = [int(i) for i in sys.stdin.readline().strip().split()]
merge_sort(S, 0, n)
print(' '.join(map(str, S)))
print(count)
|
N = int(input())
S = [int(s) for s in input().split()]
snt = 10 ** 9 + 1
cnt = 0
# L, R = [0] * 500000, [0] * 500000
def merge(S, N, left, mid, right):
global cnt
# N1 = mid - left
# N2 = right - mid
# for i in range(N1):
# L[i] = S[left + i]
# for i in range(N2):
# R[i] = S[mid + i]
# L[N1] = R[N2] = snt
L = S[left:mid] + [snt]
R = S[mid:right] + [snt]
i, j = 0, 0
for k in range(left, right):
cnt += 1
if L[i] <= R[j]:
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
def merge_sort(S, N, left, right):
if left + 1 < right:
mid = int((left + right) / 2)
merge_sort(S, N, left, mid)
merge_sort(S, N, mid, right)
merge(S, N, left, mid, right)
merge_sort(S, N, 0, N)
print(*S)
print(cnt)
| 1 | 107,937,347,390 | null | 26 | 26 |
def isPrimeNum(in_num):
if in_num <= 1:
return False
elif in_num == 2:
return True
elif in_num % 2 == 0:
return False
else:
if pow(2, in_num-1, in_num) == 1:
return True
else:
return False
num_len = int(input())
cnt = 0
for i in range(num_len):
num = int(input())
if isPrimeNum(num)==True:
cnt = cnt + 1
print(str(cnt))
|
X,Y,A,B,C=map(int,input().split())
ls_a=sorted(list(map(int,input().split())))
ls_b=sorted(list(map(int,input().split())))
ls_c=sorted(list(map(int,input().split())))
ls_x=ls_a[A-X:A]
ls_y=ls_b[B-Y:B]
ls_c.reverse()
ans=sum(ls_x)+sum(ls_y)
a=b=c=0
for _ in range(min([X+Y,C])):
if a==len(ls_x):
m=min([ls_y[b],ls_c[c]])
if m==ls_y[b]:
ans+=(-ls_y[b]+ls_c[c])
b+=1
c+=1
else:
break
elif b==len(ls_y):
m=min([ls_x[a],ls_c[c]])
if m==ls_x[a]:
ans+=(-ls_x[a]+ls_c[c])
a+=1
c+=1
else:
break
else:
m=min([ls_x[a],ls_y[b],ls_c[c]])
if m==ls_x[a]:
ans+=(-ls_x[a]+ls_c[c])
a+=1
c+=1
elif m==ls_y[b]:
ans+=(-ls_y[b]+ls_c[c])
b+=1
c+=1
else:
break
print(ans)
| 0 | null | 22,397,375,972,580 | 12 | 188 |
x = int(input())
if 30 <= x:
print("Yes")
else:
print("No")
|
n,k = map(int,input().split())
P = list(map(int,input().split()))
s=0
for i in range(k):
s += P[i]
ms=s
for i in range(len(P)-k):
s +=(P[i+k]-P[i])
if s>ms :
ms=s
print( (ms+k)/2)
| 0 | null | 40,171,609,232,438 | 95 | 223 |
i = input()
if(i=='ABC'):
print('ARC')
else:
print('ABC')
|
import numpy as np
from numba import jit
@jit('i4[:](i4,i4,i4[:])',cache = True)
def solve(n,k,A):
l,r=0,0
for i in range(k):
B=np.zeros(n+1,dtype=np.int64)
for x,y in enumerate(list(A)):
l=max(0,x-y)
r=min(n,x+y+1)
B[l]+=1
B[r]-=1
A=np.cumsum(B[:-1])
if A[A==n].size==n:
break
return A
n,k=map(int,input().split())
a=list(map(int,input().split()))
A=np.array(a)
X=solve(n,k,A)
print(*X,sep=' ')
| 0 | null | 19,850,797,621,794 | 153 | 132 |
# -*- coding:utf-8 -*-
def reac(H,W):
for i in range(H):
for l in range(W):
print('#',end='')
print('')
data = []
while True:
try:
di = input()
if di == '0 0':
break
data.append(di)
except:
break
for i in range(len(data)):
x = data[i]
h = x.split()
reac(int(h[0]),int(h[1]))
print('')
|
while True:
H, W = map(int, input().split())
if H == 0 and W == 0:
break
for j in range(H):
for i in range(W):
print("#", end="")
print()
print()
| 1 | 774,669,292,892 | null | 49 | 49 |
import numpy as np
n = int(input())
a = np.zeros(n,dtype=int)
b = np.zeros(n,dtype=int)
for i in range(n):
a[i],b[i] = map(float, input().split())
#listをsortする
a.sort()
b.sort()
if n%2 == 1:
a0cen = a[(n-1)//2]
b0cen = b[(n-1)//2]
nn = b0cen - a0cen + 1
else:
a0cen1 = a[(n-2)//2]+a[n//2]
b0cen1 = b[(n-2)//2]+b[n//2]
nn = int(b0cen1 -a0cen1 +1)
print(nn)
|
from collections import deque
import sys
n = int(input())
if n == 1:
print('a')
sys.exit()
q = deque([])
q.append((1, 'a', '1'))
cur = 1
while cur != n:
num = len(q)
j = 0
while j < num:
a, b, c = q.popleft()
for i in range(1, max(map(int, list(c)))+2):
q.append((i, b + chr(96+i), c + str(i)))
j += 1
cur += 1
for i in range(len(q)):
a, b, c = q.popleft()
print(b)
| 0 | null | 34,822,963,588,110 | 137 | 198 |
x = list(map(int, input().split()))
for i, j in enumerate(x):
if j == 0:
print(i+1)
|
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
#solve
def solve():
n = II()
a = LI()
d = defaultdict(int)
ans = 0
for i in range(n):
x = i + 1 - a[i]
ans += d[x]
d[a[i] + i + 1] += 1
print(ans)
return
#main
if __name__ == '__main__':
solve()
| 0 | null | 19,616,224,354,720 | 126 | 157 |
l="abcdefghijklmnopqrstuvwxyz"
print(l[l.index(input())+1])
|
from math import gcd as g
a, b = map(int, input().split())
print((a*b)//g(a,b))
| 0 | null | 102,485,815,404,948 | 239 | 256 |
clr = list(map(int, input().split()))
k = int(input())
for i in range(k):
if clr[2] <= clr[1] :
clr[2] *= 2
elif clr[1] <= clr[0]:
clr[1] *= 2
else:
break
if clr[2] > clr[1] > clr[0] :
print("Yes")
else:
print("No")
|
A, B, C = map(int, input().split())
K = int(input())
i_ans = 0
j_ans = 0
for i in range(0,8):
B_after = B * (2 ** i)
if B_after > A:
i_ans = i
break
B_after = B * (2 ** i_ans)
for j in range(0,8):
C_after = C * (2 ** j)
if C_after > B_after:
j_ans = j
break
if i_ans + j_ans <=K:
print('Yes')
else:
print('No')
| 1 | 6,923,029,990,198 | null | 101 | 101 |
x = 1
while x != '0':
x = input()
if x != '0':
sum = 0
for s in x:
sum += int(s)
print(sum)
|
a = [[[0 for r in range(10)] for f in range(3)] for b in range(4)]
n = int(input())
for i in range(n):
b, f, r, v = map(int, input().strip().split())
a[b - 1][f - 1][r - 1] += v
for b in range(4):
for f in range(3):
print(''.join(' {}'.format(a[b][f][r]) for r in range(10)))
if b < 3:
print('#'*20)
| 0 | null | 1,358,036,190,372 | 62 | 55 |
n,m,l = map(int, input().split())
wf=[[float("inf") for i in range(n)] for j in range(n)]
for i in range(m):
a,b,c = list(map(int,input().split()))
wf[a-1][b-1] = c
wf[b-1][a-1] = c
q = int(input())
st=[list(map(int,input().split())) for i in range(q)]
from scipy.sparse.csgraph import floyd_warshall
for i in range(n):
wf[i][i]=0
wf=floyd_warshall(wf)
for i in range(n):
for j in range(n):
if wf[i][j] <= l:
wf[i][j] = 1
else:
wf[i][j] = float("inf")
wf=floyd_warshall(wf)
for que in st:
s,t=que
if wf[s-1][t-1] == float("inf"):
print(-1)
else:
print(int(wf[s-1][t-1]-1))
|
import sys
input = sys.stdin.readline
N, M, L = map(int, input().split())
INF = 10**18
G = [[INF]*N for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
if c <= L:
G[a][b] = c
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])
G2 = [[INF]*N for i in range(N)]
for i in range(N):
for j in range(N):
if G[i][j] <= L:
G2[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
G2[i][j] = min(G2[i][j], G2[i][k]+G2[k][j])
Q = int(input())
ans = []
for i in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if G2[s][t] == INF:
ans.append(-1)
else:
ans.append(G2[s][t]-1)
print(*ans, sep="\n")
| 1 | 173,464,945,253,340 | null | 295 | 295 |
R=int(input())
print((R*2)*3.14)
|
radius = int(input())
print(44/7*radius)
| 1 | 31,332,576,424,640 | null | 167 | 167 |
n=int(input())
s=str(input())
ans="Yes"
if len(s)%2==1:
ans="No"
for i in range(len(s)//2):
if s[i]!=s[len(s)//2+i]:
ans="No"
break
print(ans)
|
n=int(input())
d={"AC":0,"WA":0,"TLE":0,"RE":0}
for _ in range(n):
d[input()]+=1
for d1, d2 in d.items():
print(d1,'x',d2)
| 0 | null | 78,116,223,626,418 | 279 | 109 |
def f(a,b):
if (b == 0): return a
a = a * 1.05
if (a%1000 != 0): a = a - a%1000 + 1000
return f(a,b-1)
print int(f(100000,input()))
|
H, A = map(int, input().split())
res = H // A
H -= A * res
print(res + 1 if H > 0 else res)
| 0 | null | 38,461,051,229,600 | 6 | 225 |
from math import pi
r = int(input())
print(2 * int(r) * pi)
|
from collections import deque
h,w=map(int,input().split())
s=[list(input()) for _ in range(h)]
ans=0
for i in range(h):
for j in range(w):
if s[i][j]==".":
cnt=[[-1]*w for _ in range(h)]
cnt[i][j]=0
queue=deque()
queue.append([i,j])
for k in range(100*h*w):
if len(queue)==0:
break
num=queue.popleft()
num1=num[0]
num2=num[1]
if num1!=0:
if s[num1-1][num2]=="." and cnt[num1-1][num2]==-1:
cnt[num1-1][num2]=cnt[num1][num2]+1
queue.append([num1-1,num2])
if num2!=0:
if s[num1][num2-1]=="." and cnt[num1][num2-1]==-1:
cnt[num1][num2-1]=cnt[num1][num2]+1
queue.append([num1,num2-1])
if num1!=h-1:
if s[num1+1][num2]=="." and cnt[num1+1][num2]==-1:
cnt[num1+1][num2]=cnt[num1][num2]+1
queue.append([num1+1,num2])
if num2!=w-1:
if s[num1][num2+1]=="." and cnt[num1][num2+1]==-1:
cnt[num1][num2+1]=cnt[num1][num2]+1
queue.append([num1,num2+1])
cnt2=0
for k in range(h):
cnt2=max(cnt2,max(cnt[k]))
ans=max(ans,cnt2)
print(ans)
| 0 | null | 63,029,073,555,588 | 167 | 241 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# def
def int_mtx(N):
x = []
for _ in range(N):
x.append(list(map(int,input().split())))
return np.array(x)
def str_mtx(N):
x = []
for _ in range(N):
x.append(list(input()))
return np.array(x)
def int_map():
return map(int,input().split())
def int_list():
return list(map(int,input().split()))
def print_space(l):
return print(" ".join([str(x) for x in l]))
# import
import numpy as np
import collections as col
N = int(input())
ans = 0
for i in range(1,N):
if N%i != 0:
ans += N//i
else:
ans += N//i -1
print(ans)
|
n=int(input())-1;print(sum(n//-~i for i in range(n)))
| 1 | 2,594,724,624,690 | null | 73 | 73 |
W = input()
lis = []
cot = 0
while True:
x = input().split()
if x == ["END_OF_TEXT"]:
break
lis += x
for y in lis:
if y.lower() == W:
cot += 1
print(str(cot))
|
import sys
w = sys.stdin.readline().strip().lower()
cnt = 0
while True:
line = sys.stdin.readline().strip()
if line == 'END_OF_TEXT':
break
words = line.split(' ')
for i in words:
if i.lower() == w:
cnt += 1
print(cnt)
| 1 | 1,822,688,173,670 | null | 65 | 65 |
S = input()
List1= []
List2 = []
n1 = 0
n2 = 0
for i in range(0,len(S),2):
List1.append(S[i])
for i in range(1,len(S),2):
List2.append(S[i])
n1 = List1.count("h")
n2 = List2.count("i")
if n1 == len(List1) and n2 == len(List2) and n1 == n2:
print("Yes")
else:
print("No")
|
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n, m = map(int, input().split())
C = list(map(int, input().split()))
MAX = 10 ** 5
dp = [MAX] * (n + 1)
dp[0] = 0
for i in range(m):
c = C[i]
for j in range(n + 1):
if j >= c:
dp[j] = min(dp[j], dp[j - c] + 1)
print(dp[n])
| 0 | null | 26,797,948,126,610 | 199 | 28 |
x = input()
a = int(x)
print(a+a**2+a**3)
|
import sys
def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]
def main():
a = II()
print(a + pow(a,2) + pow(a,3))
if __name__ == "__main__":
main()
| 1 | 10,217,941,912,380 | null | 115 | 115 |
mod = 10**9 + 7
_factorial = [1]
def fact(n):
''' n! % mod '''
if n >= mod:
return 0
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
return _factorial[n]
_factorial_inv = [1]
def fact_inv(n):
''' n!^-1 % mod '''
if n >= mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
_size_inv = len(_factorial_inv)
if _size_inv < n+1:
for i in range(_size_inv, n+1):
_factorial_inv.append(modinv(_factorial[i]))
return _factorial_inv[n]
def comb(n, r):
''' nCr % mod '''
if r > n:
return 0
t = fact(n) * modinv(fact(n-r)) % mod
t = t * modinv(fact(r)) % mod
return t
def xgcd(a, b):
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(n):
g, x, _ = xgcd(n, mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % mod
x, y = sorted(map(int, input().split()))
q, r = divmod(x+y, 3)
if r != 0:
print(0)
else:
print(comb(q, y-q))
|
a, b, m = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
AB = []
for _ in range(m):
x, y, c = map(int, input().split())
x -= 1
y -= 1
AB.append(A[x]+B[y]-c)
AB.sort()
A.sort()
B.sort()
print(min(AB[0], A[0]+B[0]))
| 0 | null | 102,095,591,933,258 | 281 | 200 |
N = int(input())
d = {}
for _ in range(N):
s = input()
if s in d:
d[s] += 1
else:
d[s] = 1
d = {k: v for k, v in sorted(d.items(), key=lambda item: item[1], reverse=True)}
max_count = -1
values = []
for k, v in d.items():
if max_count < v:
max_count = v
if v != max_count:
break
values.append(k)
print("\n".join(sorted(values)))
|
n = int(input())
s = [input() for _ in range(n)]
d = {}
for i in s:
if i not in d:
d[i] = 1
else:
d[i] += 1
m = max(d.values())
l = []
for i in d.keys():
if d[i] == m:
l.append(i)
l_s = sorted(l)
for i in l_s:
print(i)
| 1 | 70,265,727,928,288 | null | 218 | 218 |
H, W, M = map(int, input().split())
row = [0] * (H + 1)
col = [0] * (W + 1)
bom = []
for i in range(M):
h, w = map(int, input().split())
bom.append([h, w])
row[h] += 1
col[w] += 1
rmax = max(row)
cmax = max(col)
cnt = row.count(rmax) * col.count(cmax)
for h, w in bom:
if rmax == row[h] and cmax == col[w]:
cnt -= 1
print(rmax + cmax - (cnt == 0))
|
from bisect import bisect_left, bisect_right
H, W, M = map(int,input().split())
targets = [list(map(lambda x: int(x) - 1, input().split())) for i in range(M)]
cnth = [0] * H
cntw = [0] * W
wlist = [[] for i in range(H)]
for i in range(M):
hi, wi = targets[i]
cnth[hi] += 1
cntw[wi] += 1
wlist[hi].append(wi)
maxhi = []
maxwi = []
maxh = max(cnth)
maxw = max(cntw)
for i in range(H):
wlist[i].sort()
if cnth[i] == maxh:
maxhi.append(i)
for i in range(W):
if cntw[i] == maxw:
maxwi.append(i)
for i in range(len(maxhi)):
for j in range(len(maxwi)):
if bisect_right(wlist[maxhi[i]], maxwi[j]) - bisect_left(wlist[maxhi[i]], maxwi[j]) == 0:
print(maxh + maxw)
exit()
print(maxh + maxw - 1)
| 1 | 4,751,596,865,440 | null | 89 | 89 |
for i in range(1,10):
for j in range(1,10):
print('%sx%s=%s'%(i,j,i*j))
|
from collections import deque
n,x,y = map(int,input().split())
adj = [[] for i in range(n)]
adj[x-1].append(y-1)
adj[y-1].append(x-1)
for i in range(n-1):
adj[i].append(i+1)
adj[i+1].append(i)
ans = [0]*(n-1)
for i in range(n):
q = deque([])
q.append(i)
dist = [-1]*n
dist[i] = 0
while len(q) > 0:
v = q.popleft()
for nv in adj[v]:
if dist[nv] != -1:
continue
dist[nv] = dist[v] + 1
q.append(nv)
for i in dist:
if i != 0:
ans[i-1] += 1
for i in ans:
print(i//2)
| 0 | null | 22,058,010,592,490 | 1 | 187 |
a,b = [int(num) for num in input().split()]
print(a*b)
|
import sys,os
from collections import defaultdict, deque
from math import ceil, floor, inf
if sys.version_info[1] >= 5:
from math import gcd
else:
from fractions import gcd
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
class Combinations:
def __init__(self,n,p):
self.n = n
self.p = p
self.g1 = [1,1]
self.g2 = [1,1]
inverse = [0,1]
for i in range(2, self.n + 1):
self.g1.append( ( self.g1[-1] * i ) % self.p )
inverse.append( ( -inverse[self.p % i] * (self.p//i) ) % self.p )
self.g2.append( (self.g2[-1] * inverse[-1]) % self.p )
def nCr(self,r):
if r < 0 or self.n < r:
return 0
r = min(r, self.n-r)
return self.g1[self.n] * self.g2[r] * self.g2[self.n-r] % self.p
def main(given=sys.stdin.readline):
input = lambda: given().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(input())
MOD = 998244353
N,M,K = LMIIS()
ans = 0
cmb = Combinations(N-1,MOD)
#i個のブロックを連結、全体でN-i個、どこを連結させるかは(N-1)Ci通り
powtable = [0] * N
powtable[N-K-1] = pow(M-1,N-K-1,MOD) % MOD
for i in range(N-K,N):
powtable[i] = powtable[i-1] * (M-1) % MOD
for i in range(K+1):
ans += powtable[N-i-1] * cmb.nCr(i)
ans %= MOD
# for i in range(K+1):
# ans += M * pow(M-1,N-i-1,MOD) * cmb.nCr(i)
# ans %= MOD
print(ans*M%MOD)
if __name__ == '__main__':
main()
| 0 | null | 19,423,925,692,974 | 133 | 151 |
H = int(input())
count = 0
while H != 1:
H //= 2
count += 1
ans = 0
for i in range(count +1):
ans += 2 ** i
print(ans)
|
H = int(input())
now = 1
for i in range(1,100):
if now <= H <= now*2-1:
print(2**i-1)
break
else:
now *= 2
| 1 | 80,386,464,384,758 | null | 228 | 228 |
[[print("{}x{}={}".format(i,j,i*j))for j in range(1,10)]for i in range(1,10)]
|
X, N = map(int, input().split()) #6,5
p = list(map(int, input().split())) #[4,7,10,6,5]
q = [(abs(X-i),i) for i in range(0,102) if not i in p]
q.sort()
print(q[0][1])
| 0 | null | 7,070,149,932,772 | 1 | 128 |
def resolve():
import sys
input = sys.stdin.readline
n = int(input().rstrip())
print(n + n*n + n*n*n)
if __name__ == "__main__":
resolve()
|
a = int(input())
class calculate:
def __init__(self,a):
self.check = a
def get_ans(self,a):
return a + a**2 + a**3
valuable = calculate(a)
#Sprint(valuable.check)
ans = valuable.get_ans(a)
print(ans)
| 1 | 10,283,816,056,480 | null | 115 | 115 |
N = int(input())
A = list(map(int, input().split()))
kabu = 0
yen = 1000
for i in range(N-1):
if A[i] < A[i+1]:
buy = yen//A[i]
kabu += buy
yen -= buy * A[i]
elif A[i] > A[i+1]:
yen += kabu * A[i]
kabu = 0
if kabu > 0:
yen += A[-1] * kabu
kabu = 0
print(yen)
|
n = int(input())
ls = list(map(int, input().split()))
xor_sum = 0
for a in ls:
xor_sum ^=a
ans = []
for i in range(n):
ans.append(str(xor_sum^ls[i]))
print(" ".join(ans))
| 0 | null | 9,889,346,413,130 | 103 | 123 |
A,B,M = [int(hoge) for hoge in input().split()]
A = [int(hoge) for hoge in input().split()]
B = [int(hoge) for hoge in input().split()]
ans = min(A) + min(B)
for i in range(M):
x,y,c = [int(hoge) for hoge in input().split()]
ans = min(ans,A[x-1]+B[y-1]-c)
print(ans)
|
import numpy as np
stdin = open(0)
A = np.fromstring(stdin.read(), np.int64, sep=' ')[1:]
A = A[A % 2 == 0]
if np.all((A % 3 == 0) | (A % 5 == 0)):
print('APPROVED')
else:
print('DENIED')
| 0 | null | 61,834,374,422,360 | 200 | 217 |
def row():
c=0
for y in range(HEIGHT):
for x in range(WIDTH):
if A[y][x]!=-1:
break
else:
c+=1
return c
def col():
c=0
for x in range(WIDTH):
for y in range(HEIGHT):
if A[y][x]!=-1:
break
else:
c+=1
return c
def obl():
c=0
for z in range(HEIGHT):
if A[z][z]!=-1:
break
else:
c+=1
y=0
for x in range(WIDTH-1,-1,-1):
if A[y][x]!=-1:
break
y+=1
else:
c+=1
return c
def main():
for b in B:
for y in range(HEIGHT):
for x in range(WIDTH):
if A[y][x]==b:
A[y][x]=-1
cnt=row()+col()+obl()
print('Yes' if cnt else 'No')
if __name__=='__main__':
HEIGHT=3
WIDTH=3
A=[[int(a) for a in input().split()] for y in range(HEIGHT)]
N=int(input())
B=[int(input()) for n in range(N)]
main()
|
import numpy as np
A=[list(map(int, input().split())) for _ in range(3)]
N=int(input())
B=[int(input()) for _ in range(N)]
for b in B:
for i in range(3):
for j in range(3):
if A[i][j]==b:A[i][j]=0
ans_axis0=np.sum(np.array(A),axis=0)
ans_axis1=np.sum(np.array(A),axis=1)
ans_naname=[A[0][0]+A[1][1]+A[2][2],A[0][2]+A[1][1]+A[2][0]]
#print(A,ans_axis0,ans_axis1,ans_naname)
if 0 in ans_axis0 or 0 in ans_axis1 or 0 in ans_naname:
print("Yes")
else:
print("No")
| 1 | 59,659,938,651,670 | null | 207 | 207 |
n,x,m=map(int,input().split())
def f(ai,m):
return (ai*ai)%m
if x==0:
print(0)
elif x==1:
print(n)
elif m==1:
print(0)
elif n<=m*2:
asum=x
ai=x
for i in range(1,n):
ai=f(ai,m)
asum+=ai
print(asum)
else:
chk=[-1]*m
asum00=[0]*m
ai,asum=x,0
for i in range(m):
if chk[ai]!=-1:
icnt0=chk[ai]
break
else:
chk[ai]=i
asum00[i]=asum
asum+=ai
ai=f(ai,m)
icnt=i
asum0=asum00[icnt0]
icntk=icnt-icnt0
n0=n-1-icnt0
nk=n0//icntk
nr=n0%icntk
asumk=asum-asum0
air,asumr=ai,0
for i in range(nr):
asumr+=air
air=f(air,m)
asumr+=air
ans=asum0+asumk*nk+asumr
print(ans)
|
n,x,m=map(int,input().split())
id=[-1 for i in range(m+1)]
s=[]
c=0
while id[x]==-1:
id[x]=c
c+=1
s.append(x)
x=x*x%m
d=c-id[x]
ans=0
if n<=d:
for i in range(n):
ans+=s[i]
else:
for i in range(id[x]):
ans+=s[i]
n-=id[x]
sum=0
for i in range(d):
sum+=s[id[x]+i]
ans+=(n//d)*sum
n=n%d
for i in range(n):
ans+=s[id[x]+i]
print(ans)
| 1 | 2,787,337,851,520 | null | 75 | 75 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
A = [-1] + A
loop_pos = None
loop_start_time = None
loop_end_time = None
visited = [-1]*(N+1)
pos = 1
i = 0
while visited[pos] == -1:
visited[pos] = i
pos = A[pos]
i += 1
if visited[pos] != -1:
loop_pos = pos
loop_start_time = visited[pos]
loop_end_time = i
# print(loop_start_time, loop_end_time)
w = loop_end_time - loop_start_time
K = min(K, loop_start_time) + max(0, K-loop_start_time)%w
# print(f"K: {K}")
pos = 1
for i in range(K):
# print(pos)
pos = A[pos]
print(pos)
|
X,Y=map(int,input().split())
def ans170(X:int, Y:int):
if Y<=X*4 and Y>=X*2 and Y%2==0:
return("Yes")
else:
return("No")
print(ans170(X,Y))
| 0 | null | 18,426,080,954,610 | 150 | 127 |
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from math import gcd, ceil
def pre(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
for _ in range(int(input()) if not True else 1):
#n, k = map(int, input().split())
#a, b = map(int, input().split())
#c, d = map(int, input().split())
#a = list(map(int, input().split()))
#b = list(map(int, input().split()))
h, w, k = map(int, input().split())
a = []
for __ in range(h):
a += [[k for k in input()]]
ans = 0
for ch1 in range(2**h):
for ch2 in range(2**w):
rowchosen = binary(ch1, h)
colchosen = binary(ch2, w)
count = 0
for i in range(h):
for j in range(w):
if rowchosen[i] != '1' and colchosen[j] != '1' and a[i][j] == '#':
count += 1
if count == k:ans+=1
print(ans)
|
#!/usr/bin/env python3
import sys
from itertools import combinations as comb
from itertools import chain
import numpy as np
# form bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
def solve(H, W, K, C):
answer = 0
for hn in range(H + 1):
for wn in range(W + 1):
for h_idxs in comb(range(H), hn):
for w_idxs in comb(range(W), wn):
cs = C.copy()
cs[h_idxs, :] = 0
cs[:, w_idxs] = 0
answer += cs.sum() == K
return answer
def main():
tokens = chain(*(line.split() for line in sys.stdin))
H = int(next(tokens))
W = int(next(tokens))
K = int(next(tokens))
C = np.array(
[
list(map(lambda x: {"#": 1, ".": 0}[x], line))
for line in tokens
]
)
answer = solve(H, W, K, C)
print(answer)
if __name__ == "__main__":
main()
| 1 | 8,956,557,000,772 | null | 110 | 110 |
l,r,d = map(int,input().split())
count = 0
for i in range(l,r + 1):
if i % d == 0:
count += 1
else:
pass
print(count)
|
def print_frame(h,w):
if h == 1:
print("#"*w)
return
if h == 2:
print("#"*w)
print("#"*w)
return
print("#"*w)
for i in range(h-2):
print("#",end="")
for j in range(w-2):
print(".",end="")
print("#")
print("#"*w)
while True:
h,w = map(int,input().split())
if h == 0 and w == 0:
break;
else :
print_frame(h,w)
print()
| 0 | null | 4,164,196,620,148 | 104 | 50 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.