code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
import math
a,b,C=map(float,input().split())
S = a*b*math.sin(C*math.pi/180)/2
c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(C*math.pi/180))
h = 2*S/a
print("{:10f}".format(S))
print("{:10f}".format(a+b+c))
print("{:10f}".format(h))
| import math
a, b, C=map(int,input().split())
S=a*b*math.sin(math.pi*C/180)/2
c=math.sqrt(a**2+b**2-2*a*b*math.cos(math.pi*C/180))
L=a+b+c
h=2*S/a
print('{:.4f}'.format(S))
print('{:.4f}'.format(L))
print('{:.4f}'.format(h))
| 1 | 180,988,553,688 | null | 30 | 30 |
x, y = map(int, input().split())
for i in range(1, x+1):
if (4*i + 2*(x - i) == y) or (2*i + 4*(x - i) == y):
print("Yes")
exit()
print("No") | a=0
X,Y=map(int,input().split())
for i in range(X+1):
for j in range(X+1-i):
if 2*i+j*4==Y and i+j==X:
a=1
if a==1:
print('Yes')
else:
print('No') | 1 | 13,856,129,590,800 | null | 127 | 127 |
p, q = 0, 1
for x in map(int, input()):
p, q = min(p + x, q + 10 - x), min(p + x + 1, q + 9 - x)
print(p)
| import sys
def main():
input=sys.stdin.readline
S=input().strip()
dp=[[0,0] for i in range(len(S)+1)]
dp[0][1]=1
for i in range(1,len(S)+1):
for j in (0,1):
if j==0:
dp[i][0]=min(dp[i-1][0]+int(S[i-1]),dp[i-1][1]+10-int(S[i-1]))
elif j==1:
dp[i][1]=min(dp[i-1][0]+int(S[i-1])+1,dp[i-1][1]+10-int(S[i-1])-1)
print(dp[len(S)][0])
if __name__=="__main__":
main() | 1 | 70,878,926,081,622 | null | 219 | 219 |
import bisect
N=int(input())
arr=list(map(int,input().split()))
arr.sort()
ans=0
for i in range(N-2):
for j in range(i+1,N-1):
k=bisect.bisect_left(arr,arr[i]+arr[j])
if k>j:
ans+=k-j-1
else:
pass
print(ans) | N, K = map(int, input().split())
# all selected
upper = sum(range(N+1))
lower = sum(range(N+1))
answer = 1
for k in range(N, K - 1, -1):
upper -= N - k
lower -= max(0, k)
answer += upper - lower + 1
# print(k, upper, lower, answer)
print(answer % (10 ** 9 + 7)) | 0 | null | 102,662,956,792,160 | 294 | 170 |
class BalancingTree:
def __init__(self, n):
self.N = n
self.root = self.node(1<<n, 1<<n)
def append(self, v):# v を追加（その時点で v はない前提）
v += 1
nd = self.root
while True:
if v == nd.value:
# v がすでに存在する場合に何か処理が必要ならここに書く
return 0
else:
mi, ma = min(v, nd.value), max(v, nd.value)
if mi < nd.pivot:
nd.value = ma
if nd.left:
nd = nd.left
v = mi
else:
p = nd.pivot
nd.left = self.node(mi, p - (p&-p)//2)
break
else:
nd.value = mi
if nd.right:
nd = nd.right
v = ma
else:
p = nd.pivot
nd.right = self.node(ma, p + (p&-p)//2)
break
def leftmost(self, nd):
if nd.left: return self.leftmost(nd.left)
return nd
def rightmost(self, nd):
if nd.right: return self.rightmost(nd.right)
return nd
def find_l(self, v): # vより真に小さいやつの中での最大値（なければ-1）
v += 1
nd = self.root
prev = 0
if nd.value < v: v = nd.value
while True:
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return prev - 1
else:
prev = nd.value
if nd.right:
nd = nd.right
else:
return prev - 1
def find_r(self, v): # vより真に大きいやつの中での最小値（なければRoot）
v += 1
nd = self.root
prev = 0
while True:
if v < nd.value:
prev = nd.value
if nd.left:
nd = nd.left
else:
return prev - 1
else:
if nd.right:
nd = nd.right
else:
return prev - 1
@property
def max(self):
return self.find_l((1<<self.N)-1)
@property
def min(self):
return self.find_r(-1)
def delete(self, v, nd = None, prev = None): # 値がvのノードがあれば削除（なければ何もしない）
v += 1
if not nd: nd = self.root
if not prev: prev = nd
while v != nd.value:
prev = nd
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return
else:
if nd.right:
nd = nd.right
else:
return
if (not nd.left) and (not nd.right):
if nd.value < prev.value:
prev.left = None
else:
prev.right = None
elif not nd.left:
if nd.value < prev.value:
prev.left = nd.right
else:
prev.right = nd.right
elif not nd.right:
if nd.value < prev.value:
prev.left = nd.left
else:
prev.right = nd.left
else:
nd.value = self.leftmost(nd.right).value
self.delete(nd.value - 1, nd.right, nd)
def __contains__(self, v: int) -> bool:
return self.find_r(v - 1) == v
class node:
def __init__(self, v, p):
self.value = v
self.pivot = p
self.left = None
self.right = None
k = (500000+1).bit_length()
dic = {}
for i in range(97, 123):
dic[chr(i)] = BalancingTree(k)
n = int(input())
s = input()
lst = []
for i in range(n):
lst.append(s[i])
dic[s[i]].append(i)
ans = []
q = int(input())
for _ in range(q):
que = input()
if que[0] == '1':
kind, i, c = que.split()
i = int(i) - 1
dic[lst[i]].delete(i)
dic[c].append(i)
lst[i] = c
else:
kind, l, r = map(int, que.split())
l -= 2; r -= 1
temp = 0
for key in dic.keys():
if dic[key].find_r(l) <= r:
temp += 1
ans.append(temp)
for i in ans:
print(i) | class SegTree:
def __init__(self, init_val, ide_ele, segfunc):
self.n = len(init_val)
self.num =2**(self.n-1).bit_length()
self.ide_ele = ide_ele
self.seg = [self.ide_ele]*2*self.num
self.segfunc = segfunc
#set_val
for i in range(self.n):
self.seg[i+self.num-1] = init_val[i]
#built
for i in range(self.num-2,-1,-1) :
self.seg[i] = segfunc(self.seg[2*i+1], self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k+1:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res = self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res, self.seg[p])
if q&1 == 1:
res = self.segfunc(res, self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res, self.seg[p])
else:
res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])
return res
import sys
input = sys.stdin.readline
N = int(input())
S = input()
L = [-1]*N
for i in range(N):
L[i] = 2**(ord(S[i]) - ord('a'))
def segfunc(a,b):
return a | b
Seg = SegTree(L,0,segfunc)
Q = int(input())
for _ in range(Q):
q,a,b = input().split()
if q == '1':
i = int(a)-1
c = 2**(ord(b) - ord('a'))
Seg.update(i,c)
elif q=='2':
l = int(a)-1
r = int(b)-1
X = Seg.query(l,r+1)
tmp = 0
for j in range(30):
if X%2==1:
tmp += 1
X//=2
print(tmp) | 1 | 62,238,291,811,820 | null | 210 | 210 |
from collections import deque
def readinput():
n = int(input())
commands = []
for i in range(n):
command = input().split()
commands.append(command)
return n,commands
def main(n,commands):
l = deque([])
for i in range(n):
command = commands[i]
if (command[0]=='insert'):
op = command[1]
l.appendleft(op)
elif(command[0]=='delete'):
op = command[1]
try:
l.remove(op)
except:
pass
elif(command[0]=='deleteFirst'):
l.popleft()
elif(command[0]=='deleteLast'):
l.pop()
else:
pass
#print(' '.join(l))
return l
def main2():
n = int(input())
l = deque([])
for i in range(n):
command = input().split()
if (command[0]=='insert'):
op = command[1]
l.appendleft(op)
elif(command[0]=='delete'):
op = command[1]
try:
l.remove(op)
except:
pass
elif(command[0]=='deleteFirst'):
l.popleft()
elif(command[0]=='deleteLast'):
l.pop()
else:
pass
#print(' '.join(l))
return l
if __name__=='__main__':
#n, commands=readinput()
#ans = main(n,commands)
ans = main2()
print(' '.join(ans))
| from collections import deque
n = int(input())
dll = deque()
for i in range(n):
command = input().split()
if command[0] == 'insert':
dll.appendleft(command[1])
elif command[0] == 'delete':
try:
dll.remove(command[1])
except:
pass
elif command[0] == 'deleteFirst':
dll.popleft()
else:
dll.pop()
print(*dll) | 1 | 51,882,601,760 | null | 20 | 20 |
s = input()
t = input()
print("Yes" if s == t[:len(t) - 1] else "No") | from collections import defaultdict
N = int(input())
As = list(map(int, input().split()))
l_count = defaultdict(int)
r_count = defaultdict(int)
for i, A in enumerate(As):
l_count[i + A] += 1
r_count[i - A] += 1
ans = 0
for k, lv in l_count.items():
rv = r_count[k]
ans += lv * rv
print(ans) | 0 | null | 23,750,080,486,058 | 147 | 157 |
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy
A, B = map(int, input().split())
print(max(0, A - 2 * B)) | from sys import stdin
a, b = [int(x) for x in stdin.readline().rstrip().split()]
print(a - 2*b if a-2*b > 0 else 0) | 1 | 166,781,118,725,610 | null | 291 | 291 |
import math
x = int(input())
initial = 100
count = 0
while initial < x:
initial += initial//100
count += 1
print(count) | s = str(raw_input())
p = str(raw_input())
i = 0
while(1):
if i == len(s):
print "No"
break
if i+len(p) >= len(s):
str = s[i:len(s)] + s[0:len(p)-len(s[i:len(s)])]
else:
str = s[i:i+len(p)]
if str == p:
print "Yes"
break
else:
i += 1 | 0 | null | 14,470,258,893,260 | 159 | 64 |
import collections
n = int(input())
num_list = list(map(int, input().split()))
all = 0
c = collections.Counter(num_list)
for i in c:
all += c[i]*(c[i]-1)//2
for k in range(n):
print(all - c[num_list[k]] + 1) | N = int(input())
A = list(map(int,input().split()))
d = {}
for a in A:
if a in d:
d[a] += 1
else:
d[a] = 1
#print(d)
s = 0
for k in d:
s += d[k] * (d[k] - 1) // 2
#print("s=",s)
for i in range(N):
t = d[A[i]]
#print("t=",t)
print(s - t * (t - 1) // 2 + (t - 1) * (t - 2) // 2) | 1 | 47,735,986,220,272 | null | 192 | 192 |
x = int(input())
ans = 0
while True:
ans += 1
if ans*x % 360 == 0:
break
print(ans)
| import math
X = int(input())
g = math.gcd(360, X)
l = X*360//g
print(l // X)
| 1 | 13,132,066,565,620 | null | 125 | 125 |
import re
W = input()
T = []
count = 0
while(1):
line = input()
if (line == "END_OF_TEXT"):
break
words = list(line.split())
for word in words:
T.append(word)
for word in T:
matchOB = re.fullmatch(W, word.lower())
if matchOB:
count += 1
print(count) | def main():
N = int(input())
S = input()
ans = 0
# password = set()
# for i in range(N - 2):
# for j in range(i + 1, N - 1):
# for k in range(10):
# if str(k) in S[j + 1:]:
# password.add(S[i] + S[j] + str(k))
for i in range(10):
for j in range(10):
for k in range(10):
i_index = S.find(str(i))
j_index = S.find(str(j), i_index + 1)
k_index = S.find(str(k), j_index + 1)
if i_index != -1 and j_index != -1 and k_index != -1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 65,487,019,726,480 | 65 | 267 |
from collections import deque
k = int(input())
q = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
cnt = 0
while q:
curr = q.popleft()
cnt += 1
if cnt == k:
break
if curr % 10 == 9:
q.append(curr * 10 + curr % 10 - 1)
q.append(curr * 10 + curr % 10)
elif curr % 10 == 0:
q.append(curr * 10 + curr % 10)
q.append(curr * 10 + curr % 10 + 1)
else:
q.append(curr * 10 + curr % 10 - 1)
q.append(curr * 10 + curr % 10)
q.append(curr * 10 + curr % 10 + 1)
print(curr) | k = int(input())
from collections import deque
d = deque()
c = 0
for i in range(1, 10):
d.append(i)
while True:
tmp = d.popleft()
c += 1
if c == k:
ans = tmp
break
if tmp % 10 != 0:
d.append(tmp * 10 + (tmp % 10 - 1))
d.append(tmp * 10 + tmp % 10)
if tmp % 10 != 9:
d.append(tmp * 10 + (tmp % 10 + 1))
print(ans)
| 1 | 39,994,894,446,908 | null | 181 | 181 |
s = input()
t = s[::-1]
cnt = 0
for i, j in zip(s, t):
if i != j:
cnt += 1
print(cnt // 2) | S=input()
h=len(S)//2
l=S[0:h]
r=S[h:]
Rr=r[::-1]
ans=0
for i in range(h):
if l[i]==Rr[i]:
pass
else:
ans+=1
print(ans) | 1 | 120,417,521,598,752 | null | 261 | 261 |
n, k = map(int, input().split())
snukes = []
for _ in range(k):
okashi = int(input())
snukes += [int(v) for v in input().split()]
target = 1
cnt = 0
l = list(set(snukes))
s = [int(v) for v in range(1, n + 1)]
for p in s:
if p not in l:
cnt += 1
print(cnt) | n = input()
S = [int(x) for x in raw_input().split()]
q = input()
T = [int(x) for x in raw_input().split()]
C = 0
for i in T:
for j in S:
if i==j:
C += 1
break
print C | 0 | null | 12,261,607,248,092 | 154 | 22 |
import math
x1, y1, x2, y2 = map(float, input().split())
l = math.sqrt((math.fabs(x1-x2))*(math.fabs(x1-x2))+(math.fabs(y1-y2))*(math.fabs(y1-y2)))
print('%.4f'% l) | import math
x1, y1, x2, y2 = list(map(float, input().split(' ')))
print("{0:.4f}".format(math.sqrt((x1 - x2)**2 + (y1 - y2)**2)))
| 1 | 152,622,607,072 | null | 29 | 29 |
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) | n, k = map(int, input().split())
MOD = 1000000007
def combinations(n, r, MOD):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * fact_inv[r] * fact_inv[n - r] % MOD
fact = [1, 1]
fact_inv = [1, 1]
inv = [0, 1]
for i in range(2, n + 1):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
fact_inv.append((fact_inv[-1] * inv[-1]) % MOD)
s = 0
for num_zero in range(min(k + 1, n)):
# nCz
x = combinations(n, num_zero, MOD)
# n-zCx
y = combinations(n - 1, n - num_zero - 1, MOD)
s += (x * y) % MOD
print(s % MOD)
| 0 | null | 35,102,331,465,120 | 77 | 215 |
n = int(input())
p = tuple(map(int,input().split()))
q = tuple(map(int,input().split()))
import itertools
li = [i for i in range(1,n+1)]
li2 = list(itertools.permutations(li))
cnt = 0
for i in li2:
cnt +=1
if i == p:
a = cnt
if i == q:
b = cnt
print(abs(a-b)) | from Queue import Queue
n, q = [ int( val ) for val in raw_input( ).split( " " ) ]
names = Queue( )
times = Queue( )
for i in range( n ):
name, time = raw_input( ).split( " " )
names.put( name )
times.put( int( time ) )
qsum = 0
output = []
while not times.empty( ):
name = names.get( )
time = times.get( )
if time <= q:
qsum += time
output.append( "{:s} {:d}".format( name, qsum ) )
else:
times.put( time - q )
names.put( name )
qsum += q
print( "\n".join( output ) ) | 0 | null | 50,472,707,076,672 | 246 | 19 |
s = input()
t = input()
print(sum([1 for a,b in zip(list(s), list(t)) if a != b])) | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2, log
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
from decimal import Decimal
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10**9 + 7
from decimal import *
N = INT()
L = LIST()
L.sort()
ans = 0
for i in range(N-2):
a = L[i]
for j in range(i+1, N-1):
b = L[j]
idx = bisect_left(L, a+b) - 1
if j < idx:
ans += idx - j
print(ans)
| 0 | null | 90,859,755,614,342 | 116 | 294 |
while True:
max,sum=map(int,input().split())
if max==0 and sum==0:
break
cnt=0
for i in range(1,max+1):
for j in range(i+1,max+1):
for k in range(j+1,max+1):
if i+j+k==sum:
cnt+=1
print(cnt) | # coding: utf-8
# Here your code !
def func():
data=[]
while(True):
try:
line=[ int(item) for item in input().rstrip().split(" ") ]
if(line == [0,0]):
break
data.append(line)
except EOFError:
break
except:
return inputError()
left=1
numbers=3
[print(len(sumcombination(left,line[0],numbers,line[1]))) for line in data]
def sumcombination(left,right,numbers,total):
'''
left ~ right??????????????°??????(numbers)????????´??°???????¨????total?????????????????????????????????????????????
'''
result=[]
if(numbers==1):
if( (left <= total) and (right >= total) ):
result=[total]
return(result)
for i in range(left,right+1):
if( numbers == 2):
if(i >= total-i):
break
elif( (i != total-i) and (left <= total-i) and (right >= total-i) ):
result.append([i,total-i])
elif( ( len( range(i,right+1) ) < numbers ) or ( sum( range(i+1,i+numbers) ) > total-i ) ):
break
elif( sum( range(right-numbers+2,right+1) ) < total-i ):
continue
else:
sub = sumcombination(i+1,right,numbers-1,total-i)
if(len(sub)>0):
[items.insert(0,i) for items in sub]
result.extend(sub)
return(result)
def inputError():
print("input error")
return -1
func() | 1 | 1,281,243,225,822 | null | 58 | 58 |
num = int(input())
data = list()
for i in range(1,10):
for j in range(1, 10):
data.append(i*j)
if num in data:
print('Yes')
else:
print('No') | N = int(input())
A = list(map(int, input().split()))
sum_A = sum(A)
sum_now = 0
cost = 99999999999
for a in A:
sum_now += a
cost = min(cost, abs(sum_now - (sum_A - sum_now)))
print(cost)
| 0 | null | 151,077,028,319,468 | 287 | 276 |
import sys
from collections import deque
import bisect
def input():
return sys.stdin.readline().rstrip()
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
A.sort()
# print(A)
pp = int(bisect.bisect_left(A, 0))
A_minus = deque(A[:pp])
A_plus = deque(A[pp:])
AA = deque([])
AAm = deque([])
if N == K:
ans = 1
for i in A:
ans *= i
ans %= mod
print(ans % mod)
elif K % 2 == 0:
ans = 1
while len(A_minus) >= 2:
a1 = A_minus.popleft()
a2 = A_minus.popleft()
AAm.append(a1 * a2)
while len(A_plus) >= 2:
a1 = A_plus.pop()
a2 = A_plus.pop()
AA.append(a1 * a2)
for i in range(K // 2):
if len(AAm) == 0:
temp = AA.popleft()
elif len(AA) == 0:
temp = AAm.popleft()
elif AAm[0] > AA[0]:
temp = AAm.popleft()
else:
temp = AA.popleft()
ans *= temp
ans %= mod
print(ans % mod)
elif len(A_plus) == 0:
ans = 1
for i in range(K):
ans *= A_minus.pop()
ans %= mod
print(ans % mod)
else:
ans = A_plus.pop()
while len(A_minus) >= 2:
a1 = A_minus.popleft()
a2 = A_minus.popleft()
AAm.append(a1 * a2)
while len(A_plus) >= 2:
a1 = A_plus.pop()
a2 = A_plus.pop()
AA.append(a1 * a2)
for i in range(K // 2):
if len(AAm) == 0:
temp = AA.popleft()
elif len(AA) == 0:
temp = AAm.popleft()
elif AAm[0] > AA[0]:
temp = AAm.popleft()
else:
temp = AA.popleft()
ans *= temp
ans %= mod
print(ans % mod)
if __name__ == "__main__":
main()
| mod=10**9+7
n,k=map(int,input().split())
A=list(map(int,input().split()))
K=k
B,C=[],[]
for i in A:
if i>=0:B.append(i)
else:C.append(i)
B.sort()
C.sort(key=lambda x:abs(x))
ans,flag=1,1
while k!=0:
if k>=2:
point=0
if len(B)>=2 and len(C)>=2:
if B[-1]*B[-2]>C[-1]*C[-2]:
ans *=B.pop()
point=1
else:ans *=C.pop()*C.pop()
elif len(B)>=2:ans *=B.pop()*B.pop()
elif len(C)>=2:ans *=C.pop()*C.pop()
else:flag=0
k -=2-point
else:
if len(B)>=1:ans *=B.pop()
else:flag=0
k -=1
ans %=mod
if flag:print(ans)
else:
ans=1
A=sorted(A,key=lambda x:abs(x))
for i in range(K):
ans *=A[i]
ans %=mod
print(ans) | 1 | 9,515,508,492,292 | null | 112 | 112 |
n,k=map(int,input().split())
r,s,p=map(int,input().split())
t=input()
t2 = [[] for _ in range(k)]
score = [0]*n
for i,c in enumerate(t):
t2[i%k].append(c)
score = {'r':p,'s':r,'p':s}
total = 0
for t3 in t2:
if len(t3)==0: continue
if len(t3)==1:
total += score[t3[0]]
continue
for i in range(len(t3)-1):
if t3[i] == 'e': continue
total += score[t3[i]]
if t3[i] == t3[i+1]:
t3[i+1]='e'
if t3[-1] != 'e':
total += score[t3[-1]]
print(total)
| x, y = [ int(i) for i in input().split()]
if x > y:
x, y = y, x
while True:
if x % y:
x, y = y, x % y
continue
break
print(y)
| 0 | null | 53,467,232,874,918 | 251 | 11 |
import pprint
N = int(input())
A = list(map(int, input().split()))
def student_sorting(N, A):
student_list = [0] * N
for initial_pos, activity in enumerate(A):
student_list[initial_pos] = (activity, initial_pos)
return sorted(student_list, reverse = True)
def DP(N, student_list):
DP_map = list(list(0 for row in range(N + 1 - column)) for column in range(N + 1))
ans_list = []
ans = 0
for left in range(N): #初期値設定 right = 0
activity = student_list[left][0]
distance_l = abs(left - student_list[left][1])
DP_map[left + 1][0] = DP_map[left][0] + activity * distance_l
for right in range(N): #初期値設定 left = 0
activity = student_list[right][0]
distance_r = abs((N - 1 - right) - student_list[right][1])
DP_map[0][right + 1] = DP_map[0][right] + activity * distance_r
for left in range(1, N + 1):
for right in range(1, N - left + 1):
activity = student_list[left + right - 1][0]
distance_l = abs((left - 1) - student_list[left + right - 1][1])
distance_r = abs((N - right) - student_list[left + right - 1][1])
score_if_appended_to_left = DP_map[left - 1][right] + activity * distance_l
score_if_appended_to_right = DP_map[left][right - 1] + activity * distance_r
DP_map[left][right] = max(score_if_appended_to_left, score_if_appended_to_right)
for left in range(N + 1):
row = N - left
column = left
ans_list.append(DP_map[column][row])
ans = max(ans_list)
return ans
student_list = student_sorting(N, A)
ans = DP(N, student_list)
print(ans)
| def POW(x, n, mod): #xのn乗をmodで割った際の余りの高速計算
ans = 1
while n > 0:
if n % 2 == 1:
ans *= x%mod
x = (x*x)%mod
n >>= 1 #ビットシフト
return ans
if __name__ == '__main__':
N, K = map(int, input().split())
lst = [0] * (K+1)
mod = 10 ** 9 + 7
ans = 0
for i in range(K):
k = K - i
n = K // k
v = POW(n,N,mod)
m = 2
while(m * k <= K):
v -= lst[m*k]
if v < 0:
v += mod
m += 1
lst[k] = v
v = (k * v)%mod
ans = (ans+v)%mod
print(int(ans)) | 0 | null | 35,383,600,123,520 | 171 | 176 |
import sys
from decimal import Decimal as D, ROUND_FLOOR
def resolve(in_):
x = D(next(in_))
year = 0
deposit = D('100')
rate = D('1.01')
a = D('1.')
while deposit < x:
year += 1
deposit *= rate
deposit = deposit.quantize(a, rounding=ROUND_FLOOR)
return year
def main():
answer = resolve(sys.stdin)
print(answer)
if __name__ == '__main__':
main() | import math
X = int(input())
N = 100
t = 0
while N<X:
t+=1
N = N*101//100
print(t)
| 1 | 26,986,593,498,788 | null | 159 | 159 |
N = input()
l = len(N)
# print(N[l-1])
k = N[l-1]
if k == '2' or k == '4' or k == '5' or k == '7' or k == '9':
print('hon')
elif k == '0' or k == '1' or k == '6' or k == '8':
print('pon')
elif k == '3':
print('bon') | N = str(input())
if int(N[-1])==3:
print('bon')
elif int(N[-1]) in [0, 1, 6, 8]:
print('pon')
else:
print('hon')
| 1 | 19,372,227,321,492 | null | 142 | 142 |
[a,b,c] = map(int,input().split())
n = 0
i = a
while i <= b:
if c % i == 0:
n += 1
i += 1
print(n) | N = int(input())
if N == 2:
print(1)
exit()
S = set([N-1])
lst = [N]
i = 2
while i*i <= N-1:
if (N-1) % i == 0:
S.add(i)
S.add((N-1)//i)
i += 1
i = 2
while i*i < N:
if N % i == 0:
lst.append(i)
lst.append(N//i)
i += 1
if i*i == N:
lst.append(i)
lst.sort()
for l in lst:
if l in S:
continue
_N = N
while _N % l == 0:
_N //= l
if _N % l == 1:
S.add(l)
print(len(S)) | 0 | null | 20,896,029,418,880 | 44 | 183 |
r, g, b = map(int, input().split())
k = int(input())
for i in range(k):
if r >= g:
g *= 2
elif g >= b:
b *= 2
print('Yes' if r < g < b else 'No')
| #!/usr/bin/env python3
import collections as cl
import sys
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def main():
bingo_num = []
for i in range(3):
N = LI()
bingo_num.append(N)
N = II()
for i in range(N):
b = II()
for row_i in range(3):
for col_j in range(3):
if bingo_num[row_i][col_j] == b:
bingo_num[row_i][col_j] = 0
for i in range(3):
if sum(bingo_num[i]) == 0:
print("Yes")
exit()
for j in range(3):
if bingo_num[0][j] + bingo_num[1][j] + bingo_num[2][j] == 0:
print("Yes")
exit()
sum_naname = 0
sum_naname_2 = 0
for i in range(3):
sum_naname += bingo_num[i][i]
sum_naname_2 += bingo_num[i][2 - i]
if sum_naname == 0 or sum_naname_2 == 0:
print("Yes")
exit()
print("No")
main()
| 0 | null | 33,254,415,242,808 | 101 | 207 |
import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
A = A1 * T1 + A2 * T2
B = B1 * T1 + B2 * T2
if A1 < B1 and A < B:
print(0)
return
if A1 > B1 and A > B:
print(0)
return
if A == B:
print("infinity")
return
# T1 + T2 分後にできる差
diff = abs(A - B)
if T1 * abs(A1 - B1) % diff == 0:
ans = T1 * abs(A1 - B1) // diff * 2
else:
ans = T1 * abs(A1 - B1) // diff * 2 + 1
print(ans)
if __name__ == "__main__":
main()
| T1,T2,A1,A2,B1,B2=map(int, open(0).read().split())
C1,C2=A1-B1,A2-B2
if C1<0: C1,C2=-C1,-C2
Y1=C1*T1
Y2=Y1+C2*T2
if Y2>0:
print(0)
elif Y2==0:
print("infinity")
else:
print(1+Y1//(-Y2)*2-(Y1%(-Y2)==0)) | 1 | 131,272,683,114,420 | null | 269 | 269 |
N = int(input())
l = []
for i in range(N):
l.append(input())
l.sort()
a = l[0]
k = [1]
n = [str(l[0])]
for i in range(1,N):
if a == l[i]:
k[-1] += 1
else:
a = l[i]
k.append(1)
n.append(l[i])
m = max(k)
ans = []
for i in range(len(k)):
if k[i] == m:
ans.append(n[i])
ans.sort()
for i in range(len(ans)):
print(ans[i]) | n = int(input())
A = list(enumerate(list(map(int, input().split()))))
A.sort(key=lambda x:x[1])
ans = []
for i in A: ans.append(str(i[0]+1))
print(" ".join(ans)) | 0 | null | 125,314,302,213,320 | 218 | 299 |
n, m = map(int, input().split())
from collections import deque
l = deque([i for i in range(1, n + 1)])
if n % 2 ==0:
for i in range(1, m + 1):
a, b = l.popleft(), l.pop()
if (b - a) == n / 2 or (len(l) < n // 2 and (b-a) % 2 == 1):
b = l.pop()
print(a, b)
else:
for i in range(1, m + 1):
print(i, n - i) | import sys
H, W, K = map(int, input().split())
S = [list(sys.stdin.readline().strip()) for _ in range(H)]
i = 0
j = 0
ichigo = False
no = False
for i in range(H):
j = 0
if len(set(S[i])) == 1 and "." in S[i]:
no = True
continue
while j < W:
if S[i][j] == ".":
S[i][j] = str(K)
else:
if ichigo is True:
j -= 1
K -= 1
ichigo = False
else:
S[i][j] = str(K)
ichigo = True
j += 1
ichigo = False
K -= 1
if no is True:
for i in range(H):
if S[i][0] != ".":
tmp = i
for i in reversed(range(tmp)):
if S[i][0] == ".":
for j in range(W):
S[i][j] = S[i + 1][j]
for i in range(tmp + 1, H):
if S[i][0] == ".":
for j in range(W):
S[i][j] = S[i - 1][j]
for i in range(H):
print(*S[i])
| 0 | null | 85,899,386,583,812 | 162 | 277 |
# ####################################################################
# import io
# import sys
# _INPUT = """\
# 1001
# 1079
# 432
# 12 5 2
# cabbabaacaba
# 10 2 3
# abccabaabb
# """
# sys.stdin = io.StringIO(_INPUT)
####################################################################
import sys
def p(*_a):
return
_s=" ".join(map(str,_a))
#print(_s)
sys.stderr.write(_s+"\n")
####################################################################
yn = lambda b: print('Yes') if b else print('No')
####################################################################
N = int(input())
NO = ":("
a = (N-1) // 1.08
for i in range(100):
b = a + i
if int(b * 1.08) == N:
print( int(b) )
exit()
print(NO)
| n=int(input())
for x in range(n+1):
if x*108//100==n:
print(x)
break
else:
print(":(") | 1 | 125,425,605,700,960 | null | 265 | 265 |
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
X1 = T1 * (A1 - B1)
X2 = T2 * (A2 - B2)
D = X1 + X2
if D == 0:
print("infinity")
else:
if X1 < 0:
X1, X2 = [-X1, -X2]
else:
D = -D
if D < 0:
print("0")
else:
if X1 % D == 0:
print((X1 // D) * 2)
else:
print((X1 // D) * 2 + 1)
|
#atcoder
t1,t2=map(int,input().split())
a1,a2=map(int,input().split())
b1,b2=map(int,input().split())
d1=a1-b1
d2=a2-b2
if d1*d2>0:
print(0)
else:
if d1>0 and d2<0:
plus=d1*t1+d2*t2
if plus>0:
print(0)
elif plus==0:
print("infinity")
elif plus<0:
d=-plus
k=d1*t1
if k%d==0:
print(2*k//d)
else:
print(2*(k//d)+1)
else:
d1=-d1
d2=-d2
plus=d1*t1+d2*t2
if plus>0:
print(0)
elif plus==0:
print("infinity")
elif plus<0:
d=-plus
k=d1*t1
if k%d==0:
print(2*k//d)
else:
print(2*(k//d)+1)
| 1 | 131,663,247,745,588 | null | 269 | 269 |
n, k = map(int, input().split())
p = list(map(int, input().split()))
for i in range(n):
p[i] = (p[i] + 1) / 2
ans = sum(p[:k])
pre = sum(p[:k])
for j in range(k, n):
pre = pre + p[j]- p[j - k]
ans = max(ans, pre)
print(ans) | n = int(input())
result = [input() for i in range(n)]
print('AC x ' + str(result.count("AC")))
print('WA x ' + str(result.count("WA")))
print('TLE x ' + str(result.count("TLE")))
print('RE x ' + str(result.count("RE"))) | 0 | null | 41,927,098,130,372 | 223 | 109 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(k-1, n-1):
print("Yes" if a[i+1] > a[i-k+1] else "No") | n = int(input())
if n < 10:
print(n)
quit()
count = [[0] * 10 for _ in range(10)]
for i in range(1, 10):
count[i][i] = 1
d = 1
for i in range(10, n + 1):
if i % (d * 10)== 0:
d *= 10
h = i // d
f = i % 10
count[h][f] += 1
ans = 0
for i in range(10):
for j in range(10):
ans += count[i][j] * count[j][i]
print(ans) | 0 | null | 46,965,926,136,048 | 102 | 234 |
import queue
n = int(input())
graph = {}
for _ in range(n):
i = list(map(int,input().split()))
graph[i[0]] = i[2:]
dist = [-1 for i in range(n)]
todo = queue.Queue()
seen = set()
dist[0] = 0
todo.put(1)
while (not todo.empty()):
now = todo.get()
for nx in graph[now]:
if (dist[nx-1] != -1):
continue
dist[nx-1] = dist[now-1] + 1
todo.put(nx)
for i in range(n):
print(i+1, dist[i])
| import math
import string
import collections
from collections import Counter
from collections import deque
from decimal import Decimal
import sys
import fractions
def readints():
return list(map(int, input().split()))
def nCr(n, r):
return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))
def has_duplicates2(seq):
seen = []
for item in seq:
if not(item in seen):
seen.append(item)
return len(seq) != len(seen)
def divisor(n):
divisor = []
for i in range(1, n+1):
if n % i == 0:
divisor.append(i)
return divisor
# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
n = int(input())
g = [None]*n
for i in range(n):
g[i] = readints()
# print(g)
G = [None]*n
for i in range(n):
G[i] = []
# print(G)
for i in range(n):
if len(g[i]) >= 3:
for j in range(2, len(g[i])):
# print(g[i][j])
G[i].append(g[i][j])
#print('G', G)
dist = [-1]*n
dist[0] = 0
d = deque()
d.append(0)
# print(d)
while(len(d) != 0):
v = d.popleft()
if G[v] != []:
for nv in G[v]:
if dist[nv-1] != -1:
continue
dist[nv-1] = dist[v]+1
d.append(nv-1)
for i in range(n):
print(i+1, dist[i])
| 1 | 4,471,357,120 | null | 9 | 9 |
from collections import deque
N = int(input())
A = sorted([(int(j),i) for i, j in enumerate(input().split())])[::-1]
d = deque([(0,0)])
dp = [[0 for _ in range(N + 1)] for _ in range(N + 1)]
while(len(d)>0):
i, j = d.pop()
if i + j > N - 1:
continue
tmp = dp[i][j] + A[i+j][0] * abs(A[i+j][1] - i)
if tmp > dp[i+1][j]:
if dp[i+1][j] == 0:
d.appendleft((i+1,j))
dp[i+1][j] = tmp
tmp = dp[i][j] + A[i+j][0] * abs(A[i+j][1] - N + j + 1)
if tmp > dp[i][j+1]:
if dp[i][j+1] == 0:
d.appendleft((i,j+1))
dp[i][j+1] = tmp
ans = -1
for i in range(N):
for j in range(N):
if dp[i][j] > ans:
ans = dp[i][j]
print(ans) |
class Bit:
""" used for only int(>=0)
1-indexed (ignore 0-index)
"""
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
self.depth = n.bit_length()
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def lower_bound(self, x):
""" 累積和がx以上になる最小のindexと、その直前までの累積和 """
sum_ = 0
pos = 0
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k <= self.size and sum_ + self.tree[k] < x:
sum_ += self.tree[k]
pos += 1 << i
return pos + 1, sum_
def get_less_than_x_cnt(self, x):
""" 累積和がx未満 の個数 """
lb_pos, lb_sum = self.lower_bound(x)
return lb_pos-1
def get_less_than_and_x_cnt(self, x):
""" 累積和がx以下 の個数 """
lb_pos, lb_sum = self.lower_bound(x+1)
return lb_pos-1
def get_more_than_x_cnt(self, x):
""" 累積和がxより大きい 個数 """
return self.size - self.get_less_than_and_x_cnt(x)
def main():
n = int(input())
s = list(input())
q = int(input())
ql = []
for _ in range(q):
num,a,b = map(str, input().split())
ql.append((num,a,b))
alp_d = {chr(ord('a') + i): Bit(n) for i in range(26)}
for i, si in enumerate(s):
alp_d[si].add(i+1,1)
for query in ql:
a,b,c = query
if a == '1':
b = int(b)
before = s[b-1]
alp_d[before].add(b, -1)
alp_d[c].add(b,1)
s[b-1] = c
else:
l,r = int(b),int(c)
cnt = 0
for v in alp_d.values():
if v.sum(r)-v.sum(l-1) > 0:
cnt += 1
print(cnt)
if __name__ == "__main__":
main() | 0 | null | 48,044,306,115,402 | 171 | 210 |
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
x,k,d = map(int,readline().split())
x = abs(x)
if (x >= k*d):
print(x-k*d)
elif ((k-x//d)%2):
print(abs(x%d-d))
else:
print(x%d)
| x,k,d = map(int,input().split())
min_p = abs(x)//d
min_n = min_p + 1
rest_p = abs(x)- d*min_p
rest_n = rest_p - d
if k < min_p:
print(abs(x) - k*d)
elif (k-min_p) % 2 == 0:
print(rest_p)
else:
print(abs(rest_n))
| 1 | 5,280,194,659,314 | null | 92 | 92 |
def main():
N = int(input())
count = 0
for a in range(N) :
a += 1
for b in range(N):
b += 1
c = N - a * b
if c <= 0 :
break
else :
count += 1
print(count)
if __name__ == '__main__':
main()
|
N = int(input())
ans = 0
for a in range(1, 10 ** 6 + 1):
for b in range(1, 10 ** 6 + 1):
if a * b >= N:
break
ans += 1
print(ans)
| 1 | 2,580,828,018,780 | null | 73 | 73 |
def main():
s = input()
s = list(reversed(s))
s.append('0')
dp = [[10**10 for _ in range(2)] for _ in range(len(s)+1)]
dp[0][0] = 0
for i in range(len(s)):
for j in range(2):
x = int(s[i])
x += j
for a in range(10):
ni = i+1
nj = 0
b = a-x
if b < 0:
nj = 1
b += 10
dp[ni][nj] = min(dp[ni][nj], dp[i][j]+a+b)
print(dp[len(s)][0])
main()
| N = [int(c) for c in input()]
dp = 0,1
for n in N:
a = min(dp[0]+n,dp[1]+10-n)
b = min(dp[0]+n+1,dp[1]+10-(n+1))
dp = a,b
print(dp[0]) | 1 | 70,846,667,289,568 | null | 219 | 219 |
a=str(input())
if a[0]==a[1] and a[2]==a[0] :
print('No')
else:
print('Yes')
| s = list(input())
if s[0] != s[1] or s[1] != s[2]:
print("Yes")
else:
print("No") | 1 | 54,855,725,775,720 | null | 201 | 201 |
def II(): return int(input())
def LI(): return list(map(int, input().split()))
N=II()
a=LI()
A=0
for elem in a:
A^=elem
ans=[elem^A for elem in a]
print(*ans) | from functools import reduce
from operator import xor
N = int(input())
A = list(map(int, input().split()))
def solve():
tot = reduce(xor, A, 0)
return ' '.join(map(str, [a ^ tot for a in A]))
if __name__ == "__main__":
print(solve())
| 1 | 12,538,558,869,412 | null | 123 | 123 |
N = int(input())
_L = list(map(int,input().split()))
L =[(v,i) for i,v in enumerate(_L)]
L = sorted(L,key = lambda x:(-x[0],x[1]))
dp = [[0]*(N+1) for _ in range(N+1)]
for i in range(N):#i番目の数字まで見た
for k in range(N):#k回(i-pi)のパターン
if k>i:
continue
val,ind = L[i]
dp[i+1][k+1] = max(dp[i+1][k+1],dp[i][k] + val * abs(ind-k))#先頭からk番目に動かす
dp[i+1][k] = max(dp[i+1][k],dp[i][k]+val * abs(N-1-(i-k)-ind))#すでに後ろからi-k個は使ってる=>後ろからN- (i-k)+1番目に動かす
print(max(dp[-1]))
| T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
c1 = T1*A1-T1*B1
c2 = T2*A2-T2*B2
if c1 > 0:
c1 *= -1
c2 *= -1
power = c1+c2
if power == 0:
print('infinity')
elif power < 0:
print(0)
else:
ans = 2*(-c1//power)+(c1%power > 0)
print(ans) | 0 | null | 82,991,678,811,850 | 171 | 269 |
n=int(input())
d=[]
e=[]
for i in range(n):
p=[0,0]
s=input()
for j in s:
if j==")":
if p[0]!=0:
p[0]-=1
else:
p[1]+=1
else:
p[0]+=1
if p[0]-p[1]>=0:
d.append(p)
else:
e.append(p)
d=sorted(d,key=lambda x:x[1])
e=sorted(e,key=lambda x:-x[0])
s=d+e
q=0
for i,j in s:
if q<j:
print("No")
exit()
else:
q=q-j+i
if q==0:
print("Yes")
else:
print("No")
| n=int(input())
s=[0]*n
t=[0]*n
for i in range(n):
s[i],t[i]=input().split()
t[i]=int(t[i])
print(sum(t[s.index(input())+1:])) | 0 | null | 60,632,455,054,612 | 152 | 243 |
# coding: utf-8
# Here your code !
import sys
def culc_division(x) :
"""
??\???x????´???°?????°??????????????§??????
"""
culc_list = []
for i in range(1,x+1) :
if x % i == 0 :
culc_list.append(i)
return culc_list
in_std = list(map(int, sys.stdin.readline().split(" ")))
a = in_std[0]
b = in_std[1]
c = culc_division(in_std[2])
counter = 0
for idx in range(a, b+1):
if idx in c:
counter += 1
print(counter) | a,b,c = [int(x) for x in input().split( )]
div = []
for x in range(1,c+1):
if c % x == 0:
div.append(x)
r = []
for x in range(a,b+1):
r.append(x)
answer = 0
for x in div:
for y in r:
if x == y:
answer += 1
print(answer)
| 1 | 560,355,553,988 | null | 44 | 44 |
from collections import deque
n,q=map(int,raw_input().split())
l=deque([raw_input().split()for _ in range(n)])
t=0
while len(l):
a,b=l.popleft()
b=int(b)
if q<b: t+=q;l.append([a,b-q])
else: t+=b;print a,t | import sys
input = sys.stdin.readline
T = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = (a[0] - b[0]) * T[0]
q = (a[1] - b[1]) * T[1]
if p > 0:
p *= -1
q *= -1
if p + q < 0:
print(0)
elif p + q > 0:
print(-p // (p + q) * 2 + ((-p % (p + q)) > 0))
else:
print("infinity") | 0 | null | 65,842,637,891,254 | 19 | 269 |
t, h = 0, 0
for i in range(int(input())):
tc, hc= input().split()
if tc > hc:
t += 3
elif tc < hc:
h += 3
else:
t += 1
h += 1
print('%d %d' % (t, h)) | turn=int(input())
duel=[input().split(" ")for i in range(turn)]
point=[0,0]
for i in duel:
if i[0]==i[1]:
point[0],point[1]=point[0]+1,point[1]+1
if i[0]>i[1]:
point[0]+=3
if i[0]<i[1]:
point[1]+=3
print(" ".join(map(str,point)))
| 1 | 2,000,919,851,978 | null | 67 | 67 |
import sys
import math
n = input()
s = [set(), set(), set(), set()]
ch = {0:"S", 1:"H", 2:"C", 3:"D"}
for i in xrange(n) :
kind, num = raw_input().split()
num = int(num)
for j in xrange(4) :
if (kind == ch[j]) :
s[j].add(num)
break
for i in xrange(4) :
for j in xrange(1, 14) :
if not(j in s[i]) :
print ch[i], j | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
a,b,x = list(map(int, input().split()))
import math
if x*2>=a*a*b:
the = (a*b - x/a) / (0.5*a*a)
else:
the = (b*b*a) / (2*x)
ans = math.atan(the)
print(ans*180/math.pi) | 0 | null | 82,490,400,866,562 | 54 | 289 |
import sys
import math # noqa
import bisect # noqa
import queue # noqa
def input():
return sys.stdin.readline().rstrip()
def main():
N = int(input())
que = queue.Queue()
que.put(('a', ord('a')))
while not que.empty():
res, m = que.get()
if len(res) < N:
for i in range(ord('a'), min(ord('z'), m + 1) + 1):
que.put((res + chr(i), max(m, i)))
elif len(res) == N:
print(res)
else:
break
if __name__ == '__main__':
main()
| # https://atcoder.jp/contests/sumitrust2019/tasks/sumitb2019_e
n = int(input())
nums = map(int, input().split())
MOD = 1000000007
ans = 1
cnt = [3 if i == 0 else 0 for i in range(n + 1)]
for num in nums:
ans = ans * cnt[num] % MOD
if ans == 0:
break
cnt[num] -= 1
cnt[num+1] += 1
print(ans)
| 0 | null | 91,003,488,342,402 | 198 | 268 |
A, B, C = map(int, input().split())
print('Yes' if len(set([A, B, C]))==2 else 'No')
| from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
def popcount(x):
'''xの立っているビット数をカウントする関数
(xは64bit整数)'''
# 2bitごとの組に分け、立っているビット数を2bitで表現する
x = x - ((x >> 1) & 0x5555555555555555)
# 4bit整数に 上位2bit + 下位2bit を計算した値を入れる
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f # 8bitごと
x = x + (x >> 8) # 16bitごと
x = x + (x >> 16) # 32bitごと
x = x + (x >> 32) # 64bitごと = 全部の合計
return x & 0x0000007f
N = int(input())
x = [[] for i in range(N)]
for i in range(N):
A = int(input())
for j in range(A):
p, q = map(int, input().split())
x[i].append([p-1, q])
ans = 0
for i in range(0,2**N):
flag = 1
for j in range(N):
if ((i >> j) & 1):
for xx in x[j]:
if xx[1] == 1:
if not ((i >> xx[0]) & 1):
flag = 0
break
else:
if ((i >> xx[0]) & 1):
flag = 0
break
if flag == 0:
break
if flag == 0:
continue
else:
ans = max(ans, popcount(i))
print(ans)
| 0 | null | 94,988,356,816,262 | 216 | 262 |
a, b, x = map(int, input().split())
vol = a*a*b
half=a*a*b/2
if x> half:
t = (vol-x)*2/a/a
tan = t/a
else:
t= x*2/b/a
tan=b/t
import math
ans =math.degrees(math.atan(tan))
print(ans) | # C - Slimes
def main():
n = int(input())
s = input()
p = ''
ans = ''
for v in s:
if v != p:
ans += v
p = v
else:
continue
print(len(ans))
if __name__ == "__main__":
main() | 0 | null | 166,208,969,495,952 | 289 | 293 |
N = int(input())
x = N%10
if x==0 or x==1 or x==6 or x==8:
print('pon')
elif x==2 or x==4 or x==5 or x==7 or x==9:
print('hon')
elif x==3:
print('bon') | import sys
import collections
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : map(int, input().split())
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
#a = int(input())
n , m = tin()
#s = input()
path = [[] for _ in range(n)]
for _ in range(m):
a, b = tin()
path[a-1].append(b-1)
path[b-1].append(a-1)
nn = [-1]*n
st=1
for i, p in enumerate(nn):
if nn[i] != -1:
continue
nn[i]=st
cc = st
st += 1
q = collections.deque()
q.append(i)
while q:
pos = q.popleft()
for np in path[pos]:
if nn[np] == -1:
q.append(np)
nn[np]=cc
return cc-1
#+++++
isTest=False
def pa(*vl):
if not isTest:
return
for v in vl:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | 0 | null | 10,746,984,596,898 | 142 | 70 |
import math
a,b,H,M=map(int,input().split())
theta_a = math.pi/6 * (H+M/60)
theta_b = math.pi*2*M/60
theta = abs(theta_a - theta_b)
ans = math.sqrt(a**2 + b**2 - 2*b*a*math.cos(theta))
print(ans) | import math
a, b, h, m = map(int,input().split())
m_rad = m/60 * 360
h_rad = (h/12 * 360) + (m/60 * 360/12)
rad = abs(m_rad - h_rad)
ans = (a**2 + b**2) - (2 * a * b * math.cos(math.radians(rad)))
print(math.sqrt(ans)) | 1 | 20,080,165,874,130 | null | 144 | 144 |
n, k =map(int,input().split())
MOD = 10**9 + 7
ans = 0
for i in range(k,n+2):
L = (i-1)*i / 2 #初項0,末項l,項数iの等差数列の和
H = ((n-i)+(n+1))*i //2 #初項a,末項l,項数iの等差数列の和
ans += H - L + 1
ans %= MOD
print(int(ans)) | N, K = map(int, input().split())
N += 1
res = 0
s = [i for i in range(N)]
if K == 1:
res += N
K = 2
if N == 0:
print(res)
exit(0)
res += 1
minimum = sum(s[:K - 1])
maximum = sum(s[-K + 1:])
for i in range(K, N):
minimum += s[i]
maximum += s[-i + 1]
res = (res + (maximum - minimum + 1)) % (10 ** 9 + 7)
print(res)
| 1 | 32,999,186,733,348 | null | 170 | 170 |
N, M = map(int, input().split())
H = list(map(int, input().split()))
count = [0]*N
ans = 0
for _ in range(M):
a, b = map(int, input().split())
if H[a-1] > count[b-1]:
count[b-1] = H[a-1]
if H[b-1] > count[a-1]:
count[a-1] = H[b-1]
for i in range(N):
if H[i] > count[i]:
ans += 1
print(ans) | N,M = map(int,input().split())
H = list(map(int,input().split()))
H.insert(0,0)
S = set()
for m in range(M):
A,B = map(int,input().split())
if H[A]<=H[B]:
S.add(A)
if H[A]>=H[B]:
S.add(B)
print(N-len(S)) | 1 | 25,011,781,340,312 | null | 155 | 155 |
import numpy as np
import itertools as it
H,W,N = [int(i) for i in input().split()]
dat = np.array([list(input()) for i in range(H)], dtype=str)
emp_r = ["." for i in range(W)]
emp_c = ["." for i in range(H)]
def plot(dat, dict):
for y in dict["row"]:
dat[y,:] = emp_r
for x in dict["col"]:
dat[:,x] = emp_c
return dat
def is_sat(dat):
count = 0
for y in range(W):
for x in range(H):
if dat[x, y] == "#":
count += 1
if count == N:
return True
else:
return False
# def get_one_idx(bi, digit_num):
# tmp = []
# for j in range(digit_num):
# if (bi >> j) == 1:
# tmp.append()
# plot(dat, dict={"row": [], "col":[0, 1]})
combs = it.product([bin(i) for i in range(2**H-1)], [bin(i) for i in range(2**W-1)])
count = 0
for comb in combs:
rows = comb[0]
cols = comb[1]
rc_dict = {"row": [], "col": []}
for j in range(H):
if (int(rows, 0) >> j) & 1 == 1:
rc_dict["row"].append(j)
for j in range(W):
if (int(cols, 0) >> j) & 1 == 1:
rc_dict["col"].append(j)
dat_c = plot(dat.copy(), rc_dict)
if is_sat(dat_c):
count += 1
print(count)
| S = str(input())
ans = S[0:3]
print(ans) | 0 | null | 11,895,621,620,960 | 110 | 130 |
data = list(map(float, input().split()))
print(((data[2]-data[0])**2+(data[3]-data[1])**2)**0.5)
| import math
x1,y1,x2,y2 = map(float,input().split())
ans = math.sqrt((x2-x1)**2+(y2-y1)**2)
print(round(ans,8))
| 1 | 155,559,079,750 | null | 29 | 29 |
input()
print(len([i for i in list(map(int,input().split()))[::2] if i%2])) | N, *a = map(int, open(0).read().split())
print(sum(1 for e in a[::2] if e % 2 == 1))
| 1 | 7,787,239,220,808 | null | 105 | 105 |
a,b,c = [int(i) for i in input().split()]
i=0
for num in range(a,b+1,1):
if c % num == 0:
i = i+1
else:
pass
print(i)
| deglist = raw_input().split(" ")
a = int(deglist[0])
b = int(deglist[1])
c = int(deglist[2])
cnt = 0
for x in range(a, b+1):
if c % x == 0:
cnt += 1
print cnt | 1 | 562,666,791,980 | null | 44 | 44 |
import sys
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7
N = ri()
K = ri()
nums = list(map(int, list(str(N))))
L = len(nums)
dp = [ [[0]*2 for _ in range(K+2)] for _ in range(L+1)]
dp[0][0][0] = 1
for i in range(L):
for j in range(K+1):
for k in range(2):
for d in range(10):
ni, nj, nk = i+1, j, k
if d > 0:
nj += 1
if nj > K: continue
if k == 0:
if d < nums[i]:
nk = 1
elif d > nums[i]:
continue
dp[ni][nj][nk] += dp[i][j][k]
print(sum(dp[L][K]))
| N = int(input())
K = int(input())
def func(num,counter):
remain = num%10
quotient = num//10
if counter == 0:
return 1
if num<10:
if counter ==1:
return num
else:
return 0
return func(quotient,counter-1)*remain + func(quotient-1,counter-1)*(9-remain) + func(quotient,counter)
print(func(N,K)) | 1 | 75,693,795,529,230 | null | 224 | 224 |
h = int(input())
w = int(input())
n = int(input())
ans = n // max(h,w) if n % max(h,w) == 0 else n // max(h,w) + 1
print(ans) | h= int(input())
w = int(input())
n = int(input())
a = max(h,w)
print((n+a-1)//a) | 1 | 88,614,828,533,792 | null | 236 | 236 |
import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp
INF = inf
MOD = 1000000007
n = int(input())
A = [[int(i) for i in input().split()]for j in range(n)] # nは行数
tmp = 0
res = 0
x = np.median(np.array(A), axis=0)
if n % 2 == 0:
res = int((x[1] - x[0]) * 2 + 1)
else:
res = int(x[1] - x[0] + 1)
print(res)
| n = int(input())
aa = []
bb = []
for _ in range(n):
a, b = map(int, input().split())
aa.append(a)
bb.append(b)
aa.sort()
bb.sort()
if n % 2 == 1:
ac = aa[n // 2]
bc = bb[n // 2]
print(abs(ac - bc) + 1)
else:
ac1 = aa[n // 2 - 1]
bc1 = bb[n // 2 - 1]
ac2 = aa[n // 2]
bc2 = bb[n // 2]
print((bc2 + bc1) - (ac2 + ac1) + 1)
| 1 | 17,464,543,070,840 | null | 137 | 137 |
A, B, C = map(int, input().split())
temp = B
B = A
A = temp
temp = C
C = A
A = temp
print(str(A) + " " + str(B) + " " + str(C)) | a, b, c = map(int, input().split())
t = a
a = b
b = t
tt = a
a =c
c = tt
print(a, b, c) | 1 | 37,974,436,706,048 | null | 178 | 178 |
# 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())
| print("Yes" if int(input()) >= 30 else "No")
| 0 | null | 2,912,319,246,398 | 7 | 95 |
#!/usr/bin/env python3
x, y = [int(x) for x in input().split()]
p = [300000, 200000, 100000]
if x == 1 and y == 1:
print(1000000)
elif x <= 3 and y <= 3:
print(p[x - 1] + p[y - 1])
elif x <= 3:
print(p[x - 1])
elif y <= 3:
print(p[y - 1])
else:
print(0)
| N = int(input())
A = list(map(int,input().split()))
M = max(A)
X = [1]*(M+1)
for a in A:
X[a]-=1
for i in range(a*2,M+1,a):
X[i]=-2
ans = 0
for a in A:
if X[a]>=0:
ans+=1
print(ans)
| 0 | null | 77,201,485,781,530 | 275 | 129 |
def resolve():
n = int(input())
a = list(map(int, input().split()))
all_xor = 0
for ai in a:
all_xor ^= ai
ans = []
for ai in a:
ans.append(str(all_xor ^ ai))
print(' '.join(ans))
resolve() | from collections import deque
N = int(input())
X = [list(map(int, input().split())) for _ in range(N - 1)]
tree = [[] for _ in range(N + 1)]
for i, (a, b) in enumerate(X):
tree[a].append((b, i))
tree[b].append((a, i))
visited = [False] * (N + 1)
visited[1] = True
color = [0] * (N - 1)
stack = deque()
stack.append((1, 0))
while stack:
u, c = stack.popleft()
tmp = 0
for v, i in tree[u]:
if visited[v]:
continue
tmp += 1
if tmp == c:
tmp += 1
visited[v] = True
color[i] = tmp
stack.append((v, tmp))
print(max(color))
print(*color, sep="\n")
| 0 | null | 74,646,520,885,042 | 123 | 272 |
n = int(input())
ans = 10 ** n - (9 ** n * 2 - 8 ** n)
ans %= 10 ** 9 + 7
print(ans) | n = int(input())
mod = 10**9+7
num = 10**n%mod - 2*(9**n%mod)%mod + 8**n%mod
print(num if num>=0 else num+mod)
| 1 | 3,134,734,578,624 | null | 78 | 78 |
# coding : utf-8
import math as m
r = float(input())
print ('{0:.6f} {1:.6f}'.format(r*r*m.pi, 2*r*m.pi))
| from math import pi
r = float(input())
z = r*r*pi
l = 2*r*pi
print('{} {}'.format(z,l)) | 1 | 641,070,716,100 | null | 46 | 46 |
A,B,M=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=[]
d=[]
for i in range(M):
c.append(list(map(int,input().split())))
C=min(a)+min(b)
for i in range(0,M):
d.append(a[(c[i][0]-1)]+b[(c[i][1]-1)]-c[i][2])
D=min(d)
print(min(C,D)) | A, B, M = [int(a) for a in input().split()]
a = [int(ai) for ai in input().split()]
b = [int(bi) for bi in input().split()]
x = []
y = []
c = []
for _ in range(M):
xi, yi, ci = [int(xyc) for xyc in input().split()]
x.append(xi)
y.append(yi)
c.append(ci)
min_price = min(a) + min(b)
for i in range(M):
price = a[x[i]-1] + b[y[i]-1] - c[i]
min_price = min(min_price, price)
print(min_price) | 1 | 53,881,305,145,460 | null | 200 | 200 |
#import numpy as np
from scipy.sparse.csgraph import floyd_warshall, csgraph_from_dense
from scipy.sparse import csr_matrix
N,M,L = map(int, input().split())
V = [[ 10**12 for _ in range(N) ] for _ in range(N)]
for _ in range(M):
a,b,c = map(int, input().split())
a,b = a-1, b-1
V[a][b] = c
V[b][a] = c
G = csgraph_from_dense(V, null_value=10**12)
d = floyd_warshall(G)
V2 = [[ 10**9 for _ in range(N) ] for _ in range(N)]
for i in range(N):
for j in range(N):
if 0 < d[i][j] <= L:
V2[i][j] = 1
G2 = csgraph_from_dense(V2, null_value=10**9)
d2 = floyd_warshall(G2)
Q = int(input())
for _ in range(Q):
s,t = map(int, input().split())
s,t = s-1, t-1
print(int(d2[s][t])-1 if d2[s][t] < 1000 else -1)
| N,M,L=map(int, input().split())
def warshall_floyd(d):
#d[i][j]: iからjへの最短距離
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])
return d
d=[[float("inf")]*N for i in range(N)]
#d[u][v] : 辺uvのコスト(存在しないときはinf)
for i in range(M):
x,y,z=map(int,input().split())
d[x-1][y-1]=z
d[y-1][x-1]=z
for i in range(N):
d[i][i]=0 #自身のところに行くコストは０
D=warshall_floyd(d)
E=[[float("inf")]*N for i in range(N)]
for i in range(N):
for j in range(N):
if D[i][j]==0:
E[i][j]=0
elif D[i][j]<=L:
E[i][j]=1
F=warshall_floyd(E)
N=int(input())
for i in range(N):
x,y=map(int,input().split())
if F[x-1][y-1]==float("inf"):
print(-1)
else:
print(F[x-1][y-1]-1) | 1 | 173,906,154,176,040 | null | 295 | 295 |
import math
X = int(input())
price = 100
count = 0
while price<X:
tax = price//100
price += tax
count += 1
print(count) | n=int(input())
s=0
for i in str(n):
s+=int(i)
if(s%9==0):
print("Yes")
else:
print("No") | 0 | null | 15,657,216,629,080 | 159 | 87 |
#python2.7
N,M = raw_input().split()
time=0
flag=1
A=[]
for i in range(int(N)):
A.append(raw_input().split())
while len(A)!=0:
if(int(A[0][1])>int(M)):
A[0][1]=str(int(A[0][1])-int(M))
A.append(A[0])
del A[0]
time+=int(M)
else:
time+=int(A[0][1])
print A[0][0]+" "+str(time)
del A[0] | # coding: utf-8
# Here your code !
import collections
p,q=map(int,input().split())
count =0
deq = collections.deque()
finished=[]
while 1:
try:
deq.append(input().split())
except EOFError:
break
while deq:
d = deq.popleft()
d[1]=int(d[1])
if d[1]<=q:
count+=d[1]
d[1]=count
finished.append(map(str,d))
elif d[1]>q:
d[1]-=q
count+=q
deq.append(d)
for f in finished:
print(" ".join(f)) | 1 | 45,429,426,048 | null | 19 | 19 |
H = int(input())
cnt = 0
while H != 0:
H //= 2
cnt += 1
print(2**cnt-1) | h = int(input())
num = 0
t = 0
while h != 1:
h = h//2
num += 2**t
t += 1
num += 2**t
print(num) | 1 | 80,207,174,693,282 | null | 228 | 228 |
N,K=map(int,input().split())
A=[int(x)-1 for x in input().split()]
dist={0:0}
t=i=0
while K>0:
K-=1
i+=1
t=A[t]
if t in dist:
K%=i-dist[t]
else:
dist[t]=i
print(t+1)
| N, M = map(int, input().split())
a = 1
b = N
d = set([1, N - 1])
for _ in range(M):
print(a, b)
a += 1
b -= 1
while (b - a) in d or (N - b + a) in d or (b - a) == (N - b + a): b -= 1
d.add(b - a)
d.add(N - b + a)
| 0 | null | 25,772,722,370,460 | 150 | 162 |
n, a, b = map(int, input().split())
MOD = 10**9+7
def comb(n, k, MOD):
x = 1
for i in range(k):
x *= (n-i)
x *= pow(i+1, MOD-2, MOD)
x %= MOD
return x
ans = pow(2, n, MOD) - 1 - comb(n, a, MOD) - comb(n, b, MOD)
ans += MOD
ans %= MOD
print(ans) | n=int(input(""))
aa=input("").split(" ")
lista=[]
for i in range(n):
lista+=[int(aa[i])]
lista.sort()
listtf=[]
s=0
for i in range(lista[n-1]):
listtf+=[True]
for i in range(n):
if(listtf[lista[i]-1]):
if(i<n-1 and lista[i]==lista[i+1]):
s-=1
s+=1
t=1
while(t*lista[i]<=lista[n-1]):
listtf[lista[i]*t-1]=False
t+=1
print(s)
| 0 | null | 40,234,490,666,648 | 214 | 129 |
a = []
for i in range(3):
a.extend(list(map(int,input().split())))
n = int(input())
b = []
cnt=[]
pattern=[[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]
for i in range(n):
b.append(int(input()))
for j , x in enumerate(a):
if x == b[i]:
cnt.append(j)
for q,w,e in pattern:
if q in cnt and w in cnt and e in cnt:
print('Yes')
break
else:
print('No') | a = []
for i in range(3):
a.append(list(map(int, input().split())))
n = int(input())
for i in range(n):
b = int(input())
for j in range(3):
for k in range(3):
if a[j][k] == b:
a[j][k] = 0
for i in range(3):
if sum(a[i]) == 0:
print("Yes")
exit()
for i in range(3):
if sum([a[0][i], a[1][i], a[2][i]]) == 0:
print("Yes")
exit()
if sum([a[0][0], a[1][1], a[2][2]]) == 0 or sum([a[0][2], a[1][1], a[2][0]]) == 0:
print("Yes")
exit()
print("No") | 1 | 59,815,892,023,108 | null | 207 | 207 |
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N = int(input())
A = list(map(int, input().split()))
count = 0
pos = 1
for i, a in enumerate(A):
if a == pos:
pos += 1
else:
count += 1
if count <= N - 1:
print(count)
else:
print(-1)
| n = int(input())
S = list(map(int,input().split(' ')))
q = int(input())
T = list(map(int,input().split(' ')))
C = 0
for i in S:
if i in T:
C += 1
T.remove(i)
print(C)
| 0 | null | 57,151,827,551,218 | 257 | 22 |
n, m, l = map(int,input().split())
a = list()
for i in range(n):
a.append(list(map(int,input().split())))
b = list()
for i in range(m):
b.append(list(map(int,input().split())))
for i in range(n):
line = list()
for j in range(l):
c = 0
for k in range(m):
c += a[i][k] * b[k][j]
line.append(str(c))
print(' '.join(line))
| n = int(input())
a = map(int, input().split())
ans = 0
i = 1
for x in a:
if i % 2 == x % 2 == 1: ans += 1
i += 1
print(ans) | 0 | null | 4,605,437,771,708 | 60 | 105 |
a,b,c,k=map(int,input().split())
if a>=k:
print(k)
elif a+b>=k:
print(a)
elif a+b+c>=k:
print(a*2+b-k)
else:
print(a-c) | n=int(input())
ans=10**12
d=2
while d<=n**(1/2):
if n%d==0:
ans=min(ans,d+n//d-2)
d+=1
if ans==10**12:
print(n-1)
exit()
print(ans) | 0 | null | 91,158,715,076,780 | 148 | 288 |
ABC = list(map(int,input().split()))
red = ABC[0]
green = ABC[1]
blue = ABC[2]
K = int(input())
for i in range(K):
if green <= red:
green *= 2
continue
elif blue <= green:
blue *= 2
if green > red and blue > green:
print('Yes')
else:
print('No') | #
# m_solutions2020 b
#
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """7 2 5
3"""
output = """Yes"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """7 4 2
3"""
output = """No"""
self.assertIO(input, output)
def resolve():
A, B, C = map(int, input().split())
K = int(input())
for i in range(K):
if A >= B:
B *= 2
elif B >= C:
C *= 2
if A < B < C:
print("Yes")
break
else:
print("No")
if __name__ == "__main__":
# unittest.main()
resolve()
| 1 | 6,855,208,341,070 | null | 101 | 101 |
import sys
n=int(input())
a=list(map(int,input().split()))
b=a[:]
for i in range(len(a)):
if a[i]%2!=0:
b.remove(a[i])
for i in b:
if i%3!=0:
if i%5!=0:
print('DENIED')
sys.exit()
print('APPROVED') | import sys
import bisect
stdin = sys.stdin
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def naa(N): return [na() for _ in range(N)]
def ns(): return stdin.readline().rstrip() # ignore trailing spaces
N, M = na()
A_array = na()
A_array.sort()
hap_min = 0
hap_max = 3 * (10 ** 5)
while(hap_max - hap_min > 1):
hap = (hap_min + hap_max) // 2
cnt = 0
for a in A_array:
idx = bisect.bisect_left(A_array, hap - a)
cnt += N - idx
# print(hap, hap_max, hap_min, cnt)
if cnt >= M:
hap_min = hap
else:
hap_max = hap
hap = hap_min
# print(hap)
cnt_array = [0] * N
sum_array = [0] * N
for i, a in enumerate(A_array):
idx = bisect.bisect_left(A_array, hap - a)
cnt_array[i] = N - idx
if idx != N:
sum_array[idx] += 1
# print(cnt_array, sum_array)
ans = 0
cusum = 0
cntsum = 0
for a, c, s in zip(A_array, cnt_array, sum_array):
cusum += s
cntsum += c
ans += a * (cusum + c)
print(ans - (cntsum - M) * hap)
| 0 | null | 88,274,551,070,738 | 217 | 252 |
from itertools import permutations
N = int(input())
XY = []
for _ in range(N):
x, y = map(int, input().split())
XY.append((x, y))
ans = 0
c = 0
for p in permutations(range(N)):
dist = 0
x1, y1 = XY[p[0]]
for i in p[1:]:
x, y = XY[i]
dist += ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
ans += dist
c += 1
print(ans / c)
| # -*- coding: utf-8 -*-
"""
Created on Tue Sep 8 18:25:14 2020
@author: liang
"""
H, W = map(int, input().split())
field = [input() for i in range(H)]
def Init():
return [[-1]*W for _ in range(H)]
ans = -1
from collections import deque
q = deque()
adj = ((1,0), (-1,0), (0,1), (0,-1))
def BFS(y,x):
def isValid(t):
if t[0] < 0 or t[0] >= H or t[1] < 0 or t[1] >= W or field[t[0]][t[1]] == "#":
return False
return True
d = Init()
if field[y][x] == '#':
return -1
d[y][x] = 0
q.append((y,x))
res = 0
while q:
cur = q.popleft()
for a in adj:
nex = (cur[0]+a[0], cur[1]+a[1])
if isValid(nex) and (d[nex[0]][nex[1]]== -1 or d[nex[0]][nex[1]] > d[cur[0]][cur[1]]+1):
d[nex[0]][nex[1]] = d[cur[0]][cur[1]]+1
#if res < d[nex[0]][nex[1]]:
# res = d[nex[0]][nex[1]]
res = max(res, d[nex[0]][nex[1]])
q.append(nex)
return res
for i in range(H):
for j in range(W):
tmp = BFS(i,j)
if tmp > ans:
ans = tmp
print(ans) | 0 | null | 121,098,951,322,620 | 280 | 241 |
a, b = map(int, input().split())
x = a // 0.08
y = b // 0.10
x, y = int(x), int(y)
minv = min(x, y)
maxv = max(x, y)
ans = []
for i in range(minv, maxv+2):
if int(i * 0.08) == a and int(i * 0.1) == b:
ans.append(i)
if len(ans) == 0:
print(-1)
else:
print(min(ans))
| A,B = map(int, input().split())
for X in range(1,1001):
if (X*108//100-X)==A and (X*110//100-X)==B:
print(X)
exit()
print(-1) | 1 | 56,611,586,685,848 | null | 203 | 203 |
from collections import Counter
N, M, K = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(M)]
CD = [list(map(int, input().split())) for _ in range(K)]
friend_g = [set() for i in range(N)]
for a, b in AB:
a, b = a-1, b-1
friend_g[a].add(b)
friend_g[b].add(a)
friend_count = [len(s) for s in friend_g]
g_nums = [-1]*N
current_g_num = 0
for i in range(N):
if g_nums[i] == -1:
g_nums[i] = current_g_num
q = [i]
while q:
t = q.pop()
for friend in friend_g[t]:
if g_nums[friend] == -1:
g_nums[friend] = current_g_num
q.append(friend)
# print(i, t, g_nums)
current_g_num += 1
block_count = [0]*N
for c, d in CD:
c, d = c-1, d-1
if g_nums[c] == g_nums[d]:
block_count[c] += 1
block_count[d] += 1
g_nums_counter = Counter(g_nums)
print(*(g_nums_counter[g_nums[i]] - friend_count[i] - block_count[i] - 1 for i in range(N))) | n, m, k = map(int, input().split())
f_adj_list = [[] for i in range(n)]
b_adj_list = [[] for i in range(n)]
for i in range(m):
_, __ = map(int, input().split())
_ -= 1
__ -= 1
f_adj_list[_].append(__)
f_adj_list[__].append(_)
for j in range(k):
_, __ = map(int, input().split())
_ -= 1
__ -= 1
b_adj_list[_].append(__)
b_adj_list[__].append(_)
group_id = [None for i in range(n)]
for i in range(n):
if group_id[i] is not None: continue
# i から DFS
newly_visited = [i]
group_id[i] = i
while len(newly_visited) > 0:
now = newly_visited.pop()
for j in f_adj_list[now]:
if group_id[j] is not None: continue
newly_visited.append(j)
group_id[j] = i
# group_id
# print(group_id)
# 連結成分のサイズ
from collections import Counter
cnt = Counter(group_id)
# cnt[5] = 7
ans_list = []
for i in range(n):
ans = cnt[group_id[i]]
ans -= 1 # 自分自身
ans -= len(f_adj_list[i]) # 直接の友達
for j in b_adj_list[i]:
if group_id[i] == group_id[j]:
ans -= 1
ans_list.append(ans)
print(" ".join(map(str, ans_list)))
| 1 | 61,735,092,541,252 | null | 209 | 209 |
N, K = map(int, input().split())
*A, = map(int, input().split())
for i in range(N-K):
print("Yes" if A[i]<A[i+K] else "No") | import sys
def input():
return sys.stdin.readline()[:-1]
def main():
X = int(input())
if X >= 1800:
print(1)
elif X >= 1600:
print(2)
elif X >= 1400:
print(3)
elif X >= 1200:
print(4)
elif X >= 1000:
print(5)
elif X >= 800:
print(6)
elif X >= 600:
print(7)
else:
print(8)
if __name__ == "__main__":
main()
| 0 | null | 6,911,844,685,890 | 102 | 100 |
N,K = map(int,input().split())
sunuke = [0]*(N+1)
for i in range(K):
okashi_category = input()
#print (okashi_category)
if okashi_category ==1:
sunuke[input()]=1
else:
sunukelist = list(map(int,input().split()))
for j in range(len(sunukelist)):
#print(sunukelist[j])
sunuke[sunukelist[j]]=1
print (N-sum(sunuke)) | N, K = map(int, input().split())
sunukes = [0 for k in range(N)]
for k in range(K):
d = int(input())
A = list(map(int, input().split()))
for a in A:
sunukes[a-1] += 1
assert len(A) == d
print(len([k for k in sunukes if k == 0])) | 1 | 24,558,459,489,818 | null | 154 | 154 |
N = int(input())
A = list(map(int, input().split()))
money = 1000
kabu = 0
for i in range(N-1):
if kabu > 0:
money += kabu*A[i]
kabu = 0
if A[i] < A[i+1]:
kabu = money//A[i]
money -= kabu*A[i]
if kabu > 0:
money += kabu*A[-1]
print(money)
| n, k = map(int,input().split())
have = [False] * n
for _ in range(k):
d = input()
a = list(map(lambda x: int(x)-1, input().split()))
for x in a:
have[x] = True
print(have.count(False))
| 0 | null | 16,012,136,792,598 | 103 | 154 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
import numpy as np
def main():
n, k = map(int, input().split())
p = np.array(read().split(), np.int32)
p += 1
pcum = np.zeros(n + 1, np.int32)
pcum[1:] = p.cumsum()
sum_k = pcum[k:] - pcum[:-k]
print(sum_k.max()/2)
if __name__ == '__main__':
main()
| b = input()
if b.islower():
print("a")
else:
print("A") | 0 | null | 42,880,914,817,686 | 223 | 119 |
s = input()
p = input()
if p in s + s:
print('Yes')
else:
print('No') | N=300005
n,m,nums=map(int,input().split())
x=[0 for i in range(nums)]
y=[0 for i in range(nums)]
rows=[0 for i in range(N)]
cols=[0 for i in range(N)]
for i in range(nums):
xx,yy=map(int,input().split())
x[i]=xx
y[i]=yy
rows[xx]+=1
cols[yy]+=1
cnt_row=0
cnt_col=0
max_row=0
max_col=0
for i in range(N):
if(rows[i]>max_row):
max_row=rows[i]
cnt_row=0
if(rows[i]==max_row):
cnt_row+=1
for i in range(N):
if(cols[i]>max_col):
max_col=cols[i]
cnt_col=0
if(cols[i]==max_col):
cnt_col+=1
ans=max_row+max_col
cnt=0
for i in range(nums):
if(rows[x[i]]==max_row and cols[y[i]]==max_col):
cnt+=1
if(cnt==cnt_row*cnt_col):
ans-=1
print(ans) | 0 | null | 3,235,545,279,620 | 64 | 89 |
from itertools import product
import copy
H,W,K = list(map(int, input().split()))
A = []
for i in range(H):
A.append(list(map(int, input())))
#SM = [np.cumsum(A[i]) for i in range(H)]
ANS = []
for pat in product(['0','1'], repeat = H-1):
res = []
cnt = 0
now = copy.copy(A[0])
for i in range(1,H):
p = pat[i-1]
if p == '1':
res.append(now)
now = copy.copy(A[i])
cnt += 1
else:
for j in range(W):
now[j] += A[i][j]
res.append(now)
"""
print("---")
print(pat)
print(res)
print(cnt)
"""
wk2 = [0] * len(res)
cnt2 = 0
flg = True
for x in range(W):
for j in range(len(res)):
if res[j][x] > K:
# 横に割った段階で、すでに最小単位がKを超えてたら実現不可能
flg = False
break
if wk2[j] + res[j][x] > K:
cnt2 += 1
wk2 = [0] * len(res)
break
for j in range(len(res)):
wk2[j] += res[j][x]
if not flg:
break
if flg:
ANS.append(cnt + cnt2)
#print(pat, cnt, cnt2)
print(min(ANS))
| import itertools
def check(H, W, K, S, p):
num_groups = p.count(True) + 1
group_total = [0] * num_groups
ret = p.count(True)
for j in range(W):
group_value = [0] * num_groups
group_value[0] += int(S[0][j])
group_idx = 0
for i in range(H-1):
if p[i]:
group_idx += 1
group_value[group_idx] += int(S[i+1][j])
if max(group_value) > K:
return float("inf")
group_total_tmp = list(map(sum, zip(group_value, group_total)))
if max(group_total_tmp) <= K:
group_total = group_total_tmp
else:
group_total = group_value
ret += 1
return ret
def main():
H, W, K = map(int, input().split())
S = [input() for _ in range(H)]
ans = float("inf")
for p in itertools.product([True, False], repeat=H-1):
ans = min(ans, check(H, W, K, S, p))
print(ans)
if __name__ == "__main__":
main()
| 1 | 48,604,271,322,662 | null | 193 | 193 |
a = 100000;
n = int(input())
while n > 0:
n -= 1
a = 105*a//100
a = ((a - 1) // 1000 + 1) * 1000
print(a)
| n=int(input())
ans=100000
for i in range(n):
ans+=ans*0.05
if ans%1000!=0:
ans-=ans%1000
ans+=1000
ans=int(ans)
print(ans)
| 1 | 956,467,328 | null | 6 | 6 |
S = input()
L = len(S)
K = int(input())
dp = [[[0,0] for _ in range(K+1)] for _ in range(L+1)]
dp[0][0][0] = 1
for i,c in enumerate(S):
c = int(c)
for k in reversed(range(K+1)):
for d in range(10):
nk = k + (d>0)
if nk > K: continue
dp[i+1][nk][1] += dp[i][k][1]
if d > c: continue
less = int(d < c)
dp[i+1][nk][less] += dp[i][k][0]
print(sum(dp[-1][-1])) | import sys
import math
sys.setrecursionlimit(1000000)
N = int(input())
K = int(input())
from functools import lru_cache
@lru_cache(maxsize=10000)
def f(n,k):
# print('n:{},k:{}'.format(n,k))
if k == 0:
return 1
if k== 1 and n < 10:
return n
keta = len(str(n))
if keta < k:
return 0
h = n // (10 ** (keta-1))
b = n % (10 ** (keta-1))
ret = 0
for i in range(h+1):
if i==0:
ret += f(10 ** (keta-1) - 1, k)
elif 1 <= i < h:
ret += f(10 ** (keta-1) - 1, k-1)
else:
ret += f(b,k-1)
return ret
print(f(N,K)) | 1 | 76,354,888,831,440 | null | 224 | 224 |
x=int(input())
k=0
s=0
if x//500>0:
k=x//500
s+=k*1000
x=x-k*500
if x//5>0:
k=x//5
s+=k*5
x=x-k*5
print(s)
| s=input()
t=input()
ans=0
for i in range(len(s)):
if s[i]!=t[i]:
ans+=1
print(ans) | 0 | null | 26,638,174,426,546 | 185 | 116 |
class Dice:
def __init__(self, hoge):
self.num = hoge
self.face = {'U': 0, 'W': 3, 'E': 2, 'N': 4, 'S': 1, 'B': 5}
def move(self, direct):
previouse = {k: v for k, v in self.face.items()}
if direct == 'E':
self.face['U'] = previouse['W']
self.face['W'] = previouse['B']
self.face['E'] = previouse['U']
self.face['B'] = previouse['E']
elif direct == 'W':
self.face['U'] = previouse['E']
self.face['W'] = previouse['U']
self.face['E'] = previouse['B']
self.face['B'] = previouse['W']
elif direct == 'N':
self.face['U'] = previouse['S']
self.face['N'] = previouse['U']
self.face['S'] = previouse['B']
self.face['B'] = previouse['N']
elif direct == 'S':
self.face['U'] = previouse['N']
self.face['N'] = previouse['B']
self.face['S'] = previouse['U']
self.face['B'] = previouse['S']
def get_upper(self):
return self.num[self.face['U']]
if __name__ == '__main__':
dice = Dice([int(x) for x in input().split()])
for d in input():
dice.move(d)
print (dice.get_upper())
| S, T = input().split()
print(T + S) | 0 | null | 51,930,997,872,670 | 33 | 248 |
from collections import Counter
N = int(input())
S = input()
ctr = Counter(S)
res = 0
for i in range(N - 1):
for j in range(i + 1, N):
k = 2 * j - i
if k < N and (S[i] != S[j] and S[i] != S[k] and S[j] != S[k]):
res += 1
print(ctr["R"] * ctr["G"] * ctr["B"] - res)
| import sys
input = sys.stdin.buffer.readline
MOD = 10**9 + 7
N, K = map(int, input().split())
A = list(map(int, (input().split())))
pos, neg = [], []
for a in A:
if a<0:
neg.append(a) # 負
else:
pos.append(a) # 0以上
if pos:
if N==K: # 全て選択で負の数が奇数ならfalse（正にできない）
ok = (len(neg)%2 == 0)
else:
ok = True
else:
ok = (K%2 == 0) # すべて負で奇数ならfalse（正にできない）
ans = 1
if ok == False: # false（正にできない）場合、絶対値が小さいものからk個かける
A.sort(key=abs)
for i in range(K):
ans *= A[i]
ans %= MOD
else:
pos.sort() # 後ろから取っていくので正は昇順
neg.sort(reverse=True) # 後ろから取っていくので負は降順
if K%2:
ans *= pos.pop() # kが奇数個なら1個は正を選ぶ
p = [] # 2個ずつかけた数を格納
while len(pos)>=2:
p.append(pos.pop() * pos.pop())
while len(neg)>=2: # 負を2回かけるのでxは正
p.append(neg.pop() * neg.pop())
p.sort(reverse=True)
for i in range(K//2): # 降順にk//2個見ていく
ans *= p[i]
ans %= MOD
print(ans) | 0 | null | 22,660,903,389,368 | 175 | 112 |
n,a,b = map(int, input().split())
if (b-a)%2==0: print((b-a)//2)
else: print(min(a-1, n-b)+ 1 + (b-a-1)//2) | n,a,b = map(int,input().split())
if (a-b)%2 == 0:
print(abs(a-b)//2)
else:
if abs(a-1) <= abs(n-b):
# b -= abs(a-1)
if (a-b)%2 == 1:
b -= 1
print(abs(a-1)+abs(a-b)//2+1)
else:
print(abs(a-1)+abs(a-b)//2)
else:
# a += abs(n-b)
if (a-b)%2 == 1:
# b += 1
a += 1
print(abs(n-b)+abs(a-b)//2+1)
else:
print(abs(n-b)+abs(a-b)//2)
| 1 | 109,540,993,688,092 | null | 253 | 253 |
import sys
from io import StringIO
import unittest
import os
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
# DPの対象配列の先頭に0を追加(先頭を0桁目、でなく1桁目、として可読性を上げる)
# さらに、入力を1文字ずつ分けて、数値型でリストに格納する。
def get_dp_target(string: str) -> []:
return [0] + list(map(int, list(string)))
# 実装を行う関数
def resolve(test_def_name=""):
try:
# ※DP対象は以下の関数で取得※
n = get_dp_target(input())
target = int(input())
# ---------------------------------
# DP準備
# ---------------------------------
# DP配列作成※問題ごとに変える※
dp = [[[0 for _ in range(101)] for _ in range(2)] for _ in range(len(n) + 1)]
# DP準備(1桁目の設定)※0も処理するので1桁目の値+1回ループ
for i in range(n[1] + 1):
# 未満フラグ設定
is_smaller = True if i < n[1] else False
# ※問題ごとに変える※
# dp[1][is_smaller][?] = ? というイメージは同じ。
not_zero_count = 0 if i == 0 else 1
dp[1][is_smaller][not_zero_count] += 1
# ---------------------------------
# DP(2桁目以降を処理する) ※ポイント：各ループの回数はDP配列の要素数と同じ。
for place in range(2, len(n)):
# 未満フラグの全パターンループ(2種類しかないが・・)
for is_smaller in range(2):
# 0以外の出現回数ループ(DPの兼ね合い上、範囲は0~100でOK)
for not_zero_count in range(100):
# 値ループ
val_range = 10 if is_smaller else n[place] + 1
for val in range(val_range):
# 値によるフラグ変動
work_is_smaller = is_smaller or val < n[place]
work_not_zero_count = not_zero_count if val == 0 else not_zero_count + 1
dp[place][work_is_smaller][work_not_zero_count] += dp[place - 1][is_smaller][not_zero_count]
print(dp[len(n) - 1][0][target] + dp[len(n) - 1][1][target])
except IndexError as err:
print("インデックスエラー:", err.args[0])
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """100
1"""
output = """19"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """25
2"""
output = """14"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """314159
2"""
output = """937"""
self.assertIO(test_input, output)
def test_input_4(self):
test_input = """9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
3"""
output = """117879300"""
self.assertIO(test_input, output)
# 自作テストパターン
def test_original(self):
pass
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
| N = input()
K = int(input())
L = len(N)
dp =[[[ 0 for _ in range(2)] for _ in range(5)] for _ in range(len(N)+1)]
# dp[i][j][flg] i+1桁目までで0以外の個数がj個
# flg = 1 -> N 以下が確定している
dp[0][1][1] = int(N[0])-1
dp[0][1][0] = 1
dp[0][0][1]=1
for i in range(1,L):
for j in range(4):
b = i-1 # hitotumae
now = int(N[i])
## N上限に張り付いてる方
if now == 0:
dp[i][j][0] += dp[b][j][0]
else:
dp[i][j][1] += dp[b][j][0]
dp[i][j+1][1] += dp[b][j][0] * (now-1)
dp[i][j+1][0] += dp[b][j][0]
## 張り付いてない方
dp[i][j][1] += dp[b][j][1]
dp[i][j+1][1] += dp[b][j][1] * 9
print(dp[L-1][K][0] + dp[L-1][K][1])
| 1 | 75,893,486,356,192 | null | 224 | 224 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
class UnionFind:
def __init__(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def makeSet(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def find(self, x):
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parents[x] = y
self.length[y] += self.length[x]
else:
self.parents[y] = x
self.length[x] += self.length[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getLength(self, x):
x = self.find(x)
return self.length[x]
def isSameGroup(self, x, y):
return self.find(x) == self.find(y)
def main():
N, M, K = map(int, readline().split())
friend = [set() for _ in range(N)]
block = [set() for _ in range(N)]
uf = UnionFind(N)
for _ in range(M):
a, b = map(int, readline().split())
a-=1
b-=1
friend[a].add(b)
friend[b].add(a)
uf.unite(a, b)
for _ in range(K):
c, d = map(int, readline().split())
c-=1
d-=1
block[c].add(d)
block[d].add(c)
for i in range(N):
cnt = 0
for blk in block[i]:
if uf.isSameGroup(i, blk):
cnt += 1
ans = uf.getLength(i)-cnt-len(friend[i])-1
if i == N-1:
print(ans)
else:
print(ans, end=" ")
if __name__ == '__main__':
main() | import collections
def Z(): return int(input())
def ZZ(): return [int(_) for _ in input().split()]
def main():
N, M, K = ZZ()
F = [0] * (N+1)
output = []
par = [i for i in range(N+1)]
rank = [0] * (N+1)
# 要素xの親ノードを返す
def find(x):
if par[x] == x:
return x
par[x] = find(par[x])
return par[x]
# 要素x, yの属する集合を併合
def unite(x, y):
x, y = find(x), find(y)
if x == y:
return
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
return
# xとyが同じ集合に属するか？
def same(x, y):
return find(x) == find(y)
for _ in range(M):
a, b = ZZ()
F[a] += 1
F[b] += 1
unite(a, b)
for i in range(1, N+1): find(i)
cnt = collections.Counter(par)
for _ in range(K):
c, d = ZZ()
if same(c, d):
F[c] += 1
F[d] += 1
for i in range(1, N+1):
cc = cnt[par[i]] - F[i] - 1
output.append(cc)
print(*output)
return
if __name__ == '__main__':
main()
| 1 | 61,746,964,708,764 | null | 209 | 209 |
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
from collections import defaultdict
dd = defaultdict(int)
N=I()
M=0
for i in range(N):
s=input()
dd[s]+=1
M=max(M,dd[s])
ans=[]
for k,v in dd.items():
if v==M:
ans.append(k)
ans.sort()
for k in ans:
print(k)
main()
| import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
n = k()
ss = [v() for i in range(n)]
c = Counter(ss)
a = list(c.most_common())
maxc = a[0][1]
Ans = []
for i in a:
if i[1] == maxc:
Ans.append(i)
Ans.sort()
for i in Ans:
print(i[0]) | 1 | 70,166,062,213,496 | null | 218 | 218 |
n = int(input())
A = list(map(int, input().split()))
a = []
for i in range(len(A)):
a.append([A[i], i])
a.sort(key = lambda x: x[0], reverse = True)
dp = [[0 for i in range(n+1)] for j in range(n+1)]
for i in range(n):
for l in range(i+1):
dp[i+1][l] = max(dp[i+1][l], dp[i][l] + a[i][0]*(n-1-(i-l)-a[i][1]))
dp[i+1][l+1] = max(dp[i+1][l+1], dp[i][l] + a[i][0] * (a[i][1] - l))
ans = 0
for now in dp[n]:
ans = max(now, ans)
print(ans)
| import itertools
line1 = input().split()
rei = input().split()
rei =list(map(int,rei))
den =input().split()
den =list(map(int,den))
cupon =[list(map(int,input().split())) for i in range(int(line1[2]))]
rei_mi = min(rei)
den_mi =min(den)
no_total =rei_mi +den_mi
for s in range(int(line1[2])):
yes_total =int(rei[cupon[s][0]-1]) +int(den[cupon[s][1]-1]) - cupon[s][2]
if no_total > yes_total:
no_total =yes_total
print(no_total)
| 0 | null | 44,071,814,071,442 | 171 | 200 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.