code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
import bisect
import copy
def check(a, b, bar):
sm = 0
cnt = 0
n = len(a)
for x in a:
i = bisect.bisect_left(a, bar - x)
if i == n:
continue
cnt += n - i
sm += b[i] + x * (n-i)
return cnt, sm
n,m = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
b = copy.deepcopy(a)
for i,_ in enumerate(b[:-1]):
b[n-i-2] += b[n-i-1]
left = 0
right = b[0] * 2
while right - left > 1:
middle = ( right + left ) // 2
if check(a, b, middle)[0] < m:
right = middle
else:
left = middle
print(check(a, b, left)[1] - left * (check(a, b, left)[0]-m) )
|
import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N,num):
if N<=0:
return [[] for _ in range(num)]
elif num==1:
return [I() for _ in range(N)]
else:
read_all = [tuple(II()) for _ in range(N)]
return map(list, zip(*read_all))
#################
import cmath
pi = cmath.pi
exp = cmath.exp
def convolution(a,b):
def fft(a,sz,inv=False):
tmp = [0]*sz
mask = sz-1
p = 0
i = sz>>1
sign = 1 if inv else -1
while i:
if p&1:
cur,nex = tmp,a
else:
cur,nex = a,tmp
ei = exp(2j*pi*i*sign/sz)
w = 1
for j in range(0,sz,i):
for k in range(i):
nex[j+k] = cur[((j<<1)&mask)+k] + w*cur[(((j<<1)+i)&mask)+k]
w *= ei
p += 1
i >>= 1
if p&1:
a,tmp = tmp,a
if inv:
a = list(map(lambda x: x/sz, a))
return a
sz = 1<<(len(a)+len(b)-2).bit_length()
a = a + [0]*(sz-len(a))
b = b + [0]*(sz-len(b))
fa = fft(a,sz)
fb = fft(b,sz)
fafb = [fai*fbi for fai,fbi in zip(fa,fb)]
ab = fft(fafb,sz,inv=True)
return [round(x.real) for x in ab[:len(a)+len(b)-1]]
N,M = II()
A = III()
h = [0]*(max(A))
for a in A:
h[a-1] += 1
conv = [0,0] + convolution(h,h)
ans = 0
for k in range(2,2*max(A)+1)[::-1]:
if conv[k]<M:
ans += k*conv[k]
M -= conv[k]
else:
ans += k*M
break
print(ans)
| 1 | 108,093,338,813,008 | null | 252 | 252 |
house_info = [[[0 for i in xrange(10)]for j in xrange(3)]for k in xrange(4)]
n = input()
for i in xrange(n):
b,f,r,v=map(int,raw_input().split())
house_info[b-1][f-1][r-1] += v
for i in xrange(4):
for j in xrange(3):
result = " " + " ".join(map(str,house_info[i][j]))
print result
if i < 3:
print "####################"
|
a = [[[0 for r in range(10)] for f in range(3)] for b in range(4)]
n = int(input())
for i in range(n):
b, f, r, v = map(int, input().strip().split())
a[b - 1][f - 1][r - 1] += v
for b in range(4):
for f in range(3):
print(''.join(' {}'.format(a[b][f][r]) for r in range(10)))
if b < 3:
print('#'*20)
| 1 | 1,087,334,674,242 | null | 55 | 55 |
class dice:
directions = ['S', 'E', 'N', 'W']
def __init__(self, strlabels):
label = strlabels.split()
self.top = label[0]
self.side = label[1:5]
self.side[2], self.side[3] = self.side[3], self.side[2]
self.down = label[5]
#print(self.top, self.side, self.down)
def roll(self, direction):
tmp = self.top
self.top = self.side[(self.directions.index(direction)+2)%4]
self.side[(self.directions.index(direction)+2)%4] = self.down
self.down = self.side[self.directions.index(direction)]
self.side[self.directions.index(direction)] = tmp
#print(self.top, self.side, self.down)
def pFace(self, initial):
if initial == 'u':
print(self.top)
elif initial == 'd':
print(self.down)
else:
print(self.side[directions.index(direction)])
dice1 = dice(input())
for direction in input():
dice1.roll(direction)
dice1.pFace('u')
|
class Dice:
def __init__(self, list1):
self.f = list1
def move(self, direct):
if direct == "N":
self.f[0], self.f[1], self.f[4], self.f[5] = self.f[1], self.f[5], self.f[0], self.f[4]
return self.f
elif direct == "E":
self.f[0], self.f[2], self.f[3], self.f[5] = self.f[3], self.f[0], self.f[5], self.f[2]
return self.f
elif direct == "S":
self.f[0], self.f[1], self.f[4], self.f[5] = self.f[4], self.f[0], self.f[5], self.f[1]
return self.f
elif direct == "W":
self.f[0], self.f[2], self.f[3], self.f[5] = self.f[2], self.f[5], self.f[0], self.f[3]
return self.f
data = list(map(int, input().split()))
direction = input()
dice = Dice(data)
for i in direction:
dice.move(i)
print(dice.f[0])
| 1 | 238,429,646,610 | null | 33 | 33 |
import collections
N = int(input())
S = [input() for _ in range(N)]
c = collections.Counter(S)
d = c.most_common()
cnt = 0
for i in range(len(c)-1):
if d[i][1] == d[i+1][1]:
cnt += 1
else:
break
e = []
for j in range(cnt+1):
e.append(d[j][0])
e.sort()
for k in range(len(e)):
print(e[k])
|
def main():
h, n = map(int, input().split())
arr = [list(map(int, input().split())) for _ in range(n)]
dp = [[float("inf")]*(2*10**4+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
p, a, b = i+1, arr[i][0], arr[i][1]
for j in range(2*10**4+1):
if j < a:
dp[p][j] = dp[p-1][j]
else:
if dp[p][j-a] + b < dp[p-1][j]:
dp[p][j] = dp[p][j-a] + b
else:
dp[p][j] = dp[p-1][j]
print(min(dp[-1][h:2*10**4+1]))
if __name__ == "__main__":
main()
| 0 | null | 75,790,703,587,860 | 218 | 229 |
from collections import deque
n=int(input())
que=deque()
for i in range(n):
command=input()
if command=="deleteFirst":
que.popleft()
elif command=="deleteLast":
que.pop()
else:
command,num=command.split()
num=int(num)
if command=="insert":
que.appendleft(num)
else:
if num in que:
que.remove(num)
print(*que,sep=" ")
|
from _collections import deque
n = int(input())
data_input = []
dlList = deque()
for i in range(n):
x = input().split()
if x[0] == 'insert':
dlList.appendleft(x[1])
elif x[0] == 'delete':
if x[1] in dlList:
dlList.remove(x[1])
else :
pass
elif x[0] == 'deleteFirst':
dlList.popleft()
elif x[0] == 'deleteLast':
dlList.pop()
else:
pass
print(' '.join(dlList))
| 1 | 47,008,622,020 | null | 20 | 20 |
x,n = map(int,input().split())
p = list(map(int,input().split()))
dic = {}
lis = []
for i in range(0,102):
if i not in p:
dic[i] = abs(x-i)
lis.append(i)
mini = min(dic.values())
for j in lis:
if mini == dic[j]:
print(j)
break
|
import math
n=int(input())
x=list(map(int, input().split()))
y=list(map(int, input().split()))
print(sum([abs(a-b) for (a,b) in zip(x,y)]))
print(math.sqrt(sum([abs(a-b)**2 for (a,b) in zip(x,y)])))
print(math.pow(sum([abs(a-b)**3 for (a,b) in zip(x,y)]), 1/3))
print((max([abs(a-b) for (a,b) in zip(x,y)])))
| 0 | null | 7,173,354,390,972 | 128 | 32 |
n=int(input())
zp=[]
zl=[]
for i in range(n):
a,b=map(int,input().split())
zp.append(a+b)
zl.append(a-b)
ans=max((max(zp)-min(zp)),(max(zl)-min(zl)))
print(ans)
|
def solve():
a, b = input().split()
if a > b:
print(b*int(a))
else:
print(a*int(b))
if __name__ == '__main__':
solve()
| 0 | null | 43,685,794,105,482 | 80 | 232 |
N, M = map(int, input().split())
A = list(map(int, input().split()))
k = sum(A) / (4*M)
print('Yes' if [a >= k for a in A].count(True) >= M else 'No')
|
n,m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort(reverse = True)
s = sum(a)
res = "Yes"
for i in range(m):
if a[i] * 4 * m < s:
res = "No"
print(res)
| 1 | 38,932,418,339,848 | null | 179 | 179 |
s,t = input().split()
a,b = map(int,input().split())
A = input()
if A == s:print(a-1,b)
else:print(a,b-1)
|
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()
| 0 | null | 64,771,861,421,178 | 220 | 204 |
x=[]
z=[]
A,b=map(int,input().split())
for i in range(0,A):
a=list(map(int,input().split()))
x.append(a)
for s in range(0,b):
q=int(input())
z.append(q)
for i in range(A):
l=0
for s in range(b):
l += x[i][s]*z[s]
print(l)
|
nml=input().split()
n,m,l=int(nml[0]),int(nml[1]),int(nml[2])
A_=[input() for i in range(n)]
B_=[input() for i in range(m)]
A,B=[],[]
for i in range(n):
A_[i]=A_[i].split()
for i in A_:
A.append(list(map(lambda i:int(i),i)))
for i in range(m):
B_[i]=B_[i].split()
for i in B_:
B.append(list(map(lambda i:int(i),i)))
AB=[]
for i in range(n):
AB.append([])
for i in range(n):
for j in range(l):
AB[i].append(0)
for i in range(n):
for j in range(l):
for k in range(m):
AB[i][j]+=(A[i][k]*B[k][j])
for i in AB:
print(*i)
| 0 | null | 1,274,115,559,640 | 56 | 60 |
a,b=input().split()
A=int(a)
bb=b.replace(".","")
B=int(bb)
C=A*B
c=C//100
print(int(c))
|
a, b = input().split()
a = int(a)
b = round(100*float(b))
ans = a*b
print(int(ans//100))
| 1 | 16,477,473,501,778 | null | 135 | 135 |
import math
n = int(raw_input())
debt = 100000
for i in range(n):
debt = int(math.ceil(debt * 1.05 / 1000)) * 1000
print debt
|
from math import floor
n = int(input())
def debt(week):
debt = 100000
for i in range(1,n+1):
debt *= 1.05
amari = debt % 1000
if amari:
debt += 1000 - amari
return int(debt)
print(debt(n))
| 1 | 1,235,063,108 | null | 6 | 6 |
n = int(input())
a = int(0)
b = int(1)
if n==1:
A = b
elif n==2:
A = 2
else:
for i in range(n):
a,b = b,a+b
A = b
print(A)
|
s,t = map(str, input().split())
a,b = map(int, input().split())
u = input()
print(a-1 if s==u else a, b if s==u else b-1)
| 0 | null | 36,078,602,478,268 | 7 | 220 |
if __name__ == '__main__':
while True:
key_in = input()
data = key_in.split(' ')
a = int(data[0])
op = data[1]
b = int(data[2])
if op == '+':
print('{0}'.format(a + b))
if op == '-':
print('{0}'.format(a - b))
if op == '*':
print('{0}'.format(a * b))
if op == '/':
print('{0}'.format(a // b))
if op == '?':
break
|
import itertools
import math
n=int(input())
d=list(map(int,input().split()))
ans=0
for v in itertools.combinations(d, 2):
x=v[0]*v[1]
ans+=x
print(ans)
| 0 | null | 84,492,621,756,832 | 47 | 292 |
def floyd_warshall(G):
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j]=min(G[i][j],G[i][k]+G[k][j])
import sys
input=sys.stdin.readline
INF=10**30
N,M,L=map(int,input().split())
dp1=[[INF]*N for i in range(N)]
for i in range(N):
dp1[i][i]=0
for _ in range(M):
A,B,C=map(int,input().split())
A,B=A-1,B-1
dp1[A][B]=C
dp1[B][A]=C
floyd_warshall(dp1)
dp2=[[INF]*N for i in range(N)]
for i in range(N):
for j in range(N):
if i==j:
dp2[i][j]=0
else:
dp2[i][j]=1 if dp1[i][j]<=L else INF
floyd_warshall(dp2)
Q=int(input())
for _ in range(Q):
s,t=map(lambda x:int(x)-1,input().split())
print (dp2[s][t]-1 if dp2[s][t]!=INF else -1)
|
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
from sys import stdin
readline = stdin.readline
def readInts():
return list(map(int,readline().split()))
def readTuples():
return tuple(map(int,readline().split()))
def I():
return int(readline())
n = I()
m500 = n//500
n -= 500 * m500
m5 = n//5
print(1000 * m500 + m5 * 5)
| 0 | null | 107,731,751,314,726 | 295 | 185 |
import math
import itertools
n = int(input())
d =list(map(int,input().split()))
p = list(itertools.combinations(d, 2))
ans = 0
for i in range(len(p)):
d = p[i][0] * p[i][1]
ans = ans + d
print(ans)
|
from scipy.sparse.csgraph import floyd_warshall
N,M,L,*X = map(int, open(0).read().split())
ls = X[:3*M]
Els = [[0]*N for i in range(N)]
Q = X[3*M]
query = X[3*M+1:]
for a,b,c in zip(*[iter(ls)]*3):
if c<=L:
Els[a-1][b-1] = c
Els[b-1][a-1] = c
dist = floyd_warshall(Els)
Els2 = [[0]*N for i in range(N)]
for i in range(N):
for j in range(N):
if dist[i][j]<=L:
Els2[i][j] = 1
ans = floyd_warshall(Els2)
for s,t in zip(*[iter(query)]*2):
if ans[s-1][t-1]==float('inf'):
print(-1)
continue
print(int(ans[s-1][t-1])-1)
| 0 | null | 170,915,023,528,982 | 292 | 295 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
m = []
for i in range(0,10):
m.append(int(input()))
for i in range(0,3):
print(list(reversed(sorted(m)))[i])
|
while 1:
x, y = map(int, input().split())
if x == 0 and y == 0:
break
if x >= y:
print("{0} {1}".format(y, x))
else:
print("{0} {1}".format(x, y))
| 0 | null | 258,130,636,380 | 2 | 43 |
import sys
from collections import defaultdict
from queue import deque
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():
N, M, L = geta(int)
INF = 10**10
d = [[INF] * (N + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
d[i][i] = 0
for _ in range(M):
a, b, c = geta(int)
d[a][b] = c
d[b][a] = c
def warshall_froyd(_d):
for k in range(1, N + 1):
for i in range(1, N + 1):
for j in range(1, N + 1):
l = _d[i][k] + _d[k][j]
if _d[i][j] > l:
_d[i][j] = l
warshall_froyd(d)
f = [[INF] * (N + 1) for _ in range(N + 1)]
for i in range(N + 1):
f[i][i] = 0
for j in range(N + 1):
if d[i][j] <= L:
f[i][j] = 1
warshall_froyd(f)
for _ in range(gete(int)):
s, t = geta(int)
ret = f[s][t]
print(ret - 1 if ret != INF else -1)
if __name__ == "__main__":
main()
|
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
from scipy.sparse import csr_matrix
INF = 10**12
N, M, L = map(int, input().split())
A = []; B = []; C = []
for i in range(M):
a, b, c = map(int, input().split())
A.append(a - 1); B.append(b - 1); C.append(c)
A = np.array(A); B = np.array(B); C = np.array(C)
graph = csr_matrix((C, (A, B)), (N, N))
d = floyd_warshall(graph, directed=False)
d[d <= L] = 1
d[d > L] = INF
d = floyd_warshall(d, directed=False)
Q = int(input())
for i in range(Q):
s, t = map(int, input().split())
if d[s - 1][t - 1] != INF:
print(int(d[s - 1][t - 1]) - 1)
else:
print(- 1)
| 1 | 174,124,158,238,340 | null | 295 | 295 |
input()
S=input()
print(1+sum(S[i]!=S[i+1]for i in range(len(S)-1)))
|
n = int(input())
s = input()
prev = ""
ans = ""
for i in range(n):
if s[i] == prev:
continue
prev = s[i]
ans += s[i]
print(len(ans))
| 1 | 169,504,080,499,342 | null | 293 | 293 |
N = int(input())
ns = [int(input()) for _ in range(N)]
#primes = set()
#def is_prime(n):
# if n in primes:
# return True
#
# for m in range(2, n):
# if is_prime(m) and n % m == 0:
# return False
#
# primes.add(n)
# return True
# Proof:
# if n < d ^ 2 and n mod d = 0;
# n = ad (a in N)
# ad < d ^ 2
# a < d
# QED
def is_prime(n):
if n < 2: return False
if n == 2: return True
if n % 2 == 0: return False
d = 3
while d ** 2 <= n:
if n % d == 0:
return False
d += 2
return True
print(len([n for n in ns if is_prime(n)]))
|
c = 0
while True:
try:
n = int(input())
except EOFError:
break
c += 1
for i in range(2, int(n ** 0.5 + 1)):
if n % i == 0:
c -= 1
break
print(c)
| 1 | 9,889,927,268 | null | 12 | 12 |
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
cnt = 0
for i in range(1,N + 1):
if i % 3 != 0 and i % 5 != 0:
cnt += i
print(cnt)
|
n,q=map(int,input().split())
Q=[]
sum=0
for i in range(n):
tmp=input().split()
tmp[1]=int(tmp[1])
Q.append(tmp[0])
Q.append(tmp[1])
loop=0
while loop==0:
for i in range(len(Q)//2):
tmp=[Q[0],Q[1]]
if tmp[1]>q:
sum+=q
Q.append(tmp[0])
Q.append(tmp[1]-q)
else:
sum+=tmp[1]
print(tmp[0],sum)
Q.pop(0)
Q.pop(0)
if len(Q)==0:
break
| 0 | null | 17,582,923,970,158 | 173 | 19 |
a,b=map(int,input().split())
print("%d %d %0.5f"%(a/b,a%b,a/b))
|
def resolve():
n, k = map(int,input().split())
a = 10**9+7
ans =0
for K in range(k,n+2):
ans += n*K - K**2 + K + 1
ans %= a
print(ans)
resolve()
| 0 | null | 16,876,384,307,550 | 45 | 170 |
# Aizu Problem ITP_1_2_B: Range
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
a, b, c = [int(_) for _ in input().split()]
print("Yes" if a < b < c else "No")
|
n=int(input());l=list(map(int,input().split()));p=[0]*n;d=[0]*n;p[0]=l[0]
for i in range(1,n):p[i]=l[i]+p[i-2];d[i]=max(p[i-1]if(i&1)else d[i-1],l[i]+d[i-2])
print(d[-1])
| 0 | null | 18,790,296,594,080 | 39 | 177 |
l, r, d = map(int, input().split())
print(r//d-l//d+int(l%d==0 and r%d==0))
|
n,t = map(int,input().split())
l = []
for i in range(n):
a,b = map(int,input().split())
l.append([a,b])
l.sort(key=lambda x:x[0])
dp = [[0 for i in range(t)] for i in range(n+1)]
al = []
for i in range(n):
a,b = l[i]
for j in range(t):
if dp[i][j] == 0:
if j == 0:
if j + a < t:
dp[i+1][j+a] = max(dp[i][j+a],b)
else:
al.append(b)
else:
if j + a < t:
dp[i+1][j+a] = max(dp[i][j+a],dp[i][j]+b)
else:
al.append(dp[i][j]+b)
dp[i+1][j] = max(dp[i+1][j],dp[i][j])
if len(al) > 0:
print(max(max(dp[n]),max(al)))
else:
print(max(dp[n]))
| 0 | null | 79,397,244,752,602 | 104 | 282 |
S = input()
Sliststr = list(S)
Slist = [int(s) for s in Sliststr]
Smod = [0]
mod10 = [1]
count = [0]*2019
ans = 0
for i in range(len(S)-1):
mod10.append(mod10[i]*10%2019)
for i in range(len(S)):
Smod.append((Smod[i]+Slist[-i-1]*mod10[i])%2019)
for i in range(len(Smod)):
count[Smod[i]] += 1
for i in range(2019):
ans += count[i] * (count[i]-1) // 2
print(ans)
|
s = str(input())
MOD = 2019
m = 0
digit = 1
mods = [1] + [0] * 2018
for a in s[::-1]:
m = (m + digit * int(a)) % MOD
mods[m] += 1
digit = digit * 10 % MOD
ans = 0
for x in mods:
ans += x * (x - 1) // 2
print(ans)
| 1 | 30,819,209,879,590 | null | 166 | 166 |
#!/usr/bin/env python3
from math import ceil
import heapq
def main():
n, d, a = map(int, input().split())
q = []
for i in range(n):
x, h = map(int, input().split())
heapq.heappush(q, (x, -ceil(h / a)))
bomb = 0
res = 0
while q:
x, h = heapq.heappop(q)
if h < 0:
h *= -1
if h > bomb:
heapq.heappush(q, (x + 2 * d, h - bomb))
res += h - bomb
bomb = h
else:
bomb -= h
print(res)
if __name__ == "__main__":
main()
|
from collections import deque
n , d , a = map(int,input().split())
mon = [tuple(map(int,input().split())) for i in range(n)]
mon.sort()
p = deque(mon)
baku = deque()
cou = 0
ans = 0
while p:
nowx , nowh = p.popleft()
while baku:
bx , bh = baku.popleft()
if bx >= nowx:
baku.appendleft((bx,bh))
break
elif bx < nowx:
cou -= bh
if nowh <= cou:
continue
elif nowh > cou:
k = -((-nowh+cou)//a)
ans += k
cou += a*k
baku.append((nowx+2*d,a*k))
print(ans)
| 1 | 82,160,199,710,160 | null | 230 | 230 |
n = int(input())
def yakusu(x):
xx = 2
y = []
while xx**2 < x:
if x%xx == 0:
y.append(xx)
y.append(x//xx)
xx += 1
if xx**2 == x:
y.append(xx)
y.append(x)
return y
if n == 2:
ans = 0
else:
ans = len(yakusu(n-1))
for i in yakusu(n):
nn = n
while True:
if nn%i == 0:
nn = nn//i
else:
break
if nn%i == 1:
ans += 1
print(ans)
|
n = int(input())
a = [n]
if n != 2:
a.append(n - 1)
def div_(N, k):
while N % k == 0:
N /= k
if N % k == 1:
a.append(k)
for k in range(2, int(n ** 0.5) + 1):
if n % k == 0:
div_(n,k)
if k != n / k:
div_(n, n // k)
if (n - 1) % k == 0:
a.append(k)
if k != (n - 1) / k:
a.append((n - 1) // k)
print(len(a))
| 1 | 41,173,211,710,748 | null | 183 | 183 |
import math
H, W = map(int, input().split())
print(1) if (H == 1) | (W == 1) else print(math.ceil(H*W/2))
|
def main():
H, W = map(int ,input().split())
if H == 1 or W == 1:
print(1)
else:
L1 = 0
L2 = 0
L1 = L2 = W // 2
if W % 2 == 1:
L1 += 1
ans = (L1 + L2) * (H//2)
if H % 2 == 1:
ans += L1
print(ans)
if __name__ == "__main__":
main()
| 1 | 50,990,654,391,872 | null | 196 | 196 |
import sys
input = sys.stdin.readline
N, M, L = map(int, input().split())
INF = 10**18
G = [[INF]*N for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
if c <= L:
G[a][b] = c
G[b][a] = c
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j] = min(G[i][j], G[i][k]+G[k][j])
G2 = [[INF]*N for i in range(N)]
for i in range(N):
for j in range(N):
if G[i][j] <= L:
G2[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
G2[i][j] = min(G2[i][j], G2[i][k]+G2[k][j])
Q = int(input())
ans = []
for i in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if G2[s][t] == INF:
ans.append(-1)
else:
ans.append(G2[s][t]-1)
print(*ans, sep="\n")
|
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
from collections import defaultdict
n, m, l = map(int, readline().split())
dist = [[INF] * n for _ in range(n)]
for _ in range(m):
a, b, c = map(int, readline().split())
a, b = a - 1, b - 1
dist[a][b] = c
dist[b][a] = c
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
dist2 = [[INF] * n for _ in range(n)]
for i in range(n):
for j in range(n):
if dist[i][j] <= l:
dist2[i][j] = 1
for k in range(n):
for i in range(n):
for j in range(n):
dist2[i][j] = min(dist2[i][j], dist2[i][k] + dist2[k][j])
q = int(readline())
for _ in range(q):
s, t = map(int, readline().split())
s, t = s - 1, t - 1
if dist2[s][t] == INF:
print(-1)
else:
print(dist2[s][t] - 1)
if __name__ == '__main__':
main()
| 1 | 174,077,104,206,460 | null | 295 | 295 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
n = int(input())
r = []
while n > 0:
n -= 1
t1 = n % 26
r.append(chr(t1+97))
n = n // 26
r2 = "".join(r[::-1])
print(r2)
if __name__ == '__main__':
main()
|
N = int(input())
ans = ''
while N:
N -= 1
N, mod = divmod(N, 26)
ans += chr(ord('a') + mod)
print(ans[::-1])
| 1 | 11,955,105,576,684 | null | 121 | 121 |
def run():
X, N = [int(v) for v in input().rstrip().split()]
p = []
if N > 0:
p = [int(v) for v in input().rstrip().split()]
i = -1
try:
i = p.index(X)
except ValueError:
pass
if i == -1:
# not contained
return X
d1 = {}
for k in range(0, 102):
d1[k] = k
for v in p:
del d1[v]
l2 = sorted(list(d1.keys()))
l2.append(X)
l2.sort()
i = l2.index(X)
r = 0
if i == 0:
r = l2[1]
elif (i + 1) == len(l2):
r = l2[-2]
else:
v1 = l2[i + 1] - X
v2 = X - l2[i - 1]
if v1 < v2 :
r = l2[i + 1]
elif v1 > v2 :
r = l2[i - 1]
else:
# v1 == v2
r = l2[i - 1]
return r
r = run()
print(r)
|
from sys import stdin
readline = stdin.readline
def i_input(): return int(readline().rstrip())
def i_map(): return map(int, readline().rstrip().split())
def i_list(): return list(i_map())
def main():
X, N = i_map()
if N == 0:
print(X)
exit()
P = i_list()
p = list(map(lambda x: abs(x - X), P))
p.sort()
for i, j in enumerate(p, 1):
if i // 2 != j:
ans = X - (i // 2)
if ans in P:
ans = X + (i // 2)
break
else:
if N % 2 == 1:
ans = X - ((N + 1) // 2)
else:
ans = X - (N // 2)
if ans in P:
ans = X + (N // 2)
print(ans)
if __name__ == "__main__":
main()
| 1 | 14,089,823,631,360 | null | 128 | 128 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from functools import reduce, lru_cache
import collections, heapq, itertools, bisect
import math, fractions
import sys, copy
sys.setrecursionlimit(1000000)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline().rstrip())
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline().rstrip())
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007
def divisors(N):
divs = set([1, N])
i = 2
while i ** 2 <= N:
if N % i == 0:
divs.add(i)
divs.add(N//i)
i += 1
return sorted(list(divs))
def is_ok(N, K):
if K <= 1:
return False
while N % K == 0:
N //= K
return N % K == 1
def main():
N = I()
ans = 0
for divisor in divisors(N-1):
if is_ok(N, divisor):
ans += 1
for divisor in divisors(N):
if is_ok(N, divisor):
ans += 1
print(ans)
if __name__ == '__main__':
main()
|
a, b, c, d = map(int, input().split())
if d <= a:
print(d)
elif d <= a + b:
print(a)
else:
print(a-(d-(a+b)))
| 0 | null | 31,744,473,702,282 | 183 | 148 |
M1, D1 = map(int, input().split())
M2, D2 = map(int, input().split())
if M1 in [1, 3, 5, 7, 8, 10, 12]:
if D1 == 31:
print(1)
else:
print(0)
elif M1 in [4, 6, 9, 11]:
if D1 == 30:
print(1)
else:
print(0)
elif M1 == 2:
if D1 == 28:
print(1)
else:
print(0)
|
#!/usr/bin python3
# -*- coding: utf-8 -*-
#######################################################################
# ナップサック
# 重さ：Wー10**5くらい
# 価値：N*max_Viー10**11くらい
# dp[w]:wの重さで可能な最大の価値
# dp[w]とdp[w-wi]+vi(i番目のアイテムをとる場合)との大きいほうで更新
#######################################################################
n, t = map(int, input().split())
dp = [0] * (t+1)
itm = [list(map(int, input().split())) for _ in range(n)]
itm.sort()
for w_ , v_ in itm:
for i in range(1,t+1):
dp[max(0,i-w_)] = max(dp[max(0,i-w_)], dp[i] + v_)
print(dp[0])
| 0 | null | 138,310,482,482,000 | 264 | 282 |
S = list(input())
N = int(input())
normalFlag = True
front = []
back = []
for _ in range(N):
q = list(map(str,input().split()))
if q[0] == '1':
normalFlag = not normalFlag
else:
if q[1] == '1':
if normalFlag:
front.append(q[2])
else:
back.append(q[2])
else:
if normalFlag:
back.append(q[2])
else:
front.append(q[2])
if normalFlag:
front.reverse()
ans = front+S+back
else:
back.reverse()
S.reverse()
ans = back+S+front
print(''.join(map(str,ans)))
|
from sys import exit
import copy
#import numpy as np
#from collections import deque
d, = map(int, input().split())
c= list(map(int, input().split()))
s=[list(map(int, input().split())) for _ in range(d)]
# t=[int(input()) for _ in range(d)]
sche=[0 for _ in range(d)]
s_tmp=float("inf")*(-1)
for off in range(0,13):
last=[0 for _ in range(26)]
sche=[0 for _ in range(d)]
for day in range(1,d+1):
idx=day-1
d_tmp=float("inf")*(-1)
i_tmp=0
for t in range(26):
delta=0
l_tmp=copy.copy(last)
delta+=s[idx][t]
l_tmp[t]=day
for l in range(26):
delta-=0.5*(off+1)*c[l]*((day-l_tmp[l])+(day+off-l_tmp[l]))
if delta>=d_tmp:
d_tmp=delta
i_tmp=t
sche[idx]=i_tmp+1
# score+=d_tmp
last[i_tmp]=day
# print(score)
# print(i_tmp+1)
score=0
last=[0 for _ in range(26)]
for i in range(1,d+1):
idx=i-1
score+=s[idx][sche[idx]-1]
for l in range(26):
score-=c[l]*(i-last[l])
last[sche[idx]-1]=i
# print(score)
if score>=s_tmp:
s_tmp=score
sche_tmp=copy.copy(sche)
for i in sche_tmp:
print(i)
# print(s_tmp)
| 0 | null | 33,658,539,729,988 | 204 | 113 |
import sys
N, M = map(int, input().split())
if N==1 and M == 0:
print('0')
sys.exit()
d={}
ans = 0
for i in range(M):
s, c = map(int, input().split())
if s == 1 and c == 0 and N == 1:
ans = -2
elif s == 1 and c == 0:
ans = -1
elif s in d and c != d[s]:
ans = -1
else:
d[s] = c
if ans == -1:
print(ans)
elif ans == -2:
print('0')
else:
for i in range(N):
if i+1 in d:
print(d[i+1], end='')
elif i+1 == 1:
print('1', end='')
else:
print('0', end='')
|
N,M=map(int,input().split())
if N == 1:begin,end=0,10
elif N==2:begin,end=10,100
else: begin,end=100,1000
ans = -1
SC=[]
for i in range(M):
s,c = map(int,input().split())
SC.append((s,c))
for n in range(begin,end):
count = 0
n = str(n)
for i in range(M):
if int(n[SC[i][0]-1])==SC[i][1]:count+=1
if count==M:
ans=n
break
print(ans)
| 1 | 60,488,942,333,622 | null | 208 | 208 |
n = input()
print("Yes" if n.find('7') != -1 else "No")
|
from sys import stdin
input = stdin.readline
from time import time
from random import randint
from copy import deepcopy
start_time = time()
def calcScore(t, s, c):
scores = [0]*26
lasts = [0]*26
for i in range(1, len(t)):
scores[t[i]] += s[i][t[i]]
dif = i - lasts[t[i]]
scores[t[i]] -= c[t[i]] * dif * (dif-1) // 2
lasts[t[i]] = i
for i in range(26):
dif = len(t) - lasts[i]
scores[i] -= c[i] * dif * (dif-1) // 2
return scores
def greedy(c, s):
day_lim = len(s)
socres = [0]*26
t = [0]*day_lim
lasts = [0]*26
for i in range(1, day_lim):
pls = [v for v in socres]
mns = [v for v in socres]
for j in range(26):
pls[j] += s[i][j]
mns[j] -= c[j] * (i - lasts[j])
sum_mns = sum(mns)
pt = sum_mns - mns[0] + pls[0]
idx = 0
for j in range(1, 26):
tmp = sum_mns - mns[j] + pls[j]
if pt < tmp:
pt = tmp
idx = j
t[i] = idx
lasts[idx] = i
for j in range(26):
if j == idx:
socres[j] = pls[j]
else:
socres[j] = mns[j]
return socres, t
def subGreedy(c, s, t, day):
day_lim = len(s)
socres = [0]*26
t = [0]*day_lim
lasts = [0]*26
for i in range(1, day_lim):
if day <= i:
pls = [v for v in socres]
mns = [v for v in socres]
for j in range(26):
pls[j] += s[i][j]
mns[j] -= c[j] * (i - lasts[j])
sum_mns = sum(mns)
pt = sum_mns - mns[0] + pls[0]
idx = 0
for j in range(1, 26):
tmp = sum_mns - mns[j] + pls[j]
if pt < tmp:
pt = tmp
idx = j
t[i] = idx
lasts[idx] = i
for j in range(26):
if j == idx:
socres[j] = pls[j]
else:
socres[j] = mns[j]
else:
scores[t[i]] += s[i][t[i]]
lasts[t[i]] = i
for j in range(26):
dif = i - lasts[j]
scores[j] -= c[j] * dif
return socres, t
def shuffle(t):
rng = len(t)//2
for _ in range(50):
idx = randint(1, rng)
t[idx], t[idx+1] = t[idx+1], t[idx]
return t
D = int(input())
c = list(map(int, input().split()))
s = [[0]*26 for _ in range(D+1)]
for i in range(1, D+1):
s[i] = list(map(int, input().split()))
scores, t = greedy(c, s)
t = shuffle(t)
scores = calcScore(t, s, c)
sum_score = sum(scores)
while time() - start_time < 1.86:
typ = randint(1, 100)
if typ <= 70:
for _ in range(100):
tmp_t = deepcopy(t)
tmp_t[randint(1, D)] = randint(0, 25)
tmp_scores = calcScore(tmp_t, s, c)
sum_tmp_score = sum(tmp_scores)
if sum_score < sum_tmp_score:
sum_score = sum_tmp_score
t = deepcopy(tmp_t)
scores = deepcopy(tmp_scores)
elif typ <= 97:
for _ in range(100):
tmp_t = deepcopy(t)
dist = randint(1, 15)
p = randint(1, D-dist)
q = p + dist
tmp_t[p], tmp_t[q] = tmp_t[q], tmp_t[p]
tmp_scores = calcScore(tmp_t, s, c)
sum_tmp_score = sum(tmp_scores)
if sum_score < sum_tmp_score:
sum_score = sum_tmp_score
t = deepcopy(tmp_t)
scores = deepcopy(tmp_scores)
elif typ <= 100:
tmp_t = deepcopy(t)
day = randint(D//4*3, D)
tmp_scores, tmp_t = subGreedy(c, s, tmp_t, day)
sum_tmp_score = sum(tmp_scores)
if sum_score < sum_tmp_score:
sum_score = sum_tmp_score
t = deepcopy(tmp_t)
scores = deepcopy(tmp_scores)
for v in t[1:]:
print(v+1)
| 0 | null | 21,965,418,569,222 | 172 | 113 |
import fractions
mod=10**9+7
def lcm(m,n):return m//fractions.gcd(m,n)*n
n=int(input())
a=list(map(int,input().split()))
l=a[0]
ans=0
for i in a:l=lcm(i,l)
for i in a:ans+=l*pow(i,mod-2,mod)%mod
print(ans%mod)
|
input_int = input()
input_str = input()
K = int(input_int)
S = str(input_str)
if len(S)<=K:
print(S)
elif len(S)>K:
print(S[:K]+'...')
| 0 | null | 53,513,127,650,840 | 235 | 143 |
# coding: utf-8
a, b = map(str,input().split())
a = int(a)
b = int(b.replace(".", ""))
print(a*b//100)
|
ini = lambda : int(input())
inm = lambda : map(int,input().split())
inl = lambda : list(map(int,input().split()))
gcd = lambda x,y : gcd(y,x%y) if x%y else y
a,b = input().split()
b = b[:-3] + b[-2:]
ans = int(a) * int(b)
ans = ans // 100
print(ans)
| 1 | 16,494,824,778,872 | null | 135 | 135 |
from itertools import product
def solve():
N = int(input())
graph = {i: [] for i in range(1, N+1)}
for i in range(N):
A = int(input())
for _ in range(A):
x,y = map(int, input().split())
graph[i+1].append((x,y))
def dfs(nodes):
searched = [-1] * N
stack = [i+1 for i,node in enumerate(nodes) if node == 1]
ret_len = len(stack)
while stack:
node = stack.pop(0)
for x,y in graph[node]:
if nodes[x-1] != y: return -1
if searched[x-1] == -1:
searched[x-1] = y
if y == 1: stack.append(x)
# print(nodes, searched)
return ret_len
ret = 0
for nodes in product([0,1], repeat=N):
ret = max(ret, dfs(nodes))
print(ret)
solve()
|
#!/usr/bin/env python3
import sys, math
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans=count=0
n,m=map(int,input().split())
A=list(map(int,input().split()))
dp=[inf]*(n+1)
dp[0]=0
for a in A:
for i in range(a,n+1):
dp[i]=min(dp[i],dp[i-a]+1)
print(dp[n])
| 0 | null | 60,551,491,678,630 | 262 | 28 |
N = int(input())
ans = 0
ans = -(-N//2)
print(ans)
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N = int(readline())
print((N+1) // 2)
return
if __name__ == '__main__':
main()
| 1 | 58,749,888,117,030 | null | 206 | 206 |
s=raw_input().strip()
print s+('es' if s[-1]=='s' else 's')
|
string = input()
if string[-1] == 's':
out = string + "es"
else:
out = string + "s"
print(out)
| 1 | 2,358,203,506,458 | null | 71 | 71 |
def insertionSort(a,n,g):
global cnt
for i in range(g,n):
v = a[i]
j = i-g
while j>=0 and a[j]>v:
a[j+g] = a[j]
j = j-g
cnt+=1
a[j+g] = v
def shellSort(a,n):
global m
global g
h = 1
while True:
if h>n:
break
g.append(h)
h = 3*h+1
m = len(g)
g.reverse()
for i in range(m):
insertionSort(a,n,g[i])
n = int(input())
a = [int(input()) for i in range(n)]
g = []
cnt = 0
m = 0
shellSort(a,n)
print(m)
print(*g)
print(cnt)
for i in range(n):
print(a[i])
|
def insertionSort(A, n, g, cnt):
for i in range(g, n):
v = A[i]
j = i - g
while (j >= 0) and (A[j] > v):
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
return cnt
def shellSort(A, n, m, G):
cnt = 0
for i in range(m):
cnt = insertionSort(A, n, G[i], cnt)
return cnt
n = int(input())
A = []
for i in range(n):
A.append(int(input()))
h = 1
p = 1
G = []
if n < 2:
G = [1]
p = 2
else:
while h < n:
G.append(h)
h = 3 ** p + h
p += 1
G.reverse()
cnt = shellSort(A, n, p - 1, G)
print(p - 1)
print(" ".join(map(str, G)))
print(cnt)
for i in range(n):
print(A[i])
| 1 | 30,390,052,600 | null | 17 | 17 |
N = int(input())
A = [int(i) for i in input().split()]
if N == 0 and A[0] != 1:
print(-1)
exit()
nodes = [0] * (N+1)
nodes[0] = 1
for i in range(1, N+1):
node = (nodes[i-1]-A[i-1])*2
if node < A[i]:
print(-1)
exit()
nodes[i] = node
#print(nodes)
nodes[-1] = A[-1]
for i in range(N-1, -1, -1):
nodes[i] = min(nodes[i], nodes[i+1]+A[i])
#print(nodes)
print(sum(nodes))
|
N = int(input())
ans = 0
for i in range(1, N + 1):
n = N // i # 項数n
cnt = (n * (2 * i + (n - 1) * i)) // 2 # 初項i, 項数n の等差数列の和の公式
ans += cnt
print(ans)
| 0 | null | 14,920,632,434,072 | 141 | 118 |
from math import pi
r = float(input())
print (format(r**2*pi, '.6f'),format(r*pi*2, '.6f'))
|
# 入力
# 値は全てint
# Nは本数、Kは切る回数、AはN本の木のそれぞれの長さ(リスト)
N,K = map(int,input().split())
A = list(map(int,input().split()))
# 二分探索
# lが左端、rが右端
l,r = 0, 10**9
# 整数で返すので、差が１より大きい時はループする
while r - l > 1:
# 真ん中を設定
x = (r+l) // 2
# 切る回数をc
c = 0
for a in A:
# それぞれの丸太の(長さ-1)をxで割った値の合計が、切る回数
c += (a-1) // x
# 切る回数がKよりも小さい時はOKなので右端を寄せる
if c <= K:
r = x
else:
l = x
print(r)
| 0 | null | 3,523,380,829,322 | 46 | 99 |
n = int(input())
data = list(zip([int(n) for n in input().split()], [int(n) for n in input().split()]))
dist = []
for pair in data:
dist.append(abs(pair[0] - pair[1]))
print(sum(dist))
print(pow(sum(n ** 2 for n in dist), 1 / 2))
print(pow(sum(n ** 3 for n in dist), 1 / 3))
print(max(dist))
|
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
*a, = map(int, input().split())
s = [0]*(n+1)
for i in range(len(a)):
s[i+1] = s[i] + a[i]
for i in range(len(s)):
s[i] = (s[i] - i)%k
from collections import defaultdict
cnt = defaultdict(int)
left = 0
right = k-1
if right > n:
right = n
for i in range(right+1):
cnt[s[i]] += 1
ans = 0
while left < right:
ans += cnt[s[left]]-1
if right == n:
cnt[s[left]] -= 1
left += 1
else:
cnt[s[left]] -= 1
left += 1
right += 1
cnt[s[right]] += 1
print(ans)
| 0 | null | 68,849,732,904,768 | 32 | 273 |
from math import sqrt
N = int(input())
# Cが固定されAxBを入れ替えるときは省略したい
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
ans = 0
""" for C in range(1,N):
ans += len(make_divisors(N-C)) """
for A in range(1,N):
ans += (N-1)//A
print(ans)
|
import itertools
n =int(input())
p =tuple(map(int,input().split()))
q =tuple(map(int,input().split()))
l = list(range(1,n+1))
r = list(itertools.permutations(l, n))
print(abs(r.index(p)-r.index(q)))
| 0 | null | 51,754,176,147,300 | 73 | 246 |
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N, M = map(int, input().split())
A = list(sorted(map(int, input().split())))
S = sum(A)
acc = [0] * (N + 1)
for i in range(1, N + 1):
acc[i] = acc[i - 1] + A[i - 1]
def check(x):
total = 0
cnt = 0
for a in A:
l = -1
r = N
while r - l > 1:
m = (l + r) // 2
if A[m] + a >= x:
r = m
else:
l = m
cnt += N - r
total += acc[N] - acc[r]
total += a * (N - r)
return (total, cnt)
left = 0
right = 10 ** 6
while right - left > 1:
mid = (left + right) // 2
res = check(mid)
if res[1] >= M:
left = mid
else:
right = mid
res = check(left)
ans = res[0]
print(ans - (res[1] - M) * left)
|
import bisect
n,m=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
ng=-1
ok=A[-1]*2+1
B=[[0]*n for k in range(2)]
ii=0
while ok-ng>1:
mid=(ok+ng)//2
d=0
for i in range(n):
c=n-bisect.bisect_right(A,mid-A[i],lo=0,hi=len(A))
B[ii][i]=c
d=d+c
if d<m:
ok=mid
ii=(ii+1)%2
else:
ng=mid
D=[0]
for i in range(n):
D.append(D[-1]+A[n-i-1])
ans=0
for i in range(n):
x=B[(ii+1)%2][i]
ans=ans+A[i]*x+D[x]
ans=ans+(m-sum(B[(ii+1)%2]))*ok
print(ans)
| 1 | 107,827,541,846,820 | null | 252 | 252 |
X, Y, Z = map(int, input().split())
print("%d %d %d"%(Z, X, Y))
|
input_line = input()
Line = input_line.split()
Line = [int(s) for s in Line]
if Line[0] == Line[1]:
print("Yes")
else:
print("No")
| 0 | null | 60,459,536,839,900 | 178 | 231 |
def isprime(n):
if n < 2: return 0
elif n == 2: return 1
if n % 2 == 0: return 0
for i in range(3, n, 2):
if i > n/i: return 1
if n % i == 0 : return 0
return 1
N = int(input())
n = [int(input()) for i in range(N)]
a = [i for i in n if isprime(i)]
print(len(a))
|
n = int(input())
ans = 0
for x in (int(input()) for _ in range(n)):
flg = True
for y in range(2, int(x**0.5+1)):
if x % y == 0:
flg = False
break
if flg:
ans += 1
print(ans)
| 1 | 10,342,341,470 | null | 12 | 12 |
import sys
def main():
orders = sys.stdin.readlines()[1:]
dna_set = set()
for order in orders:
command, dna = order.split(" ")
if command == "insert":
dna_set.add(dna)
elif command == "find":
if dna in dna_set:
print("yes")
else:
print("no")
if __name__ == "__main__":
main()
|
# AOJ ALDS1_4_C Dictionary
# Python3 2018.7.3 bal4u
dic = {}
n = int(input())
for i in range(n):
id, s = input().split()
if id == "insert": dic[s] = 1
else: print("yes" if s in dic else "no")
| 1 | 77,439,175,900 | null | 23 | 23 |
from random import choice
from time import time
start_time = time()
d = int(input())
*C, = map(int, input().split())
S = [list(map(int, input().split())) for i in range(d)]
X = []
L = [-1 for j in range(26)]
for i in range(d):
max_diff = -10**10
best_j = 0
for j in range(26):
memo = L[j]
L[j] = i
diff = S[i][j] - sum([C[jj] * (i - L[jj]) for jj in range(26)])
if diff > max_diff:
max_diff = diff
best_j = j
L[j] = memo
L[best_j] = i
X.append(best_j)
def f(X):
score = 0
L = [-1 for j in range(26)]
A = [0 for j in range(26)]
for i in range(d):
score += S[i][X[i]]
A[X[i]] += (i - L[X[i]]) * (i - L[X[i]] - 1) // 2
L[X[i]] = i
for j in range(26):
A[j] += (d - L[j]) * (d - L[j] - 1) // 2
score -= C[j] * A[j]
return score
max_score = f(X)
while time() - start_time < 1.8:
i = choice(range(d))
j = choice(range(26))
memo = X[i]
X[i] = j
score = f(X)
if score > max_score:
max_score = score
else:
X[i] = memo
a = choice(range(7))
i0 = choice(range(d - a))
i1 = i0 + a
memo = X[i0], X[i1]
X[i0], X[i1] = X[i1], X[i0]
score = f(X)
if score > max_score:
max_score = score
else:
X[i0], X[i1] = memo
for x in X:
print(x + 1)
|
n,k = map(int, input().split())
a = list(map(int, input().split()))
l = [0]*(n-k+1)
l[0] = sum(a[:k])
for i in range(k,n): l[i-k+1] = l[i-k] + a[i] - a[i-k]
for i in range(1,n-k+1):
if l[i-1] < l[i]: print("Yes")
else: print("No")
| 0 | null | 8,493,178,927,728 | 113 | 102 |
n=int(input())
if n%2==0:print(n//2)
else:print(n//2+1)
|
from collections import deque
n=int(input())
que_r=deque()
for i in range(n):
s=input()
l=len(s)
if s[0]=="i":
que_r.appendleft(s[7:])
elif s[6]==" ":
try:
que_r.remove(s[7:])
except: pass
elif l>10:
que_r.popleft()
elif l>6:
que_r.pop()
print(*que_r)
| 0 | null | 29,553,056,316,208 | 206 | 20 |
K = input()
NUM = list(map(int,input().split()))
count = 0
for num in range(NUM[1]-NUM[0]+1):
if ((NUM[0]+num )% int(K) == 0):
print("OK")
count += 1
break
if (count == 0):
print("NG")
|
K = int(input())
A,B = map(int,input().split())
if (A-1)//K == B//K:
print("NG")
else:
print("OK")
| 1 | 26,782,818,237,278 | null | 158 | 158 |
h, w, n = map(int, open(0))
print(0 - -n // max(h, w))
|
import math
a = int(input())
b = int(input())
n = int(input())
dum = max(a,b)
ans = n/dum
print(math.ceil(ans))
| 1 | 88,780,259,739,270 | null | 236 | 236 |
a,b = map(int,input().split())
if b-a>=0:
print('unsafe')
else:
print('safe')
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
t1, t2 = LI()
a1, a2 = LI()
b1, b2 = LI()
p = (a1 - b1) * t1
q = (a2 - b2) * t2
if p > 0:
p = -p
q = -q
if p + q == 0:
print('infinity')
elif p + q < 0:
print(0)
else:
print((-p // (p + q)) * 2 + bool(-p % (p + q)))
| 0 | null | 80,053,963,837,050 | 163 | 269 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
??´?????????
"""
suits = {"S": 0, "H": 1, "C": 2, "D": 3}
nsuits = ["S", "H", "C", "D"]
cards = [[0 for i in range(13)] for j in range(4)]
n = int(input())
for i in range(n):
inp = input().split(" ")
s = inp[0]
c = int(inp[1]) - 1
cards[suits[s]][c] = 1
for i in range(4):
for j in range(13):
if cards[i][j] == 0:
print("{0} {1}".format(nsuits[i], j+1))
|
N, K, C = map(int, input().split())
S = input()
def get_positions():
res = []
i = 0
while i < N and len(res) < K:
if S[i] == "o":
res.append(i)
i = i + C + 1
else:
i += 1
return res
l = get_positions()
S = S[::-1]
r = get_positions()
for i in range(K):
r[i] = N - 1 - r[i]
S = S[::-1]
lastl = [-1] * (N + 1)
for i in range(K):
lastl[l[i] + 1] = i
for i in range(N):
if lastl[i + 1] == -1:
lastl[i + 1] = lastl[i]
lastr = [-1] * (N + 1)
for i in range(K):
lastr[r[i]] = i
for i in range(N-1, -1, -1):
if lastr[i] == -1:
lastr[i] = lastr[i + 1]
for i in range(N):
if S[i] == "x":
continue
li = lastl[i]
ri = lastr[i + 1]
cnt = 0
if li != -1:
cnt += (li + 1)
if ri != -1:
cnt += (ri + 1)
if li != -1 and ri != -1 and r[ri] - l[li] <= C:
cnt -= 1
if cnt >= K:
continue
print(i + 1)
| 0 | null | 20,723,480,274,770 | 54 | 182 |
class Dice:
def __init__(self, faces):
self.faces = tuple(faces)
def roll_north(self):
self.faces = (self.faces[1], self.faces[5], self.faces[2],
self.faces[3], self.faces[0], self.faces[4])
def roll_south(self):
self.faces = (self.faces[4], self.faces[0], self.faces[2],
self.faces[3], self.faces[5], self.faces[1])
def roll_west(self):
self.faces = (self.faces[2], self.faces[1], self.faces[5],
self.faces[0], self.faces[4], self.faces[3])
def roll_east(self):
self.faces = (self.faces[3], self.faces[1], self.faces[0],
self.faces[5], self.faces[4], self.faces[2])
def number(self, face_id):
return self.faces[face_id - 1]
dice = Dice(list(map(int, input().split())))
n = int(input())
for i in range(n):
(face1, face2) = map(int, input().split())
if face2 == dice.number(3) or face2 == dice.number(4):
dice.roll_west()
while dice.number(2) != face2:
dice.roll_north()
while dice.number(1) != face1:
dice.roll_west()
print(dice.number(3))
|
# your code goes here
#dice2
def np(dl,nu):
l=0
while dl[l]!=nu:
l+=1
return l
def si(n1,n2):
if n1==1:
if n2==2:
return 3
elif n2==3:
return 5
elif n2==4:
return 2
else:
return 4
elif n1==2:
if n2==1:
return 4
elif n2==3:
return 1
elif n2==4:
return 6
else:
return 3
elif n1==3:
if n2==2:
return 6
elif n2==5:
return 1
elif n2==1:
return 2
else:
return 5
elif n1==4:
if n2==1:
return 5
elif n2==2:
return 1
elif n2==5:
return 6
else:
return 2
elif n1==5:
if n2==1:
return 3
elif n2==3:
return 6
elif n2==4:
return 1
else:
return 4
elif n1==6:
if n2==3:
return 2
elif n2==2:
return 4
elif n2==5:
return 3
else:
return 5
D=[int(i) for i in input().split()]
q=int(input())
for i in range(q):
n=[int(i) for i in input().split()]
# print(n)
p=[]
for j in range(2):
p.append(np(D,n[j]))
# print(p)
print(D[si(p[0]+1,p[1]+1)-1])
| 1 | 247,309,837,868 | null | 34 | 34 |
N, M, X = map(int, input().split())
C = []
A = []
for i in range(N):
tmp = list(map(int, input().split()))
C.append(tmp[0])
A.append(tmp[1:])
ans = -1
for i in range(1, 1 << N):
price = 0
skill = [0] * M
b = len(bin(i)) - 2
for j in range(b):
price += C[j] * (i >> j & 1)
for k in range(M):
skill[k] += A[j][k] * (i >> j & 1)
if min(skill) >= X and (price < ans or ans < 0):
ans = price
print(ans)
|
n , m , x = map(int, input().split())
a = list(list(map(int, input().split())) for _ in range(n))
c = []
for i in range(n):
c.append(a[i][0])
a[i].pop(0)
ans = 1000000000
# bit全探索
for i in range(1 << n):
score = [0] * m
tmp = 0
for j in range(n):
if (i >> j) % 2 == 1:
tmp += c[j]
for k in range(m):
score[k] += a[j][k]
if min(score) >= x:
ans = min(ans , tmp)
if(ans == 1000000000):
print(-1)
else:
print(ans)
| 1 | 22,300,216,057,210 | null | 149 | 149 |
FAST_IO = 0
if FAST_IO:
import io, sys, atexit
rr = iter(sys.stdin.read().splitlines()).next
sys.stdout = _OUTPUT_BUFFER = io.BytesIO()
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
else:
rr = raw_input
rri = lambda: int(rr())
rrm = lambda: map(int, rr().split())
rrmm = lambda n: [rrm() for _ in xrange(n)]
####
from collections import defaultdict as ddic, Counter, deque
import heapq, bisect, itertools
MOD = 10 ** 9 + 7
def solve(N, A):
from fractions import gcd
g = A[0]
for x in A:
g= gcd(g,x)
if g > 1:
return "not coprime"
seen = set()
for x in A:
saw = set()
while x % 2 == 0:
x //= 2
saw.add(2)
d = 3
while d*d <= x:
while x%d == 0:
saw.add(d)
x //= d
d += 2
if x > 1:
saw.add(x)
for p in saw:
if p in seen:
return "setwise coprime"
seen |= saw
return "pairwise coprime"
N= rri()
A = rrm()
print solve(N, A)
|
# -*- config: utf-8 -*-
if __name__ == '__main__':
for i in range(int(raw_input())):
nums = map(lambda x:x**2,map(int,raw_input().split()))
nums.sort()
if nums[0]+nums[1] == nums[2]:
print "YES"
else :
print "NO"
| 0 | null | 2,062,060,518,390 | 85 | 4 |
s=input()
ch=False
for i in s:
if i=="7":ch=True
if ch:print("Yes")
else:print("No")
|
a=int(input())
str_a=str(a)
list_a=list(str_a)
count=0
for i in range(0,len(list_a)):
if(list_a[i]=='7'):
count+=1
else:
count+=0
if(count>1 or count==1):
print('Yes')
else:
print('No')
| 1 | 34,293,882,750,402 | null | 172 | 172 |
from math import log, ceil
N, K = map(int, input().split())
res = ceil(log(N, K))
if res == 0:
res = 1
print(res)
|
N,R=map(int,input().split())
num=0
while N>=R:
N=N/R
num+=1
print(num if N==0 else num+1)
| 1 | 64,576,144,444,252 | null | 212 | 212 |
from collections import deque
def bfs():
que=deque([])
que.append(0)
v[0]=0
while que:
p=que.popleft()
for l in L[p]:
if v[l-1]==-1:
que.append(l-1)
v[l-1]=v[p]+1
n=int(input())
L=[]
for i in range(n):
A=[]
A=list(map(int,input().split()))
L.append(A[2:])
v=[-1]*n
bfs()
for i in range(n):
print(i+1,v[i])
|
t=int(input())
taro=0
hanako=0
for i in range(t):
S=input().split()
if S[0]==S[1]:
taro+=1
hanako+=1
elif S[0]>S[1]:
taro+=3
else:
hanako+=3
print(taro,hanako)
| 0 | null | 990,614,329,100 | 9 | 67 |
a = 0
for i in input():
a += int(i)
print("Yes" if a%9==0 else "No")
|
N = input()
list = []
for i in range(len(N)):
list.append(int(N[i]))
if sum(list) % 9 ==0:
print('Yes')
else:
print('No')
| 1 | 4,472,028,887,416 | null | 87 | 87 |
n = input()
l = [int(i) for i in input().split()]
print(' '.join([str(min(l)),str(max(l)),str(sum(l))]))
|
input()
list=[int(i) for i in input().split()]
print(min(list),max(list),sum(list))
| 1 | 746,502,235,200 | null | 48 | 48 |
#coding: UTF-8
l = raw_input().split()
W = int(l[0])
H = int(l[1])
x = int(l[2])
y = int(l[3])
r = int(l[4])
if x >=r:
if y >=r:
if x <=(H -r):
if y <=(H-r):
print "Yes"
else:
print "No"
else:
print"No"
else:
print "No"
else:
print "No"
|
K = int(input())#asking lenght of string wanted to be shorted
S = input()#asking string
if len(S)>K:##set that S must be greater than K
print (S[:K], "...",sep="")# to print only the K number of the string
else:
print (S)
| 0 | null | 10,110,640,196,480 | 41 | 143 |
s, t = input().split()
a, b = [int(i) for i in input().split()]
u = input()
if s == u:
a -= 1
elif t == u:
b -= 1
print(a, b)
|
s,t = input().split()
d={}
d[s], d[t] = map(int,input().split())
d[input()] -= 1
print(d[s],d[t])
| 1 | 72,119,351,232,600 | null | 220 | 220 |
nums = [int(e) for e in input().split()]
Sheep = nums[0]
Wolves = nums[1]
if Sheep > Wolves:
print("safe")
else:
print("unsafe")
|
import itertools
import math
import fractions
import functools
s, w = map(int, input().split())
if w >= s :print("unsafe")
else: print("safe")
| 1 | 28,969,704,026,316 | null | 163 | 163 |
n = int(input())
g = [[] for _ in range(n)]
for i in range(n):
a = int(input())
for _ in range(a):
x,y = map(int,input().split())
g[i].append((x-1,y))
ans = 0
for bit in range(1<<n):
f = True
for i in range(n):
if bit&(1<<i) and f:
for x,y in g[i]:
if y ==1 and bit&(1<<x):
continue
elif y ==0 and bit&(1<<x)==0:
continue
else:
f = False
break
if f:
ans = max(ans,bin(bit).count('1'))
print(ans)
|
n=int(input())
a=[]
x=[]
for _ in range(n):
A=int(input())
X=[list(map(int,input().split())) for _ in range(A)]
a.append(A)
x.append(X)
ans=0
for i in range(2**n):
tmp=[0]*n
for j in range(n):
if (i>>j)&1:
tmp[j]=1
for k in range(n):
if a[k]==0:
continue
for h in range(a[k]):
hito=x[k][h][0]-1
singi=x[k][h][1]
if tmp[k]==1:
if tmp[hito]!=singi:
break
else:
continue
break
else:
ans=max(ans,sum(tmp))
print(ans)
| 1 | 121,170,079,714,618 | null | 262 | 262 |
a, b = map(str, input().split())
c, d = map(int, input().split())
e = str(input())
if e==a:
print(c-1, d)
elif e==b:
print(c, d-1)
|
import itertools
n = int(input())
l = list(map(int,input().split()))
count = 0
for item in itertools.combinations(l, 3):
if len(set(item)) == 3:
if item[0] + item[1] > item[2] and item[1] + item[2] > item[0] and item[2] + item[0] > item[1]:
count += 1
print(count)
| 0 | null | 38,297,660,459,978 | 220 | 91 |
from collections import deque
def main():
h, w = map(int, input().split())
ls = [input() for _ in range(h)]
def trans(a, b):
return a * w + b
ls2 = [[] for _ in range(h * w)]
for i in range(h):
for j in range(w):
# check ij
if ls[i][j] == '#':
continue
if i >= 1 and ls[i-1][j] != '#':
ls2[trans(i, j)].append(trans(i-1, j))
if i <= h-2 and ls[i+1][j] != '#':
ls2[trans(i, j)].append(trans(i + 1, j))
if j <= w-2 and ls[i][j+1] != '#':
ls2[trans(i, j)].append(trans(i, j + 1))
if j >= 1 and ls[i][j-1] != '#':
ls2[trans(i, j)].append(trans(i, j - 1))
#print(ls2)
def route(i):
count = 1
ss = deque(ls2[i])
next = deque()
explored = {i}
while ss or next:
if not ss:
count +=1
ss = next
next = deque()
now =ss.popleft()
if now in explored:
continue
else:
explored.add(now)
next.extend(ls2[now])
return count-1
ans = 0
for i in range(h * w - 1):
if ls2[i] == []:
continue
ans = max(ans, route(i))
print(ans)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
import bisect
import heapq
import itertools
import math
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
bunshi=1
bunbo=1
for i in range(r):
bunbo = bunbo*(i+1)%mod
bunshi = bunshi*(n-i)%mod
return (bunshi*pow(bunbo,mod-2,mod))%mod
mod = 10**9+7
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return [list(map(int, input().split())) for _ in range(n)]
#bisect.bisect_left(list,key)はlistのなかでkey未満の数字がいくつあるかを返す
#つまりlist[i] < x となる i の個数
#bisect.bisect_right(list, key)はlistのなかでkey以下の数字がいくつあるかを返す
#つまりlist[i] <= x となる i の個数
#これを応用することで
#len(list) - bisect.bisect_left(list,key)はlistのなかでkey以上の数字がいくつあるかを返す
#len(list) - bisect.bisect_right(list,key)はlistのなかでkeyより大きい数字がいくつあるかを返す
#これらを使うときはあらかじめlistをソートしておくこと！
def maze_solve(S_1,S_2,maze_list):
d = deque()
d.append([S_1,S_2])
dx = [0,0,1,-1]
dy = [1,-1,0,0]
while d:
v = d.popleft()
x = v[0]
y = v[1]
for i in range(4):
nx = x + dx[i]
ny = y + dy[i]
if nx < 0 or nx >= h or ny < 0 or ny >= w:
continue
if dist[nx][ny] == -1:
dist[nx][ny] = dist[x][y] + 1
d.append([nx,ny])
return max(list(map(lambda x: max(x), dist)))
h,w = MI()
if h==1 and w == 2:
print(1)
elif h == 2 and w == 1:
print(1)
else:
ans = 0
maze = [list(input()) for _ in range(h)]
dist = [[-1]*w for _ in range(h)]
start_list = []
for i in range(h):
for j in range(w):
if maze[i][j] == "#":
dist[i][j] = 0
else:
start_list.append([i,j])
dist_copy = deepcopy(dist)
for k in start_list:
dist = deepcopy(dist_copy)
ans = max(ans,maze_solve(k[0],k[1],maze))
print(ans+1)
| 1 | 94,582,054,947,050 | null | 241 | 241 |
n = int(input())
i = 0
list_n = [n]
map_n = map(int, input().split())
list_n = list(map_n)
for value in reversed(list_n):
print(value, end ='')
if value != list_n[0]:
print(' ', end = '')
print()
|
input()
print(*input().split()[::-1],sep=' ')
| 1 | 987,207,560,038 | null | 53 | 53 |
import math
from math import gcd
INF = float("inf")
import sys
input=sys.stdin.readline
import itertools
def main():
n = int(input())
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
l = sorted(list(itertools.permutations(range(1,n+1), n)))
ans = []
for i in range(len(l)):
if l[i] == p:
ans.append(i)
elif l[i] == q:
ans.append(i)
if len(ans) == 1:
print(0)
else:
print(abs(ans[0]-ans[1]))
if __name__=="__main__":
main()
|
S = int(input())
n = S // 3
p = 1000000000 + 7
N = 2000
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
def MOD_binom(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
answer = 0
for i in range(1, n + 1):
answer += MOD_binom(S - 2*i - 1, i-1, p)
print(answer % p)
| 0 | null | 51,986,125,956,028 | 246 | 79 |
if __name__ == '__main__':
n = int(input())
S = [0,0,0,0]
for _ in range(n):
cmd = input()
if cmd == "AC":
S[0] += 1
elif cmd == "TLE":
S[2] += 1
elif cmd == "WA":
S[1] += 1
else:
S[3] += 1
for i in range(4):
if i == 0:
print("AC x " + str(S[0]))
elif i == 1:
print("WA x " + str(S[1]))
elif i == 2:
print("TLE x " + str(S[2]))
else:
print("RE x " + str(S[3]))
|
N = int(input())
ac = 0
wa = 0
tle = 0
re = 0
for i in range(N):
s = input()
if s == 'AC':
ac += 1
elif s == 'WA':
wa += 1
elif s == 'TLE':
tle += 1
else:
re += 1
t = [ac, wa, tle, re]
for i in range(4):
if i == 0:
print('AC x ' + str(ac))
if i == 1:
print('WA x ' + str(wa))
if i == 2:
print('TLE x ' + str(tle))
if i == 3:
print('RE x ' + str(re))
| 1 | 8,636,169,147,576 | null | 109 | 109 |
N,M = map(int,input().split())
A = [int(x) for x in input().split()]
if N - sum(A) >= 0 :
print(N-sum(A))
else :
print("-1")
|
a,b=map(int,input().split())
List = list(map(int, input().split()))
wa = 0
for i in range(b):
wa += List[i]
res = a - wa
if res < 0:
res = -1
print(res)
| 1 | 31,960,841,016,288 | null | 168 | 168 |
n = int(input())
c0 = 0
c1 = 0
c2 = 0
c3 = 0
for i in range(n):
c = input()
if c == 'AC':
c0 += 1
elif c == 'WA':
c1 += 1
elif c == 'TLE':
c2 += 1
else:
c3 += 1
print(f'AC x {c0}')
print(f'WA x {c1}')
print(f'TLE x {c2}')
print(f'RE x {c3}')
|
s = []
n = int(input())
for i in range(n):
s.append(input())
print("AC x " + str(s.count("AC")))
print("WA x " + str(s.count("WA")))
print("TLE x " + str(s.count("TLE")))
print("RE x " + str(s.count("RE")))
| 1 | 8,664,707,743,692 | null | 109 | 109 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
S, T = input().split()
A, B = map(int, readline().split())
U = input()
if S == U:
A -= 1
if T == U:
B -= 1
print(A, B)
if __name__ == '__main__':
main()
|
# coding=utf-8
from __future__ import division
from math import sqrt
def main():
n = input()
while n:
scores = map(int, raw_input().split())
m = sum(scores) / n
print sqrt(sum([(x - m) ** 2 for x in scores]) / n)
n = input()
if __name__ == '__main__':
main()
| 0 | null | 35,935,592,200,560 | 220 | 31 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
???????????????
"""
inputstr = input().strip()
cmdnum = int(input().strip())
for i in range(cmdnum) :
cmd = input().strip().split()
if cmd[0] == "print":
start = int(cmd[1])
end = int(cmd[2]) + 1
print(inputstr[start:end])
if cmd[0] == "reverse":
start = int(cmd[1])
end = int(cmd[2]) + 1
prev = inputstr[:start]
revr = inputstr[start:end]
next = inputstr[end:]
inputstr = prev + revr[::-1] + next
if cmd[0] == "replace":
start = int(cmd[1])
end = int(cmd[2]) + 1
inputstr = inputstr[:start] + cmd[3] + inputstr[end:]
|
N,M,L = map(int,input().split())
A = [list(map(int,input().split()))for i in range(N)]
B = [list(map(int,input().split()))for i in range(M)]
ANS = [[0]*L for i in range(N)]
for x in range(N):
for y in range(L):
for z in range(M):
ANS[x][y]+=B[z][y]*A[x][z]
for row in range(N):
print("%d"%ANS[row][0],end="")
for col in range(1,L):
print(" %d"%(ANS[row][col]),end="")
print()
| 0 | null | 1,733,982,868,490 | 68 | 60 |
x,y = map(int,input().split())
if y % 2 != 0:
print('No')
elif x * 2 <= y <= x * 4:
print('Yes')
else:
print('No')
|
if __name__ == '__main__':
x, y = map(int, input().split())
ans = 'No'
for i in range(x+1):
legs = 4*i+2*(x-i)
if legs == y:
ans = 'Yes'
break
print(ans)
| 1 | 13,656,414,205,600 | null | 127 | 127 |
string = input()
num = int(input())
orders = [input().split() for _ in range(num)]
for order in orders:
start = int(order[1])
end = int(order[2]) + 1
if order[0] == "reverse":
string = string[:start] + string[start:end][::-1] + string[end:]
elif order[0] == "replace":
string = string[:start] + order[3] + string[end:]
elif order[0] == "print":
print(string[start:end])
|
n = int(input())
XY = [[] for _ in range(n)]
ans = 0
for i in range(n):
a = int(input())
for _ in range(a):
x, y = map(int, input().split())
XY[i].append((x-1, y))
for i in range(2**n):
correct = [False]*n
tmp_cnt = 0
flag = True
for j in range(n):
if i&(1<<j):
correct[j] = True
tmp_cnt += 1
for j in range(n):
if correct[j]:
for x, y in XY[j]:
if (y==0 and correct[x]) or (y==1 and not correct[x]):
flag = False
if flag:
ans = max(tmp_cnt, ans)
print(ans)
| 0 | null | 61,646,897,402,442 | 68 | 262 |
# C Marks
N, K = map(int, input().split())
A = list(map(int, input().split())) # リストがうまく作れてない？
j = 0
i = K
ct = 1
while ct <= (N - K):
if A[j] < A[i]:
print("Yes")
else:
print("No")
j += 1
i += 1
ct += 1
|
n,k=map(int,input().split())
a=list(map(int,input().split()))
for i in range(0,n-k):
if a[i]<a[k+i]:print("Yes")
else :print("No")
| 1 | 7,154,735,967,852 | null | 102 | 102 |
#ITP1_7_D
n,m,l=map(int,input().split())
a=[]
b=[]
for _ in range(n):
a.append(list(map(int,input().split())))
for _ in range(m):
b.append(list(map(int,input().split())))
c=[[0 for _ in range(l)] for _ in range(n)]
for i in range(n):
for j in range(l):
for k in range(m):
c[i][j]+=a[i][k]*b[k][j]
for i in range(n):
for j in range(l-1):
print(c[i][j],end=" ")
print(c[i][-1])
|
import sys
input = sys.stdin.readline
def main():
N = int(input())
S = input().rstrip()
if N % 2 == 1:
ans = "No"
else:
if S[:N // 2] == S[N // 2:]:
ans = "Yes"
else:
ans = "No"
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 74,472,286,548,082 | 60 | 279 |
from collections import deque
n = int(input())
mylist = deque()
for i in range(n):
a = input()
if a == "deleteFirst":
mylist.popleft()
elif a == "deleteLast":
mylist.pop()
else:
a,key = a.split()
if a == "insert":
mylist.appendleft(key)
else:
try:
mylist.remove(key)
except:
pass
print(' '.join(mylist))
|
from collections import deque
N = int(input())
L = deque()
for i in range(N):
C= input().split()
if C[0] == "insert":
L.appendleft(C[1])
elif C[0] == "delete":
try:
L.remove(C[1])
except ValueError:
pass
elif C[0] == "deleteFirst":
L.popleft()
elif C[0] == "deleteLast":
L.pop()
print(" ".join(L))
| 1 | 49,603,545,288 | null | 20 | 20 |
import math
A, B, C, D = map(int, input().split())
#何ターンで倒せるかを比較、ターン数が小さい方が強い。ターン数が同じなら高橋が勝ち。
if math.ceil(C / B) <= math.ceil(A / D):
print("Yes")
else:
print("No")
|
import math
a,b,c,d = map(int,input().split())
def death_time(hp,atack):
if hp%atack == 0:
return hp/atack
else:
return hp//atack + 1
takahashi_death = death_time(a,d)
aoki_death = death_time(c,b)
if aoki_death<=takahashi_death:
print("Yes")
else:
print("No")
| 1 | 29,765,233,936,010 | null | 164 | 164 |
import math
while 1:
n=int(input())
if n==0:
break
ave=0.0
aru=0.0
m=[float(i) for i in input().split()]
for i in range(n):
ave=ave+m[i]
ave=ave/n
for i in range(n):
aru=aru+(m[i]-ave)*(m[i]-ave)
aru=math.sqrt(aru/n)
print("%.5f"% aru)
|
def resolve():
t = input()
print(t.replace('?','D'))
if __name__ == "__main__":
resolve()
| 0 | null | 9,230,576,852,200 | 31 | 140 |
import statistics
while True:
n = int(input())
if n == 0:
break
scores = list((int(x) for x in input().split()))
std = statistics.pstdev(scores)
print("{0:.8f}" . format(round(std,8)))
|
n, m = map(int, input().split())
L = list(map(int, input().split()))
a = 0
for i in range(len(L)):
a = a + L[i]
a = a / (4*m)
nL = sorted(L, reverse=True)
if a <= nL[m-1]:
print("Yes")
else:
print("No")
| 0 | null | 19,495,364,286,992 | 31 | 179 |
N = int(input())
S = input()
if N % 2 != 0:
print("No")
exit()
x = int(len(S) / 2)
y = S[0:x]
z = S[x:len(S)]
if y == z:
print("Yes")
else:
print("No")
|
N = int(input())
A = list(map(int, input().split()))
print("APPROVED" if all(a&1 or (a%3==0 or a%5==0) for a in A) else "DENIED")
| 0 | null | 107,817,445,689,348 | 279 | 217 |
def ri(): return int(input())
def rli(): return list(map(int, input().split()))
def rls(): return list(map(str, input().split()))
def pl(a): print(" ".join(list(map(str, a))))
N = ri()
a = rls()
bubble = a[:]
flag = True
while(flag):
flag = False
for i in range(1, N):
if(bubble[-i][1] < bubble[-i-1][1]):
hold = bubble[-i]
bubble[-i] = bubble[-i-1]
bubble[-i-1] = hold
flag = True
pl(bubble)
print("Stable") # ?????????Stable
selection = a[:]
for i in range(N):
minj = i
for j in range(i, N):
if(selection[j][1] < selection[minj][1]):
minj = j
hold = selection[i]
selection[i] = selection[minj]
selection[minj] = hold
pl(selection)
print("Stable" if bubble == selection else "Not stable")
|
def main():
X = int(input())
for A in range(-200, 200):
for B in range(-200, 200):
if A**5 - B**5 == X:
print(A, B)
exit()
if __name__ == '__main__':
main()
| 0 | null | 12,688,757,170,112 | 16 | 156 |
def move_dice(d, dir):
if(dir == 'N'):
d[0], d[1], d[4], d[5] = d[1], d[5], d[0], d[4]
if(dir == 'S'):
d[0], d[1], d[4], d[5] = d[4], d[0], d[5], d[1]
if(dir == 'E'):
d[0], d[2], d[3], d[5] = d[3], d[0], d[5], d[2]
if(dir == 'W'):
d[0], d[2], d[3], d[5] = d[2], d[5], d[0], d[3]
dice = list(map(int, input().split()))
command = input()
for c in command:
move_dice(dice, c)
print(dice[0])
|
class diceClass:
label = []
def __init__(self,l):
if len(l) == 6:
self.label = l
def move(self,c):
if c.upper() == 'N':
buf = []
buf.append(self.label[1])
buf.append(self.label[5])
buf.append(self.label[2])
buf.append(self.label[3])
buf.append(self.label[0])
buf.append(self.label[4])
self.label = buf
elif c.upper() == 'E':
buf = []
buf.append(self.label[3])
buf.append(self.label[1])
buf.append(self.label[0])
buf.append(self.label[5])
buf.append(self.label[4])
buf.append(self.label[2])
self.label = buf
elif c.upper() == 'W':
buf = []
buf.append(self.label[2])
buf.append(self.label[1])
buf.append(self.label[5])
buf.append(self.label[0])
buf.append(self.label[4])
buf.append(self.label[3])
self.label = buf
elif c.upper() == 'S':
buf = []
buf.append(self.label[4])
buf.append(self.label[0])
buf.append(self.label[2])
buf.append(self.label[3])
buf.append(self.label[5])
buf.append(self.label[1])
self.label = buf
def get_label(self):
return self.label[0]
in_line = raw_input().split()
dice = diceClass(in_line)
move = raw_input()
for c in move:
dice.move(c)
print dice.get_label()
| 1 | 231,049,367,740 | null | 33 | 33 |
import sys
for i in sys.stdin:
a, b = map(int, i.split())
print len(str(a+b))
|
word, num = input(), 0
while True:
sentence = input()
if sentence=="END_OF_TEXT":
break
word_list = sentence.lower().replace(".", " ").split()
for i in word_list:
if word==i:
num += 1
print(num)
| 0 | null | 907,354,706,372 | 3 | 65 |
from functools import lru_cache
import sys
sys.setrecursionlimit(10 ** 8)
h,n=map(int,input().split())
ab=[tuple(map(int,input().split())) for _ in range(n)]
ab.sort(key=lambda abi:(abi[1]/abi[0],abi[0]))
@lru_cache(maxsize=None)
def dp(i):
if i<=0:
return 0
else:
ans=float('inf')
for a,b in ab:
val=b+dp(i-a)
if val<ans:
ans=val
else:
break
return ans
print(dp(h))
|
import math
H, N = 9, 3
ARR = [
[8, 3],
[4, 2],
[2, 1]
]
H, N = 100, 6
ARR = [
[1, 1],
[2, 3],
[3, 9],
[4, 27],
[5, 81],
[6, 243],
]
H,N = map(int,input().split())
ARR = [list(map(int,input().split())) for i in range(N)]
def calculate(h, n, arr):
brr = [math.inf] * (h + 1)
brr[0] = 0
for i in range(h + 1):
for j in range(n):
damage = arr[j][0]
cost = arr[j][1]
nextDamage = min(i + damage, h)
nextCost = min(brr[nextDamage], brr[i] + cost)
brr[nextDamage] = nextCost
print(brr[-1])
calculate(H, N, ARR)
| 1 | 81,369,044,372,718 | null | 229 | 229 |
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))
h,n=mp()
a=sum(lmp())
print("Yes" if a>=h else "No")
|
N = int(input())
if N % 2 == 0:
ans = (N / 2) - 1
else:
ans = (N - 1) / 2
print(int(ans))
| 0 | null | 115,567,581,620,550 | 226 | 283 |
from collections import deque
n = int(input())
g = [[] for _ in range(n)]
ab = []
for _ in range(n-1):
a, b = map(int, input().split())
a, b = a - 1, b - 1
g[a].append(b)
g[b].append(a)
ab.append((a, b))
q = deque([0])
chk = [False] * n
chk[0] = True
res = [0] * n
par = [0] * n
while q:
x = q.popleft()
cnt = 1
for y in g[x]:
if chk[y]:
continue
if res[x] == cnt:
cnt += 1
res[y], par[y], chk[y] = cnt, x, True
cnt += 1
q.append(y)
ans = []
for a, b in ab:
if par[a] == b:
ans.append(res[a])
else:
ans.append(res[b])
print(max(ans), *ans, sep="\n")
|
def f(u, i, d, t, vis):
if vis[u]:
return
vis[u] = True
z = t[u]
c = 1
for v in z:
if vis[v]:
continue
if c == i:
c += 1
d[u].update({v: c})
f(v, c, d, t, vis)
c += 1
def main():
from collections import defaultdict
import sys
sys.setrecursionlimit(100000)
n = int(input())
t = [[] for _ in range(n + 1)]
m = []
for _ in range(n - 1):
i, j = map(int, input().split())
t[i].append(j)
t[j].append(i)
m.append([i, j])
d = defaultdict(dict)
vis = [False for _ in range(n + 1)]
f(1, len(t[1]) + 1, d, t, vis)
ans = ''
if t.count([]) == n:
ans += str(n - 1) + '\n'
else:
ans += str(max(len(i) for i in t)) + '\n'
for (u, v) in m:
ans += str(d[u][v]) + '\n'
print(ans)
if __name__ == '__main__':
main()
| 1 | 135,520,250,022,978 | null | 272 | 272 |
n=int(input())
A=sorted(list(map(int,input().split())))
ans=0
if n==1 : print(0);exit()
for i in range(n-1):
# if i==0 : ans+=A[-1];continue
ans+=A[-((i+1)//2+1)]
print(ans)
|
import sys
n = int(input())
A=[int(e)for e in sys.stdin]
cnt = 0
G = [int((3**i-1)/2)for i in range(14,0,-1)]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A,sep='\n')
| 0 | null | 4,589,685,283,732 | 111 | 17 |
W, H, x, y, r = map(int, input().split(' '))
# 高さ
if (r <= y <= (H - r)) and (r <= x <= (W - r)):
print('Yes')
else:
print('No')
|
n,m = map(int,input().split())
ans_list = [False for _ in range(n+1)]
pe_list = [0 for _ in range(n+1)]
ac=0
pe=0
for _ in range(m):
p,s = input().split()
if not ans_list[int(p)]:
if s == 'AC':
ac+=1
pe+=pe_list[int(p)]
ans_list[int(p)]=True
else:
pe_list[int(p)]+=1
print(ac,pe)
| 0 | null | 47,052,435,571,860 | 41 | 240 |
import numpy as np
def main():
N, K = [int(x) for x in input().split()]
A = [float(x) for x in input().split()]
F = [float(x) for x in input().split()]
A = np.array(sorted(A))
F = np.array(sorted(F, reverse=True))
if K >= np.sum(A)*N:
print(0)
exit()
min_time = 0
max_time = A[-1] * F[0]
while max_time != min_time:
tgt_time = (min_time + max_time)//2
ideal_a = np.floor(tgt_time*np.ones(N)/F)
cost = A - ideal_a
require_k = np.sum(cost[cost > 0])
if require_k <= K:
max_time = tgt_time
else:
min_time = tgt_time+1
print(int(max_time))
if __name__ == "__main__":
main()
|
import sys
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
A, B = na()
print(A * B)
| 0 | null | 90,693,948,011,868 | 290 | 133 |
a, b = map(int,input().split())
if a > b:
a, b = b, a
print(str(a) * b)
|
search_s = input()
cnt = 0
while True:
s = input()
if s == "END_OF_TEXT": break
word_list = s.lower().split()
for word in word_list:
if word == search_s:cnt += 1
print(cnt)
| 0 | null | 42,874,107,359,118 | 232 | 65 |
import math
debt = 100
for i in range(int(input())):
debt = math.ceil(debt * 1.05)
print(int(debt) * 1000)
|
# -*- coding: utf-8 -*-
a = list(map(int, input().split()))
ans = 0
for i in a:
if i == 1:
ans += 300000
elif i == 2:
ans += 200000
elif i == 3:
ans += 100000
if a[0] == a[1] == 1:
ans += 400000
print(ans)
| 0 | null | 70,261,650,397,870 | 6 | 275 |
import copy
n = int(raw_input())
cards = raw_input().split()
cards1 = copy.deepcopy(cards)
cards2 = copy.deepcopy(cards)
def isbig(card1, card2):
if int(card1[1]) > int(card2[1]):
return 2
elif int(card1[1]) == int(card2[1]):
return 1
else:
return 0
def BubbleSort(c, n):
temp = 0
for i in range(n):
for j in reversed(range(i+1,n)):
if isbig(c[j], c[j-1]) == 0:
temp = c[j]
c[j] = c[j-1]
c[j-1] = temp
return c
def SelectionSort(c, n):
temp = 0
for i in range(n):
minj = i
for j in range(i,n):
if isbig(c[j], c[minj]) == 0:
minj = j
temp = c[i]
c[i] = c[minj]
c[minj] = temp
#print("*{:}".format(c))
return c
def isstable(unsort, sort):
for i in range(n):
for j in range(i+1,n):
for k in range(n):
for l in range(k+1,n):
if isbig(unsort[i], unsort[j]) == 1 and unsort[i] == sort[l] and unsort[j] == sort[k]:
return 0
return 1
for i in range(n):
if i != n-1:
print BubbleSort(cards1, n)[i],
else:
print BubbleSort(cards1, n)[i]
if isstable(cards, BubbleSort(cards1, n)) == 1:
print("Stable")
else:
print("Not stable")
for i in range(n):
if i != n-1:
print SelectionSort(cards2, n)[i],
else:
print SelectionSort(cards2, n)[i]
if isstable(cards, SelectionSort(cards2, n)) == 1:
print("Stable")
else:
print("Not stable")
|
def main():
N = int(input())
R = tuple(int(input()) for _ in range(N))
min_ = float('inf')
max_ = -float('inf')
for i in range(N):
max_ = max(max_, R[i] - min_)
min_ = min(min_, R[i])
print(max_)
main()
| 0 | null | 18,722,965,700 | 16 | 13 |
(h,n),*c=[[*map(int,i.split())]for i in open(0)]
d=[0]*20002
for i in range(h):d[i]=min(d[i-a]+b for a,b in c)
print(d[h-1])
|
N, S = map(int, input().split())
A = list(map(int, input().split()))
MOD = 998244353
dp = [[0] * (S + 1) for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
ai = A[i]
for j in range(S + 1):
here = dp[i][j]
# aiがTに含まれない
dp[i + 1][j] += here
# aiがTに含まれるが, Uに含まれない
dp[i + 1][j] += here
dp[i + 1][j] %= MOD
# aiがUに含まれる
if j + ai <= S:
dp[i + 1][j + ai] += dp[i][j]
dp[i + 1][j + ai] %= MOD
print(dp[N][S])
| 0 | null | 49,475,088,776,300 | 229 | 138 |
n=int(input())
A=[]
for i in range(n):
a=str(input())
A.append(a)
import collections
c = collections.Counter(A)
ma= c.most_common()[0][1]
C=[i[0] for i in c.items() if i[1] >=ma ]
C.sort(reverse=False)
for j in range(len(C)):
print(C[j])
|
s = input().split()
st = []
for i in range(len(s)):
c = s.pop(0)
if c == '+':
b = st.pop(0)
a = st.pop(0)
ans = a + b
st.insert(0,ans)
elif c == '-':
b = st.pop(0)
a = st.pop(0)
ans = a - b
st.insert(0,ans)
elif c == '*':
b = st.pop(0)
a = st.pop(0)
ans = a * b
st.insert(0,ans)
else:
st.insert(0, int(c))
print(st.pop(0))
| 0 | null | 35,085,708,874,480 | 218 | 18 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.