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
|
|---|---|---|---|---|---|---|
s = input()
if len(s) % 2 == 1:
print('No')
else:
ans = "Yes"
for i in range(len(s)):
if i % 2 == 0 and s[i] != 'h':
ans = "No"
break
if i % 2 == 1 and s[i] != 'i':
ans = "No"
break
print(ans)
|
s = str(input())
#print(s[0]+s[1])
hitati = "hi"
for i in range(5):
if s == hitati:
print("Yes")
exit()
else:
hitati += "hi"
print("No")
| 1 | 53,518,144,105,112 | null | 199 | 199 |
def main():
n = int(input())
s = input()
cnt = 1
for i in range(1, n):
if s[i - 1] != s[i]:
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
|
n = int(input())
s = list(input())
b = 0
d = s[0]
for i in range(n):
if d != s[i]:
d = s[i]
b += 1
print(b+1)
| 1 | 170,026,759,826,140 | null | 293 | 293 |
a = [input() for i in range(2)]
b = [int(s) for s in a]
print(6 - sum(b))
|
def main():
a = int(input())
b = int(input())
if a == 1 and b == 2 or a == 2 and b == 1:
print(3)
elif a == 2 and b == 3 or a == 3 and b == 2:
print(1)
elif a == 3 and b == 1 or a == 1 and b == 3:
print(2)
if __name__ == '__main__':
main()
| 1 | 110,834,929,888,788 | null | 254 | 254 |
n = int(input())
if n>=3:
if n%2==0:
print(n//2-1)
else:
print(n//2)
else:
print(0)
|
import math
N = int(input())
print(math.floor((N - 1)/2))
| 1 | 153,331,657,265,460 | null | 283 | 283 |
n, m = map(int, input().split())
a = 1
b = m + 1
while a < b:
print(a, b)
a += 1
b -= 1
a = m + 2
b = 2 * m + 1
while a < b:
print(a, b)
a += 1
b -= 1
|
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 | 27,466,502,644,240 | 162 | 158 |
n = int(input())
debt = 100000
for i in range(n):
debt *= 1.05
if debt % 1000 > 0:
tmp = debt % 1000
debt -= tmp
debt += 1000
print(int(debt))
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def update(x):
y = x * 105 // 100
r = y % 1000
y = y // 1000 * 1000
if r: y += 1000
return y
def main():
n = int(input())
x = 100000
for _ in range(n):
x = update(x)
print(x)
if __name__ == "__main__": main()
| 1 | 1,160,209,092 | null | 6 | 6 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from math import ceil
def main():
n, k, *a = map(int, read().split())
def isOK(x):
kaisu = 0
for ae in a:
kaisu += ceil(ae / x) - 1
if kaisu <= k:
return True
else:
return False
ng = 0
ok = max(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if isOK(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
|
N, K = map(int, input().split())
A = [int(i) for i in input().split()]
def f(length, ls):
cur = 0
for a in ls:
if a%length == 0:
cur += a//length - 1
else:
cur += a//length
if cur <= K:
return True
else:
return False
ok, ng = max(A), 0
while abs(ok - ng) > 1:
z = (ok+ng)//2
if f(z, A) == True:
ok = z
else:
ng = z
print(ok)
| 1 | 6,499,517,094,112 | null | 99 | 99 |
import sys
from collections import deque
input = sys.stdin.readline
def dfs(N):
alphabet = "abcdefghij"
stack = deque(["a"])
while stack:
s = stack.pop()
if len(s) == N:
print(s)
continue
suffixes = []
for al in alphabet:
suffixes.append(al)
if al not in s:
break
for suffix in reversed(suffixes):
stack.append("".join((s, suffix)))
def main():
N = int(input())
dfs(N)
if __name__ == "__main__":
main()
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
# アルファベットと数字の対応
alp_to_num = {chr(i+97): i for i in range(26)}
ALP_to_num = {chr(i+97).upper(): i for i in range(26)}
num_to_alp = {i: chr(i+97) for i in range(26)}
num_to_ALP = {i: chr(i+97).upper() for i in range(26)}
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
def main():
N = NI()
ans = []
def dfs(s, i, max_num):
if i == N:
ans.append(s)
return
for n in range(max_num+2):
dfs(s + num_to_alp[n], i+1, max(max_num, n))
dfs("a", 1, 0)
ans.sort()
for a in ans:
print(a)
if __name__ == "__main__":
main()
| 1 | 52,605,586,656,098 | null | 198 | 198 |
# ANSHUL GAUTAM
# IIIT-D
from math import *
from copy import * # ll = deepcopy(l)
from heapq import * # heappush(hp,x)
from string import * # alpha = ascii_lowercase
from random import * # l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import * # bisect_left(arr,x,start,end) => start and end parameters are temporary
from sys import stdin # bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize # minn = -maxsize
from operator import * # d = sorted(d.items(), key=itemgetter(1))
from itertools import * # pre = [0] + list(accumulate(l))
from decimal import Decimal # a = Decimal(a) # use this for math questions
from collections import Counter # d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)
'''
5
24 11 8 3 16
'''
def solve(l):
n = len(l)
ans,maxx = 0,max(l)
done = [0]*(maxx+1)
l.sort()
ans = 0
d = dict(Counter(l))
for i in l:
zz = 2
while(i*zz <= maxx):
done[i*zz] = 1
zz += 1
for i in l:
if(not done[i] and d[i] == 1):
ans += 1
return ans
N = int(stdin.readline())
l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l)
print(ans)
|
import itertools
from collections import deque
from sys import stdin
input = stdin.readline
def main():
H, W = list(map(int, input().split()))
M = [input()[:-1] for _ in range(H)]
def bfs(start):
dist = [[float('inf')]*W for _ in range(H)]
dist[start[0]][start[1]] = 0
is_visited = [[0]*W for _ in range(H)]
is_visited[start[0]][start[1]] = 1
q = deque([start])
max_ = 0
while len(q):
now_h, now_w = q.popleft()
if M[now_h][now_w] == '#':
return
for next_h, next_w in ((now_h+1, now_w),
(now_h-1, now_w),
(now_h, now_w-1),
(now_h, now_w+1)):
if not(0 <= next_h < H) or not(0 <= next_w < W) or \
(is_visited[next_h][next_w] == 1) or \
M[next_h][next_w] == '#':
# (dist[next_h][next_w] != float('inf')) or \
continue
dist[next_h][next_w] = dist[now_h][now_w] + 1
is_visited[next_h][next_w] = 1
max_ = max(max_, dist[next_h][next_w])
q.append((next_h, next_w))
return max_
max_ = 0
for h in range(H):
for w in range(W):
if M[h][w] == '.':
max_ = max(bfs((h, w)), max_)
print(max_)
if(__name__ == '__main__'):
main()
| 0 | null | 54,251,183,093,220 | 129 | 241 |
N = [int(i) for i in input()]
dp = [0, float('inf')]
# dp = [桁上げしてない, 桁上げあった]
for n in N :
ndp = [0] * 2
ndp[0] = min(dp[0] + n, dp[1] + n)
ndp[1] = min(dp[0] + 11 - n, dp[1] + 9 - n)
dp = ndp
print(min(dp[0], dp[1]))
|
def main():
n = input()
a, b = 0, 1
for i in n:
x = int(i)
a, b = min(a + x, b + 10 - x), min(a + x + 1, b + 10 - x - 1)
print(a)
main()
| 1 | 70,704,427,156,320 | null | 219 | 219 |
#ALL you can eat
#0-1 なっぷサック問題をとく* N
#要領T-1のバックと 大きさがA,価値がBの荷物がNこずつある。 この時これらを使って価値をT-1をこえない範囲で最大にする方法を考える。
#dpl[N][V]=1番目からN番目までの荷物を用いて、重さをVにする上で実現可能な価値の最大値
N,T=map(int,input().split())
d=[]
for i in range(N):
a,b=map(int,input().split())
d.append((a,b))
dpl=[[0 for i in range(T)] for j in range(N+1)]
for i in range(N):
weight,value=d[i]
for j in range(T):
if j>=weight:
dpl[i+1][j]=max(dpl[i][j],dpl[i][j-weight]+value)
else:
dpl[i+1][j]=dpl[i][j]
#dpr[K][V]=K番目からN番目までの荷物を用いて、重さをVにする上で実現可能な価値の最大値
dpr=[[0 for i in range(T)] for j in range(N+2)]
for i in range(1,N+1):
weight,value=d[-i]
for j in range(T):
if j>=weight:
dpr[N+1-i][j]=max(dpr[N+2-i][j],dpr[N+2-i][j-weight]+value)
else:
dpr[N+1-i][j]=dpr[N+2-i][j]
#dpr[K][V]=K番目からN番目までの荷物を用いて重さをV以下にする上で実現可能な価値の最大値にする
for i in range(1,N+1):
for j in range(1,T):
dpr[i][j]=max(dpr[i][j],dpr[i][j-1])
ans=0
for i in range(N):
sub=d[i][1]
#i+1番目の物を使わない
add=0
for j in range(T):
add=max(add,dpl[i][j]+dpr[i+2][T-1-j])
sub+=add
ans=max(sub,ans)
print(ans)
|
def ints():
return [int(x) for x in input().split()]
def ii():
return int(input())
N, T = ints()
dp = [[0]*T for j in range(N+1)]
F = sorted([ints() for i in range(N)])
for i in range(N):
a, b = F[i]
for t in range(T):
dp[i+1][t] = max(dp[i+1][t], dp[i][t])
nt = t+a
if nt<T:
dp[i+1][nt] = max(dp[i+1][nt], dp[i][t]+b)
w = max([F[i][1] + dp[i][T-1] for i in range(1, N)])
print(w)
| 1 | 151,530,584,972,068 | null | 282 | 282 |
from collections import defaultdict
dic = defaultdict(int)
N = int(input())
for i in range(N):
temp = str(input())
dic[temp] += 1
MAX = max(dic.values())
ans = []
for x in dic.keys():
if dic[x] == MAX:
ans.append(x)
ans.sort()
print(*ans,sep="\n")
|
N = int(input())
dp = [True] * 10**6
count = 0
if N % 2 == 0:
times = 0
while(N % 2 == 0):
times += 1
N //= 2
i = 1
while(times-i >= 0):
times -= i
i += 1
count += 1
f = 3
while f**2 < N:
if N % f == 0:
times = 0
while(N % f == 0):
times += 1
N //= f
i = 1
while(times-i >= 0):
times -= i
i += 1
count += 1
else:
f += 2
if N != 1:
count += 1
print(count)
| 0 | null | 43,349,005,703,930 | 218 | 136 |
N=int(input())
A= list(map(int,input().split()))
B=[0 for _ in range(N)]
for a in A:
B[a-1]+=1
for b in B:
print(b)
|
n = int(input())
an = [0 for _ in range(n)]
for i in input().split():
an[int(i)-1] += 1
for a in an:
print(a)
| 1 | 32,656,296,852,348 | null | 169 | 169 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
class Edge:
def __init__(self, to, id):
self.to = to
self.id = id
def main():
n = int(readline())
g = [[] for _ in range(n)]
for i in range(n-1):
a, b = map(int, readline().split())
g[a-1].append(Edge(b-1, i))
g[b-1].append(Edge(a-1, i))
dq = deque()
done = [0 for _ in range(n)]
dq.append(0)
done[0] = 1
edgecolor = [0 for _ in range(n-1)]
while len(dq) > 0:
v = dq.pop()
c = -1
for i in range(len(g[v])):
nx = g[v][i].to
edge_id = g[v][i].id
if done[nx]:
c = edgecolor[edge_id]
k = 1
for i in range(len(g[v])):
nx = g[v][i].to
edge_id = g[v][i].id
if done[nx]:
continue
if k == c:
k += 1
edgecolor[edge_id] = k
k += 1
done[nx] = 1
dq.append(nx)
mx = max(edgecolor)
print(mx)
for ec in edgecolor:
print(ec)
if __name__ == '__main__':
main()
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
from collections import defaultdict
n = int(input())
ns = defaultdict(set)
uvs = [None]*(n-1)
for i in range(n-1):
u,v = map(int, input().split())
u -= 1
v -= 1
ns[u].add(v)
ns[v].add(u)
uvs[i] = (u,v)
s = [(0, -1)]
cs = {(0,-1): -1}
seen = [False]*n
seen[0] = True
while s:
u,prev = s.pop()
val = 0
cc = cs[u,prev]
for v in ns[u]:
if seen[v]:
continue
if val==cc:
val += 1
cs[v,u] = val
val += 1
seen[v] = True
s.append((v,u))
ans = []
for u,v in uvs:
if (u,v) in cs:
ans.append(cs[u,v]+1)
else:
ans.append(cs[v,u]+1)
print(max(ans))
write("\n".join(map(str, ans)))
| 1 | 136,174,582,155,520 | null | 272 | 272 |
def common_raccoon_vs_monster():
# 入力
H, N = map(int, input().split())
A = list(map(int, input().split()))
# 必殺技の合計攻撃力
sum_A = 0 # 必殺技の攻撃力の合計
for i in range(len(A)):
sum_A += A[i]
# 比較
if H > sum_A:
return 'No'
else:
return 'Yes'
result = common_raccoon_vs_monster()
print(result)
|
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
mod = 998244353
n, k = map(int, input().split())
l = []
r = []
for _ in range(k):
l_, r_ = map(int, input().split())
l.append(l_)
r.append(r_)
dp = [0] * (n + 1)
dp_csum = [0] * (n + 1)
dp[1] = 1
dp_csum[1] = 1
for i in range(2, n + 1):
for j in range(k):
left = i - r[j]
right = i - l[j]
if right >= 1:
dp[i] += dp_csum[right] - dp_csum[max(left, 1) - 1]
dp[i] %= mod
dp_csum[i] = dp_csum[i - 1] + dp[i]
dp_csum[i] %= mod
print(dp[-1])
| 0 | null | 40,457,275,472,390 | 226 | 74 |
import sys
input = sys.stdin.readline
from collections import deque
class Graph:
def __init__(self, n, directed=False, decrement=True, destroy=False, edges=[]):
self.n = n
self.directed = directed
self.decrement = decrement
self.destroy = destroy
self.edges = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
self.info = [-1]*self.n
for x, y in edges:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edges[x].add(y)
if self.directed == False:
self.edges[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edges[i] = set(map(lambda x: x - 1, adjacent_list))
else:
self.edges[i] = set(adjacent_list)
def bfs(self, start=1, goal=-1, time=0, save=False):
"""
:param start: スタート地点
:param goal: ゴール地点
:param save: True = 前回の探索結果を保持する
:return: （ループがあっても）最短距離。存在しなければ -1
"""
if self.decrement:
start -= 1
goal -= 1
if not save:
self.parent = [-1] * self.n
p, t = start, time
self.parent[p] = -2
next_set = deque([(p, t)])
while next_set:
p, t = next_set.popleft()
for q in self.edges[p]:
if self.parent[q] != -1:
continue
if q == goal:
return t + 1
self.parent[q] = p
next_set.append((q, t + 1))
return -1
def connection_counter(self):
"""
:return: 連結成分の個数。有効グラフではあまり意味がない。
"""
cnt = 0
self.parent = [-1] * self.n
for start in range(self.n):
if self.parent[start] == -1:
cnt += 1
self.bfs(start + self.decrement, save=True)
return cnt
def distance_list(self, start=1, save=False):
"""
:param start: スタート地点
:return: スタート地点から各点への距離のリスト
"""
dist = [-1]*self.n
if self.decrement:
start -= 1
if not save:
self.parent = [-1] * self.n
p, t = start, 0
self.parent[p] = -2
dist[p] = 0
next_set = deque([(p, t)])
while next_set:
p, t = next_set.popleft()
for q in self.edges[p]:
if self.parent[q] != -1:
continue
dist[q] = t + 1
self.parent[q] = p
next_set.append((q, t + 1))
return dist
def path_list(self, start=1):
"""
:return: スタート地点から最短経路で進んだ時の、各頂点の一個前に訪問する頂点番号
訪問しない場合は -1 を返す
"""
self.distance_list(start)
if self.decrement:
start -= 1
return list(p + self.decrement for p in self.parent[1:])
##################################################################################################
N, M = map(int, input().split())
graph = Graph(N, directed=False, decrement=True, destroy=False)
for _ in range(M):
x, y = map(int, input().split())
graph.add_edge(x, y)
res = graph.path_list()
if -1 in res:
print("No")
else:
print("Yes")
print(*res, sep="\n")
|
N, K = map(int, input().split())
A = [0]*(N+2)
for i in range(N+1):
A[i+1] += A[i] + i
ans = 0
for i in range(K, N+2):
minv = A[i]
maxv = A[N+1]-A[N-i+1]
ans += maxv-minv+1
ans %= 10**9+7
print(ans)
| 0 | null | 26,834,423,324,530 | 145 | 170 |
N=int(input())
f=[0]*10000
for i in range(100):
for j in range(100):
for k in range(100):
n=(i+1)**2+(j+1)**2+(k+1)**2+(i+1)*(j+1)+(j+1)*(k+1)+(k+1)*(i+1)
if n<=10000:
f[n-1]+=1
for i in range(N):
print(f[i])
|
n=int(input())
s=input()
mid=n//2
if(s[:mid]==s[mid:]):
print("Yes")
else:
print("No")
| 0 | null | 77,062,940,700,836 | 106 | 279 |
from math import sin, cos, pi
def koch_curve(d, p1, p2):
if d == 0:
return
s = [None, None]
u = [None, None]
t = [None, None]
s[0] = (2*p1[0] + p2[0])/3
s[1] = (2*p1[1] + p2[1])/3
t[0] = (p1[0] + 2*p2[0])/3
t[1] = (p1[1] + 2*p2[1])/3
u[0] = (t[0] - s[0])*cos(1/3*pi) - (t[1] - s[1])*sin(1/3*pi) + s[0]
u[1] = (t[0] - s[0])*sin(1/3*pi) + (t[1] - s[1])*cos(1/3*pi) + s[1]
koch_curve(d-1, p1, s)
print(s[0], s[1])
koch_curve(d-1, s, u)
print(u[0], u[1])
koch_curve(d-1, u, t)
print(t[0],t[1])
koch_curve(d-1, t, p2)
num = int(input())
print(0.0, 0.0)
koch_curve(num, [0.0, 0.0], [100.0, 0.0])
print(100.0, 0.0)
|
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
mod=pow(10,9)+7
n,m=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
left=0
right=(10**5)*2+5
s=ruiseki(a)
ans=0
while 1:
mid=(left+right)//2
cnt=0
for i in range(n):
tmp=bisect.bisect_left(a,mid-a[i])
cnt+=n-tmp
if cnt<m:
right=mid
else:
left=mid
# print(left,right,mid)
if right-left<=1:
break
for i in range(n):
tmp=bisect.bisect(a,left-a[i])
cnt=n-tmp
ans+=cnt*a[i]+s[n]-s[tmp]
m-=cnt
ans+=m*left
print(ans)
| 0 | null | 54,211,598,976,810 | 27 | 252 |
s = input()
n = len(s)
a = [0]*(n+1)
yama = []
tani = []
for i in range(n):
if s[i] == '<':
a[i+1] = a[i] + 1
for i in range(n)[::-1]:
if s[i] == '>':
a1 = a[i+1] + 1
if i != 0:
if s[i-1] == '<':
a[i] = max(a[i], a1)
else:
a[i] = a1
else:
a[i] = a1
ans = sum(a)
print(ans)
|
n=int(input())
l0=[[] for _ in range(n)]
l1=[[] for _ in range(n)]
for i in range(n):
a=int(input())
for j in range(a):
x,y=map(int,input().split())
if y==0:
l0[i].append(x)
else:
l1[i].append(x)
ans=0
for i in range(2**n):
s0=set()
s1=set()
num=0
num1=[]
num0=[]
for j in range(n):
if (i>>j) & 1:
num1.append(j+1)
for k in range(len(l0[j])):
s0.add(l0[j][k])
for k in range(len(l1[j])):
s1.add(l1[j][k])
else:
num0.append(j+1)
for j in range(len(s1)):
if s1.pop() in num0:
num=1
break
if num==0:
for j in range(len(s0)):
if s0.pop() in num1:
num=1
break
if num==0:
ans=max(ans,len(num1))
print(ans)
| 0 | null | 139,085,442,121,340 | 285 | 262 |
choise = {1, 2, 3}
for i in range(2):
choise.remove(int(input()))
print(list(choise)[0])
|
a = int(input())
b = int(input())
num = [a, b]
for i in range(1, 4):
if i not in num:
print(i)
break
| 1 | 110,704,446,884,232 | null | 254 | 254 |
def some():
n, k = map(int, input().split(" "))
h = map(int, input().split(" "))
print(len([i for i in h if i >= k]))
some()
|
# coding: utf-8
# 二分探索（応用）
def loading(pack_list, k, q):
truck = 0
idx = 0
for pack in pack_list:
if pack > q:
return False
if truck + pack > q:
idx += 1
truck = 0
truck += pack
if truck > 0:
idx += 1
return False if idx > k else True
if __name__ == "__main__":
n, k = [int(i) for i in input().split()]
pack = []
for _ in range(n):
pack.append(int(input()))
min = 0
max = int(1E20)
# min = sum(pack) // n
# max = sum(pack)
q = (max + min) // 2
res = loading(pack, k, q)
while min + 1 != max:
min, max = [min, q] if res else [q, max]
q = (max + min) // 2
res = loading(pack, k, q)
print(max)
| 0 | null | 89,520,702,794,148 | 298 | 24 |
def main():
s = input()
if s == 'ABC':
print('ARC')
else:
print('ABC')
if __name__ == "__main__":
main()
|
S=input()
if S == "ABC":print("ARC")
else : print("ABC")
| 1 | 23,995,961,755,428 | null | 153 | 153 |
def main():
from fractions import gcd
from math import ceil
n, m, *a = map(int, open(0).read().split())
b = [0 for _ in range(n)]
a.sort()
for i, j in enumerate(a):
c = 0
while j % 2 == 0:
c += 1
j = j // 2
a[i] = j
b[i] = c
if len(set(b)) > 1:
print(0)
exit()
lcm = 1
for i in a:
lcm = (lcm * i) // gcd(lcm, i)
k = b[0] - 1
ans = ceil(m // 2 ** k // lcm / 2)
print(ans)
if __name__ == "__main__":
main()
|
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
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())
from collections import defaultdict
from collections import Counter
import bisect
def main():
X = LS()
S_ = X[0]
T = X[1]
A, B = MI()
U = S()
if U == S_:
print(A - 1, B)
else:
print(A, B - 1)
if __name__ == "__main__":
main()
| 0 | null | 87,153,449,474,048 | 247 | 220 |
n = int(input())
a = list(map(int, input().split()))
target = 1
for i in range(n):
if a[i] == target:
target += 1
if target >= 2:
print(n - target + 1)
else:
print(-1)
|
n = int(input())
a = list(map(int, input().split()))
ans = 0
cnt = 0
for i in range(n) :
if a[i] == cnt + 1 :
cnt += 1
if cnt > 0 :
print(n-cnt)
else :
print("-1")
| 1 | 115,092,188,793,320 | null | 257 | 257 |
while True:
(n, x) = [int(i) for i in input().split()]
if n == x == 0:
break
count = 0
for a in range(1, n + 1):
if a >= x:
break
for b in range(a + 1, n + 1):
if sum([a,b]) >= x:
break
for c in range(b + 1, n + 1):
if sum([a,b,c]) == x:
count += 1
print(count)
|
def solve(sup,rest,digit,used1,used2):
if rest<0:
return 0
if digit==0:
if rest==0:
return 1
else:
return 0
sum=0
for i in range(1,sup+1):
if i!=used1 and i!=used2:
if used1==0:
sum+=solve(sup,rest-i,digit-1,i,used2)
elif used2==0:
sum+=solve(sup,rest-i,digit-1,used1,i)
else:
sum+=solve(sup,rest-i,digit-1,used1,used2)
return sum
N=[]
X=[]
while True:
n,x=map(int,raw_input().split())
if (n,x)==(0,0):
break
N.append(n)
X.append(x)
for i in range(len(N)):
print('%d'%(solve(N[i],X[i],3,0,0)/6))
| 1 | 1,271,224,755,168 | null | 58 | 58 |
n,m=list(map(int,input().split()))
mA=[list(map(int,input().split())) for i in range(n)]
mB=[int(input()) for j in range(m)]
for ma in mA:
print(sum([a*b for a, b in zip(ma,mB)]))
|
n = int(input())
AC = 0
WA = 0
TLE = 0
RE = 0
for i in range(n):
s = input()
if(s == "AC"):
AC += 1
elif(s == "WA"):
WA += 1
elif(s == "TLE"):
TLE += 1
else:
RE += 1
print('AC x {}'.format(AC))
print('WA x {}'.format(WA))
print('TLE x {}'.format(TLE))
print('RE x {}'.format(RE))
| 0 | null | 4,889,204,656,672 | 56 | 109 |
import math
n,k = (int(x) for x in input().split())
An = [int(i) for i in input().split()]
left = 0
right = max(An)
def check(x):
chk = 0
for i in range(n):
chk += math.ceil(An[i]/x)-1
return chk
while right-left!=1:
x = (left+right)//2
if check(x)<=k:
right = x
else:
left = x
print(right)
|
def check(x, A, K):
import math
sumA = 0
for a in A:
if a > x:
sumA += math.ceil(a / x) - 1
if sumA <= K:
return True
else:
return False
def resolve():
_, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
ok = max(A) # maxVal when minimize
ng = -1 # maxVal when maximize
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if mid > 0 and check(mid, A, K):
ok = mid
else:
ng = mid
print(ok)
resolve()
| 1 | 6,524,526,191,900 | null | 99 | 99 |
x, y = map(int, input().split())
mod = 10 ** 9 + 7
if (x + y) % 3 != 0:
ans = 0
else:
n, m = (2 * x - y) / 3, (2 * y - x) / 3
ans = 0
if n >= 0 and m >= 0:
n, m = int(n), int(m)
ans = 1
for i in range(min(m, n)):
ans = ans * (n + m - i) % mod
ans *= pow(i + 1, mod - 2, mod)
print(ans % mod)
|
x,y=map(int,input().split())
if (2*y-x)%3==0 and(2*x-y)%3==0 and (2*y-x)>=0 and (2*x-y)>=0:
a=(2*y-x)//3
b=(2*x-y)//3
numerator=1
denominator=1
for i in range(a):
numerator=(numerator*(a+b-i))%(10**9+7)
denominator=(denominator*(a-i))%(10**9+7)
print((numerator*pow(denominator,10**9+5,10**9+7))%(10**9+7))
else:
print(0)
| 1 | 149,748,015,275,680 | null | 281 | 281 |
X,K,D=input().split(' ')
x,k,d=abs(int(X)),int(K),int(D)
x_par=x%d
x_num=int((x-x_par)/d)
s=0
if x_num<=k:
x_div=x-x_num*d
k-=x_num
if k%2==0:
s=abs(x_div)
else:
s=x_div-d
else:
s=x-d*k
print(abs(s))
|
x,k,d=map(int, input().split())
if abs(x)//d>=k:
#print("ひ")
print(abs(x)-d*k)
elif (k-abs(x)//d)%2==0:
#print("fu")
print(abs(x)%d)
else:
#print("mi")
print(d-abs(x)%d)
| 1 | 5,161,890,304,252 | null | 92 | 92 |
lis = ["SUN","MON","TUE","WED","THU","FRI","SAT"]
S = input()
x = lis.index(S)
print(7-x)
|
AL=["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"]
N=input()
l=0
for i in AL:
if N==i:
print(AL[l+1])
else:
l+=1
| 0 | null | 112,668,622,955,196 | 270 | 239 |
A, B = [int(n) for n in input().split(" ")]
XstartA = A / 0.08
XendA = (A + 1) / 0.08
XstartB = B / 0.1
XendB = (B + 1) / 0.1
start = XstartA
if XstartA < XstartB:
start = XstartB
end = XendA
if XendB < XendA:
end = XendB
S = int(start)
E = int(end) + 1
ans = -1
for i in range(S, E + 1):
if start <= i and i < end:
ans = i
break
print(ans)
|
N = int(input())
A = list(map(int,input().split()))
ls = [0] * (N + 1)
for a in A:
ls[a] += 1
C = 0
for i in set(A):
n = ls[i]
C += n * (n - 1) //2
for a in A:
n = ls[a]
print(C - (n - 1))
| 0 | null | 52,128,361,330,566 | 203 | 192 |
import itertools
from collections import deque
from sys import stdin
input = stdin.readline
def main():
H, W = list(map(int, input().split()))
M = [input()[:-1] for _ in range(H)]
def bfs(start):
dist = [[float('inf')]*W for _ in range(H)]
dist[start[0]][start[1]] = 0
is_visited = [[0]*W for _ in range(H)]
is_visited[start[0]][start[1]] = 1
q = deque([start])
max_ = 0
while len(q):
now_h, now_w = q.popleft()
if M[now_h][now_w] == '#':
return
for next_h, next_w in ((now_h+1, now_w),
(now_h-1, now_w),
(now_h, now_w-1),
(now_h, now_w+1)):
if not(0 <= next_h < H) or not(0 <= next_w < W) or \
(is_visited[next_h][next_w] == 1) or \
M[next_h][next_w] == '#':
# (dist[next_h][next_w] != float('inf')) or \
continue
dist[next_h][next_w] = dist[now_h][now_w] + 1
is_visited[next_h][next_w] = 1
max_ = max(max_, dist[next_h][next_w])
q.append((next_h, next_w))
return max_
max_ = 0
for h in range(H):
for w in range(W):
if M[h][w] == '.':
max_ = max(bfs((h, w)), max_)
print(max_)
if(__name__ == '__main__'):
main()
|
H ,W = map(int,input().split())
from collections import deque
S = [input() for i in range(H)]
directions = [[0,1],[1,0],[-1,0],[0,-1]]
counter = 0
#インデックス番号 xが行番号 yが列番号
for x in range(H):
for y in range(W):
if S[x][y]=="#":
continue
que = deque([[x,y]])
memory = [[-1]*W for _ in range(H)]
memory[x][y]=0
while True:
if len(que)==0:
break
h,w = que.popleft()
for i,k in directions:
x_new,y_new = h+i,w+k
if not(0<=x_new<=H-1) or not(0<=y_new<=W-1) :
continue
elif not memory[x_new][y_new]==-1 or S[x_new][y_new]=="#":
continue
memory[x_new][y_new] = memory[h][w]+1
que.append([x_new,y_new])
counter = max(counter,max(max(i) for i in memory))
print(counter)
| 1 | 94,166,098,444,740 | null | 241 | 241 |
# coding: utf-8
class Dice(object):
def __init__(self, num_list):
self.num = num_list
def west(self):
num = list(self.num)
before = [5, 2, 0, 3]
after = [2, 0, 3, 5]
for i in range(4):
self.num[after[i]] = num[before[i]]
return self.num[5]
def east(self):
num = list(self.num)
before = [5, 2, 0, 3]
after = [3, 5, 2, 0]
for i in range(4):
self.num[after[i]] = num[before[i]]
return self.num[5]
def north(self):
num = list(self.num)
before = [0, 1, 5, 4]
after = [4, 0, 1, 5]
for i in range(4):
self.num[after[i]] = num[before[i]]
return self.num[5]
def south(self):
num = list(self.num)
before = [0, 1, 5, 4]
after = [1, 5, 4, 0]
for i in range(4):
self.num[after[i]] = num[before[i]]
return self.num[5]
if __name__ == "__main__":
num_list = [int(i) for i in raw_input().split()]
dice = Dice(num_list)
for order in raw_input():
if order == "E": dice.east()
elif order == "W": dice.west()
elif order == "S": dice.south()
elif order == "N": dice.north()
print dice.num[0]
|
A,B,C,D = [int(x) for x in input().split()]
if A % D == 0 :
takahashi = A // D
else:
takahashi = A // D + 1
if C % B == 0 :
aoki = C // B
else:
aoki = C // B + 1
if takahashi >= aoki:
print('Yes')
else:
print('No')
| 0 | null | 14,937,009,760,960 | 33 | 164 |
# import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
N = int(input())
S = input()
# n, *a = map(int, open(0))
# N, M = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
all = S.count("R") * S.count("G") * S.count("B")
cnt = 0
for i in range(N):
for j in range(i, N):
k = 2 * j - i
if k >= N:
continue
if S[i] != S[j] and S[i] != S[k] and S[j] != S[k]:
cnt += 1
print(all - cnt)
|
N = int(input())
S = input()
count = 0
RGBlist = [[S.count('R')],[S.count('G')],[S.count('B')]]
for i in range(1,N):
RGBlist[0].append(RGBlist[0][-1] - (S[i-1] == 'R'))
RGBlist[1].append(RGBlist[1][-1] - (S[i-1] == 'G'))
RGBlist[2].append(RGBlist[2][-1] - (S[i-1] == 'B'))
for i in range(N-2):
si = S[i]
for j in range(i+1,N-1):
sj = S[j]
if si==sj:
continue
else:
RGB = set(['R','G','B'])
RGB -= set([si,sj])
k=j+1
kji=j-i
if RGB == {'R'}:
rgb = 0
elif RGB =={'G'}:
rgb = 1
else:
rgb = 2
if k+kji-1 < len(S):
count += RGBlist[rgb][k] - ({S[k+kji-1]} == RGB)
else:
count += RGBlist[rgb][k]
print(count)
| 1 | 36,029,247,178,028 | null | 175 | 175 |
while True:
(H, W) = [int(x) for x in input().split()]
if H == W == 0:
break
for row in range(H):
if row % 2 == 0:
for w in range(W):
if w % 2 == 0:
print("#", end="")
else:
print(".", end="")
else:
print()
else:
for w in range(W):
if w % 2 == 0:
print(".",end="")
else:
print("#",end="")
print()
print()
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
U = max(A)+1
L = 0
def can(x, K):
ct = 0
for i in range(N):
ct += (A[i]-1)//x
if ct <= K:
return True
else:
return False
while U-L > 1:
x = (U+L+1)//2
if can(x, K):
U = x
else:
L = x
print(U)
| 0 | null | 3,659,905,814,430 | 51 | 99 |
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)
|
n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
routes = [[] for _ in range(len(h) + 1)]
for _ in range(m):
a, b = list(map(int, input().split()))
routes[a].append(b)
routes[b].append(a)
good = 0
for i in range(1, len(routes)):
if len(routes[i]) == 0:
good += 1
continue
if h[i - 1] > max([h[j - 1] for j in routes[i]]):
good += 1
print(good)
| 1 | 25,085,950,983,928 | null | 155 | 155 |
#141dの応用
from collections import deque
X,Y,A,B,C = map(int, input().split())
p_list = [int(e) for e in input().split()]
q_list = [int(e) for e in input().split()]
r_list = [int(e) for e in input().split()]
p_list.sort(reverse=True)
q_list.sort(reverse=True)
r_list.sort(reverse=False)
#リストから高い方のみ取り出し
red_apples = p_list[0:min(A,X)]
green_apples = q_list[0:min(B,Y)]
colorless_apples = r_list
#print("R:",red_apples)
#print("G:",green_apples)
#print("*:",colorless_apples)
#print("########################")
#不足分をまず食べておく
if len(red_apples) < X:
shortage = X - len(red_apples)
red_apples += colorless_apples[0:shortage]
del colorless_apples[0:shortage]
if len(green_apples) < Y:
shortage = Y - len(green_apples)
green_apples += colorless_apples[0:shortage]
del colorless_apples[0:shortage]
#print("R:",red_apples)
#print("G:",green_apples)
#print("*:",colorless_apples)
#print("##########################")
eat_apples = red_apples + green_apples
eat_apples.sort(reverse=True)
#print("E:",eat_apples)
#print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
lowest_apple = eat_apples.pop(-1)
replaced_deque = deque() #左高 右低
#replaced_deque | eat_apples | colorless_apples
#| 1 1 2 5 7 8 12 35 58 98 | 1 3 5 7 9
#3 | 1 2 5 7 8 12 35 58 98 | 3 5 7 9
#3 3 | 2 5 7 8 12 35 58 98 | 5 7 9
#3 3 5 | 5 7 8 12 35 58 98 | 7 9
#3 3 5 | 5 7 8 12 35 58 98 | 7 9
#3 5 7 | 5 7 8 12 35 58 98 | 9
#5 7 9 | 5 7 8 12 35 58 98 |
#リンゴを低い方から、残った無色に入れ替えた方がよければ入れ替えていく。入れ替える際はより低い方を選択する
for i in range(len(colorless_apples)):
#print("eat_apples :" ,eat_apples)
#print("replaced_deque:" ,replaced_deque)
#print("lowest :" ,lowest_apple)
#print("candidate :" ,colorless_apples[i])
#print("##########################")
if colorless_apples[i] > lowest_apple:
replaced_deque.appendleft(colorless_apples[i])
if len(eat_apples) > 0:
if replaced_deque[-1] < eat_apples[-1]:
lowest_apple = replaced_deque.pop()
else:
lowest_apple = eat_apples.pop(-1)
else:
lowest_apple = replaced_deque.pop()
print(sum(eat_apples) + sum(replaced_deque) + lowest_apple)
|
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, A):
dp = [0] * (N + 1)
dp[0] = 1000
for i in range(1, N + 1):
dp[i] = dp[i - 1]
for j in range(1, i):
dp[i] = max(dp[i], (dp[j] // A[j - 1]) * A[i - 1] + dp[j] % A[j - 1])
print(dp[N])
if __name__ == '__main__':
input = sys.stdin.readline
N = int(input())
*A, = map(int, input().split())
main(N, A)
| 0 | null | 26,180,838,628,030 | 188 | 103 |
S,T = (x for x in input().split())
A,B = map(int,input().split())
U = input()
if S == U:
A -= 1
else:
B -= 1
print(A,B)
|
N = [int(_) for _ in list(input())]
a, b = 0, 1
for n in N:
a, b = min(a+n, b+10-n), min(a+(n+1), b+10-(n+1))
print(a)
| 0 | null | 71,616,847,181,098 | 220 | 219 |
n, m = map(int, input().split())
a = input().split()
a_sum = 0
for b in a:
a_sum += int(b)
if a_sum > n:
print(-1)
else:
print(n - a_sum)
|
# coding: utf-8
import sys
import collections
def main():
n, quantum = map(int, raw_input().split())
processes = [x.split() for x in sys.stdin.readlines()]
for p in processes:
p[1] = int(p[1])
queue = collections.deque(processes)
elapsed = 0
while queue:
# print elapsed, queue
head = queue.popleft()
if head[1] > quantum:
head[1] -= quantum
queue.append(head)
elapsed += quantum
else:
elapsed += head[1]
print head[0], elapsed
if __name__ == '__main__':
main()
| 0 | null | 16,083,670,785,172 | 168 | 19 |
n = int(input())
point = [0, 0]
for i in range(n):
a, b = input().split()
if a > b:
point[0] += 3
elif a < b:
point[1] += 3
else:
point[0] += 1
point[1] += 1
print(*point)
|
# -*-coding:utf-8
def main():
inputLine = int(input())
taro = hanako = 0
for i in range(inputLine):
tokens = list(input().split())
if(tokens[0] > tokens[1]):
taro += 3
elif(tokens[0] < tokens[1]):
hanako += 3
else:
taro += 1
hanako += 1
print('%d %d' % (taro, hanako))
if __name__ == '__main__':
main()
| 1 | 2,025,332,579,392 | null | 67 | 67 |
def insertionSort(A,input_num):
for i in range(input_num):
v = A[i]
j = i - 1
while(j >= 0 and A[j] > v):
A[j + 1] = A[j]
j -= 1
A[j + 1] = v
print(*A)
input_num = int(input())
A = list(map(int, input().split()))
insertionSort(A,input_num)
|
def main():
a = int(input())
print((a+a**2+a**3))
if __name__ == "__main__":
main()
| 0 | null | 5,052,495,393,902 | 10 | 115 |
N, K = map(int, input().split())
arr = list(map(int, input().split()))
jj = 0
koho=[]
for i in range(K):
jj+=arr[i]
koho.append(jj)
for i in range(N-K):
jj+=arr[i+K]
jj-=arr[i]
koho.append(jj)
a=max(koho)
print(a/2+(K/2))
|
N, K = map(int,input().split())
P = [0]+list(map(int,input().split()))
for i in range(1,N+1):
p = P[i]
p = (1+p)/2
P[i] = p+P[i-1]
ans = 0
for i in range(N-K+1):
ans = max(ans,P[i+K]-P[i])
print(ans)
| 1 | 75,150,407,749,340 | null | 223 | 223 |
# -*- coding: utf-8 -*-
from sys import stdin
input = stdin.readline
def main():
a, b, c, d = list(map(int,input().split()))
print(max([a*c, a*d, b*c, b*d]))
if __name__ == "__main__":
main()
|
a, b, c, d = map(int, input().split())
ans = -float("INF") # 答えがマイナスになることがあるので、負の無限大を初期値にしておきます
for x in (a, b):
for y in (c, d):
ans = max(ans, x * y)
print(ans)
| 1 | 3,017,306,955,300 | null | 77 | 77 |
import itertools, math
N = int(input())
ls, L = [], 0
for i in range(N):
x, y = map(int, input().split(' '))
ls.append([x, y])
perms = itertools.permutations(range(N))
for perm in perms:
for i in range(N - 1):
L += math.sqrt((ls[perm[i + 1]][0] - ls[perm[i]][0]) ** 2 + (ls[perm[i + 1]][1] - ls[perm[i]][1]) ** 2)
print(L / math.factorial(N))
|
a = int(input())
a-=1
cnt = 0
for i in range(1,a):
if i < a:
a -= 1
cnt += 1
else :
break
print (cnt)
| 0 | null | 150,614,251,877,320 | 280 | 283 |
n = int(input())
lis = list(map(int, input().split()))
m = 0
for a in lis:
m = m ^ a
for a in lis:
print(m ^ a, end=" ")
|
n,k = map(int,input().split())
keta = 1
while True:
if n >= k:
n = n//k
keta += 1
else:
break
print(keta)
| 0 | null | 38,593,672,160,248 | 123 | 212 |
n = int(input())
a = list(map(int, input().split()))
a_to_index = [0] * n
for i in range(n):
a_to_index[a[i]-1] = i + 1
a.sort()
ans = [0] * n
for index, ai in enumerate(a):
ans[index] = a_to_index[ai-1]
print(*ans)
|
n=int(input())
a=list(map(int,input().split()))
nu={}
for i in range(len(a)):
nu[a[i]+1]=i+1
nu=sorted(nu.items())
b=[]
for i in nu:
b.append(str(i[1]))
mojiretu = ' '.join(b)
print(mojiretu)
| 1 | 180,760,445,715,570 | null | 299 | 299 |
N = int(input())
tax_min = int(N*0.08/1.08)
tax_max = int((N+1)*0.08/1.08)
if tax_min != tax_max:
print(":(")
else: print(N - tax_min)
|
N = int(input())
a = int(N / 1.08) # min
b = int((N + 1) / 1.08) # max
ans = ':('
for i in range(a, b + 1):
if int(i * 1.08) == N:
ans = i
break
print(ans)
| 1 | 126,070,921,364,652 | null | 265 | 265 |
input=raw_input().split()
a1=int(input[0])
a2=int(input[1])
print "%d %d"%(a1*a2,2*(a1+a2))
|
w,h = map(int, raw_input().split())
print(str(w*h) + ' ' + str((w+h)*2))
| 1 | 303,126,377,810 | null | 36 | 36 |
N = int(input())
print(N/2/N) if N % 2 == 0 else print((N+1)/2/N)
|
n = int(input())
s = [input() for _ in range(n)]
t = ('AC', 'WA', 'TLE', 'RE')
for i in t:
print(i, 'x', s.count(i))
| 0 | null | 92,923,240,841,068 | 297 | 109 |
a, b = map(int, input().split())
c =1
if b > a:
a, b = b, a
while c != 0:
c = a % b
a = b
b = c
print(a)
|
x,y = map(int,raw_input().split())
if x==y:
print x
else:
if y>x:
tmp = x
x = y
y = tmp
i=2
ans = 1
al = []
while i*i<=x:
if x % i ==0:
if y % i==0:
al.append(i)
x = x/i
y = y/i
continue
i+=1
if len(al)==0:
pass
else:
for j in al:
ans *= j
print ans
| 1 | 8,208,800,348 | null | 11 | 11 |
N, A, B = map(int, input().split())
A, B = min(A, B), max(A, B)
d = B - A
if d % 2 == 0:
print(d // 2)
else:
if (A - 1 <= N - B):
A, B = A - 1, B - 1
else:
A, B = N - B, N - A
ans = min(B, A + 1 + (B - A - 1) // 2)
print(ans)
|
n, a, b = map(int, input().split())
# 偶奇一致
if a % 2 == b % 2:
print((b - a) // 2)
else:
left = a - 1
right = n - b
if left > right:
cnt = right + 1
left = min(a + cnt, n)
print((n - left) // 2 + cnt)
else:
cnt = left + 1
right = max(b - cnt, 1)
print((right - 1) // 2 + cnt)
| 1 | 109,160,238,826,220 | null | 253 | 253 |
a, b, c = [int(s) for s in input().split()]
hit = 0
for i in range(a, b + 1):
if c % i == 0:
hit += 1
print(hit)
|
N=int(input())
A=[]
for i in range(N):
D=list(map(int,input().split()))
A.append(D)
for i in range(N-2):
if A[i][0]==A[i][1] and A[i+1][0]==A[i+1][1] and A[i+2][0]==A[i+2][1]:
print('Yes')
break
else:
print('No')
| 0 | null | 1,543,911,125,850 | 44 | 72 |
#ABC145B
n = int(input())
s = input()
print("Yes" if s[:n//2]==s[n//2:] else "No")
|
n=int(input())
s=list(input())
if n%2==1:
print("No")
elif s[:n//2]==s[n//2:n]:
print("Yes")
else:
print("No")
| 1 | 146,720,202,166,752 | null | 279 | 279 |
# unionfind
class Uf:
def __init__(self, N):
self.p = list(range(N))
self.rank = [0] * N
self.size = [1] * N
def root(self, x):
if self.p[x] != x:
self.p[x] = self.root(self.p[x])
return self.p[x]
def same(self, x, y):
return self.root(x) == self.root(y)
def unite(self, x, y):
u = self.root(x)
v = self.root(y)
if u == v: return
if self.rank[u] < self.rank[v]:
self.p[u] = v
self.size[v] += self.size[u]
self.size[u] = 0
else:
self.p[v] = u
self.size[u] += self.size[v]
self.size[v] = 0
if self.rank[u] == self.rank[v]:
self.rank[u] += 1
def count(self, x):
return self.size[self.root(x)]
N, M, K = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(M)]
CD = [list(map(int, input().split())) for _ in range(K)]
uf = Uf(N+1)
M = [-1] * (N+1)
for a, b in AB:
uf.unite(a, b)
M[a] -= 1
M[b] -= 1
for c, d in CD:
if uf.same(c, d):
M[c] -= 1
M[d] -= 1
for i in range(1, N+1):
M[i] += uf.count(i)
print(" ".join(map(str, M[1:])))
|
H=int(input())
W=int(input())
N=int(input())
K=H
if K<W: K=W
sum = 0
ans= 0
for i in range(1,K+1):
if sum < N:
sum += K
ans = i
#print(ans, K)
print(ans)
| 0 | null | 75,246,204,849,888 | 209 | 236 |
from math import *
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
def is_ok(arg):
tmp=0
for i in a:
tmp+=ceil(i/arg)-1
return tmp<=k
def meguru_bisect(ng, ok):
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(meguru_bisect(0, max(a)))
|
N = int(input())
A = [int(temp) for temp in input().split()]
cou = 0
for mak in range(1,N) :
for j in range(mak,N)[ : : -1] :
if A[j] < A[j - 1] :
tem = int(A[j])
A[j] = int(A[j - 1])
A[j - 1] = int(tem)
cou = cou + 1
A = [str(temp) for temp in A]
print(' '.join(A))
print(cou)
| 0 | null | 3,271,632,657,590 | 99 | 14 |
def solve():
N = int(input())
ans = 0
for i in range(1, N+1):
if i%3 != 0 and i%5 != 0:
ans += i
print(ans)
if __name__ == "__main__":
solve()
|
def to_fizzbuzz(number):
if number % 15 == 0:
return 'FizzBuzz'
if number % 3 == 0:
return 'Fizz'
if number % 5 == 0:
return 'Buzz'
else:
return str(number)
# return i
def main():
N = int(input())
# this list concludes "FizzBuzz", "Fizz" or "Buzz"
fblist = []
for number in range(1, 10**6):
result = to_fizzbuzz(number)
fblist.append(result)
# the list up to N
n_list = fblist[0:N]
# this list contains only numbers and up to N
n_numlist = []
for s in n_list:
if s.isdigit() == True:
n_numlist.append(int(s))
print(sum(n_numlist))
main()
| 1 | 35,069,092,526,692 | null | 173 | 173 |
currAndRot2FBLR = {
'N':{'N':'F','E':'R','S':'B','W':'L'},
'E':{'E':'F','S':'R','W':'B','N':'L'},
'S':{'S':'F','W':'R','N':'B','E':'L'},
'W':{'W':'F','N':'R','E':'B','S':'L'}
}
dice = {
'1': {'F':'2F', 'R':'4R', 'B':'5B', 'L':'3L'},
'2': {'F':'6F', 'R':'4F', 'B':'1F', 'L':'3F'},
'3': {'F':'6L', 'R':'2F', 'B':'1R', 'L':'5F'},
'4': {'F':'6R', 'R':'5F', 'B':'1L', 'L':'2F'},
'5': {'F':'6B', 'R':'3F', 'B':'1B', 'L':'4F'},
'6': {'F':'5B', 'R':'4L', 'B':'2F', 'L':'3R'}
}
faces = list(map(int, input().split()))
cmd = input()
## initial state
currNum = '1'
currDir = 'N'
for c in cmd:
numDir = dice[currNum][currAndRot2FBLR[currDir][c]]
currNum = numDir[0]
currFBLR = numDir[1]
currDir = {v:k for k,v in currAndRot2FBLR[currDir].items()}[currFBLR]
print(faces[int(currNum) - 1])
|
MAX = 10 ** 5 * 2
mod = 10 ** 9 + 7
frac = [1]
inv_frac=[1]
def pow(a, n):
if n == 0 : return 1
elif n == 1 : return a
tmp = pow(a, n//2)
tmp = (tmp * tmp) % mod
if n % 2 == 1 :
tmp = (tmp * a) % mod
return tmp
def inv(x):
return pow(x, mod - 2 )
for i in range(1,MAX + 1 ):
frac.append( (frac[-1] * i) % mod )
inv_frac.append(inv(frac[-1])%mod)
def comb(n, k):
if k >= n or k < 0 : return 1
return (frac[n]*inv_frac[n-k] * inv_frac[k]) %mod
n,k = map(int,input().split())
count=0
b=inv(n)
for i in range(min(n,k+1)):
a=comb(n,i)
count=(count+a*a*(n-i)*b)%mod
print(count)
| 0 | null | 33,514,406,549,358 | 33 | 215 |
a, b, c = map(int, raw_input().split())
counter = 0
for i in xrange(a, b+1):
if c % i == 0:
counter += 1
print counter
|
a,b,c=list(map(int,input().split()))
y=0
for x in range(a,b+1):
if c%x==0:
y+=1
print(y)
| 1 | 572,146,550,866 | null | 44 | 44 |
import math
a,b,h,m=map(int,input().split())
res=min(abs(h*30+m/2-m*6),abs(h*30+m/2-m*6-360))
ans=a**2+b**2-2*a*b*math.cos(res*math.pi/180)
print(math.sqrt(ans))
|
import math
x1,y1,x2,y2 = map(float,input().split(" "))
print("{:.5f}".format(math.sqrt((x2-x1)**2 + (y2-y1)**2)))
| 0 | null | 10,175,910,094,948 | 144 | 29 |
N, M = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
dp = [50001] * (N + 1)
dp[0] = 0
for c in C:
for n in range(c, N + 1):
dp[n] = min(dp[n], dp[n - c] + 1)
print(dp[-1])
|
n,m = map(int,input().split())
c = [int(i) for i in input().split()]
dp = [[float("INF")]*(n+1) for _ in range(m+1)]
dp[0][0] = 0
for i in range(m):
for yen in range(n+1):
if yen - c[i] < 0: dp[i+1][yen] = dp[i][yen]
else: dp[i+1][yen] = min(dp[i][yen],dp[i+1][yen-c[i]]+1)
print(dp[m][n])
| 1 | 147,753,680,864 | null | 28 | 28 |
#!/usr/bin/env python3
import bisect
def main():
N = int(input())
L = sorted(map(int, input().split()))
ans = 0
for a in range(N - 2):
for b in range(a + 1, N - 1):
ans += bisect.bisect_right(L, L[a] + L[b] - 1) - b - 1
print(ans)
if __name__ == "__main__":
main()
|
import bisect
def binary_search(items, a, b, i, j):
def c_is_x(c):
is1 = c > max(a - b, b - a)
is2 = c < a + b
if is1 and is2:
return 0
elif is1:
return 1
else:
return 2
low = j+1
high = len(items) - 1
while low <= high:
mid = (low + high) // 2
ans = items[mid]
c_type = c_is_x(ans)
if c_type == 0 and mid != i and mid != j:
return mid
elif c_type == 1:
low = mid + 1
else:
high = mid - 1
return None
N = int(input())
L = list(map(int, input().split()))
L.sort()
# print(L)
count = 0
for i in range(N):
for j in range(i+1, N):
# i = N - i - 1
# j = N - j - 1
a = L[i]
b = L[j]
k = bisect.bisect_left(L, a+b, lo=j) - 1
if k < N:
c = L[k]
# print(a, b, c, a+b)
# print(i, j, k)
count += max(k - j, 0)
print(count)
| 1 | 171,351,668,508,088 | null | 294 | 294 |
import sys
for l in sys.stdin:
n, m = map(int, l.split())
print(len(str(n+m)))
|
values = input()
a, b, c = [int(x) for x in values.split()]
cnt = 0
for i in range(a, b + 1):
if 0 == c % i:
cnt += 1
print(cnt)
| 0 | null | 276,608,502,300 | 3 | 44 |
import numpy as np
from numba import njit
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
@njit(cache=True)
def pos(W,h,w):
return h*W+w
def solve(H,W,G):
N = H*W+W
INF=10**18
dp = np.full((N,N),INF)
for i in range(N):
dp[i][i] = 0
for h in range(H):
for w in range(W):
if G[h][w]: continue
for i in range(4):
dh = [0,1,0,-1][i]
dw = [1,0,-1,0][i]
if 0<=h+dh<H and 0<=w+dw<W:
if G[h+dh][w+dw]: continue
dp[pos(W,h,w)][pos(W,h+dh,w+dw)] = 1
dp[pos(W,h+dh,w+dw)][pos(W,h,w)] = 1
ans = 0
for k in range(N):
for i in range(N):
for j in range(N):
dp[i][j] = min(dp[i][j],dp[i][k]+dp[k][j])
for i in range(N):
for j in range(N):
if dp[i][j] != INF:
ans = max(ans,dp[i][j])
return ans
def main():
H,W=mi()
G = [[0] * W for _ in range(H)]
for h in range(H):
S = list(input())
for w in range(W):
G[h][w] = S[w] == "#"
print(solve(H,W,np.array(G,bool)))
def cc_export():
from numba.pycc import CC
cc = CC('my_module')
# basic types: https://numba.pydata.org/numba-doc/0.13/types.html
cc.export('pos', '(i8,i8,i8,)')(pos)
cc.export('solve', '(i8,i8,b1[:,:],)')(solve)
cc.compile()
if __name__ == '__main__':
try:
from my_module import solve
from my_module import pos
except:
cc_export()
exit()
main()
|
from collections import deque
import copy
h,w = map(int,input().split())
l = [['#']*(w+2)]
for i in range(h):
l.append(['#']+list(input())+['#'])
l.append(['#']*(w+2))
ans = 0
directions = [(1,0),(0,1),(-1,0),(0,-1)]
for i in range(1,h+1):
for j in range(1,w+1):
visited = copy.deepcopy(l)
if visited[i][j]=='.':
visited[i][j] = 0
que = deque([(i,j)])
while que:
v = que.popleft()
for dir in directions:
nv = (v[0]+dir[0],v[1]+dir[1])
if visited[nv[0]][nv[1]] == '.':
times = visited[v[0]][v[1]]+1
visited[nv[0]][nv[1]] = times
que.append(nv)
ans = max(times,ans)
# print((i,j),ans)
print(ans)
| 1 | 94,797,347,149,120 | null | 241 | 241 |
a, b, c, d, e = [int(_) for _ in input().split()]
print(c * 60 + d - a * 60 - b - e)
|
a,b,c,d,e=map(int,input().split())
x=a*60+b
y=c*60+d
print(y-x-e)
| 1 | 18,161,865,804,412 | null | 139 | 139 |
N = int(input())
tmp = 1000
while N > tmp:
tmp += 1000
print(tmp - N)
|
N=input()
n=int(N)
k=int(n%1000)
if k==0:
print(0)
else:
print(1000-k)
| 1 | 8,460,646,602,498 | null | 108 | 108 |
def cut(S,H,W,K):
cnt,h = 0,0
OP = [[0 for _ in range(W)] for _ in range(H)]
while "#" not in S[h]:
h += 1
burst = False
for i in range(h,H):
if "#" not in S[i]:
OP[i] = [OP[i-1][j] for j in range(W)]
burst = False
else:
cnt += 1
cnt_h = 1
for j in range(W):
OP[i][j] = cnt
if S[i][j] == "#" and cnt_h < S[i].count("#"):
cnt += 1
cnt_h += 1
for i in reversed(range(h)):
for j in range(W):
OP[i][j] = OP[i+1][j]
for i in range(H):
OP[i] = " ".join(map(str,OP[i]))
return OP
def main():
H,W,K = map(int,input().split())
S = [input() for _ in range(H)]
ans = cut(S,H,W,K)
for i in range(H):
print(ans[i])
if __name__ == "__main__":
main()
|
import numpy as np
h, w, k = map(int, input().split())
grid = []
for _ in range(h):
grid.append(list(map(str, input().rstrip())))
grid = (np.array(grid)).reshape(h, -1)
x, y = np.where(grid == "#")
arr = np.zeros((h, w), dtype=int)
arr[x, y] = np.arange(1, k+1)
np.maximum.accumulate(arr, axis=1, out=arr)
for w in range(w - 2, -1, -1):
arr[:, w] += arr[:, w+1] * (arr[:, w] == 0)
for i in range(1, h):
if arr[i, -1] == 0:
arr[i] += arr[i - 1]
for j in range(h - 1, -1, -1):
if arr[j, -1] == 0:
arr[j] += arr[j+1]
for i in range(h):
print(*arr[i])
| 1 | 143,624,800,894,688 | null | 277 | 277 |
import bisect, copy, heapq, math, sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
def celi(a,b):
return -(-a//b)
sys.setrecursionlimit(5000000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
a,b=map(int,input().split())
ans=1
while ans*8//100!=a or ans//10!=b:
ans+=1
if ans>2*10**5:
print(-1)
exit()
print(ans)
|
A, B = [int(_) for _ in input().split()]
aa = [int(i * 0.08) for i in range(1, 10000)]
bb = [int(i * 0.1) for i in range(1, 10000)]
for i, a, b in zip(range(1, 10000), aa, bb):
if (a, b) == (A, B):
print(i)
exit()
print(-1)
| 1 | 56,269,437,727,208 | null | 203 | 203 |
import sys
def f(x,y):
return x-y,x+y
def main():
n = int(input())
x = [0]*n
y = [0]*n
for i in range(n):
x[i],y[i] = map(int,input().split())
f0 = [0]*n
f1 = [0]*n
for i in range(n):
f0[i],f1[i] = f(x[i],y[i])
print(max(max(f0)-min(f0),max(f1)-min(f1)))
if __name__ == "__main__":
main()
|
N = int(input())
a,b = [], []
for i in range(N):
x,y = map(int, input().split())
a.append(x-y)
b.append(x+y)
a.sort()
b.sort()
ans = max(a[-1] - a[0], b[-1] - b[0])
print(ans)
| 1 | 3,439,309,225,800 | null | 80 | 80 |
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()
s = S()
rgb = [None for _ in range(n)]
rgb_acc = [None for _ in range(n)]
rgb_st = {"R","G","B"}
rgb_lst = ["R","G","B"]
for i, char in enumerate(s):
if char == "R":
rgb[i] = [1,0,0]
elif char == "G":
rgb[i] = [0,1,0]
else:
rgb[i] = [0,0,1]
rgb_acc[0] = rgb[0]
for i in range(1, n):
rgb_acc[i] = rgb_acc[i-1][:]
index = 0 if s[i]=="R" else 1 if s[i]=="G" else 2
rgb_acc[i][index] += 1
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
if s[i]!=s[j]:
ex = rgb_st - {s[i], s[j]}
ex = ex.pop()
index = 0 if ex=="R" else 1 if ex=="G" else 2
cnt = rgb_acc[n-1][index]-rgb_acc[j][index]
if j+1 <= 2*j-i < n:
if s[2*j-i] == ex:
cnt -= 1
ans += cnt
print(ans)
main()
|
N = int(input())
S = input()
assert len(S) == N
count = 0
# j-i = k-jを探す
for i in range(0, len(S)-2):
for j in range(i+1, len(S)-1):
k = j + (j - i)
if k < len(S):
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
count += 1
numR = 0
numG = 0
numB = 0
for s in S:
if s == 'R':
numR += 1
elif s == 'G':
numG += 1
else:
numB += 1
print(numR * numG * numB - count)
| 1 | 36,066,331,286,120 | null | 175 | 175 |
import itertools
n = int(input())
S = list(input())
L = [k for k, v in itertools.groupby(S)]
print(len(L))
|
n=int(input())
s=list(input())
for x in range(n-1):
if s[x]==s[x+1]:
s[x]='1'
print(len(s)-s.count('1'))
| 1 | 170,124,402,411,470 | null | 293 | 293 |
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.buffer.readline
N, M = map(int, input().split())
nextcity = [[] for _ in range(N)]
sgn = [0 for _ in range(N)]
while M:
M -= 1
A, B = map(int, input().split())
A -= 1
B -= 1
nextcity[A].append(B)
nextcity[B].append(A)
def bfs(cnt, lis):
nextvisit = []
for j in lis:
for item in nextcity[j]:
if sgn[item] == 0:
nextvisit.append(item)
sgn[item] = cnt
if nextvisit:
bfs(cnt, nextvisit)
return None
else:
return None
cnt = 0
for k in range(N):
if sgn[k] == 0:
cnt += 1
sgn[k] = cnt
bfs(cnt, [k])
print(cnt -1)
|
n=int(input())
a=list(map(int,input().split()))
res=0
for i in range(n):
res^=a[i]
ans=[]
for i in range(n):
ans.append(res^a[i])
print(*ans)
| 0 | null | 7,399,402,453,052 | 70 | 123 |
import sys
input = sys.stdin.readline
N, K = map(int, input().split())
A = list(map(int, input().split()))
MOD = 10**9+7
p, n = [], []
for Ai in A:
if Ai>=0:
p.append(Ai)
else:
n.append(Ai)
if len(n)==N and K%2==1:
n.sort(reverse=True)
ans = 1
for ni in n[:K]:
ans *= ni
ans %= MOD
print(ans)
exit()
if K==N and len(n)%2==1:
ans = 1
for Ai in A:
ans *= Ai
ans %= MOD
print(ans)
exit()
p.sort(reverse=True)
n.sort()
l = []
if K%2==1:
ans = p[0]
p = p[1:]
else:
ans = 1
for i in range(len(p)//2):
l.append(p[2*i]*p[2*i+1])
for i in range(len(n)//2):
l.append(n[2*i]*n[2*i+1])
l.sort(reverse=True)
for li in l[:K//2]:
ans *= li
ans %= MOD
print(ans)
|
ct=0
def merge(A,left,mid,right):
global ct
n1=mid-left
n2=right-mid
l=[A[left+i] for i in xrange(n1)]
r=[A[mid+i] for i in xrange(n2)]
l.append(float('inf'))
r.append(float('inf'))
i=0
j=0
for k in xrange(left,right):
ct+=1
if l[i]<=r[j]:
A[k]=l[i]
i=i+1
else:
A[k]=r[j]
j=j+1
def mergesort(A,left,right):
if left+1<right:
mid=(left+right)/2
mergesort(A,left,mid)
mergesort(A,mid,right)
merge(A,left,mid,right)
n=input()
s=map(int,raw_input().split())
mergesort(s,0,n)
i=0
s=map(str,s)
print(" ".join(s))
print(ct)
| 0 | null | 4,725,219,120,412 | 112 | 26 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
mod = 10**9+7
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
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, 10**5+5 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
ans = 0
for i in range(0, n-k+1):
ans += a[i]*cmb(n-i-1, k-1, mod)
ans %= mod
a.sort()
for i in range(0, n-k+1):
ans -= a[i]*cmb(n-i-1, k-1, mod)
ans %= mod
print(ans)
|
MAX = 10 ** 6
MOD = 10 ** 9 + 7
fac = [0] * MAX
finv = [0] * MAX
inv = [0] * MAX
def COMinit():
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 COM(n, r):
if n < r or r < 0 or n < 0:
return 0
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD
def main():
COMinit()
n, k = map(int, input().split())
a = sorted(list(map(int, input().split())), reverse=True)
i = 0
sum_max = 0
sum_min = 0
while n - i - 1 >= k - 1:
cnt = COM(n - i - 1, k - 1)
sum_max += a[i] * cnt
sum_min += a[n - i - 1] * cnt
i += 1
ans = (sum_max - sum_min) % MOD
print(ans)
if __name__ == '__main__':
main()
| 1 | 95,771,090,682,978 | null | 242 | 242 |
N = int(input())
ans = (N + 1) // 2 / N
print(ans)
|
def main():
n = int(input())
even = n // 2
print(1 - even / n)
if __name__ == "__main__":
main()
| 1 | 177,153,048,441,160 | null | 297 | 297 |
mod_val = 10**9+7
n, k = map(int, input().split())
factorials = [1]*(n+1) # values 0 to n
for i in range(2, n+1):
factorials[i] = (factorials[i-1]*i)%mod_val
def mod_binomial(a, b):
numerator = factorials[a]
denominator = (factorials[b]*factorials[a-b])%mod_val
invert = pow(denominator, mod_val-2, mod_val)
return (numerator*invert)%mod_val
partial = 0
# m is number of rooms with no people
for m in range(min(k+1, n)):
# m places within n to place the 'no people' rooms
# put n-(n-m) people in n-m rooms (n-m) must be placed to be non-empty
partial = (partial + (mod_binomial(n, m) * mod_binomial(n-1, m))%mod_val)%mod_val
print(partial)
|
#!/usr/bin/env python3
l, r, d = map(int, input().split())
n = (l-1) // d + 1
m = r // d
print(m-n+1)
| 0 | null | 37,277,851,136,428 | 215 | 104 |
days = ["SUN", 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
days.reverse()
d = input()
print(days.index(d)+1)
|
s = input()
days = ["", "SAT", "FRI", "THU", "WED", "TUE", "MON", "SUN"]
print(days.index(s))
| 1 | 133,180,373,139,310 | null | 270 | 270 |
#!/usr/bin/env python3
_, *a = map(int, open(0).read().split())
a.sort()
p = [0] * a[-1]
for i in a:
for j in range(1, a[-1] // i + 1):
p[j * i - 1] += j
print(sum(i == 1 for i in p))
|
# simpleバージョン
class BinaryIndexedTree:
def __init__(self,size):
self.N = size
self.bit = [0]*(size+1)
def add(self,x,w): # 0-indexed
x += 1
while x <= self.N:
self.bit[x] += w
x += (x & -x)
def _sum(self,x): # 1-indexed
ret = 0
while x > 0:
ret += self.bit[x]
x -= (x & -x)
return ret
def sum(self,l,r): # [l,r)
return self._sum(r) - self._sum(l)
def __str__(self): # for debug
arr = [self.sum(i,i+1) for i in range(self.N)]
return str(arr)
class BIT:
""" 区間加算BIT(区間加算・区間合計取得) """
def __init__(self, N):
# 添字0が使えないので、内部的には全て1-indexedとして扱う
N += 1
self.N = N
self.data0 = [0] * N
self.data1 = [0] * N
def _add(self, data, k, x):
k += 1
while k < self.N:
data[k] += x
k += k & -k
def _get(self, data, k):
k += 1
s = 0
while k:
s += data[k]
k -= k & -k
return s
def add(self, l, r, x):
""" 区間[l,r)に値xを追加 """
self._add(self.data0, l, -x*(l-1))
self._add(self.data0, r, x*(r-1))
self._add(self.data1, l, x)
self._add(self.data1, r, -x)
def query(self, l, r):
""" 区間[l,r)の和を取得 """
return self._get(self.data1, r-1) * (r-1) + self._get(self.data0, r-1) \
- self._get(self.data1, l-1) * (l-1) - self._get(self.data0, l-1)
def ctoi(c):
return ord(c) - ord('a')
def main():
N = int(input())
S = input()
Q = int(input())
query = [input().split() for i in range(Q)]
bits = [BIT(N) for i in range(26)]
s = []
for i, c in enumerate(S):
bits[ctoi(c)].add(i,i+1,1)
s.append(c)
for a, b, c in query:
if a == '1':
i = int(b) - 1
bits[ctoi(s[i])].add(i,i+1,-1)
bits[ctoi(c)].add(i,i+1,1)
s[i] = c
else:
l = int(b) - 1
r = int(c)
a = 0
for i in range(26):
if bits[i].query(l,r):
a += 1
print(a)
if __name__ == "__main__":
main()
| 0 | null | 38,341,628,525,232 | 129 | 210 |
x1,y1,x2,y2 = map(float,input().split())
distance = ( (x1 - x2)**2 + (y1 - y2)**2 )**(1/2)
print('{}'.format(distance))
|
n,m = map(int,input().split())
*hl, = map(int,input().split())
ansl = [1]*n
for _ in [0]*m:
a,b = map(int,input().split())
if hl[a-1] > hl[b-1]:
ansl[b-1] = 0
elif hl[a-1] < hl[b-1]:
ansl[a-1] = 0
else:
ansl[a-1] = 0
ansl[b-1] = 0
print(sum(ansl))
| 0 | null | 12,649,601,143,770 | 29 | 155 |
x = int(input())
n = 100
ans = 0
while True:
ans += 1
n += n // 100
if n >= x:
print(ans)
exit()
|
n=int(input())
a=[int(x) for x in input().rstrip().split()]
a.sort()
ma=max(a)
dp=[0]*ma
for i in a:
dp[i-1]+=1
l=[0]*ma
ans=0
for i in a:
j=i
if l[i-1]==0 and dp[i-1]==1:
ans+=1
while(j<=ma):
l[j-1]+=1
if j+i<=ma:
j+=i
else:
break
print(ans)
| 0 | null | 20,622,971,763,674 | 159 | 129 |
list = []
while True:
a = int(input())
if(a == 0): break
else: list.append(a)
for i in range(len(list)):
print("Case %d: %d" %(i+1,list[i]))
|
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,632,910,334,720 | 42 | 188 |
def cut(S,H,W,K):
cnt,h = 0,0
OP = [[0 for _ in range(W)] for _ in range(H)]
while "#" not in S[h]:
h += 1
burst = False
for i in range(h,H):
if "#" not in S[i]:
OP[i] = [OP[i-1][j] for j in range(W)]
burst = False
else:
cnt += 1
cnt_h = 1
for j in range(W):
OP[i][j] = cnt
if S[i][j] == "#" and cnt_h < S[i].count("#"):
cnt += 1
cnt_h += 1
for i in reversed(range(h)):
for j in range(W):
OP[i][j] = OP[i+1][j]
for i in range(H):
OP[i] = " ".join(map(str,OP[i]))
return OP
def main():
H,W,K = map(int,input().split())
S = [input() for _ in range(H)]
ans = cut(S,H,W,K)
for i in range(H):
print(ans[i])
if __name__ == "__main__":
main()
|
#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline
def main():
string=""
n = int(input())
for i in range(n):
string+="ACL"
print(string)
if __name__=="__main__":
main()
| 0 | null | 72,805,433,317,408 | 277 | 69 |
n = int(input())
A = list(map(int, input().split()))
MAX_N = max(A)+ 1
cnt = [0] * MAX_N
for a in A:
for i in range(a, MAX_N, a):
if cnt[i] <= 2:
cnt[i] += 1
ans = 0
for a in A:
if cnt[a] == 1:
ans += 1
print(ans)
|
import collections
n = int(input())
line = list(map(int, input().split( )))
arr = sorted(line)
coll = collections.Counter(arr)
#最大値
Ma = arr[-1]
#ソートしたn番目のやつの判定はn+1以降でおっけい.
#同じ数字がある敵は無視
s = set()
for i in range(n):
if coll[arr[i]] >= 2:
s.add(arr[i])
for j in range(2, Ma//arr[i]+1):
s.add(arr[i]*j)
cnt = 0
#print(s)
for a in arr:
if a in s: continue
cnt += 1
print(cnt)
| 1 | 14,479,047,416,170 | null | 129 | 129 |
N = int(input())
A = list(map(int, input().split()))
cnt = 0
now = 0
for a in A:
if a == now + 1:
now += 1
else:
cnt += 1
if now == 0:
print(-1)
else:
print(cnt)
|
# Begin Header {{{
from math import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations, combinations_with_replacement
# }}} End Header
# _________コーディングはここから！！___________
mod = 10**9+7
n = int(input())
ans=0
ans+=pow(10, n, mod)
ans-=pow(9, n, mod)*2
ans+=pow(8, n, mod)
print(ans%mod)
| 0 | null | 59,003,907,791,512 | 257 | 78 |
N = int(input())
if N % 2 == 1:
print(0)
else:
rlt = 0
i = 10
while N // i > 0:
rlt += N // i
i *= 5
print(rlt)
|
def resolve():
N = int(input())
if N % 2 == 1:
return print(0)
ans = 0
tmp = N // 2
while tmp:
tmp //= 5
ans += tmp
print(ans)
if __name__ == "__main__":
resolve()
| 1 | 116,429,853,468,490 | null | 258 | 258 |
S = input()
a = len(S)
count = 0
for i in range(a):
if S[i] != S[-(i+1)]:
count += 1
if a%2 ==0:
print(int(count/2))
else:
print(int((count +1)/2))
|
K = int(input())
A, B = map(int, input().split())
check = A
#print(check%K)
while check <= B:
if check%K == 0:
print("OK")
exit()
else:
check += 1
print("NG")
| 0 | null | 73,432,267,240,488 | 261 | 158 |
# AtCoder Beginner Contest 146
# E - Rem of Sum is Num
# https://atcoder.jp/contests/abc146/tasks/abc146_e
from collections import defaultdict
N, K = map(int, input().split())
*A, = map(int, input().split())
A = [0]+A
d = []
c = defaultdict(int)
x = 0
ans = 0
for i, a in enumerate(A):
x += a - 1
x %= K
d.append(x)
if i-K >= 0:
c[d[i-K]] -= 1
ans += c[x]
c[x] += 1
print(ans)
|
import sys
s = input()
def match(a):
if a[0:2] == 'hi':
return a[2:]
else:
print('No')
sys.exit()
if len(s)%2 == 1:
print('No')
sys.exit()
else:
while len(s) > 1:
s = match(s)
print('Yes')
| 0 | null | 95,112,380,562,800 | 273 | 199 |
import sys
input = sys.stdin.readline
from bisect import bisect, bisect_left
from itertools import accumulate
def main():
def check(x):
count = 0
for a in aaa:
if x <= a:
count += n
else:
count += n - bisect_left(aaa, x - a)
return count >= m
n, m = map(int, input().split())
aaa = list(map(int, input().split()))
aaa.sort()
acc = [0] + list(accumulate(aaa))
sum_a = acc[-1]
l, r = 0, 200001
while l + 1 < r:
mid = (l + r) // 2
if check(mid):
l = mid
else:
r = mid
# 合計がlより大きい組み合わせの和と組数を求める→Mに足りない分だけ合計がlの組を採用
ans = 0
count = 0
for a in aaa:
if l <= a:
ans += sum_a + a * n
count += n
else:
omit = bisect(aaa, l - a)
if omit < n:
ans += sum_a - acc[omit] + a * (n - omit)
count += n - omit
ans += l * (m - count)
print(ans)
if __name__ == '__main__':
main()
|
import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N,num):
if N<=0:
return [[] for _ in range(num)]
elif num==1:
return [I() for _ in range(N)]
else:
read_all = [tuple(II()) for _ in range(N)]
return map(list, zip(*read_all))
#################
import cmath
pi = cmath.pi
exp = cmath.exp
def convolution(a,b):
def fft(a,sz,inv=False):
tmp = [0]*sz
mask = sz-1
p = 0
i = sz>>1
sign = 1 if inv else -1
while i:
if p&1:
cur,nex = tmp,a
else:
cur,nex = a,tmp
ei = exp(2j*pi*i*sign/sz)
w = 1
for j in range(0,sz,i):
for k in range(i):
nex[j+k] = cur[((j<<1)&mask)+k] + w*cur[(((j<<1)+i)&mask)+k]
w *= ei
p += 1
i >>= 1
if p&1:
a,tmp = tmp,a
if inv:
a = list(map(lambda x: x/sz, a))
return a
sz = 1<<(len(a)+len(b)-2).bit_length()
a = a + [0]*(sz-len(a))
b = b + [0]*(sz-len(b))
fa = fft(a,sz)
fb = fft(b,sz)
fafb = [fai*fbi for fai,fbi in zip(fa,fb)]
ab = fft(fafb,sz,inv=True)
return [round(x.real) for x in ab[:len(a)+len(b)-1]]
N,M = II()
A = III()
h = [0]*(max(A))
for a in A:
h[a-1] += 1
conv = [0,0] + convolution(h,h)
ans = 0
for k in range(2,2*max(A)+1)[::-1]:
if conv[k]<M:
ans += k*conv[k]
M -= conv[k]
else:
ans += k*M
break
print(ans)
| 1 | 108,046,243,208,958 | null | 252 | 252 |
while True:
s = list(input())
if s == ['-']:
break
for _ in range(int(input())):
h = int(input())
s = s[h:] + s[:h]
for c in s:
print(c, end='')
print('')
|
while True:
data = input()
if(data == "-"):break
m = int(input())
tmp = []
for i in range(m):
num = int(input())
if(len(tmp) == 0):
tmp = data[num:] + data[:num]
data = ""
else:
data = tmp[num:] + tmp[:num]
tmp = ""
if(data): print(data)
else: print(tmp)
| 1 | 1,884,119,150,660 | null | 66 | 66 |
n,q = map(int,input().split())
name = []
time = []
for i in range(n):
tmp = input().split()
name.append(str(tmp[0]))
time.append(int(tmp[1]))
total = 0
result = []
while True:
try:
if time[0] > q:
total += q
time[0] = time[0] - q
tmp = time.pop(0)
time.append(tmp)
tmp = name.pop(0)
name.append(tmp)
elif q >= time[0] and time[0] > 0:
total += time[0]
time.pop(0)
a = name.pop(0)
print(a,total)
else:
break
except:
break
|
A =int(input())
B =int(input())
res = 6- A -B
print(res)
| 0 | null | 55,661,093,522,850 | 19 | 254 |
import sys
input = sys.stdin.readline
def main():
n,a,b = [int(i) for i in input().strip().split()]
if (b-a) % 2 == 0:
print(abs(b - a) // 2)
else:
ans = min(a - 1, n - b) + 1 + (b - a - 1) // 2
print(ans)
return
if __name__ == "__main__":
main()
|
import fractions
def is_lcm(X, Y):
return X*Y // fractions.gcd(X, Y)
N, M = map(int, input().split())
print(is_lcm(N, M))
| 0 | null | 110,973,019,389,280 | 253 | 256 |
n = int(input()) - 1 # n=n-1
print(sum([(n//x - x)*2 + 1 for x in range(1, int(n**0.5) + 1)]))
|
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import defaultdict
def main():
n, x, m = map(int, input().split())
d1 = defaultdict(int)
r = 0
while n:
if d1[x]:
cycle = d1[x] - n
t0 = 0
cycle2 = cycle
while cycle2:
t0 += x
x = x**2 % m
cycle2 -= 1
c, rem = divmod(n, cycle)
r += c * t0
while rem:
r += x
x = x**2 % m
rem -= 1
print(r)
sys.exit()
else:
d1[x] = n
r += x
x = x**2 % m
n -= 1
print(r)
if __name__ == '__main__':
main()
| 0 | null | 2,683,539,828,302 | 73 | 75 |
N, M, L = map(int, input().split())
D = [[1000000000000]*N for i in range(N)]
for i in range(N):
D[i][i] = 0
for i in range(M):
A, B, C = map(int, input().split())
A, B = A-1, B-1
D[A][B] = C
D[B][A] = C
for k in range(N):
for i in range(N):
for j in range(N):
D[i][j] = min(D[i][j], D[i][k]+D[k][j])
E = [[1000000000000]*N for i in range(N)]
for i in range(N):
E[i][i] = 0
for i in range(N):
for j in range(N):
if D[i][j] <= L:
E[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
E[i][j] = min(E[i][j], E[i][k]+E[k][j])
Q = int(input())
for i in range(Q):
s, t = map(int, input().split())
s, t = s-1, t-1
if E[s][t] == 1000000000000:
r = -1
else:
r = E[s][t]-1
print(r)
|
import sys
import itertools
# import numpy as np
import time
import math
from heapq import heappop, heappush
from collections import defaultdict
from collections import Counter
from collections import deque
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N, M, L = map(int, input().split())
dist = [[INF] * N for _ in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
if c > L:
continue
a -= 1
b -= 1
dist[a][b] = c
dist[b][a] = c
Q = int(input())
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
fuel = [[INF] * N for _ in range(N)]
for i in range(N):
for j in range(N):
fuel[i][j] = 1 if dist[i][j] <= L else INF
for k in range(N):
for i in range(N):
for j in range(N):
fuel[i][j] = min(fuel[i][j], fuel[i][k] + fuel[k][j])
for i in range(Q):
s,t = map(int, input().split())
if fuel[s - 1][t - 1] != INF:
print(fuel[s - 1][t - 1] - 1)
else:
print(-1)
| 1 | 173,341,419,338,460 | null | 295 | 295 |
import sys
k1 = [[0 for i in xrange(10)] for j in xrange(3)]
k2 = [[0 for i in xrange(10)] for j in xrange(3)]
k3 = [[0 for i in xrange(10)] for j in xrange(3)]
k4 = [[0 for i in xrange(10)] for j in xrange(3)]
n = input()
for i in xrange(n):
m = map(int,raw_input().split())
if m[0] == 1:
k1[m[1]-1][m[2]-1] = k1[m[1]-1][m[2]-1] + m[3]
elif m[0] == 2:
k2[m[1]-1][m[2]-1] = k2[m[1]-1][m[2]-1] + m[3]
elif m[0] == 3:
k3[m[1]-1][m[2]-1] = k3[m[1]-1][m[2]-1] + m[3]
elif m[0] == 4:
k4[m[1]-1][m[2]-1] = k4[m[1]-1][m[2]-1] + m[3]
for i in xrange(3):
for j in xrange(10):
x = ' ' + str(k1[i][j])
sys.stdout.write(x)
if j == 9:
print ""
print"#"*20
for i in xrange(3):
for j in xrange(10):
y = ' ' + str(k2[i][j])
sys.stdout.write(y)
if j == 9:
print ""
print"#"*20
for i in xrange(3):
for j in xrange(10):
z = ' ' + str(k3[i][j])
sys.stdout.write(z)
if j == 9:
print ""
print"#"*20
for i in xrange(3):
for j in xrange(10):
zz = ' ' + str(k4[i][j])
sys.stdout.write(zz)
if j == 9:
print ""
|
import sys
s=list(input())
r=list(reversed(s))
n=len(s)
for i in range(n):
if s[i]!=r[i]:
print('No')
sys.exit()
s1=s[:]
del s1[(n-1)//2:]
r1=list(reversed(s1))
for i in range(len(s1)):
if s1[i]!=r1[i]:
print('No')
sys.exit()
s2=s[:]
del s2[:(n+3)//2-1]
r2=list(reversed(s2))
for i in range(len(s2)):
if s2[i]!=r2[i]:
print('No')
sys.exit()
print('Yes')
| 0 | null | 23,854,146,190,908 | 55 | 190 |
n=int(input())
k=int(input())
if n<10:
if k==0:
print(1)
elif k==1:
print(n)
else:
print(0)
exit()
#10
#0の数は高々3つまでなので、jは0,1,2,3の配列だけ持てば良い
#i桁目までは高々100
#
#dp[i][j][smaller]=
lenn=len(str(n))
dp=[[[0]*2 for _ in range(4)] for _ in range(lenn)]
#smallerは、0：:通常、1:未満の2パターン
if int(str(n)[0])==1:
dp[0][0][0]=1
dp[0][1][1]=1
else:
dp[0][0][0]=1
dp[0][1][0]=int(str(n)[0])-1
dp[0][1][1]=1
#print(dp)
for i in range(lenn-1):
dp[i+1][0][0]+=dp[i][0][0]
dp[i+1][1][0]+=dp[i][0][0]*9+dp[i][1][0] #+dp[i][0][1]*max(0,(int(str(n)[i])-1))
dp[i+1][2][0]+=dp[i][1][0]*9+dp[i][2][0] #+dp[i][1][1]*max(0,(int(str(n)[i])-1))
dp[i+1][3][0]+=dp[i][2][0]*9+dp[i][3][0] #+dp[i][2][1]*max(0,(int(str(n)[i])-1))
#print(dp)
if int(str(n)[i+1])==0:
dp[i+1][0][1]+=dp[i][0][1]
dp[i+1][1][1]+=dp[i][1][1]
dp[i+1][2][1]+=dp[i][2][1]
dp[i+1][3][1]+=dp[i][3][1]
elif int(str(n)[i+1])==1:
dp[i+1][1][1]+=dp[i][0][1]
dp[i+1][2][1]+=dp[i][1][1]
dp[i+1][3][1]+=dp[i][2][1]
dp[i+1][1][0]+=dp[i][1][1]
dp[i+1][2][0]+=dp[i][2][1]
dp[i+1][3][0]+=dp[i][3][1]
else:
dp[i+1][1][1]+=dp[i][0][1]
dp[i+1][2][1]+=dp[i][1][1]
dp[i+1][3][1]+=dp[i][2][1]
dp[i+1][1][0]+=dp[i][1][1]
dp[i+1][2][0]+=dp[i][2][1]
dp[i+1][3][0]+=dp[i][3][1]
dp[i+1][1][0]+=dp[i][0][1]*(int(str(n)[i+1])-1)
dp[i+1][2][0]+=dp[i][1][1]*(int(str(n)[i+1])-1)
dp[i+1][3][0]+=dp[i][2][1]*(int(str(n)[i+1])-1)
#print(dp)
print(sum(dp[-1][k]))
|
import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
N = ins()
K = ini()
def solve():
M = len(N)
dp_eq = [[0 for _ in range(K + 1)] for _ in range(M)]
dp_less = [[0 for _ in range(K + 1)] for _ in range(M)]
dp_eq[0][K - 1] = 1
dp_less[0][K] = 1
dp_less[0][K - 1] = ord(N[0]) - ord("0") - 1
for i in range(1, M):
is_zero = N[i] == "0"
for k in range(K + 1):
if is_zero:
dp_eq[i][k] = dp_eq[i - 1][k]
elif k < K:
dp_eq[i][k] = dp_eq[i - 1][k + 1]
dp_less[i][k] = dp_less[i - 1][k]
if k < K:
dp_less[i][k] += dp_less[i - 1][k + 1] * 9
if not is_zero:
dp_less[i][k] += dp_eq[i - 1][k]
if k < K:
dp_less[i][k] += dp_eq[i - 1][k + 1] * (ord(N[i]) - ord("0") - 1)
return dp_eq[M - 1][0] + dp_less[M - 1][0]
print(solve())
| 1 | 75,921,389,632,832 | null | 224 | 224 |
from collections import deque
n,q = list(map(int, input().split()))
P = deque([[p,int(t)] for p,t in [input().split() for _ in range(n)]])
time = 0
while len(P) > 0:
pi = P.popleft()
if pi[1] > q:
P.append([pi[0],pi[1]-q])
time += q
else:
time += pi[1]
print(pi[0],time)
|
#!/usr/bin/env python
#-*- coding: utf-8 -*-
class Queue:
def __init__(self):
self.l = []
def enqueue(self, x):
self.l.append(x)
def dequeue(self):
x = self.l[0]
del self.l[0]
return x
def is_empty(self):
return len(self.l) == 0
class Process:
def __init__(self, name, time):
self.name = name
self.time = time
if __name__ == '__main__':
n, q = map(int, raw_input().split())
Q = Queue()
i = 0
while i != n:
tmp = raw_input().split()
Q.enqueue(Process(tmp[0], int(tmp[1])))
i += 1
cnt = 0
while not Q.is_empty():
p = Q.dequeue()
if p.time > q:
p.time -= q
cnt += q
Q.enqueue(p)
else:
cnt += p.time
print p.name, cnt
| 1 | 44,660,925,060 | null | 19 | 19 |
import math
nums = [int(e) for e in input().split()]
n = nums[0]
m = nums[1]
x = -1
y = -1
ms = []
if n%2 == 0:
x = 1
y = n
count = True
while x < y:
if y-x <= n/2 and count:
y -= 1
count = False
ms += [[x,y]]
x += 1
y -= 1
else:
x = 1
y = n
while x < y:
ms += [[x, y]]
x += 1
y -= 1
# print(ms)
for i in range(m):
print(str(ms[i][0]) + " " + str(ms[i][1]))
|
x = int(input())
if x >= 30:
ans = 'Yes'
else:
ans = 'No'
print(ans)
| 0 | null | 17,109,310,107,202 | 162 | 95 |
def main():
A, B, N = map(int, input().split())
x = min(B-1, N)
ans = int((A*x)/B) - A*int(x/B)
print(ans)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
def main():
import sys
input = sys.stdin.readline
A, B, N = map(int, input().split())
x = min(B - 1, N)
print((A * x) // B - A * (x // B))
if __name__ == '__main__':
main()
| 1 | 28,112,273,918,064 | null | 161 | 161 |
a,b,c = map(int,input().split())
cnt = 0
for d in range(a,b+1):
if c%d==0: cnt+=1
print(cnt)
|
L, R, d = map(int, input().split())
if L%d==0:
st = L
else:
st = (L//d+1)*d
count = 0
for i in range(st, R+1, d):
if i <= R:
count += 1
else:
break
print(count)
| 0 | null | 4,009,039,615,492 | 44 | 104 |
a = list(map(int,input().split()))
T = a.index(0)
print(T+1)
#
|
X = list(map(int, input().split()))
print(X.index(0) + 1)
| 1 | 13,447,129,525,300 | null | 126 | 126 |
h, w, k, = map(int, input().split())
c = [0] * h
for i in range(h):
c[i] = input()
y = 0
for i in range(2 ** (h + w)):
x = 0
a = [0] * (h + w)
for j in range(h + w):
if (i // (2 ** j)) % 2 == 1:
a[j] = 1
for j in range(h):
if a[j] == 0:
for l in range(w):
if a[h+l] == 0:
if c[j][l] == '#':
x += 1
if x == k:
y += 1
print(y)
|
N=int(input())
L=list(map(int,input().split()))
i=0
n=1
while True:
if i==N:
break
if L[i]==n:
n+=1
i+=1
if n==1:
print(-1)
else:
print(N-n+1)
| 0 | null | 62,121,651,772,348 | 110 | 257 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.