code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
N, M, *HAB = map(int, open(0).read().split())
H, AB = [0] + HAB[:N], HAB[N:]
good = [False] + [True] * N
for a, b in zip(*[iter(AB)] * 2):
if H[a] >= H[b]:
good[b] = False
if H[b] >= H[a]:
good[a] = False
print(sum(good)) | n = int(input())
#a, b, c, x, y = map(int, input().split())
#al = list(map(int, input().split()))
#al=[list(input()) for i in range(n)]
x = 1
mn = n-1
while x**2 <= n:
if n % x == 0:
y = n//x
mn = min(mn, x+y-2)
x+=1
print(mn)
| 0 | null | 93,570,334,677,150 | 155 | 288 |
# -*- coding: utf-8 -*-
"""
Created on Sun Jul 8 10:56:33 2018
@author: maezawa
"""
n = int(input())
adj = [[] for _ in range(n)]
d = [0 for _ in range(n)]
f = [0 for _ in range(n)]
for j in range(n):
ain = list(map(int, input().split()))
u = ain[0]
k = ain[1]
for i in range(k):
adj[u-1].append(ain[i+2]-1)
adj[u-1].sort()
#print(*adj[u-1])
t = 1
for j in range(n):
if d[j] == 0:
stack = [j]
while stack:
#print(stack)
current = stack[-1]
if d[current] == 0:
d[current] = t
t += 1
flag = 0
for k in adj[current]:
if d[k] == 0:
stack.append(k)
flag = 1
break
if flag == 0:
f[current] = t
t += 1
stack.pop()
#print('current = {}, t = {}'.format(current, t))
#print('stack', *stack)
for i in range(n):
print('{} {} {}'.format(i+1, d[i], f[i]))
| from bisect import bisect_left
def main():
def eratosthenes(n):
A = [i for i in range(2, n+1)]
P = []
i = 2
while i**2 <= n:
prime = min(A)
P.append(prime)
j = 0
while j < len(A):
if A[j] % prime == 0:
A.pop(j)
continue
j += 1
i += 1
for a in A:
P.append(a)
return P
x = int(input())
prime_table = eratosthenes(100003)
idx = bisect_left(prime_table, x)
ans = prime_table[idx]
print(ans)
if __name__ == '__main__':
main() | 0 | null | 52,550,335,384,382 | 8 | 250 |
s=input()
q=int(input())
quary=[]
for i in range(q):
temp=list(input().split())
quary.append(temp)
switch=False
first=''
last=''
for i in range(q):
if quary[i][0]=='1':
if switch:
switch=False
else:
switch=True
else:
if quary[i][1]=='1':
if switch:
last+=quary[i][2]
else:
first+=quary[i][2]
else:
if switch:
first+=quary[i][2]
else:
last+=quary[i][2]
s=first[::-1]+s+last
if switch:
print(s[::-1])
else:
print(s) | def resolve():
S = input()
Q = int(input())
reverse = False
import collections
left = collections.deque([])
right = collections.deque([])
for i in range(Q):
query = input().split()
if query[0] == "1":
reverse = (not reverse)
continue
if query[1] == "1":
if reverse:
right.append(query[2])
else:
left.appendleft(query[2])
elif query[1] == "2":
if reverse:
left.appendleft(query[2])
else:
right.append(query[2])
if reverse:
ans = "{}{}{}".format("".join(reversed(right)), "".join(reversed(S)), "".join(reversed(left)))
else:
ans = "{}{}{}".format("".join(left), S, "".join(right))
print(ans)
if '__main__' == __name__:
resolve() | 1 | 57,359,385,211,868 | null | 204 | 204 |
N = int(input())
S = list(input())
print("".join(chr(65+(ord(s)-65+N)%26) for s in S)) | N = int(input())
S = input()
ret = ''
for s in S:
o = ord(s) - ord('A') + N
ret += chr(ord('A') + o % 26)
print(ret) | 1 | 134,714,412,719,250 | null | 271 | 271 |
import math
import sys
s = list(sys.stdin.readline().rstrip())
k = int(sys.stdin.readline().rstrip())
if len(set(s)) == 1:
print(len(s) * k // 2)
sys.exit()
ss = s * 2
tmp, tmp2 = 0, 0
for i in range(len(s) - 1):
if s[i] == s[i + 1]:
tmp += 1
s[i + 1] = '-1'
for i in range(len(s) * 2 - 1):
if ss[i] == ss[i + 1]:
tmp2 += 1
ss[i + 1] = '-1'
print(tmp + (tmp2 - tmp) * (k - 1)) | n=int(input())
s=[]
t=[]
for i in range(9):
s.append([])
for i in range(100):
t.append([[],[]])
for i in range(1,n+1):
a=str(i)
b=max(int(a[0]),int(a[len(a)-1]))
c=min(int(a[0]),int(a[len(a)-1]))
if b!=0 and c!=0:
if b==c:
s[b-1].append(i)
elif int(a[0])<int(a[len(a)-1]):
t[b*9+c][0].append(i)
else:
t[b*9+c][1].append(i)
ans=0
for i in range(9):
x=len(s[i])
ans+=x**2
for i in range(100):
x=len(t[i][0])
y=len(t[i][1])
ans+=2*x*y
print(ans) | 0 | null | 131,213,590,400,870 | 296 | 234 |
from collections import namedtuple
Task = namedtuple('Task', 'name time')
class Queue:
def __init__(self, n):
self.n = n
self._l = [None for _ in range(self.n + 1)]
self._head = 0
self._tail = 0
def enqueue(self, x):
self._l[self._tail] = x
self._tail += 1
if self._tail > self.n:
self._tail -= self.n
def dequeue(self):
if self.isEmpty():
raise IndexError("pop from empty queue")
else:
e = self._l[self._head]
self._l[self._head] = None
self._head += 1
if self._head > self.n:
self._head -= self.n
return e
def isEmpty(self):
return self._head == self._tail
def isFull(self):
return self._tail == self.n
if __name__ == '__main__':
n, q = map(int, input().split())
queue = Queue(n+1)
for _ in range(n):
name, time = input().split()
time = int(time)
queue.enqueue(Task(name=name, time=time))
now = 0
while not queue.isEmpty():
task = queue.dequeue()
t = task.time
if t <= q:
now += t
print(task.name, now)
else:
now += q
queue.enqueue(Task(task.name, t - q))
| import collections
import sys
n,q = map(int,input().split())
data = [[i for i in input().split()]for i in range(n)]
time = 0
while data:
task = data[0]
del data[0]
if int(task[1]) <= q:
time += int(task[1])
print(task[0],time)
else:
time += q
task[1] = str(int(task[1]) - q)
data.append(task) | 1 | 44,226,140,442 | null | 19 | 19 |
# import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
enu = enumerate
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
N = int(input())
L = [input() for _ in range(N)]
up = []
do = []
for li in L:
l = li.count("(")
r = li.count(")")
ext_neg = 0
ext_pos = 0
tl, tr = 0, 0
if 0 <= l - r:
for op in li:
if op == "(":
tl += 1
elif op == ")":
tr += 1
ext_neg = min(ext_neg, tl - tr)
ext_pos = max(ext_pos, tl - tr)
up.append((l - r, ext_neg, ext_pos))
else:
for op in li[::-1]:
if op == ")":
tl += 1
elif op == "(":
tr += 1
ext_neg = min(ext_neg, tl - tr)
ext_pos = max(ext_pos, tl - r)
do.append((r - l, ext_neg, ext_pos))
up.sort(key=lambda tup: (-tup[1], -tup[0]))
do.sort(key=lambda tup: (-tup[1], -tup[0]))
# print(up)
# print(do)
curl = 0
for upi in up:
dif, ext_neg, ext_pos = upi
if curl + ext_neg < 0:
print("No")
exit()
curl += dif
curr = 0
for doi in do:
dif, ext_neg, ext_pos = doi
if curr + ext_neg < 0:
print("No")
exit()
curr += dif
if curl == curr:
print("Yes")
else:
print("No")
| s=input()
x=list(map(int,s.split()))
x.sort()
print("%d %d %d"%tuple(x)) | 0 | null | 12,058,143,634,442 | 152 | 40 |
from sys import stdin
from collections import defaultdict as dd
from collections import deque as dq
import itertools as it
from math import sqrt, log, log2
from fractions import Fraction
# t = int(stdin.readline())
# for _ in range(t):
# n, m = map(int, stdin.readline().split())
# nums = list(map(int, stdin.readline().split()))
# n = int(input())
# if n%10 in [2, 4, 5, 7, 9]:
# print('hon')
# elif n%10 in [0, 1, 6, 8]:
# print('pon')
# else:
# print('bon')
k = int(input())
s = input()
ans = s[:k] + ('...' if len(s) > k else '')
print(ans) | import numpy as np
inpt = input()
inpt_list = inpt.split(" ")
X, K, D = [int(x) for x in inpt_list]
X_abs = np.abs(X)
num = X_abs // D
rem = K - num
if rem < 0:
out = X_abs - D*K
else:
if rem%2==0:
out = X_abs - num*D
else:
out = np.abs(X_abs - num*D - D)
print(out) | 0 | null | 12,510,076,207,068 | 143 | 92 |
# coding: utf-8
# ?????????????????¨????????????
class Dice(object):
def __init__(self):
# ???????????????????????°
# ????????¶???
self.dice = (2, 5), (3, 4), (1, 6) # x, y, z
self.ax = [[0, False], [1, False], [2, False]]
self.axmap = [0, 1, 2]
self.mm = {"N": (0, 2), "S": (2, 0), "E": (1, 2), "W": (2, 1), "R": (0, 1), "L": (1, 0)}
def rotate(self, dir):
def rot(k, r):
# k?????????????????????????????????????????§?§????
# r?????????????????¢???????§????
t = self.axmap[r]
self.axmap[k], self.axmap[r] = t, self.axmap[k]
self.ax[t][1] = not self.ax[t][1]
rot(*self.mm[dir])
def top(self):
z = self.ax[self.axmap[2]]
return self.dice[z[0]][z[1]]
def right(self):
y = self.ax[self.axmap[1]]
return self.dice[y[0]][y[1]]
def front(self):
x = self.ax[self.axmap[0]]
return self.dice[x[0]][x[1]]
if __name__=="__main__":
dice = Dice()
labels = input().split()
q = int(input())
for _ in range(q):
a, b = input().split()
p = labels.index(a) + 1
for _ in range(4):
if p==dice.top():
break
dice.rotate("N")
for _ in range(4):
if p==dice.top():
break
dice.rotate("E")
p = labels.index(b) + 1
for _ in range(4):
if p==dice.front():
break;
dice.rotate("R")
print(labels[dice.right()-1]) | n = input()
if n[-1]== "2" or n[-1]== "4" or n[-1]== "5" or n[-1]== "7" or n[-1]== "9":
print("hon")
elif n[-1]== "3":
print("bon")
else:
print("pon") | 0 | null | 9,826,264,358,460 | 34 | 142 |
import math
import sys
if __name__ == '__main__':
for line in sys.stdin:
a,b = map(int,line.split())
print(math.gcd(a,b),(a*b) // math.gcd(a,b))
| while True:
try:
a, b = map(int, input().split())
if a < b:
b, a = a, b
x, y = a, b
while b: a, b = b, a%b
gcd = a
lcm = (x*y)//gcd
print(gcd, lcm)
except:
break | 1 | 513,576,772 | null | 5 | 5 |
import sys
sys.setrecursionlimit(1000000)
N = int(input())
X = input()
pc = X.count('1')
if pc == 0:
print(*[1]*N, sep='\n')
exit()
elif pc == 1:
if int(X, 2) == 1:
for i in range(N-1):
print(2)
print(0)
exit()
else:
for i in range(N):
if i == N-1:
print(2)
elif X[i] == '0':
print(1)
else:
print(0)
exit()
mod_plus_1, mod_minus_1 = 0, 0
for i in range(N):
mod_plus_1 = (mod_plus_1*2+int(X[i])) % (pc+1)
mod_minus_1 = (mod_minus_1*2+int(X[i])) % (pc-1)
def f(x):
if x == 0:
return 0
else:
return f(x % bin(x).count('1'))+1
mods_p1, mods_m1 = [1 % (pc+1)], [1 % (pc-1)]
for i in range(N-1):
mods_p1.append(mods_p1[-1]*2 % (pc+1))
mods_m1.append(mods_m1[-1]*2 % (pc-1))
mods_p1 = mods_p1[::-1]
mods_m1 = mods_m1[::-1]
for i in range(N):
if X[i] == '0':
x = mod_plus_1 + mods_p1[i]
x %= (pc+1)
else:
x = mod_minus_1 - mods_m1[i]
x %= (pc-1)
if x == 0:
print(1)
else:
print(f(x)+1)
| #import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
#import heapq
#from fractions import gcd
#input=sys.stdin.readline
import bisect
n=int(input())
x=input()
p=0
for i in x:
if i=="1":
p+=1
rp=0
rq=0
for i in range(n):
if x[i]=="1":
rp+=pow(2,(n-1-i),p+1)
rp%=p+1
if p!=1:
rq+=pow(2,(n-1-i),p-1)
rq%=p-1
else:
rq=pow(2,(n-1-i))
def popcnt1(n):
return bin(n).count("1")
res=[0]*n
for i in range(1,n+1):
res[i-1]=i%popcnt1(i)
for i in range(n):
ans=0
if x[i]=="1":
if p==1:
print(0)
continue
q=rq-pow(2,(n-1-i),p-1)
q%=p-1
while True:
if q==0:
print(1+ans)
break
ans+=1
q=res[q-1]
else:
q=rp+pow(2,(n-1-i),p+1)
q%=p+1
while True:
if q==0:
print(1+ans)
break
ans+=1
q=res[q-1] | 1 | 8,303,090,539,072 | null | 107 | 107 |
a, b = input().split()
str = ''
if int(a)<=int(b):
for _ in range(int(b)):
str += a
else:
for _ in range(int(a)):
str += b
print(str) | X,N = map(int, input().split())
P = list(map(int, input().split()))
min = 51
for i in range(102):
if i not in P and abs(X-i) < min:
min = abs(X-i)
ans = i
print(ans) | 0 | null | 49,219,923,481,760 | 232 | 128 |
N = int(input())
R = [int(input()) for i in range(N)]
maxv = -20000000000
minv = R[0]
for i in range(1, N):
maxv = max(R[i] - minv, maxv)
minv = min(R[i], minv)
print(maxv) | import sys
d = -float('inf')
n = int(input())
l = int(input())
for s in sys.stdin:
r = int(s)
d = max(d, r-l)
l = min(l, r)
print(d)
| 1 | 12,655,554,460 | null | 13 | 13 |
n = int(input())
a = list(map(int, input().split()))
for n in a:
if n % 2 == 0:
if not n % 3 == 0 and not n % 5 == 0:
print("DENIED")
break
else:
print("APPROVED") | MOD = 10 ** 9 + 7
n, k = map(int, input().split())
ans = 0
for x in range(k, n + 2):
p = x * (x - 1) // 2
q = x * (x - 1) // 2 + (n - x + 1) * x
ans += q - p + 1
print(ans % MOD)
| 0 | null | 50,997,401,783,292 | 217 | 170 |
# coding: utf-8
# Your code here!
X,K,D=map(int,input().split())
move=min(abs(X)//D,K)
ans=abs(X)-move*D
if move==K:
print(ans)
else:
if (K-move)%2==0:
print(ans)
else:
print(abs(ans-D)) | S = input()
Q = int(input())
Query = [input() for _ in range(Q)]
inv = False
add = ['','']
for query in Query:
if query[0]=='1':
inv = not inv
else:
add[(query[2] == '1') ^ inv] += query[-1]
ans = add[1][::-1] + S + add[0]
if inv:
ans = ans[::-1]
print(ans)
| 0 | null | 31,169,730,348,810 | 92 | 204 |
# B
z = list(map(int, input().split(" ")))
maxnum = z[0]*z[2]
for i in range(2):
for j in range(2):
x = z[i]
y = z[j+2]
prod = x*y
# print(x, y, prod, maxnum, prod > maxnum)
if prod > maxnum:
maxnum = prod
print(maxnum) | dic = {}
l = []
n = int(input())
for i in range(n):
s = input()
#sが新規キーか否かで操作を変える
if s in dic:
dic[s] += 1
#新規ではないならvalueを1増やす
else:
dic[s] = 1
m = max(dic.values())
for i in dic:
if dic[i] == m:
l += [i]
print(*sorted(l)) | 0 | null | 36,623,807,183,172 | 77 | 218 |
def gcds(*numbers):
from math import gcd
from functools import reduce
return reduce(gcd, numbers)
def resolve():
K = int(input())
ans = 0
import itertools
for i, j, k in itertools.combinations_with_replacement(range(1, K+1), 3):
l = len(set([i, j, k]))
mu = 1
if l == 3:
mu = 6
elif l == 2:
mu = 3
ans += gcds(i, j, k) * mu
print(ans)
if '__main__' == __name__:
resolve() | import math
K = int(input())
ans = 0
for a in range(1, K+1):
for b in range(a, K+1):
for c in range(b, K+1):
s = math.gcd(a, b)
t = math.gcd(s, c)
if a == c:
ans += t
elif (a == b or b == c) and a != c:
ans += 3*t
else:
ans += 6*t
print(ans) | 1 | 35,442,967,522,326 | null | 174 | 174 |
#E
H,N=map(int,input().split())
A=[0 for i in range(N)]
dp=[float("inf") for i in range(10**4+1)]
dp[0]=0
for i in range(N):
a,b=map(int,input().split())
A[i]=a
for j in range(10**4+1):
if j+a>10**4:
break
dp[j+a]=min(dp[j]+b,dp[j+a])
if H+max(A)>10**4:
print(min(dp[H:]))
else:
print(min(dp[H:H+max(A)])) | h, n = map(int, input().split())
magics = [list(map(int, input().split())) for _ in range(n)]
max_a = max(a for a,b in magics)
dp = [0] * (h+max_a)
for i in range(1,h+max_a):
dp[i] = min(dp[i-a]+b for a, b in magics)
print(dp[h]) | 1 | 80,986,412,921,778 | null | 229 | 229 |
s = input().replace('?', 'D')
print(s)
| T = input()
lt = list(T)
for i in range(len(lt)):
if lt[i] == '?':
lt[i] = 'D'
T = ''.join(lt)
print(T) | 1 | 18,371,671,990,308 | null | 140 | 140 |
print(1*(input()[:2]!=input()[:2])) | n=int(input())
s,t=input().split()
ans=str()
for i in range(n):
ans+=s[i]+t[i]
print(ans)
| 0 | null | 118,263,026,559,060 | 264 | 255 |
list = []
a, b, c = map(list.append, raw_input().split())
list = sorted(list)
for i in range(3):
print list[i], | N = int(input())
A = list(map(int, input().split()))
flag = True
for n in A:
if n % 2 == 0 and (n % 3 != 0 and n % 5 != 0):
flag = False
print("APPROVED" if flag else "DENIED")
| 0 | null | 34,826,808,809,056 | 40 | 217 |
n = int(input())
dict = set()
for _ in range(n):
c, s = input().split()
if c == 'insert':
dict.add(s)
else:
print(('no', 'yes')[s in dict])
| if __name__ == '__main__':
try:
n = int(raw_input())
except:
print 'the first input must be integer value!'
exit()
genoms = set([])
answers = []
for _ in range(n):
values = raw_input().split()
order = values[0]
genom = values[1]
if order == "insert":
genoms.add(genom)
else:
# TODO: fasten here!
answers.append('yes' if genom in genoms else 'no' )
# print(genoms)
# print(answers)
for answer in answers:
print answer | 1 | 73,621,658,902 | null | 23 | 23 |
H, A = [int(x) for x in input().split()]
if H % A == 0:
print(H//A)
else:
print(H//A + 1)
| input()
array = input().split()
array.reverse()
print(' '.join(array)) | 0 | null | 38,910,661,194,392 | 225 | 53 |
N, *A = map(int, open(0).read().split())
cur = 0
for i in range(N):
if A[i] == cur + 1:
cur += 1
if cur == 0:
print(-1)
else:
print(N - cur)
| n=int(input())
a=list(map(int,input().split()))
if not 1 in set(a):
print("-1")
exit()
b=1
for i in range(n):
if a[i]==b:
b+=1
print(n-b+1) | 1 | 114,775,506,098,392 | null | 257 | 257 |
def resolve():
N = int(input())
XY = []
for i in range(N):
A = int(input())
xy = [list(map(int, input().split())) for _ in range(A)]
XY.append(xy)
ans = 0
for _bits in range(1<<N):
bits = list(map(int, bin(_bits)[2:].zfill(N)))
unmatch = False
for i in range(N):
if bits[i] == 0:
continue
for x, y in XY[i]:
if bits[x-1] != y:
unmatch = True
break
if unmatch:
break
else:
ans = max(ans, bin(_bits).count('1'))
print(ans)
if '__main__' == __name__:
resolve() | n=int(input())
j=10501
l=[0 for i in range(j)]
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
v=x*x+y*y+z*z+y*x+x*z+z*y
if(v<j):
l[v]+=1
for i in range(n):
print(l[i+1]) | 0 | null | 64,637,482,766,308 | 262 | 106 |
x = [str(s) for s in sorted([int(s) for s in input().split(" ")])]
print(" ".join(x)) | a = input().split()
v = 2
while int(v) >= 1:
if int(a[int(v)-1]) < int(a[int(v)]):
pass
else:
b = int(a[int(v)-1])
a[int(v)-1] = int(a[int(v)])
a[int(v)] = int(b)
v = int(v) - 1
if int(a[1]) < int(a[2]):
pass
else:
b = int(a[1])
a[1] = int(a[2])
a[2] = int(b)
print('%d %d %d' % (int(a[0]),int(a[1]),int(a[2])))
| 1 | 412,912,705,260 | null | 40 | 40 |
N = list(input().split())
A = int(N[0])
b1,b2 = N[1].split('.')
B = int(b1+b2)
prd = list(str(A*B))
ans = 0
if len(prd) < 3:
ans = 0
else:
prd.pop()
prd.pop()
ans = int(''.join(prd))
print(ans)
| from decimal import Decimal
A, B = input().split()
A = Decimal(A)
B = Decimal(B)
ans = int(A * B)
print(ans)
| 1 | 16,574,384,536,002 | null | 135 | 135 |
a,b,k = map(int, input().split())
m = k if a > k else a
a -= m
b -= min(k-m, b)
print(f'{a} {b}') | a, b, k = map(int, input().split())
t_fin = max(0, a - k)
a_fin = max(0, b - (k - (a - t_fin)))
print('{} {}'.format(t_fin, a_fin))
| 1 | 104,028,333,267,628 | null | 249 | 249 |
n = int(input())
lst = []
for i in range(n):
x, l = map(int, input().split())
lst.append((x + l, x - l))
sorted_lst = sorted(lst)
num = 0
ans = n
while True:
tmp = sorted_lst[num][0]
for i in range(num + 1, n):
if tmp > sorted_lst[i][1]:
ans -= 1
else:
num = i
break
if i == n - 1:
num = i
break
if num == n - 1:
break
print(ans) | count = 1
while True:
x = int(input())
if x == 0:
break
print('Case %d: %d' % (count, x))
count += 1
| 0 | null | 45,171,942,471,616 | 237 | 42 |
n = int(input())
s = [input() for i in range(n)]
c0 = 0
c1 = 0
c2 = 0
c3 = 0
for i in range(len(s)):
if s[i] == "AC":
c0 += 1
elif s[i] == "WA":
c1 += 1
elif s[i] == "TLE":
c2 += 1
else:
c3 += 1
print("AC x ", str(c0))
print("WA x ", str(c1))
print("TLE x ", str(c2))
print("RE x ", str(c3)) | import sys
sys.setrecursionlimit(10**9)
f=lambda:map(int,input().split())
n,st,sa=f()
st-=1
sa-=1
g=[[] for _ in range(n)]
for _ in range(n-1):
a,b=f()
g[a-1].append(b-1)
g[b-1].append(a-1)
def dfs(v,p=-1,d=0):
l[v]=d
for c in g[v]:
if c==p: continue
dfs(c,v,d+1)
def dist(s):
global l
l=[0]*n
dfs(s)
return l
lt=dist(st)
la=dist(sa)
m=0
for i in range(n):
if lt[i]<la[i]: m=max(m,la[i])
print(m-1) | 0 | null | 63,035,583,145,052 | 109 | 259 |
import itertools
n = int(input())
tastes = list(map(int, input().split()))
ans_lists = []
for v in itertools.combinations(tastes, 2):
cure = v[0]*v[1]
ans_lists.append(cure)
ans = 0
for i in ans_lists:
ans += i
print(ans) | n,*d=map(int,open(0).read().split())
ans=0
for i in range(n):
for j in range(i+1,n):
ans+=d[i]*d[j]
print(ans) | 1 | 168,816,383,529,408 | null | 292 | 292 |
k = int(input())
s = "1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51"
l = s.split(",")
print(int(l[k-1])) | import sys
mod = 10 ** 9 + 7
N, K = map(int,input().split())
A = list(map(int,input().split()))
A.sort(reverse = True)
if A[0] < 0 and K % 2 == 1:
ans = 1
for i in range(K):
ans *= A[i]
ans %= mod
print(ans)
sys.exit()
l = 0
r = N-1
ans = 1
if K % 2 == 1:
ans *= A[0]
l += 1
for _ in range(K // 2):
if A[l] * A[l+1] > A[r] * A[r-1]:
ans *= A[l] * A[l+1]
ans %= mod
l += 2
else:
ans *= A[r] * A[r-1]
ans %= mod
r -= 2
print(ans) | 0 | null | 29,768,114,303,200 | 195 | 112 |
A,V=map(int,input().split()) #A：鬼
B,W=map(int,input().split()) #B:逃走者
T=int(input())
dis=abs(A-B)
time=V-W #逃走者から見た鬼の秒速(鬼の方が早いとtime>0、それ以外の場合はtime<=0)
if time<=0:
print('NO')
else:
if time*T>=dis:
print('YES')
else:
print('NO')
| a, v = map(int, input().split())
b, w = map(int, input().split())
t = int(input())
if a < b:
if a + v * t >= b + w * t:
print("YES")
else:
print("NO")
else:
if a - v * t <= b - w * t:
print("YES")
else:
print("NO")
| 1 | 15,121,889,273,470 | null | 131 | 131 |
num = []
while True:
l = map(int, raw_input().split())
if l[0] == l[1] == l[2] == -1:
break
if l[0]*l[1] < 0:
num.append("F")
else:
sum = l[0] + l[1]
if sum >= 80:
num.append("A")
elif sum >= 65:
num.append("B")
elif sum >= 50:
num.append("C")
elif sum >= 30:
if l[2] >= 50:
num.append("C")
else:
num.append("D")
else:
num.append("F")
for i in range(len(num)):
print num[i] | # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
error_print(e - s, 'sec')
return ret
return wrap
class Combination:
def __init__(self, n, mod):
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, n + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
self.MOD = mod
self.N = n
self.g1 = g1
self.g2 = g2
self.inverse = inverse
def __call__(self, n, r):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD
@mt
def slv(N, K):
ans = 0
M = 10**9 + 7
C = Combination(N*2+1, M)
def H(n, r):
return C(n+r-1, r)
K = min(N-1, K)
for k in range(K+1):
m = N - k
t = C(N, k) * H(m, k)
ans += t
ans %= M
return ans
def main():
N, K = read_int_n()
print(slv(N, K))
if __name__ == '__main__':
main()
| 0 | null | 34,345,104,795,290 | 57 | 215 |
a = int(input())
print('YNeos'[a<30::2])
| N, M = map(int, input().split())
print('Yes' if N <= M else 'No')
| 0 | null | 44,228,718,729,832 | 95 | 231 |
h,a = map(int,input().split())
ct=h//a
a=h-ct*a
if a>0:
ct+=1
print(ct) | def solve():
h, a = map(int, input().split())
print(-(-h//a))
if __name__ == '__main__':
solve()
| 1 | 76,832,129,861,632 | null | 225 | 225 |
n = int(input())
v = [input() for i in range(n)]
for i in ["AC", "WA", "TLE", "RE"]:
print("{} x {}".format(i, v.count(i))) | 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')) | 0 | null | 78,592,729,025,596 | 109 | 280 |
n = int(input())
s = ["" for i in range(n)]
t = [0 for i in range(n)]
for i in range(n):
a, b = input().split()
s[i], t[i] = a, int(b)
x = input()
ans = 0
flag = False
for i in range(n):
if s[i] == x:
flag = True
elif flag:
ans += t[i]
print(ans) | N = int(input())
l = []
for _ in range(N):
s, t = input().split()
t = int(t)
l.append([s, t])
X = input()
ans = 0
found = False
for s in l:
if found:
ans += s[1]
continue
if s[0] == X:
found = True
print(ans) | 1 | 96,816,005,321,020 | null | 243 | 243 |
n,m=map(int,input().split())
h=list(map(int,input().split()))
c=0
d=[0]*n
for i in range(m):
a,b=map(int,input().split())
d[a-1]=max(d[a-1],h[b-1])
d[b-1]=max(d[b-1],h[a-1])
for i in range(n):
if h[i]>d[i]:
c+=1
print(c) |
k = int(input())
s = str(input())
if len(s) > k:
print(s[:k], end='')
print("...")
else:
print(s)
| 0 | null | 22,254,088,585,120 | 155 | 143 |
from collections import Counter
s = input()
n = len(s)
digits = [int(c) for c in s[::-1]]
a = [0] * (n + 1)
p = 2019
for i, digit in enumerate(digits):
a[i + 1] = (digit * pow(10, i, p) + a[i]) % p
counter = Counter(a)
ans = 0
for count in counter.values():
ans += count * (count - 1) // 2
print(ans) | # -*- coding utf-8 -*-
MOD = 10 ** 9 + 7
r = int(input())
ans = r * r
print(ans)
| 0 | null | 87,812,649,296,370 | 166 | 278 |
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
import itertools
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(int,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
N = I()
ans = [0 for _ in range(10050)]
for i in range(1,100):
for j in range(1,100):
for k in range(1,100):
v = (i+j+k)**2 - (i*j + j*k + k*i)
if v < 10050:
ans[v] += 1
for i in range(N):
print(ans[i+1])
| import sys
sys.setrecursionlimit(200001)
N, M = [int(n) for n in input().split()]
S = input()
p1 = False
x1 = 0
m1 = N
c1 = 0
for n in S:
if n == "1":
if p1:
c1 += 1
else:
c1 = 1
p1 = True
else:
p1 = False
if c1 > 0:
if c1 > x1:
x1 = c1
if c1 < m1:
m1 = c1
def rest(l, ans):
s = M
while s > 0:
if s >= l:
ans.append(l)
return ans
if S[l-s] == "1":
if s == 1:
return -1
s -= 1
continue
l -= s
if rest(l, ans) == -1:
s -= 1
else:
ans.append(s)
return ans
return -1
if x1 > M - 1:
ans = -1
else:
ans = rest(N, [])
if ans == -1:
print(-1)
else:
print(" ".join([str(n) for n in ans])) | 0 | null | 73,312,016,822,840 | 106 | 274 |
N, K = map(int ,input().split())
A = [int(x) for x in input().split()]
checked = [False] * N
root=[0]
idx = 0
checked[0]=True
for k in range(K):
root.append(A[idx]-1)
idx = A[idx]-1
if (checked[idx]):
break
checked[idx]=True
else:
print(idx+1)
exit(0)
for i, r in enumerate(root):
if r == root[-1]:
break
root2=root[i:]
l = len(root2)-1
idx = root2[(K-i)%(l)]
print(idx+1)
| import math
A, B, H, M = list(map(lambda n: int(n), input().split(" ")))
thetaM = 6 * M
thetaH = 30 * H + 0.5 * M
theta = math.radians(180 - abs(abs(thetaH - thetaM) - 180))
print(math.sqrt(A ** 2 + B ** 2 - 2 * A * B * math.cos(theta))) | 0 | null | 21,440,178,066,532 | 150 | 144 |
c = int(input())
n = 0
for i in range(1,10):
if c /i < 10 and c %i ==0:
n += 1
break
ans = 'Yes' if n >= 1 else 'No'
print(ans) | N = int(input())
A = input().split()
num_list = [0] * N
def combination(n):
C = [0]
for i in range(2,n+1):
C.append(int(i*(i-1)/2))
return C
com = combination(N)
sum_com = 0
for i in range(N):
num_list[int(A[i])-1] += 1
for i in range(N):
if num_list[i] == 0:
continue
else:
sum_com += com[num_list[i]-1]
for i in range(N):
print(sum_com - num_list[int(A[i])-1] + 1)
| 0 | null | 103,655,585,690,980 | 287 | 192 |
N, K = map(int, input().split())
S = []
for _ in range(K):
l, r = map(int, input().split())
S.append((l, r))
mod = 998244353
dp = [0] * (N+1)
cumsum_dp = [0] * (N+1)
dp[1] = 1
cumsum_dp[1] = 1
for i in range(2, N+1):
for s in S:
fr = max(0, i-s[1]-1)
to = max(0, i-s[0])
dp[i] += (cumsum_dp[to]-cumsum_dp[fr]) % mod
cumsum_dp[i] = (cumsum_dp[i-1] + dp[i]) % mod
print(dp[N]%mod) | D = int(input())
C = [int(T) for T in input().split()]
S = [[] for TD in range(0,D)]
for TD in range(0,D):
S[TD] = [int(T) for T in input().split()]
Type = 26
Last = [0]*Type
SatD = [0]*D
SatA = [0]*(D+1)
for TD in range(0,D):
Test = int(input())-1
Last[Test] = TD+1
SatD[TD] = S[TD][Test]
for TC in range(0,Type):
SatD[TD] -= C[TC]*(TD+1-Last[TC])
SatA[TD+1] = SatA[TD]+SatD[TD]
print('\n'.join(str(T) for T in SatA[1:])) | 0 | null | 6,290,528,999,924 | 74 | 114 |
#!usr/bin/env python3
import sys
class Die:
def __init__(self, pips):
self.pips = pips
def move_die(self, direction):
tmp = int()
if direction == 'N':
tmp = self.pips[0]
self.pips[0] = self.pips[1]
self.pips[1] = self.pips[5]
self.pips[5] = self.pips[4]
self.pips[4] = tmp
del tmp
elif direction == 'S':
tmp = self.pips[0]
self.pips[0] = self.pips[4]
self.pips[4] = self.pips[5]
self.pips[5] = self.pips[1]
self.pips[1] = tmp
del tmp
elif direction == 'E':
tmp = self.pips[0]
self.pips[0] = self.pips[3]
self.pips[3] = self.pips[5]
self.pips[5] = self.pips[2]
self.pips[2] = tmp
del tmp
elif direction == 'W':
tmp = self.pips[0]
self.pips[0] = self.pips[2]
self.pips[2] = self.pips[5]
self.pips[5] = self.pips[3]
self.pips[3] = tmp
del tmp
def spin_die_clockwise(self):
tmp = self.pips[1]
self.pips[1] = self.pips[2]
self.pips[2] = self.pips[4]
self.pips[4] = self.pips[3]
self.pips[3] = tmp
del tmp
def get_upside(self):
return self.pips[0]
def get_frontside(self):
return self.pips[1]
def get_rightside(self):
return self.pips[2]
def init_die():
pips = [int(pip) for pip in sys.stdin.readline().strip('\n').split()]
die = Die(pips)
return die
def roll_die(die):
directions = list(sys.stdin.readline().strip('\n'))
for direction in directions:
die.move_die(direction)
return die
def main():
die = init_die()
q = int(sys.stdin.readline().strip('\n'))
for question in range(q):
q_pips = [int(pip) for pip in sys.stdin.readline().strip('\n').split()]
if q_pips[0] == die.pips[0]:
pass
elif q_pips[0] == die.pips[1]:
die.move_die('N')
elif q_pips[0] == die.pips[2]:
die.move_die('W')
elif q_pips[0] == die.pips[3]:
die.move_die('E')
elif q_pips[0] == die.pips[4]:
die.move_die('S')
elif q_pips[0] == die.pips[5]:
die.move_die('N')
die.move_die('N')
while die.get_frontside() != q_pips[1]:
die.spin_die_clockwise()
print(die.get_rightside())
if __name__ == '__main__':
main() | import random
class Dice():
def __init__(self):
self.face = [i for i in range(6)]
self.memo = [i for i in range(6)]
def setface(self,initface):
for i in range(6):
self.face[i] = initface[i]
def roll(self,direction):
for i in range(6):
self.memo[i] = self.face[i]
index = {'E':(3,1,0,5,4,2),'N':(1,5,2,3,0,4),'S':(4,0,2,3,5,1),'W':(2,1,5,0,4,3)}
for i in range(6):
self.face[i] = self.memo[index[direction][i]]
def top(self):
return self.face[0]
dice = Dice()
initface = list(map(int,input().split()))
dice.setface(initface)
q = int(input())
for _ in range(q):
u,f = map(int,input().split())
while True:
dice.roll(['E','N','S','W'][random.randint(0,3)])
if dice.face[0]==u and dice.face[1]==f:
print(dice.face[2])
break
| 1 | 258,445,976,792 | null | 34 | 34 |
N = int(input())
count = {}
max_count = 0
for _ in range(N):
s = input()
if s not in count:
count[s] = 0
count[s] += 1
max_count = max(max_count, count[s])
longest = []
for s, c in count.items():
if c == max_count:
longest.append(s)
longest.sort()
for s in longest:
print(s) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
N = int(readline())
XY = np.array(read().split(),np.int64)
X = XY[::2]; Y = XY[1::2]
dx = X[:,None] - X[None,:]
dy = Y[:,None] - Y[None,:]
dist_mat = (dx * dx + dy * dy) ** .5
answer = dist_mat.sum() / N
print(answer) | 0 | null | 108,941,627,754,290 | 218 | 280 |
x=list(input())
print('Yes' if '7' in x else 'No') | a,b,c,d=map(int,input().split())
ac = c/b
cc = -(-a//d)
if ac<=cc:
print('Yes')
else:
print('No') | 0 | null | 31,892,476,890,720 | 172 | 164 |
def main():
X = int(input())
v = 100
ans = 0
while v < X:
ans += 1
v = int(v * 101 // 100)
print(ans)
if __name__ == '__main__':
main()
| N ,M= input().split()
a=[]
N=int(N)
M=int(M)
for i in range(N):
a.append(list(map(int,input().split())))
b=[int(input()) for i in range(M)]
x=[0 for i in range(N)]
for i in range(N):
for j in range(M):
x[i]+=a[i][j]*b[j]
print("\n".join(map(str,x))) | 0 | null | 14,016,785,004,288 | 159 | 56 |
# coding: utf-8
# Your code here!
n = int(input())
m = [1,1]
if n == 0:
print(1)
elif n == 1:
print(1)
else:
for i in range(2, n+1):
m.append( m[i-1] + m[i-2] )
print(m.pop())
| def fib2(n):
a1, a2 = 1, 0
while n > 0:
a1, a2 = a1 + a2, a1
n -= 1
return a1
n = int(input())
print(fib2(n)) | 1 | 2,097,815,838 | null | 7 | 7 |
n = int(input())
s = input().split()
q = int(input())
t = input().split()
c = 0
for i in t:
for j in s:
if i == j:
c += 1
break
print(c)
| S=[]
T=[]
n=int(input())
s=input().split()
for i in range(n):
S.append(s[i])
q=int(input())
t=input().split()
for j in range(q):
T.append(t[j])
cnt=0
for i in range(q):
for j in range(n):
if T[i]==S[j]:
cnt+=1
break
print(cnt)
| 1 | 68,596,443,484 | null | 22 | 22 |
#!/usr/bin/env python3
import sys
input=sys.stdin.readline
mod=998244353
n,k=map(int,input().split())
arr=[list(map(int,input().split())) for i in range(k)]
dp=[0]*(n+1)
dp[1]=1
acum=[0]*(n+1)
for i in range(k):
l,r=arr[i]
if 1+l<=n:
acum[1+l]+=1
if 1+r+1<=n:
acum[1+r+1]-=1
for i in range(2,n+1):
acum[i]+=acum[i-1]
acum[i]%=mod
dp[i]=acum[i]
for j in range(k):
l,r=arr[j]
if i+l<=n:
acum[i+l]+=dp[i]
if i+r+1<=n:
acum[i+r+1]-=dp[i]
print(dp[n]%mod) | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)
INF = 10 ** 9 + 1 # sys.maxsize # float("inf")
MOD = 998244353
def debug(*x):
print(*x, file=sys.stderr)
def solve(N, K, SS):
count = [0] * (N + 10)
count[0] = 1
accum = [0] * (N + 10)
accum[0] = 1
for pos in range(1, N):
ret = 0
for left, right in SS:
start = pos - right - 1
end = pos - left
ret += (accum[end] - accum[start])
ret %= MOD
count[pos] = ret
accum[pos] = accum[pos - 1] + ret
ret = count[N - 1]
return ret % MOD
def main():
# parse input
N, K = map(int, input().split())
SS = []
for i in range(K):
SS.append(tuple(map(int, input().split())))
print(solve(N, K, SS))
# tests
T1 = """
5 2
1 1
3 4
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
4
"""
T2 = """
5 2
3 3
5 5
"""
TEST_T2 = """
>>> as_input(T2)
>>> main()
0
"""
T3 = """
5 1
1 2
"""
TEST_T3 = """
>>> as_input(T3)
>>> main()
5
"""
T4 = """
60 3
5 8
1 3
10 15
"""
TEST_T4 = """
>>> as_input(T4)
>>> main()
221823067
"""
T5 = """
10 1
1 2
"""
TEST_T5 = """
>>> as_input(T5)
>>> main()
55
"""
def _test():
import doctest
doctest.testmod()
g = globals()
for k in sorted(g):
if k.startswith("TEST_"):
doctest.run_docstring_examples(g[k], g, name=k)
def as_input(s):
"use in test, use given string as input file"
import io
f = io.StringIO(s.strip())
g = globals()
g["input"] = lambda: bytes(f.readline(), "ascii")
g["read"] = lambda: bytes(f.read(), "ascii")
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
if sys.argv[-1] == "-t":
print("testing")
_test()
sys.exit()
main()
| 1 | 2,701,525,196,300 | null | 74 | 74 |
a,b=map(int,input().split())
ans=-1
for n in range(10*b,10*(b+1)):
if int(n*1.1)-b == int(n*1.08)-a:
ans=n
break
print(ans)
| A, B = map(int, input().split())
a = [i for i in range(int((A-1)*100/8 ), int((A+1)*100/8 ))]
b = [i for i in range(int((B-1)*100/10), int((B+1)*100/10))]
a = [i for i in a if int(i*0.08) == A]
b = [i for i in b if int(i*0.10) == B]
ans = list(set(a) & set(b))
if ans and min(ans) > 0:
print(min(ans))
else:
print(-1)
| 1 | 56,519,576,147,438 | null | 203 | 203 |
def main():
K, X = map(int, input().split())
if 500 * K >= X:
ans = "Yes"
else:
ans = "No"
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
from string import ascii_uppercase
letters = ascii_uppercase + ascii_uppercase
shift = int(input())
s = input()[:-1]
for char in s: print(letters[letters.index(char) + shift], end = '')
print() | 0 | null | 116,912,241,504,352 | 244 | 271 |
#!/usr/bin/env python
# coding: utf-8
# In[5]:
H,N = map(int, input().split())
A = []; B = []
for _ in range(N):
a,b = map(int, input().split())
A.append(a)
B.append(b)
# In[12]:
a_max = max(A)
dp = [0]*(H+a_max)
for i in range(H+a_max):
dp[i] = min(dp[i-a] + b for a,b in zip(A,B))
print(min(dp[H-1:]))
# In[ ]:
| import sys
input = sys.stdin.readline
H, N = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(N)]
dp = [10**10]*(H+1)
dp[0] = 0
for i in range(H):
for ab in AB:
a,b = ab[0], ab[1]
idx = i+a if i+a < H else H
dp[idx] = min(dp[idx], dp[i]+b)
print(dp[H])
| 1 | 81,216,664,775,272 | null | 229 | 229 |
SIZE=100001; MOD=10**9+7 #998244353 #ここを変更する
SIZE += 1
inv = [0]*SIZE # inv[j] = j^{-1} mod MOD
fac = [0]*SIZE # fac[j] = j! mod MOD
finv = [0]*SIZE # finv[j] = (j!)^{-1} mod MOD
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2,SIZE):
inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD
fac[i] = fac[i-1]*i%MOD
finv[i]= finv[i-1]*inv[i]%MOD
def choose(n,r): # nCk mod MOD の計算
if 0 <= r <= n:
return (fac[n]*finv[r]%MOD)*finv[n-r]%MOD
else:
return 0
# coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
read = sys.stdin.read
n,k = [int(i) for i in readline().split()]
a = [int(i) for i in readline().split()]
a.sort()
ans = 0
for i in range(n):
ans += a[i]*choose(i,k-1)
ans -= a[i]*choose(n-i-1,k-1)
ans %= MOD
print(ans)
| class Node(object):
def __init__(self, num, prv = None, next = None):
self.num = num
self.prv = prv
self.next = next
class DoublyLinkedList(object):
def __init__(self):
self.start = self.last = None
def insert(self, num):
new_element = Node(num)
if self.start is None: # 空の場合
self.start = self.last = new_element
else:
new_element.next = self.start
self.start.prv = new_element
self.start = new_element
def delete(self, target):
it = self.start
while it is not None: # 該当する最初のノードを見つける
if it.num == target:
if it.prv is None and it.next is None: # ノードが一つだけの時
self.start = self.last = None
else:
if it.prv is not None: # 先頭ではない
it.prv.next = it.next
else: # 先頭の場合、先頭の次をstartにする
self.start = self.start.next
if it.next is not None: # 最後ではない場合
it.next.prv = it.prv
else: # 最後の場合、最後の一つ前をlastにする
self.last = self.last.prv
break
it = it.next
def deleteFirst(self):
if self.start is self.last:
self.start = self.last = None
else:
self.start.next.prv = None
self.start = self.start.next
def deleteLast(self):
if self.start is self.last:
self.start = self.last = None
else:
self.last.prv.next = None
self.last = self.last.prv
def contentToArray(self):
n_list = []
it = self.start
while it is not None:
n_list.append(it.num)
it = it.next
return ' '.join(n_list)
def main():
from sys import stdin
N = int(input())
linkedList = DoublyLinkedList() # インスタンス作成
for i in range(N):
command = stdin.readline().rstrip().split()
if command[0] == 'insert':
linkedList.insert(command[1])
elif command[0] == 'delete':
linkedList.delete(command[1])
elif command[0] == 'deleteFirst':
linkedList.deleteFirst()
elif command[0] == 'deleteLast':
linkedList.deleteLast()
print(linkedList.contentToArray())
if __name__ == "__main__":
main()
| 0 | null | 47,815,838,769,080 | 242 | 20 |
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():
N, M = MI()
A = LI()
ans = N - sum(A)
print(-1 if ans < 0 else ans)
if __name__ == '__main__':
solve()
| n, m = map(int,input().split())
lst = list(map(int,input().split()))
x = 0
for i in range(m):
x = x + lst[i]
if (x > n):
print("-1")
else:
print(n - x) | 1 | 31,874,762,622,828 | null | 168 | 168 |
a,b,c,d = map(int,input().split())
A = [a,b]
B = [c,d]
INF = float("INF")
M = -INF
for i in A:
for j in B:
M = max(i*j,M)
print(M) | import math
n, m = map(int, input().split())
if n >= 2:
a = math.factorial(n)/(math.factorial(2)*math.factorial(n-2))
else:
a = 0
if m >= 2:
b = math.factorial(m)/(math.factorial(2)*math.factorial(m-2))
else:
b = 0
print(int(a + b)) | 0 | null | 24,348,451,799,530 | 77 | 189 |
import math
a, b, C = map(int, input().split())
rad_C = math.radians(C)
c = math.sqrt(a ** 2 + b ** 2 - 2 * a * b * math.cos(rad_C))
h = b * math.sin(rad_C)
L = a + b + c
s = a * h / 2
print(s)
print(L)
print(h) | X = int(input())
deposit = 100
y_later = 0
while deposit < X:
y_later += 1
deposit += deposit // 100
print(y_later) | 0 | null | 13,698,166,478,560 | 30 | 159 |
x, y = [int(i) for i in input().split()]
if x < y:
a = x
x = y
y = a
def kouyakusu(x,y):
yakusu = x % y
if yakusu == 0:
print(y)
return y
else:
kouyakusu(y,yakusu)
max_kouyakusu = kouyakusu(x,y) | import math
H, A = [int(i) for i in input().split()]
print(math.ceil(H / A))
| 0 | null | 38,604,283,121,414 | 11 | 225 |
def function(arg):
xyabc, pa, qb, rc = arg.split('¥n')
X,Y,A,B,C = map(int, xyabc.split())
oishisa_A = list(map(int, pa.split()))
oishisa_B = list(map(int, qb.split()))
oishisa_C = list(map(int, rc.split()))
oishisa_A.sort(reverse=True)
oishisa_A = oishisa_A[:X] # at most X
oishisa_B.sort(reverse=True)
oishisa_B = oishisa_B[:Y] # at most Y
oishisa_C.sort(reverse=True)
oishisa = oishisa_A + oishisa_B + oishisa_C
oishisa.sort(reverse=True)
results = 0
for i in range(X+Y):
results += oishisa[i]
return results
if __name__ == '__main__':
xyabc = input()
pa = input()
qb = input()
rc = input()
print(function(xyabc+'¥n'+pa+'¥n'+qb+'¥n'+rc))
| x,y,a,b,c=map(int, input().split())
*p,=map(int, input().split())
*q,=map(int, input().split())
*r,=map(int, input().split())
from heapq import *
p=[-i for i in p]
q=[-i for i in q]
r=[-i for i in r]
heapify(p)
heapify(q)
heapify(r)
ans=0
cnt=0
pt=heappop(p)
qt=heappop(q)
rt=heappop(r)
n=x+y
while (x>=0 or y>=0) and cnt<n:
if rt==0:
if pt<=qt:
ans-=pt
x-=1
cnt+=1
if p and x>0: pt=heappop(p)
else: pt=0
else:
ans-=qt
y-=1
cnt+=1
if q and y>0: qt=heappop(q)
else: qt=0
elif pt<=rt:
ans-=pt
x-=1
cnt+=1
if p and x>0: pt=heappop(p)
else: pt=0
elif qt<=rt:
ans-=qt
y-=1
cnt+=1
if q and y>0: qt=heappop(q)
else: qt=0
else:
ans-=rt
cnt+=1
if r: rt=heappop(r)
else: rt=0
print(ans)
| 1 | 44,987,787,662,274 | null | 188 | 188 |
inputStr = input()
numList = inputStr.split(' ')
numList = [int(x) for x in numList]
#print('a: ',numList[0])
#print('b: ',numList[1])
if numList[0]==numList[1]:
print('a == b')
elif numList[0]>numList[1]:
print('a > b')
elif numList[0]<numList[1]:
print('a < b') | a,b=[int(x) for x in input().split()]
if a < b :
print('a < b')
elif a > b :
print('a > b')
else:
print('a == b')
| 1 | 357,223,038,150 | null | 38 | 38 |
i = raw_input().strip().split()
a = int(i[0])
b = int(i[1])
c = int(i[2])
if a < b and b < c:
print "Yes"
else:
print "No" | a,b,c=map(int, input().split())
0<=a<=100,0<=b<=100,0<=c<=100,
if a<b:
if b<c:
print('Yes')
else:
print('No')
else:
print('No')
| 1 | 391,420,534,202 | null | 39 | 39 |
#coding:utf-8
#1_1_B
def gcd(x, y):
while x%y != 0:
x, y = y, x%y
return y
x, y = map(int, input().split())
print(gcd(x, y)) | def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x % y)
x, y = [int(n) for n in input().split()]
print(gcd(x, y)) | 1 | 7,955,531,132 | null | 11 | 11 |
s = list(input())
k = int(input())
s += '+'
releki = []
cnt = 1
pre = s[0]
for i in range(1,len(s)):
if pre==s[i]:
cnt += 1
else:
releki.append([pre,cnt])
pre = s[i]
cnt = 1
ans = 0
for i in range(len(releki)):
ans += releki[i][1]//2
if len(releki)==1:
print((len(s)-1)*k//2)
exit()
if s[0]!=s[-3]:
print(ans*k)
else:
a = releki[0][1]
b = releki[-1][1]
ans = ans*k - (k-1)*(a//2 +b//2 -(a+b)//2)
print(ans)
| import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
S = list(input())
K = int(input())
leng = len(S)
if len(set(S))==1:
print(K*leng//2)
exit()
if S[0]!=S[-1] or K==1:
last = S[0]
cnt = 0
for s in S[1:]:
if s==last:
cnt += 1
last = '.'
else:
last = s
print(cnt*K)
else:
S += ['.']
cnt = 1
lis = []
last = S[0]
for s in S[1:]:
if s==last:
cnt += 1
else:
lis.append(cnt)
last = s
cnt = 1
first = lis.pop(0)
end = lis.pop()
others = sum([i//2 for i in lis])
ans = first//2 + others*K + (first+end)//2*(K-1)+end//2
print(ans)
| 1 | 175,116,692,458,940 | null | 296 | 296 |
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
from itertools import combinations_with_replacement
INF = float('inf')
def main():
N, M, Q = map(int, readline().split())
abcd = []
for _ in range(Q):
a,b,c,d = map(int, readline().split())
abcd.append([a,b,c,d])
As = combinations_with_replacement(range(1,M+1),N)
ans = 0
for A in As:
score = 0
for a,b,c,d in abcd:
if A[b-1] - A[a-1] == c:
score += d
ans = max(ans, score)
print(ans)
if __name__ == '__main__':
main()
| n, m, q = map(int, input().split())
abcd = []
for _ in range(q):
abcd.append(tuple(map(int, input().split())))
ans = 0
from itertools import combinations_with_replacement
for A in combinations_with_replacement(list(range(1, m+1)), n):
suma = 0
for a,b,c,d in abcd:
if A[b-1] - A[a-1] == c:
suma += d
ans = max(ans, suma)
print(ans)
| 1 | 27,656,965,881,880 | null | 160 | 160 |
n = int(input())
ss = [input() for _ in range(n)]
cnt = {}
ans =0
for s in ss:
if s not in cnt:
cnt[s]=0
ans += 1
print(ans)
| h1, m1, h2, m2, k = map(int, input().split())
st = h1 * 60 + m1
en = h2 * 60 + m2
print(max(0, en - st - k)) | 0 | null | 24,101,567,490,980 | 165 | 139 |
x = int(input())
b,cnt = 100, 0
while True:
a = b
b = b + a // 100
cnt += 1
if b >= x:
break
print(cnt)
| import math
X = int(input())
ans = 0
money = 100 #初期金額
while money < X:
money += money//100
ans += 1
print(ans)
| 1 | 27,155,156,576,792 | null | 159 | 159 |
n, m = map(int, input().split())
days = input().split()
x = 0
for day in days:
x = x + int(day)
if x <= n:
print(n - x)
else:
print(-1) | N, M =map(int,input().split())
A = list(map(int, input().split()))
# x = 宿題をする日の合計
x = sum(A)
if N >= x:
print(N - x)
else:
print("-1")
| 1 | 31,869,197,879,832 | null | 168 | 168 |
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
result = min(a) + min(b)
for _ in range(M):
x, y, c = map(int, input().split())
discount = a[x-1] + b[y-1] - c
result = min(result, discount)
print(result) | def run(s):
'''
'''
print('{}{}'.format(s, 'es' if s[-1] == 's' else 's'))
if __name__ == '__main__':
s = input()
run(s) | 0 | null | 28,255,218,272,632 | 200 | 71 |
from heapq import heappush, heappop
N, M = map(int, input().split())
s = input()
INF = 10**18
dp_cnt = [INF]*(N+1)
dp_next = [0]*(N+1)
dp_cnt[N] = 0
q = [(0,N)]
for i in range(N-1, -1, -1):
while True:
cnt, j = q[0]
if j-i>M:
heappop(q)
else:
break
dp_cnt[i] = cnt
if s[i]=='1':
cnt = INF
j = 0
cnt += 1
heappush(q, (cnt, i))
dp_next[i] = j
if dp_cnt[0]>=INF:
print(-1)
exit()
x = 0
ans = []
while x<N:
y = dp_next[x]
ans += [str(y-x)]
x = y
print(*ans) | # python3.4.2用
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') #無限大
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(sys.stdin.readline()) #整数読み込み
def ifn(): return float(sys.stdin.readline()) #浮動小数点読み込み
def isn(): return sys.stdin.readline().split() #文字列読み込み
def imn(): return map(int, sys.stdin.readline().split()) #整数map取得
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) #整数-1map取得
def fmn(): return map(float, sys.stdin.readline().split()) #浮動小数点map取得
def iln(): return list(map(int, sys.stdin.readline().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, sys.stdin.readline().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')
def sieves_of_e(n):
is_prime = [True] * (n+1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5)+1):
if not is_prime[i]: continue
for j in range(i * 2, n+1, i): is_prime[j] = False
return is_prime
H,W = imn()
s = [input() for _ in range(H)]
dp = [[INF for _ in range(W)] for _ in range(H)]
dp[0][0] = 0
if s[0][0] == '#': dp[0][0] = 1
for i in range(H):
for j in range(W):
if i+1 < H:
cnt = dp[i][j]
if s[i][j] == "." and s[i+1][j] == "#":
cnt += 1
dp[i+1][j] = min(dp[i+1][j], cnt)
if j+1 < W:
cnt = dp[i][j]
if s[i][j] == "." and s[i][j+1] == "#":
cnt += 1
dp[i][j+1] = min(dp[i][j+1], cnt)
print(dp[-1][-1]) | 0 | null | 94,371,345,210,442 | 274 | 194 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
N = int(input())
G = [list(map(lambda x: int(x)-1, input().split()))[2:] for _ in range(N)]
D = [-1]*N
D2 = [-1]*N
def dfs(cur, now):
if D[cur] != -1: return now
now += 1
D[cur] = now
for nex in G[cur]:
now = dfs(nex,now)
now += 1
D2[cur] = now
return now
now = 0
for i in range(N):
now = dfs(i,now)
for i in range(N):
print(i+1,D[i],D2[i])
| time=1
n=int(input())
A=[[] for i in range(n)]
d=[0 for i in range(n)]
f=[0 for i in range(n)]
for i in range(n):
a=list(map(int,input().split()))
for j in range(a[1]):
A[i].append(a[2+j]-1)
def dfs(q,num):
global d,f,time
d[num]=time
for nx in q[num]:
if d[nx]==0:
time+=1
dfs(q,nx)
time+=1
f[num]=time
for i in range(n):
if d[i]==0:#unvisit
dfs(A,i)
time+=1
for i in range(n):
print(i+1,d[i],f[i])
| 1 | 2,615,958,180 | null | 8 | 8 |
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(n):
if ((i+1)*a[i])%2!=0:
ans+=1
print(ans) | import sys
input = sys.stdin.readline
n = int(input())
num = list(map(int, input().split()))
mod = 10**9+7
num = tuple(num)
def gcd(a, b):
while b: a, b = b, a % b
return a
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
lcd = dict()
for i in num:
j = primeFactor(i)
for x,y in j.items():
if not x in lcd.keys():
lcd[x] = y
else:
lcd[x] = max(lcd[x],y)
lc = 1
for i,j in lcd.items():
lc *= pow(i,j,mod)
ans =0
for i in range(n):
ans += lc*pow(num[i], mod-2, mod)
ans %= mod
print(ans) | 0 | null | 47,623,865,473,672 | 105 | 235 |
import sys
import math
import copy
from heapq import heappush, heappop, heapify
from functools import cmp_to_key
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = float("inf")
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def zaatsu(nums):
ref = list(set(copy.copy(nums)))
ref.sort()
dic = dict()
for i, num in enumerate(ref):
dic[num] = i
return [dic[num] for num in nums]
def solve():
n, d, a = getList()
li = []
for i in range(n):
li.append(getList())
li.sort()
ichi = [x[0] for x in li]
imos = [0] * n
cur = 0
ans = 0
for i, (x, h) in enumerate(li):
cur -= imos[i]
hp = h - cur * a
if hp <= 0:
continue
thr = hp // a
if hp % a != 0:
thr += 1
ans += thr
cur += thr
owari = bisect_right(ichi, x + 2 * d)
if owari != n:
imos[owari] += thr
print(ans)
def main():
n = getN()
for _ in range(n):
solve()
return
if __name__ == "__main__":
# main()
solve()
| from operator import itemgetter
from bisect import bisect_right
n, d, a = map(int, input().split())
monster = [tuple(map(int, input().split())) for _ in range(n)]
monster.sort(key=itemgetter(0))
xx = [xi for xi, hi in monster]
ans = 0
imos = [0] * (n + 1)
for i, (xi, hi) in enumerate(monster):
hi -= imos[i]
if hi > 0:
c = (hi + a - 1) // a
ans += c
idx = bisect_right(xx, xi + 2 * d)
imos[i] += c * a
imos[idx] -= c * a
# update imos
imos[i + 1] += imos[i]
print(ans)
| 1 | 82,560,075,206,492 | null | 230 | 230 |
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N = getN()
divisors = []
def make_divisors(n):
for i in range(1, int(math.sqrt(n)) + 1):
a, b = 0, 0
if n % i == 0:
a = i
b = n // i
divisors.append([a, b])
make_divisors(N)
ans = float('inf')
for i in divisors:
a, b = i
ans = min(ans, a + b - 2)
print(ans) | n=int(input())
a=1
ans=n
while a*a<=n:
if n%a==0:
ans=min(a+n//a-2,ans)
a+=1
print(ans) | 1 | 162,022,610,903,648 | null | 288 | 288 |
N = int(input())
X = list(map(int, input().split()))
ans = [0] * (N + 1)
for v in X:
ans[v] += 1
print(*ans[1:], sep="\n")
| n = int(input())
a = list(map(int, input().split()))
menber = [0]*n
for value in a:
menber[value-1] += 1
for i in menber:
print(i) | 1 | 32,600,282,223,740 | null | 169 | 169 |
# https://atcoder.jp/contests/ddcc2020-qual/tasks/ddcc2020_qual_c
# 横で切り分けてから、いちごが無い行は上の行のをコピる
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
rr = range
def read_ints():
return list(map(int, read().split()))
def read_map_as_int(H):
'''
#→1,.→0として読み込む
'''
ret = []
for _ in range(H):
ret.append([1 if s == '#' else 0 for s in read()[:-1]])
# 内包表記はpypyでは若干遅いことに注意
# #numpy使うだろうからこれを残しておくけど
return ret
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from fractions import gcd
c = 0
def ret_row(s: list):
ret = [-1] * W
l = 0
global c
for r, ss in enumerate(s):
if ss == 1:
c += 1
for j in rr(l, r + 1):
ret[j] = c
l = r + 1
for j in rr(l, W):
ret[j] = c
# assert -1 not in ret # あとで消す
return ret
H, W, K = read_ints()
S = read_map_as_int(H)
ans = []
for s in S:
if 1 not in s:
ans.append([-1] * W)
else:
ans.append(ret_row(s))
if ans[0][0] == -1:
i = 0
while ans[i][0] == -1:
i += 1
for j in rr(W):
ans[0][j] = ans[i][j]
for i in rr(1, H):
if ans[i][0] != -1:
continue
for j in rr(W):
ans[i][j] = ans[i - 1][j]
for a in ans:
print(*a)
| H,W,K,*s = open(0).read().split()
H = int(H)
W = int(W)
K = int(K)
ans = [[0] * W for _ in range(H)]
using = 0
unpainted = -1
for i in range(H):
appeared = -1
for j in range(W):
if s[i][j] == '#':
if appeared < 0:
appeared = 1
using += 1
for k in range(j+1):
ans[i][k] = using
else:
using += 1
ans[i][j] = using
else:
if appeared > 0:
ans[i][j] = using
if appeared < 0:
if using > 0:
ans[i] = ans[i-1]
else:
unpainted += 1
if unpainted >= 0:
for i in range(unpainted,-1,-1):
ans[i] = ans[i+1]
for x in ans:
print(*x)
| 1 | 143,609,186,583,392 | null | 277 | 277 |
MOD = 10**9 + 7
N = 10**6 # 10**6が限界
factorial_mod = [1, 1] # factrial_mod[i] := i! mod p
modular_multiplicative_inverse = [0, 1] # モジュラ逆数 := i^(-1) ≡ x (mod p) となるx
factorial_inverse_mod = [1, 1] # factrial_inverse_mod[i] := (i!)^(-1) mod p
for i in range(2, N + 1): # O(N)
factorial_mod.append((factorial_mod[i - 1] * i) % MOD)
modular_multiplicative_inverse.append((-modular_multiplicative_inverse[MOD % i] * (MOD // i)) % MOD)
factorial_inverse_mod.append((factorial_inverse_mod[i-1] * modular_multiplicative_inverse[i]) % MOD)
def nCr_mod(n, r):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return factorial_mod[n] * factorial_inverse_mod[r] * factorial_inverse_mod[n - r] % MOD
def nPr_mod(n, r):
return factorial_mod[n] * factorial_inverse_mod[n - r] % MOD
# ---------------------- #
n, k = (int(x) for x in input().split())
ans = 0
for i in range(min(n - 1, k) + 1):
# nCi * n-iHi = nCi * n-1Ci
ans += nCr_mod(n, i) * nCr_mod(n - 1, i)
ans %= MOD
print(ans)
| N, K = map(int, input().split())
MOD = 1000000007
fact = [0] * (N+1)
finv = [0] * len(fact)
inv = [0] * len(fact)
fact[0] = fact[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, len(fact)):
fact[i] = fact[i-1] * i % MOD
# inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
inv[i] = - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
nCr = lambda n, r: fact[n] * finv[n-r] * finv[r] % MOD
nHr = lambda n, r: nCr(n+r-1, r)
# ans = 0
# for i in range(min(N-1, K) + 1):
# ans += nCr(N, i) * nHr(N-i, i)
# ans = sum(nCr(N, i) * nHr(N-i, i) for i in range(min(N-1, K) + 1))
ans = sum(nCr(N, i) * nCr(N-1, i) for i in range(min(N-1, K) + 1))
print(ans % MOD) | 1 | 67,012,693,039,838 | null | 215 | 215 |
h,w,k = map(int, input().split())
s = []
st = 0
zero = [0 for i in range(h)]
z = 0
for i in range(h):
t = input()
st += t.count('#')
zero[i] = t.count('#')
s.append(t)
cake = 0
ans = [[0 for j in range(w)] for i in range(h)]
for i in range(h):
if zero[i] == 0:
continue
cake += 1
t = 0
for j in range(w):
if s[i][j] == '#':
t += 1
if t >= 2:
cake += 1
ans[i][j] = cake
for i in range(h-1):
if zero[i+1] != 0:
continue
if ans[i][0] == 0:
continue
for j in range(w):
ans[i+1][j] = ans[i][j]
for i in range(h-1,0,-1):
if zero[i-1] != 0:
continue
for j in range(w):
ans[i-1][j] = ans[i][j]
for i in range(h):
print (*ans[i]) | h,w,k = map(int,input().split())
lst = []
cut1 = []
for i in range(h):
l = input()
if '#' in l:
cut1.append(i)
lst.append(l)
res = [[float('inf')]*w for _ in range(h)]
cut2 = []
for c in cut1:
tmp_cut = []
for j in range(len(lst[c])):
if lst[c][j]=='#':
tmp_cut.append(j)
cut2.append(tmp_cut)
cnt = 1
for e,i in enumerate(cut1):
for j in cut2[e]:
res[i][j] = cnt
cnt += 1
for r in res:
mn = min(r)
mx = max(r)
if (mn==mx) and (mn==float('inf')):
pass
else:
mx = max(set(r) - {float('inf')})
if mn==mx:
for i in range(w):
if r[i] == float('inf'):
r[i] = mn
else:
for i in range(w):
if r[i] == float('inf'):
r[i] = mn
else:
mn = min(mx, r[i])
for i in range(w):
tmp = []
for j in range(h):
if res[j][i] != float('inf'):
tmp.append(res[j][i])
num = min(tmp)
for j in range(h):
if res[j][i] == float('inf'):
res[j][i] = num
else:
num = res[j][i]
for r in res:
print(*r) | 1 | 143,760,152,805,324 | null | 277 | 277 |
inps = input().split()
if len(inps) >= 2:
a = int(inps[0])
b = int(inps[1])
if a > b:
print("a > b")
elif a < b:
print("a < b")
else:
print("a == b")
else:
print("Input illegal.") | input_list = map(int, raw_input().split())
ineq = ""
if input_list[0] < input_list[1]:
ineq = "<"
elif input_list[0] > input_list[1]:
ineq = ">"
else:
ineq = "=="
print "a %s b" % (ineq) | 1 | 355,200,939,170 | null | 38 | 38 |
#!/usr/bin/env python3
def main():
N, M = map(int, input().split())
A = [int(x) for x in input().split()]
if N >= sum(A):
print(N - sum(A))
else:
print(-1)
if __name__ == '__main__':
main()
| from math import gcd
K = int(input())
sum = 0
for a in range(1, K+1):
for b in range(1, K+1):
p = gcd(a, b)
for c in range(1, K+1):
sum += gcd(p, c)
print(sum) | 0 | null | 33,834,082,423,410 | 168 | 174 |
import sys
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))#might need to remove the -1
def invr():
return(map(int,input().split()))
d, t, s = invr()
if d/s<=t:
print('Yes')
else:
print('No') | N,A,B = map(int,input().split())
dif = abs(A-B)
if(dif%2 == 0):
ans = dif//2
else:
A1_diff = A-1
#B1_diff = B-1
#AN_diff = N-A
BN_diff = N-B
ans = min(A1_diff, BN_diff)+1+(dif-1)//2
print(ans) | 0 | null | 56,739,262,455,370 | 81 | 253 |
x = int(input())
n = x // 100
if n * 105 >= x:
print(1)
else:
print(0) | X=int(input())
i=0
while True:
if 100*i<=X and X<=105*i:
print(1)
exit()
elif 105*i<X and X<100*(i+1):
print(0)
exit()
i+=1
| 1 | 127,721,848,877,060 | null | 266 | 266 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
A = LI()
d = {}
for x in A:
for i in range(2,int(math.sqrt(x))+1):
cnt = 0
while x % i == 0:
cnt += 1
x //= i
if cnt:
if i in d:
d[i] = max(d[i],cnt)
else:
d[i] = cnt
if x == 1: break
else:
if x in d:
d[x] = max(d[x],1)
else:
d[x] = 1
m = 1
for i,x in d.items():
m = (m * i ** x) % MOD
ans = 0
for x in A:
ans += (m * pow(x,MOD-2,MOD)) % MOD
print(ans % MOD)
if __name__ == '__main__':
main() | import math
N = int(input())
A = list(map(int, input().split()))
mod = 10**9+7
primes = [0]*(10**6+1)
def prime_fac(n):
temp = n
Flag = True
for i in range(2, int(math.sqrt(n)) + 1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
primes[i] = max(primes[i], cnt)
Flag = False
if temp != 1:
primes[temp] = max(primes[temp], 1)
if Flag:
primes[n] = max(primes[n], 1)
for a in A:
prime_fac(a)
LCM = 1
for p, i in enumerate(primes):
if i:
LCM *= pow(p, i, mod)
LCM %= mod
ans = 0
for a in A:
ans += LCM * pow(a, mod-2, mod) % mod
ans %= mod
print(ans) | 1 | 87,877,150,745,062 | null | 235 | 235 |
x = int(input())
money = 100
cnt = 0
while x > money:
money += money//100
cnt += 1
print(cnt)
| #!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def solve(N: int, P: "List[int]"):
ans = 0
l = INF
for pi in P:
l = min(l, pi)
if pi <= l:
ans += 1
return ans
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
P = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
print(f'{solve(N, P)}')
if __name__ == '__main__':
main()
| 0 | null | 56,162,437,682,688 | 159 | 233 |
from collections import deque
n = int(input())
l = deque()
for _ in range(n):
command = input().split()
if command[0] == "insert":
l.appendleft(command[1])
elif command[0] == "delete":
try:
ind = l.remove(command[1])
except ValueError:
pass
elif command[0] == "deleteFirst":
l.popleft()
elif command[0] == "deleteLast":
l.pop()
print (" ".join(l)) | # coding: utf-8
N,P = list(map(int, input().split()))
S = '0'+input()
#N=200000
#P=9893
#S= '0'+'1234567890' * 20000
if (P==2)|(P==5):
sum=0
for i in range(N, 0, -1):
if int(S[i]) % P == 0:
sum+= i
print(sum)
else:
dp1 = [0] * (N+1)
dp2 = [0] * (N+1)
dp3 = [0] * P
dp1[N] = int(S[N]) % P
dp3[int(dp1[N])] += 1
k = 1
for i in range(N - 1, 0, -1):
dp1[i] = (dp1[i + 1] + (int(S[i]) * 10 * k)) % P
dp3[int(dp1[i])] += 1
k = (k * 10) % P
sum = 0
for i in range(P):
if i == 0:
sum += (dp3[i] * (dp3[i] - 1)) // 2 + dp3[i]
continue
if dp3[i] == 0: continue
sum += (dp3[i] * (dp3[i] - 1)) // 2
print(int(sum))
| 0 | null | 29,264,262,546,332 | 20 | 205 |
import math
import numpy
a,b,c = map(int, input().split())
d = c - a - b
if d > 0 and d*d > 4 * a * b:
print("Yes")
else:
print("No")
| import sys
input = sys.stdin.readline
n = int(input())
a_ord = ord('a')
s = ["a"]
ans = []
def dfs(s):
max_ord = a_ord
for i in s:
max_ord = max(max_ord, ord(i))
for i in range(a_ord, max_ord + 2):
t = s[:]
t.append(chr(i))
if len(t) == n:
ans.append("".join(t))
else:
dfs(t)
if n == 1:
print('a')
else:
dfs(s)
ans.sort()
for w in ans:
print(w) | 0 | null | 51,813,054,382,530 | 197 | 198 |
x,k,d = list(map(int,input().split()))
x = abs(x)
point =x % d
num = x//d
if num<k:
rest = k - num
if rest%2==0:
pass
else:
point = d -point
else:
point = x - k*d
print(point) | from functools import reduce
N = int(input())
A = [int(n) for n in input().split()]
X = reduce(int.__xor__, A)
ans = [X^a for a in A]
print(*ans) | 0 | null | 8,881,397,948,812 | 92 | 123 |
def main():
n = int(input())
A = []
for _ in range(n):
x, l = map(int, input().split())
A.append([x - l, x + l])
A.sort(key = lambda x: x[1])
ans, lmax = 0, -10 ** 11
for a in A:
if lmax <= a[0]:
ans += 1
lmax = a[1]
print(ans)
if __name__ == '__main__':
main()
| import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import floyd_warshall
n, m, l = map(int, input().split())
INF = 1 << 60
# 距離のmatrixを作る
dist = [[INF] * n for _ in range(n)]
# 対角行列の成分は０
for i in range(n):
dist[i][i] = 0
# 燃料の最大値より小さい場合に辺が張れる
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
if c > l:
continue
dist[a][b] = c
dist[b][a] = c
# 全点間の最短距離を求める
dist = floyd_warshall(csr_matrix(dist))
# 初期状態を１にする。燃料が足りない経路は迂回したいのでINFを置いておく
dist2 = np.full_like(dist, 1)
dist2[np.where(dist > l)] = INF
# 足し込むことで何回給油するべきかがわかる
dist2 = floyd_warshall(dist2, directed=False)
dist2 = dist2.astype(int)
# 無限大の経路は辿れない。-1を出力したいので０を置いていく
dist2[dist2 == INF] = 0
q = int(input())
# 初期状態を１としているので、１を引いて答えとする
ans = []
for _ in range(q):
s, t = map(int, input().split())
ans.append(dist2[s - 1, t - 1] - 1)
print(*ans, sep="\n") | 0 | null | 131,658,975,226,912 | 237 | 295 |
A,B,C,K = map(int,input().split())
Current_Sum = 0
if K <= A :
ans = K
elif K <= (A + B):
ans = A
else:
K -= (A + B)
ans = A - K
print(ans)
| N = int(input())
S = list()
for i in range(N):
S.append(input())
judge = ['AC', 'WA', 'TLE', 'RE']
count = [0] * 4
for i in range(N):
letter = S[i]
ind = judge.index(letter)
count[ind] += 1
for i in range(len(judge)):
print(judge[i], "x", str(count[i]))
| 0 | null | 15,294,967,750,720 | 148 | 109 |
import sys
stdin = sys.stdin
def main():
N = int(stdin.readline().rstrip())
A = list(map(int,stdin.readline().split()))
mod = 10**9+7
ans = 0
for i in range(61):
bits = 0
for x in A:
if (x>>i)&1:
bits += 1
ans += ((bits*(N-bits))* 2**i) %mod
ans %= mod
print(ans)
main() | N = int(input())
A = list(map(int, input().split()))
MOD = 10**9+7
num_one_for_digit = [0]*61
for i in range(N):
b = bin(A[i])[2:].zfill(61)
for d in range(61):
if b[d] == "1":
num_one_for_digit[d] += 1
ans = 0
t = 1
for d in range(60, -1, -1):
n_1 = num_one_for_digit[d]
ans += n_1 * (N - n_1) * t % MOD
ans %= MOD
t *= 2
print(ans%MOD) | 1 | 122,540,491,274,982 | null | 263 | 263 |
import sys
n=int(input())
for i in range(n):
list=input().split()
list=[int(j) for j in list]
list.sort()
if list[0]*list[0]+list[1]*list[1]==list[2]*list[2]:
print("YES")
else:print("NO") | A,B,C = input().split()
A = int(A)
B = int(B)
C = int(C)
if A == B == C :
print('No')
elif A == B :
print('Yes')
elif B == C :
print('Yes')
elif C == A :
print('Yes')
elif A == B == C :
print('No')
else :
print('No') | 0 | null | 34,040,750,103,776 | 4 | 216 |
N = int(input())
A = list(map(int, input().split()))
s = sum(A)
av = s / 2
x = 0
y = 0
for i in range(N):
x += A[i]
if x < av < x +A[i+1]:
y = s - x - A[i+1]
if x > y:
print(A[i+1]-x+y)
else:
print(A[i+1]-y+x)
elif x == av:
print(0) | n,x,t=[int(i) for i in input().split()]
k=n//x
if n%x:
print((k+1)*t)
else:
print(k*t) | 0 | null | 73,538,803,704,530 | 276 | 86 |
if int(input()) % 9 == 0:
print("Yes")
else:
print("No") | N = input()
sum = 0
for i in range(10):
sum += N.count(str(i)) * i
print('Yes' if sum%9 == 0 else 'No') | 1 | 4,351,558,877,248 | null | 87 | 87 |
bil_date = []
flag = 0
for i in range(4):
bil_date.append([[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0]])
all_date_amo = int(input())
for i in range(all_date_amo):
date = [int(indate) for indate in input().split()]
bil_date[date[0]-1][date[1]-1][date[2]-1] = bil_date[date[0]-1][date[1]-1][date[2]-1] + date[3]
if bil_date[date[0]-1][date[1]-1][date[2]-1] < 0:
bil_date[date[0]-1][date[1]-1][date[2]-1] = 0
if bil_date[date[0]-1][date[1]-1][date[2]-1] > 9:
bil_date[date[0]-1][date[1]-1][date[2]-1] = 9
for bil in bil_date:
for flo in bil:
for room in flo:
print(' {}'.format(room),end='')
print('')
if flag == 3:
pass
else:
for i in range(20):
print('#',end='')
print('')
flag = flag + 1
| x, y, a, b, c = map(int, input().split())
red = list(map(int, input().split()))
green = list(map(int, input().split()))
colorless = list(map(int, input().split()))
red.sort(reverse = True)
green.sort(reverse = True)
colorless.sort(reverse = True)
ret = red[:x] + green[:y]
ret.sort()
for i in range(len(colorless)):
if ret[i] < colorless[i]:
ret[i] = colorless[i]
else:
break
print(sum(ret)) | 0 | null | 22,808,497,864,152 | 55 | 188 |
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**8)
def geta(fn=lambda s: s.decode()):
return map(fn, readline().split())
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def main():
k, x = geta(int)
if k * 500 >= x:
print('Yes')
else:
print("No")
if __name__ == "__main__":
main() | 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
s = int(input())
mod = 10 **9 + 7
N = s
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
l = s//3
ans = 0
if s <= 2:
print(0)
else:
for i in range(l):
ans += cmb(s%3 + 3 * i +(l-i)-1, (l-i)-1,mod)
print(ans%mod) | 0 | null | 50,776,248,491,408 | 244 | 79 |
N,K,C = map(int, input().split())
S = input()
w = []
for i in range(len(S)):
if S[i]=="o":
w.append(i)
# print(w)
# early date
early = []
tmpwd = -1
for i in range(len(w)):
if len(early) >= K:
continue
if tmpwd<0:
tmpwd = w[i]
elif w[i]>tmpwd+C:
tmpwd = w[i]
else:
continue
early.append(w[i])
# print(early)
# later date
late = []
tmpwd = -1
for i in reversed(range(len(w))):
if len(late)>=K:
continue
if tmpwd < 0:
tmpwd = w[i]
elif w[i] < tmpwd-C:
tmpwd = w[i]
else:
continue
late.append(w[i])
wd = set(early) & set(late)
early.sort()
late.sort()
# print(early,late)
for i in range(K):
if early[i]==late[i]:
print(early[i]+1) | import math
def f_gcd(a, b):
return math.gcd(a, b)
k = int(input())
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
for c in range(1, k+1):
ans += f_gcd(math.gcd(a, b), c)
print(ans) | 0 | null | 38,102,908,667,252 | 182 | 174 |
S,T=[input() for i in range(2)]
U=list(S)
W=list(T)
if S in T and len(S)+1==len(T) and U[0]==W[0]:
print("Yes")
else:
print("No") | a, b, c = list(map(int, input().split()))
if a == b == c:
print('No')
elif a == b:
print('Yes')
elif b == c:
print('Yes')
elif a == c:
print('Yes')
else:
print('No')
| 0 | null | 44,604,966,672,420 | 147 | 216 |
#coding:utf-8
def seki(a, b):
c = []
gou = 0
d = []
for i in range(len(a)):
for j in range(len(b[0])):
for k in range(len(b)):
gou += a[i][k] * b[k][j]
d.append(gou)
gou = 0
c.append(d)
d=[]
return c
n, m, l = [int(i) for i in input().rstrip().split()]
a = [list(map(int , input().rstrip().split())) for i in range(n)]
b = [list(map(int , input().rstrip().split())) for i in range(m)]
c = seki(a,b)
for i in c:
print(" ".join(list(map(str,i)))) | import sys
N, M, L = map(int, raw_input().split())
a = []
b = []
for n in range(N):
a.append(map(int, raw_input().split()))
for m in range(M):
b.append(map(int, raw_input().split()))
c = [[0 for l in xrange(L)] for n in xrange(N)]
for n in xrange(N):
for l in xrange(L):
for m in xrange(M):
c[n][l] += a[n][m] * b[m][l]
for n in xrange(N):
for l in xrange(L-1):
sys.stdout.write(str(c[n][l])+" ")
print c[n][L-1] | 1 | 1,436,865,693,688 | null | 60 | 60 |
n,m,k = map(int,input().split())
def cmb(n, r, mod):#コンビネーションの高速計算
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 998244353 #出力の制限
N = n #Nの最大値
g1 = [0]*(N+1) #元テーブル(p(n,r))
g1[0] = g1[1] = 1
g2 = [0]*(N+1) #逆元テーブル
g2[0] = g2[1] = 1
inverse = [0]*(N+1) #逆元テーブル計算用テーブル
inverse[0],inverse[1] = 0,1
for i in range(2,N+1):
g1[i] = (g1[i-1] * i) % mod
inverse[i] = (-inverse[mod % i] * (mod//i)) % mod
g2[i] = (g2[i-1] * inverse[i]) % mod
# i組 -> m * (n-1)Ci * (m-1)^(n-1-i)
ans = 0
for i in range(k+1):
ans += m * cmb(n-1,i,mod) * pow(m-1,n-1-i,mod)
ans %= mod
print(ans) | # coding: utf-8
def solve(*args: str) -> str:
n, m, k = map(int, args[0].split())
mod = 998244353
if m == 1 and n-1 == k:
return str(1)
ncr = 1
p = m*pow(m-1, n-1, mod) % mod
ret = p
iR = [1]*(k+1)
im = pow(m-1, mod-2, mod)
for i in range(1, k+1):
iR[i] = max(1, (-(mod//i) * iR[mod % i]) % mod)
ncr = (ncr * (n-i)*iR[i]) % mod
p = (p*im) % mod
ret += p*ncr % mod
return str(ret % mod)
if __name__ == "__main__":
print(solve(*(open(0).read().splitlines())))
| 1 | 23,155,491,438,910 | null | 151 | 151 |
n,a,b=map(int, input().split())
if (b-a)%2==0:
print((b-a)//2)
else:
print(min(a+(b-a-1)//2, n-b+1+(b-a-1)//2)) | X = int(input())
if 30 <= X:
print('Yes')
else:
print('No') | 0 | null | 57,459,796,132,710 | 253 | 95 |