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
|
|---|---|---|---|---|---|---|
N = int(input())
Assertions = []
ansnum = 0
for i in range(N):
b = []
n = int(input())
for j in range(n):
xi,yi = map(int,input().split())
b.append([xi-1,yi])
Assertions.append(b)
for i in range(2**N):
select = []
ans = [0 for _ in range(N)]
index = []
flag = True
for j in range(N):
if ((i >> j) & 1):
select.append(Assertions[j])
index.append(j)
ans[j] = 1
for idx in index:
for Assert in Assertions[idx]:
if ans[Assert[0]] != Assert[1]:
flag = False
break
if flag:
ansnum = max(ansnum,len(index))
print(ansnum) | from itertools import *
N = int(input())
H = []
A = []
for i in range(N):
for j in range(int(input())):
x,y = map(int, input().split())
H+=[[i,x-1,y]]
for P in product([0,1],repeat=N):
for h in H:
if P[h[0]]==1 and P[h[1]]!=h[2]:
break
else:
A+=[sum(P)]
print(max(A)) | 1 | 122,070,064,170,110 | null | 262 | 262 |
import collections
#https://note.nkmk.me/python-prime-factorization/
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
def f(n):
for i in range(1,20):
if n<(i*(i+1))//2:
return i-1
n = int(input())
c = collections.Counter(prime_factorize(n))
ans = 0
for i in c.keys():
ans += f(c[i])
print(ans) | N = int(input())
c = 0
b = [0]*1000
p = 0
while N % 2 == 0:
b[p] += 1
N //= 2
if b[p]!=0:
p += 1
i = 3
while i * i <= N:
if N % i == 0:
b[p] += 1
N //= i
else:
i += 2
if b[p]!=0:
p += 1
if N==i:
b[p] += 1
N //= i
if N!=1:
p += 1
b[p] += 1
for v in b:
for i in range(1,v+1):
if i<=v:
c += 1
v -= i
else:
break
print(c) | 1 | 16,857,563,824,310 | null | 136 | 136 |
N = list(input())
if "7" in N:
print("Yes")
else:
print("No") | N=input()
i=0
while 1:
for a in N:
if a=="7":
print("Yes")
i=1
break
if i==1:
break
print("No")
break
| 1 | 34,433,217,310,112 | null | 172 | 172 |
import itertools
n = int(input())
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
ls = list(itertools.permutations(range(1, n + 1)))
print(abs(ls.index(p) - ls.index(q))) | import sys
input = sys.stdin.readline
I=lambda:int(input())
MI=lambda:map(int,input().split())
LI=lambda:list(map(int,input().split()))
from collections import deque
res=0
INF=10**9
N,u,v=MI()
G=[[] for _ in [0]*(N+1)]
for i in range(N-1):
a,b=MI()
G[a].append(b)
G[b].append(a)
def bfs(a):
q=deque()
q.append(a)
d=[INF]*(N+1)
d[a]=0
res=0
while q:
r=q.popleft()
for nr in G[r]:
if d[nr]==INF:
q.append(nr)
d[nr]=d[r]+1
res+=1
return d
aoki=bfs(v)
taka=bfs(u)
m=0
for i in range(1,N+1):
if taka[i]<aoki[i]:
m=max(aoki[i],m)
print(m-1) | 0 | null | 108,983,532,844,832 | 246 | 259 |
n = int(input())
s = input()
ans = 0
for i in range(n-2):
if s[i:i+3] == "ABC":
ans += 1
print(ans) | n = int(input())
s = list(input())
abc_cnt = 0
cnt = 0
i = 0
while(i < n - 2):
if(s[i] == 'A' and s[i+1] == 'B' and s[i+2] == 'C'):
cnt += 1
if i < n -3:
i = i+3
else:
i += 1
else:
i += 1
print(cnt) | 1 | 99,583,100,322,492 | null | 245 | 245 |
def main():
n, k = map(int, input().split())
h_lst = list(map(int, input().split()))
ans = 0
for h in h_lst:
if h >= k:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| n,k=map(int,input().split())
l=list(map(int,input().split()))
ans=sum(x>=k for x in l)
print(ans) | 1 | 178,689,255,846,410 | null | 298 | 298 |
#coding:utf-8
while True:
try:
a, b = map(int, raw_input(). split())
x = a * b
while True:
c = a % b
a = b
b = c
if b == 0:
break
x = x / a
print("%d %d" % (a, x))
except:
break | import sys
def gcd(a, b):
return gcd(b, a % b) if a % b else b
def lcm(a, b):
return a * b / gcd(a, b)
for line in sys.stdin:
data = map(int, line.split())
a, b = data
print "%d %d" % (gcd(a, b), lcm(a, b)) | 1 | 680,612,130 | null | 5 | 5 |
# coding: utf-8
# Here your code !
import math
def func():
try:
(rows,columns) = [ int(item) for item in input().rstrip().split(" ") ]
data = [ [ int(item) for item in input().rstrip().split(" ") ] for i in range(rows) ]
except:
return inputError()
[item.append(sum(item)) for item in data]
data.append( [sum( [ item[i] for item in data ] ) for i in range(columns+1) ])
result=""
for row in data:
for item in row:
result += str(item)+" "
result=result.rstrip()
result += "\n"
print(result.rstrip())
def inputError():
'''
print("input Error")
return -1
'''
print("input Error")
return -1
func() | s = input()
for _ in range(int(input())):
code=input().split()
if code[0]=='print' :
print("".join(s[int(code[1]):int(code[2])+1]))
elif code[0]=='reverse':
s = s[:int(code[1])] + s[int(code[1]):int(code[2])+1][::-1] + s[int(code[2])+1:]
elif code[0]=='replace':
s = s[:int(code[1])] + code[3] + s[int(code[2])+1:] | 0 | null | 1,723,517,676,572 | 59 | 68 |
import string
from itertools import zip_longest
turn = int(input())
dic = {s: i for i, s in enumerate(string.ascii_lowercase)}
t_s, h_s = 0, 0
for _ in range(turn):
t, h = input().split()
if t == h:
t_s += 1
h_s += 1
for t_c, h_c in zip_longest(t, h, fillvalue='a'):
if dic[t_c] > dic[h_c]:
t_s += 3
break
elif dic[t_c] < dic[h_c]:
h_s += 3
break
print(t_s, h_s)
| N, K = map(int, input().split())
A = list(map(int, input().split()))
def is_ok(mid):
s = 0
for j in range(N):
if mid < A[j]:
s += A[j] // mid
return s <= K
max_A = 10**9 + 1
ng = 0
ok = max_A
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
print(ok) | 0 | null | 4,255,148,870,390 | 67 | 99 |
# 筐体の手が'k'回前と同じ場合, その回は勝てないが, 'k'回後は勝てる
# 筐体が出した各回の手をメモ, ただし'k'回前と同じ場合のみ ’-1’をメモする
# 勝ち手が'k'回前と同じ場合は加算なし, それ以外('-1'を含む)は勝ち点を加算
n,k = map(int,input().split())
r,s,p = map(int,input().split())
t = input()
ans = 0
memo = []
for i in range(n):
if i < k or t[i] != memo[i-k]:
memo.append(t[i])
if t[i] == 'r': ans += p
elif t[i] == 's': ans += r
else: ans += s
else:
memo.append('-1')
print(ans)
| #!/usr/bin/python3
# -*- coding:utf-8 -*-
import numpy
def main():
n = int(input())
la, lb = [], []
for _ in range(n):
a, b = map(int, input().split())
la.append(a)
lb.append(b)
la.sort(), lb.sort()
if n % 2 == 0:
s = (n-1)//2
e = s + 2
ma = sum(la[s:e]) / 2.0
mb = sum(lb[s:e]) / 2.0
print(int(2 * (mb - ma) + 1))
if n % 2 == 1:
ma = la[n//2]
mb = lb[n//2]
print(mb - ma + 1)
if __name__=='__main__':
main()
| 0 | null | 61,797,530,049,212 | 251 | 137 |
def main():
n, kk = map(int, input().split())
mod = 10**9+7
fact = [1, 1]
for i in range(2, 2*10**5+1):
fact.append(fact[-1]*i % mod)
def nCr(n, r, mod=10**9+7):
return pow(fact[n-r]*fact[r] % mod, mod-2, mod)*fact[n] % mod
ans = [1]
for k in range(1, n):
ans.append(nCr(n-1, k)*nCr(n, k) % mod)
print(sum(ans[:min(kk+1, n)]) % mod)
main()
| MOD = 10 ** 9 + 7
class Factorial:
def __init__(self, n, mod):
self.f = [1]
self.mod = mod
for j in range(1, n + 1):
self.f.append(self.f[-1] * j % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for j in range(n, 0, -1):
self.i.append(self.i[-1] * j % mod)
self.i.reverse()
def factorial(self, j):
return self.f[j]
def ifactorial(self, j):
return self.i[j]
def comb(self, n, k):
return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0
N, K = map(int, input().split())
K = min(K, N - 1)
F = Factorial(N + 1, MOD)
ans = 0
for k in range(K + 1):
tmp = F.comb(N, k) * F.factorial(N - 1) * F.ifactorial(N - 1 - k) * F.ifactorial(k)
ans += (tmp % MOD)
ans %= MOD
print (ans) | 1 | 67,121,482,272,768 | null | 215 | 215 |
s = input()
for _ in range(int(input())):
c = input().split()
a = int(c[1])
b = int(c[2])
if c[0] == "replace":
s = s[:a] + c[3] + s[b+1:]
elif c[0] == "reverse":
s = s[:a] + s[a:b+1][::-1] + s[b+1:]
else:
print(s[a:b+1])
| n, k = map(int, input().split())
p = list(map(lambda x: (1+int(x))/2, input().split()))
s = sum(p[0:k])
ans = s
for i in range(k, n):
s += p[i] - p[i-k]
ans = max(ans, s)
print(ans) | 0 | null | 38,589,162,259,580 | 68 | 223 |
x = int(input())
ans = x // 500 * 1000
x = x % 500
ans += x // 5 * 5
print(ans) | X = int(input())
ans = X//500 * 1000
X %= 500
ans += X//5 * 5
print(ans)
| 1 | 42,745,841,366,130 | null | 185 | 185 |
N=input()
if N.count("7"):
print("Yes")
else:
print("No") | #!/usr/bin/env python3
n = input()
ans = 'No'
for i in n:
if int(i) == 7:
ans = 'Yes'
print(ans)
| 1 | 34,293,137,314,260 | null | 172 | 172 |
n = int(input())
for i in range(1,n+1):
if i % 3 == 0 or i % 10 == 3:
print(" {}".format(i), end='')
else:
x = i
while True:
x = x // 10
if x == 0:
break
elif x % 10 == 3:
print(" {}".format(i), end='')
break
print("") | #coding:utf-8
#3????????°???????????????
n = input()
print "",
for i in xrange(1, n+1):
if i % 3 == 0:
print i,
elif "3" in str(i):
print i, | 1 | 946,030,372,790 | null | 52 | 52 |
def main():
A,B,M=map(int,input().split())
a=[int(_) for _ in input().split()]
b=[int(_) for _ in input().split()]
ans=min(a)+min(b)
for m in range(M):
x,y,c=map(int,input().split())
ans=min(ans,a[x-1]+b[y-1]-c)
print(ans)
main() | a,b,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
x=[list(map(int,input().split())) for _ in range(m)]
ans=min(a)+min(b)
for i in range(m):
ans=min(ans,(a[x[i][0]-1]+b[x[i][1]-1]-x[i][2]))
print(ans)
| 1 | 53,851,902,703,780 | null | 200 | 200 |
cards = int(input())
i = 0
cardlist = []
while(i < cards):
cardlist.append(list(map(str,input().split())))
i += 1
SP = [False] * 13
HR = [False] * 13
CL = [False] * 13
DY = [False] * 13
for i in cardlist:
num = int(i[1])-1
if (i[0] == "S"):
SP[num] = True
elif(i[0] == "H"):
HR[num] = True
elif(i[0] == "C"):
CL[num] = True
elif(i[0] == "D"):
DY[num] = True
c = 0
for i in SP:
c += 1
if i == False:
print("S %d" %c)
c = 0
for i in HR:
c += 1
if i == False:
print("H %d" %c)
c = 0
for i in CL:
c += 1
if i == False:
print("C %d" %c)
c = 0
for i in DY:
c += 1
if i == False:
print("D %d" %c)
| M = 1000000007
n = int(input())
a = list(map(int,input().split()))
S = [0]
for i in range(n):
S.append((S[-1]+a[i])%M)
sum = 0
for i in range(n-1):
sum += (a[i]*(S[n]-S[i+1]))%M
print(sum%M) | 0 | null | 2,452,678,239,368 | 54 | 83 |
import random
d=int(input())
C=[int(i) for i in input().split()]
s=[[int(i) for i in input().split()] for q in range(d)]
sco=0
L=[0 for i in range(26)]
ans=[]
#calc
for i in range(d):
mayou=random.choice(range(26))
est=s[i][mayou]+C[mayou]*(i+1-L[mayou])
ans.append(mayou)
L[mayou]=i+1
#print(mayou+1) #output
sco=est
##以下表示
"""
L=[0 for i in range(26)]
for q in range(d):
t=ans[q]
sco+=s[q][t]
L[t]=q+1
for i in range(26):
if L[i]!=-1:
sco-=C[i]*(q+1-L[i])
print(sco)
"""
m=1000000
for que in range(m):
newsco=sco
dn,q=random.choice(range(1,d)),random.choice(range(1,27))
dn-=1
q-=1
old=ans[dn]
ans[dn]=q
now=dn
cnt=1
while now!=0 and ans[now]!=old:
now-=1
cnt+=1
now=dn
while now!=d and ans[now]!=old:
newsco-=cnt*C[old]
now+=1
cnt+=1
newsco-=s[dn][old]
newsco+=s[dn][q]
now=dn
cnt=1
while now!=0 and ans[now]!=q:
now-=1
cnt+=1
now=dn
while now!=d and ans[now]!=q:
newsco+=cnt*C[q]
now+=1
cnt+=1
#print(newsco)
if newsco>sco:
sco=newsco
#print(newsco)
else:
ans[dn]=old
for ele in ans:
print(ele+1)
| for i in range(365):
print(1) | 1 | 9,664,896,250,620 | null | 113 | 113 |
n = int(input())
s_taro,s_hanako = 0,0
for trial in range(n):
taro,hanako = list(map(str, input().split()))
if taro > hanako:
s_taro += 3
elif taro < hanako:
s_hanako += 3
else:
s_taro += 1
s_hanako += 1
print(s_taro, s_hanako) | a=b=ab=[]
n, m, l = map(int, input().strip().split())
for i in range(m+n):
ab.append(list(map(int, input().strip().split())))
a,b=ab[:n],ab[n:]
for i in range(n):
c = [sum(a[i][k]*b[k][j] for k in range(m)) for j in range(l)]
print(*c) | 0 | null | 1,723,835,762,320 | 67 | 60 |
def sol(s, p):
n = len(s)
cnt = 0
if p == 2 or p == 5:
for i in range(n):
if (s[i] % p == 0):
cnt += i + 1
else:
pre = [0] * (n+2)
pre[n+1] = 0
b = 1
for i in range(n, 0, -1):
pre[i] = (pre[i+1] + s[i-1] * b) % p
b = (b * 10) % p
rec = [0] * p
rec[0] = 1
for i in range(n, 0, -1):
cnt += rec[pre[i]]
rec[pre[i]] += 1
return cnt
if __name__ == "__main__":
n, p = map(int, input().split())
s = input()
print (sol([int(i) for i in s], p)) | from collections import defaultdict
N, P = map(int, input().split())
S = input().strip()[::-1]
if P in [2, 5]:
ans = 0
for r in range(N):
if int(S[r]) % P == 0:
ans += N - r
print(ans)
exit()
cum = [0] * (N + 1)
for i in range(N):
now = int(S[i]) * pow(10, i, P)
cum[i + 1] = (cum[i] + now) % P
cnt = defaultdict(int)
for _cum in cum:
cnt[_cum] += 1
ans = 0
for k, v in cnt.items():
ans += v * (v - 1) // 2
print(ans)
| 1 | 58,089,768,764,932 | null | 205 | 205 |
N,M,L = (int(i) for i in input().split())
A = [[int(i) for i in input().split()] for i in range(N)]
B = [[int(i)for i in input().split()] for i in range(M)]
C = []
for i in range(N):
for i2 in range(L):
ans = 0
for i3 in range(M):
ans += A[i][i3]*B[i3][i2]
if i2 == L-1:
print(ans)
else:
print(ans,end=" ") | n,m,l = map(int,input().split())
A = []
for i in range(n):
a = [int(j) for j in input().split()]
A.append(a)
B = []
for j in range(m):
b = [int(k) for k in input().split()]
B.append(b)
for i in range(n):
c = []
for k in range(l):
x = 0
for j in range(m):
x += A[i][j]*B[j][k]
c.append(str(x))
print(" ".join(c)) | 1 | 1,439,064,902,080 | null | 60 | 60 |
#!/usr/bin/env python
dn = lambda a, b: len(str(a+b))
get = lambda: [int(x) for x in raw_input().split()]
if __name__ == "__main__":
while True:
try:
print "%d" % dn(*get())
except:
break | import math
while True:
try:
a =map(int,raw_input().split())
b = a[0] + a[1]
print len(str(a[0]+a[1]))
except EOFError:
break | 1 | 96,245,760 | null | 3 | 3 |
# 解説見た
n,k = map(int,input().split())
lr = [list(map(int,input().split())) for _ in range(k)]
dp = [0]*(n+1)
sdp = [0]*(n+1)
dp[1],sdp[1] = 1,1
mod = 998244353
for i in range(1,n+1):
for l,r in lr:
if i-l<0:
continue
else:
dp[i] += sdp[i-l] - sdp[max(0,i-r-1)]
sdp[i] = sdp[i-1] + dp[i]
dp[i] %= mod
sdp[i] %= mod
print(dp[-1]) | s , t = map(str, input().strip().split())
print(t+s) | 0 | null | 52,719,604,690,140 | 74 | 248 |
import sys
stdin = sys.stdin
ns = lambda : stdin.readline().rstrip()
ni = lambda : int(ns())
na = lambda : list(map(int, stdin.readline().split()))
sys.setrecursionlimit(10 ** 7)
def main():
m, d = na()
n, s = na()
if s == 1:
print(1)
else:
print(0)
if __name__ == '__main__':
main() | dates = [list(map(int, input().split())) for _ in range(2)]
print("{}".format("1" if dates[0][0] < dates[1][0] or (dates[0][0] == 12 and dates[0][1] == 1) else "0")) | 1 | 124,532,924,108,680 | null | 264 | 264 |
N = int(input())
S = []
T = []
for i in range(N):
si, ti = tuple(input().split())
S.append(si)
T.append(int(ti))
X = input()
i = S.index(X)
print(sum(T[i + 1:]))
| # coding: utf-8
# Your code here!
import sys
n=int(input())
s=list(input())
if n%2==1:
print("No")
sys.exit()
else:
for i in range(n//2):
if s[i]==s[n//2+i]:
continue
print("No")
sys.exit()
print("Yes") | 0 | null | 122,100,404,167,310 | 243 | 279 |
import itertools
n,m,q = map(int,input().split())
abcd = [list(map(int,input().split())) for _ in range(q)]
maxpt = 0
for lis in itertools.combinations_with_replacement(range(1, m+1), n):
forpt = 0
for i in range(q):
if lis[abcd[i][1]-1] - lis[abcd[i][0]-1] == abcd[i][2]:
forpt += abcd[i][3]
maxpt = max(maxpt,forpt)
print(maxpt) | import itertools
N, M, Q = map(int, input().split())
l = [i for i in range(1, M+1)]
qus = []
As = []
for _ in range(Q):
b = list(map(int, input().split()))
qus.append(b)
for v in itertools.combinations_with_replacement(l, N):
a = list(v)
A = 0
for q in qus:
pre = a[q[1]-1] - a[q[0]-1]
if pre == q[2]:
A += q[3]
As.append(A)
print(max(As)) | 1 | 27,405,093,229,962 | null | 160 | 160 |
s = input()
flg = True
while len(s) > 0:
if s.startswith("hi"):
s = s[2::]
else:
flg = False
break
if flg:
print("Yes")
else:
print("No") | S=input()
if S=="hi" or S=="hihi" or S=="hihihi" or S=="hihihihi" or S=="hihihihihi":
print("Yes")
else:
print("No") | 1 | 53,405,495,251,148 | null | 199 | 199 |
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n,m = map(int,input().split())
u = UnionFind(n)
for _ in range(m):
ai,bi = map(int,input().split())
u.union(ai,bi)
s = [0 for _ in range(n+1)]
for i in range(1,n+1):
s[u.find(i)] = 1
print(sum(s)-1) | import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.buffer.readline
N, M = map(int, input().split())
nextcity = [[] for _ in range(N)]
sgn = [0 for _ in range(N)]
while M:
M -= 1
A, B = map(int, input().split())
A -= 1
B -= 1
nextcity[A].append(B)
nextcity[B].append(A)
def dfs(cnt, city):
for item in nextcity[city]:
if sgn[item] == 0:
sgn[item] = cnt
dfs(cnt, item)
return None
cnt = 0
for k in range(N):
if sgn[k] == 0:
cnt += 1
sgn[k] = cnt
dfs(cnt, k)
print(cnt -1)
| 1 | 2,326,845,591,280 | null | 70 | 70 |
from copy import copy
import random
import math
import sys
input = sys.stdin.readline
D = int(input())
c = list(map(int,input().split()))
s = [list(map(int,input().split())) for _ in range(D)]
last = [0]*26
ans = [0]*D
score = 0
for i in range(D):
ps = [0]*26
for j in range(26):
pl = copy(last)
pl[j] = i+1
ps[j] += s[i][j]
for k in range(26):
ps[j] -= c[k]*(i+1-pl[k])
idx = ps.index(max(ps))
last[idx] = i+1
ans[i] = idx+1
score += max(ps)
for k in range(1,37001):
na = copy(ans)
x = random.randint(1,365)
y = random.randint(1,365)
z = random.randint(min(x,y),max(x,y))
if x == y:
continue
na[x-1],na[y-1] = na[y-1],na[x-1]
na[x-1],na[z-1] = na[z-1],na[z-1]
last = [0]*26
ns = 0
for i in range(D):
last[na[i]-1] = i+1
ns += s[i][na[i]-1]
for j in range(26):
ns -= c[j]*(i+1-last[j])
if k%100 == 1:
T = 300-(298*k/37000)
p = pow(math.e,-abs(ns-score)/T)
if ns > score or random.random() < p:
ans = na
score = ns
for a in ans:
print(a) | from copy import deepcopy
d=int(input())
c=list(map(int,input().split()))
s=[]
for i in range(d):
a=list(map(int,input().split()))
s.append(a)
def score_calculator(l):
score=0
las=[0]*26
for i in range(d):
for j in range(26):
las[j]+=1
las[l[i]]=0
for j in range(26):
score-=las[j]*c[j]
score+=s[i][l[i]]
return score
highest_sum_score=-1000000000000
for i in range(1,26):
last=[0]*26
temp_ans_lst=[]
for j in range(d):
daily_highest_score=-10000000000000
for k in range(26):
temp_score=s[j][k]
temp_last=deepcopy(last)
for p in range(26):
temp_last[p]+=1
temp_last[k]=0
for p in range(26):
down=temp_last[p]
for q in range(i):
qdown=down+i+1
down+=qdown
temp_score-=down*c[p]
if temp_score>daily_highest_score:
daily_highest_score=temp_score
daily_choice=k
for k in range(26):
last[k]+=1
last[daily_choice]=0
temp_ans_lst.append(daily_choice)
if score_calculator(temp_ans_lst)>highest_sum_score:
ans_lst=deepcopy(temp_ans_lst)
highest_sum_score=score_calculator(temp_ans_lst)
for i in ans_lst:
print(i+1) | 1 | 9,728,583,655,294 | null | 113 | 113 |
a=int(input())
b=input()
c=0
for i in range(a-1):
if b[i]==b[i+1]:
c=c+1
print(a-c) | import sys
import math
import fractions
from collections import defaultdict
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
S=ns().split()
print(S[1]+S[0]) | 0 | null | 136,118,410,740,818 | 293 | 248 |
nums = list(map(int, input().strip()))
nums = nums[::-1]
nums.append(0)
ans = 0
for i in range(len(nums) - 1):
if nums[i] > 5:
ans += 10 - nums[i]
nums[i+1] += 1
elif nums[i] == 5:
if nums[i + 1] >= 5:
nums[i + 1] += 1
ans += 5
else:
ans += nums[i]
ans += nums[-1]
print(ans)
| import sys
stdin = sys.stdin
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def ns(): return stdin.readline().rstrip() # ignore trailing spaces
N = ns()
ans = [0, 1000000000]
kuri = [0, 0]
five = 0
for n in N[::-1]:
n = int(n)
# print(ans)
ans_old = [ans[0], ans[1]]
ans[0] = min(ans_old[0] + n, ans_old[1] + n + 1)
ans[1] = min(ans_old[0] + 10 - n, ans_old[1] + 9 - n)
print(min(ans[0], ans[1] + 1))
| 1 | 70,969,909,718,084 | null | 219 | 219 |
N = int(input())
S = input()
slime = S[0]
for i in range(1, N):
if S[i] != slime[-1]:
slime += S[i]
print(len(slime))
| s = input()
day = ['SAT','FRI','THU','WED','TUE','MON','SUN']
for i in range(7):
if s == day[i]:
print(i + 1)
exit() | 0 | null | 151,723,629,790,570 | 293 | 270 |
a = input('')
S = []
num = 0
for i in a:
S.append(i)
for j in range(3):
if S[j] == 'R':
num += 1
if num == 2 and S[1] == 'S':
print(1)
else:
print(num) | def comb(n, k):
nu, de = 1, 1
for i in range(k):
de *= n - i
nu *= i + 1
return de // nu
def ans(N, K):
if K == 0:
return 1
N = str(int(N))
if len(N) < K or int(N) == 0:
return 0
ret = sum([9 ** K * comb(max(dig - 1, 1), K - 1)
for dig in range(K, len(N))])
ret += (int(N[0]) - 1) * 9 ** (K - 1) * comb(len(N) - 1, K - 1)
return ret + ans(N[1:], K - 1)
N = input()
K = int(input())
print(ans(N, K))
| 0 | null | 40,279,135,371,780 | 90 | 224 |
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
def prime_factorize(n):
divisors = []
# 27(2 * 2 * 7)の7を出すためにtemp使う
temp = n
for i in range(2, int(math.sqrt(n)) + 1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
# 素因数を見つけるたびにtempを割っていく
temp //= i
divisors.append([i, cnt])
if temp != 1:
divisors.append([temp, 1])
if divisors == []:
divisors.append([n, 1])
return divisors
def make_divisors(n):
divisors = []
for i in range(1, int(math.sqrt(n)) + 1):
if n % i == 0:
divisors.append(i)
# √nで無い数についてもう一個プラス
if i != n // i:
divisors.append(n // i)
return sorted(divisors)
N = getN()
# 手順としては
# ① kで出来るだけ割る
# ② kで引いていく N = mk + d(d = 1, 2, 3...)とすると, 引いて残る数はm(k - 1) + d
# つまりkで割り切れず、引いても引いても永遠に①に戻ることはない
# N = k ** i * (mk + 1)となるkの数を求める
# i == 0の時
# N - 1の約数の数 - 1(1)
ans = set()
for i in make_divisors(N - 1):
if i != 1:
ans.add(i)
# 割れるだけ割る関数
def dividor(x, k):
if k == 1:
return 0
n = x
while True:
if n % k == 0:
n //= k
else:
break
return n
# i >= 1の時
for prim in make_divisors(N):
if prim == 1:
continue
# Nを割れるだけ割る
alta = dividor(N, prim)
if alta == 1:
ans.add(prim)
continue
if alta >= prim and alta % prim == 1:
ans.add(prim)
# Nが素数でない場合はN自身が追加されない
ans.add(N)
print(len(ans)) |
def count(s1,s2):
cnt = 0
for i in range(len(s2)):
if s1[i] != s2[i]:
cnt += 1
return cnt
S1 = input()
S2 = input()
mmin = len(S2)
for i in range(len(S1)-len(S2)+1):
k = count(S1[i:len(S2)+i],S2)
if k < mmin:
mmin = k
print(mmin)
| 0 | null | 22,583,903,567,070 | 183 | 82 |
n = int(input())
a = list(map(int, input().split()))
mod = 1000000007
ans, cnt = 1, [0, 0, 0]
for i in a:
ans = ans * cnt.count(i) % mod
for j in range(3):
if cnt[j] == i:
cnt[j] += 1
break
print(ans)
| #!/usr/bin/env python3
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
def main():
N = int(input())
A = list(map(int, input().split()))
p = 10**9+7
# check[i]:= Aの中のiが出てきた順番
check = [[] for _ in range(N)]
for i in range(N):
check[A[i]].append(i)
# print(check)
ans = 1
for i in range(len(check[0])):
ans *= (3-i)
for i in range(1,N):
if len(check[i-1]) < len(check[i]):
exit(print(0))
# check[i]がcheck[i-1]のなかで何番目か調べる
for j in range(len(check[i])):
d = bisect_right(check[i-1],check[i][j])
if d < j:
exit(print(0))
ans *= d-j
ans %= p
# print(ans)
print(ans)
if __name__ == "__main__":
main()
| 1 | 130,497,703,912,740 | null | 268 | 268 |
a,b=map(str,input().split())
c,d=map(int,input().split())
k=input()
if k==a:
c-=1
else:
d-=1
print(c,d) | def resolve():
s, t = input().split()
a, b = list(map(int, input().split()))
u = input()
if u == s:
a -= 1
elif u == t:
b -= 1
print(a, b)
resolve() | 1 | 71,609,780,809,938 | null | 220 | 220 |
n = int(input())
s = list(input())
abc_cnt = 0
cnt = 0
i = 0
while(i < n - 2):
if(s[i] == 'A' and s[i+1] == 'B' and s[i+2] == 'C'):
cnt += 1
if i < n -3:
i = i+3
else:
i += 1
else:
i += 1
print(cnt) | A, B = [x for x in input().split(" ")]
print(int(A) * int(float(B) * 100 + 0.5) // 100)
| 0 | null | 58,178,810,696,540 | 245 | 135 |
# -*- coding: utf-8 -*-
import collections
n, q = map(int, raw_input().split())
prolist = [raw_input().split() for i in range(n)]
prolist = collections.deque(prolist)
time_sum = 0
while len(prolist):
process = prolist.popleft()
time = int(process[1])
if time <= q:
time_sum += time
print "%s %d" %(process[0], time_sum)
else:
time_sum += q
process[1] = str(time-q)
prolist.append(process) | s=list(input())
l=len(s)
ans=0
if len(set(s))==1:
for i in range(1,l+1):
ans+=i
print(ans)
exit()
for i in range(l-1):
if s[i]=="<" and s[i+1]==">":
left=1
right=1
for j in range(i):
if s[i-j-1]=="<":
left+=1
else:
break
for j in range(l-i-2):
if s[i+j+2]==">":
right+=1
else:
break
p=max(left,right)
q=min(left,right)
for j in range(p):
ans+=(j+1)
for j in range(q-1):
ans+=(j+1)
if s[0]==">":
ans+=1
for i in range(1,l):
if s[i]==">":
ans+=(i+1)
else:
break
if s[-1]=="<":
ans+=1
for i in range(2,l+1):
if s[-i]=="<":
ans+=i
else:
break
print(ans) | 0 | null | 78,016,954,349,672 | 19 | 285 |
n = int(input())
s = input()
print(['No','Yes'][s[:n//2]==s[n//2:]]) | n = int(input())
s = input()
ans = 'No'
if n%2 == 0:
mid = int(n/2)
if s[:mid] == s[mid:]:
ans = 'Yes'
print(ans) | 1 | 146,331,522,925,700 | null | 279 | 279 |
import math
a, b, x = map(int, input().split())
if x == a**2*b:
print(0)
elif x >= a**2*b/2:
print(90 - math.degrees(math.atan(a**3/(2*a**2*b-2*x))))
else:
print((90 - math.degrees(math.atan(2*x/(a*b**2)))))
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
n = I()
a = LI()
r = 1
c = collections.defaultdict(int)
c[0] = 3
for b in a:
r *= c[b]
r %= mod
c[b] -= 1
c[b+1] += 1
return r
print(main())
| 0 | null | 146,747,705,129,312 | 289 | 268 |
N = int(input())
ac_counter = 0
wa_counter = 0
tle_counter = 0
re_counter = 0
for i in range(N):
current = input()
if current == 'AC':
ac_counter += 1
if current == 'WA':
wa_counter += 1
if current == 'TLE':
tle_counter += 1
if current == "RE":
re_counter += 1
print("AC x " + str(ac_counter))
print("WA x " + str(wa_counter))
print("TLE x " + str(tle_counter))
print("RE x " + str(re_counter))
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
from collections import Counter
def main():
n = int(input())
d1 = {'AC':0, 'WA':0, 'TLE': 0,'RE':0}
s = []
for _ in range(n):
s.append(input())
sa = Counter(s)
for k, v in sa.items():
d1[k] += v
print('AC x', d1['AC'])
print('WA x', d1['WA'])
print('TLE x', d1['TLE'])
print('RE x', d1['RE'])
if __name__ == '__main__':
main()
| 1 | 8,664,748,824,732 | null | 109 | 109 |
n, m = list(map(int, input().split()))
s = input()
if s.find('1' * m) != -1:
print('-1')
exit(0)
i = n
rans = []
flag = True
while flag:
for j in range(m, 1 - 1, -1):
if i - j == 0:
flag = False
if i - j >= 0 and s[i - j] == '0':
rans.append(j)
i = i - j
break
print(' '.join(map(str,reversed(rans))))
| import math
x, y, X, Y = [float(i) for i in input().split()]
print(math.sqrt((x-X)**2 + abs(y-Y)**2)) | 0 | null | 69,446,274,488,460 | 274 | 29 |
def main():
match_count = int(input())
matches = [input().split() for i in range(match_count)]
taro_result = [3 if match[0] > match[1] else 1 if match[0] == match[1] else 0 for match in matches]
print('%d %d' % (sum(taro_result), sum(3 if item == 0 else 1 if item == 1 else 0 for item in taro_result)) )
main() | import math
r = float(input())
S = r*r*math.pi
l = 2*r*math.pi
print("{:.5f} {:.5f}".format(S,l)) | 0 | null | 1,296,883,024,334 | 67 | 46 |
from bisect import bisect_left
n = int(input())
L = list(map(int, input().split()))
L.sort()
cnt = 0
for a in range(n-2):
for b in range(a+1, n-1):
cnt += bisect_left(L,L[a]+L[b])-(b+1)
print(cnt) | # -*- coding: utf-8 -*-
i = 1
while (i <= 9) :
j = 1
while (j <= 9) :
print '%sx%s=%s' % (i, j, i * j)
j = j + 1
i = i + 1 | 0 | null | 85,912,064,566,212 | 294 | 1 |
from fractions import gcd
n, m = map(int, input().split())
a = list(map(int, input().split()))
def lcm(a, b):
return a*b // gcd(a, b)
"""
akが偶数だから、bk=2akとして、
bk × (2p + 1)を満たすpが存在すれば良い
2p+1は奇数のため、Xとbkの2の素因数は一致しなければならない
akに含まれる最大の2^kを探す。
"""
if len(a) == 1: lcm_all = a[0]//2
else: lcm_all = lcm(a[0]//2, a[1]//2)
amax = 0
for i in range(1, n):
lcm_all = lcm(lcm_all, a[i]//2)
amax = max(amax, a[i]//2)
f = True
if lcm_all > m:
f = False
for i in range(n):
if n == 1: break
if (lcm_all//(a[i]//2))%2 == 0:
# akの2の約数の数がそろわないので、どんな奇数を掛けても共通のXを作れない
f = False
if f:
# amaxの奇数倍でmを超えないもの
ans = (m // lcm_all + 1)//2
print(ans)
else:
print(0) | for a in range(1,10):
for b in range(1,10):
print(a, end="")
print("x", end="")
print(b, end="")
print("=", end="")
print(a*b) | 0 | null | 50,949,280,691,790 | 247 | 1 |
N=int(input())
A=list(map(int,input().split()))
A.sort()
F=[0]*(10**6+11)
# 0:OK/未調査 1:NG 2:調査した頂点 3:二度調査した頂点
for a in A:
if F[a]==1:
continue
if F[a]==2:
F[a]=1
continue
elif F[a]==0:
F[a]=2
k=2*a
while k<=10**6+1:
F[k]=1
k+=a
res=0
for a in A:
if F[a]==2:
res+=1
print(res) | n,*a=map(int,open(0).read().split())
a.sort()
num=[True for i in range(a[-1]+1)]
for i in range(n):
if num[a[i]]:
for j in range(a[-1]//a[i]+1):
if j<2:
continue
num[a[i]*j]=False
if i==n-1:
pass
elif a[i]==a[i+1]:
num[a[i]]=False
else:
pass
else:
continue
ans=0
for i in range(n):
if num[a[i]]:
ans+=1
print(ans) | 1 | 14,427,429,677,828 | null | 129 | 129 |
import sys
from math import gcd
input = lambda: sys.stdin.readline().rstrip()
n = int(input())
A = list(map(int, input().split()))
nowgcd = A[0]
# 全体のGCDを取る
for i in A:
nowgcd = gcd(nowgcd, i)
if nowgcd != 1:
print('not coprime')
exit()
# osa_k法で前処理
MAXN = 10**6 + 5
sieve = [i for i in range(MAXN + 1)]
p = 2
while p * p <= MAXN:
# まだチェックされていないなら
if sieve[p] == p:
# 次のqの倍数からp刻みでチェック入れていく
for q in range(2 * p, MAXN + 1, p):
if sieve[q] == q:
sieve[q] = p
p += 1
check = set()
for a in A:
tmp = set()
while (a > 1):
tmp.add(sieve[a])
a //= sieve[a]
for p in tmp:
if p in check:
print('setwise coprime')
exit()
check.add(p)
print('pairwise coprime')
| import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): 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")
a,b,c,d = I()
while a > 0 and c > 0:
c -= b
a -= d
if c <= 0:
print("Yes")
else:
print("No")
| 0 | null | 16,845,213,320,352 | 85 | 164 |
N,M,X=map(int,input().split())
C=[list(map(int,input().split())) for _ in range(N)]
ans=inf=float('inf')
def dfs(idx,tt,l):
global ans
for i in range(idx,N):
ntt=tt+C[i][0]
nl=[l[j]+C[i][j+1] for j in range(M)]
ok=True
for x in nl:
if x<X:
ok=False
break
if ok:
ans=min(ans,ntt)
else:
dfs(i+1,ntt,nl)
dfs(0,0,[0]*M)
print(ans if ans<inf else -1)
| N,M,X = map(int,input().split())
data = []
ans = 0
for i in range(N):
d = list(map(int,input().split()))
data.append(d)
ans += d[0]
x = 2**N + 1
ans_candidate = []
valid = False
ans += 1
ans_old = ans
for i in range(x):
if i != 0:
for l in range(len(sum)):
if sum[l] >= X and l == len(sum) -1:
valid = True
if sum[l] >= X:
continue
else:
valid = False
break
if valid and price < ans:
ans = price
sum = [0] * M
price = 0
for j in range(N):
if i >> j & 1 == 1:
price += data[j][0]
for k in range(M):
sum[k] += data[j][k+1]
if ans_old == ans:
print(-1)
else:
print(ans)
| 1 | 22,447,261,685,912 | null | 149 | 149 |
x='123'
for _ in range(2):
x=x.replace(input(),'')
print(x)
| a=int(input())
b=int(input())
z=1^2^3
print (z^a^b) | 1 | 111,118,743,630,988 | null | 254 | 254 |
def kakeru(x):
for i in range(1,10):
a = x * i
print(str(x) + 'x' +str(i) + '=' + str(a))
for i in range (1,10):
kakeru(i) | n = int(input())
p = n // 500 * 1000
n %= 500
p += n // 5 * 5
print(p) | 0 | null | 21,242,426,267,150 | 1 | 185 |
line = input()
for _ in range(int(input())):
x = input().split()
order = x[0]
a = int(x[1])
b = int(x[2])+1
if order == "print":
print(line[a:b])
elif order == "reverse":
line = line[:a] + line[a:b][::-1] + line[b:]
elif order == "replace":
line = line[:a] + x[3] + line[b:]
| n = int(input())
a = list(map(int, input().split()))
result = [0] * n
for i in range(len(a)):
result[a[i] - 1] += 1
for i in range(len(result)):
print(result[i]) | 0 | null | 17,250,228,327,992 | 68 | 169 |
a,b=[int(i)for i in input().split()]
if a<10 and b<10:
print(a*b)
else:
print('-1') | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce, lru_cache # @lru_cache(None)
from fractions import gcd
import sys
def input(): return sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**6)
# ----------------------------------------------------------- #
s = input()
print(s[:3]) | 0 | null | 86,702,819,847,920 | 286 | 130 |
n = int(input())
a = [int(i) for i in input().split()]
num = 0
is_swapped = True
i = 0
while is_swapped:
is_swapped = False
for j in range(n-1, i, -1):
if a[j] < a[j-1]:
tmp = a[j]
a[j] = a[j-1]
a[j-1] = tmp
is_swapped = True
num += 1
i += 1
print(' '.join([str(i) for i in a]))
print(num)
| N = int(input())
A = [int(i) for i in input().split()]
L = [A[i]+i+1 for i in range(N)]
R = [i + 1 - A[i] for i in range(N)]
from collections import defaultdict
l = defaultdict(int)
for i in L:
l[i] += 1
ans = 0
for r in R:
ans += l.get(r, 0)
print(ans) | 0 | null | 13,168,442,120,800 | 14 | 157 |
X = int(input())
a = X**2
print(a) | N, K = map(int, input().split())
answer = 0
while N // (K ** answer) >= 1:
answer += 1
print(answer) | 0 | null | 104,947,294,839,592 | 278 | 212 |
from sys import stdin
def main():
#入力
readline=stdin.readline
N,M=map(int,readline().split())
a=1
b=N-1
if N%2==1:
for _ in range(M):
print(a,b)
a+=1
b-=1
else:
flag=False
for _ in range(M):
if flag==False and b-a<=N//2:
flag=True
b-=1
print(a,b)
a+=1
b-=1
else:
print(a,b)
a+=1
b-=1
if __name__=="__main__":
main() | N= int(input())
S = input()
abc = "ABC"
ans = 0
j = 0
for i in range(N):
if S[i] == abc[j]:
j += 1
if S[i] == "C":
j = 0
ans += 1
elif S[i] == "A":
j = 1
else:
j = 0
print(ans) | 0 | null | 63,680,995,212,120 | 162 | 245 |
p_trump = [a + ' {}'.format(b) for a in ['S', 'H', 'C', 'D'] for b in range(1, 14)]
n = int(input())
trumps = []
for i in range(n):
trumps.append(input())
for i in p_trump:
if not i in trumps:
print(i)
| def make_divisors(n):
ans = 10 ** 12 + 10
i = 1
while i*i <= n:
if n % i == 0:
t = 0
if i != n // i:
t = i + (n//i) - 2
else:
t = i * 2 - 2
#print(i, n//i, t)
if ans > t:
ans = t
i += 1
return ans
n = int(input())
print(make_divisors(n)) | 0 | null | 81,319,054,477,664 | 54 | 288 |
n,d = map(int,input().split())
cnt = 0
md = d**2
for _ in range(n):
a,b = map(int,input().split())
if md >= (a**2+b**2):
cnt += 1
print(cnt)
| # coding: utf-8
# Your code here!
class UnionFind:
def __init__(self, size):
self.rank = [0 for i in range(size)]
self.parent = [-1 for i in range(size)]
self.children = [[i] for i in range(size)]
def Find(self, x):
parent = self.parent[x]
while parent >= 0:
x = parent
parent = self.parent[x]
return x
def Union(self, x, y):
root_x = self.Find(x)
root_y = self.Find(y)
if root_x == root_y:
return
else:
if self.rank[root_x] >= self.rank[root_y]:
self.parent[root_x] += self.parent[root_y]
self.parent[root_y] = root_x
self.rank[root_x] = max(self.rank[root_y] + 1, self.rank[root_x])
self.children[root_x] += self.children[root_y]
else:
self.parent[root_y] += self.parent[root_x]
self.parent[root_x] = root_y
self.rank[root_y] = max(self.rank[root_x] + 1, self.rank[root_y])
self.children[root_y] += self.children[root_x]
def Same(self, x, y):
return self.Find(x) == self.Find(y)
def FindRootAndSizeAndChildren(self):
return [(idx, -val, self.children[idx]) for idx, val in enumerate(self.parent) if val<0 ]
def print_lists(self):
print(self.rank)
print(self.parent)
print()
N, M = map(int, input().split())
unionfind = UnionFind(N)
for i in range(M):
a, b = map(int, input().split())
unionfind.Union(a-1, b-1)
max_size = 0
for idx, size, children in unionfind.FindRootAndSizeAndChildren():
if size > max_size:
max_size = size
print(max_size)
| 0 | null | 4,973,454,848,068 | 96 | 84 |
import math
input()
xl = [int(s) for s in input().split()]
yl = [int(s) for s in input().split()]
m1 = 0
m2 = 0
m3 = 0
m4 = 0
for x, y in zip(xl, yl):
fabs = math.fabs(x - y)
m1 += fabs
m2 += fabs ** 2
m3 += fabs ** 3
m4 = max(fabs, m4)
print(m1)
print(math.pow(m2, 1/2))
print(math.pow(m3, 1/3))
print(m4) | n=int(input())
ans=0
for a in range(1,n):
x=(n-1)//a
ans+=x
print(ans)
| 0 | null | 1,428,446,606,598 | 32 | 73 |
import sys
input = sys.stdin.readline
import collections
# 持っているビスケットを叩き、1枚増やす
# ビスケット A枚を 1円に交換する
# 1円をビスケット B枚に交換する
def main():
x = int(input())
for a in range(-200, 200):
for b in range(-200, 200):
ans = a ** 5 - b ** 5
if ans == x:
print(a, b)
exit()
def bi(num, a, b, x):
print((a * num) + (b * len(str(b))))
if (a * num) + (b * len(str(b))) <= x:
return False
return True
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| from collections import defaultdict
d = defaultdict(list)
for i in range(-120, 121):
for j in range(-120, 121):
x = i**5 - j**5
if x >= 1:
d[x] = [i, j]
X = int(input())
print('{0[0]} {0[1]}'.format(d[X])) | 1 | 25,463,656,830,042 | null | 156 | 156 |
S = input()
T = input()
count = 0
max_count = 0
for i in range(len(S) - len(T) +1):
for j in range(len(T)):
if S[i+j] == T[j]:
count += 1
if max_count <= count:
max_count = count
if j == (len(T) -1):
count = 0
print(len(T) - max_count)
| N, M = map(int, input().split())
Pajew = [i for i in range(N)]
import sys
sys.setrecursionlimit(1000000)
def find(x, Pajew):
if Pajew[x] == x:
return x
else:
a = find(Pajew[x], Pajew)
Pajew[x] =a
return a
def unite(x, y):
x = find(x, Pajew)
y = find(y, Pajew)
if x != y:
Pajew[x] = y
for _ in range(M):
a, b = map(int, input().split())
unite(a-1, b-1)
grou = 0
for i in range(N):
if i == Pajew[i]:
grou +=1
print(grou-1) | 0 | null | 2,992,476,328,912 | 82 | 70 |
mod = 10 ** 9 + 7
S = int(input())
dp = [0] * 3 + [1] * (S - 2)
for i in range(3, S + 1):
dp[i] = (1 + sum(dp[0:i - 2])) % mod
print(dp[S]) | import itertools
A,B,C=map(int,input().split())
K=int(input())
l=list(range(K+1))
for c in itertools.product(l, repeat=3):
if sum(c) == K and A*2**c[0]<B*2**c[1] and B*2**c[1]<C*2**c[2]:
print("Yes")
exit(0)
print("No")
| 0 | null | 5,103,905,271,872 | 79 | 101 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
@mt
def slv(N, M, S):
from functools import lru_cache
@lru_cache(maxsize=None)
def dfs(x):
if x == 0:
return []
for i in range(M, 0, -1):
if 0 <= x-i and S[x-i] == '0':
r = dfs(x-i)
if r is not None:
r.append(i)
return r
return None
ans = dfs(N)
if ans is None:
ans = [-1]
return ans
def main():
N, M = read_int_n()
S = read_str()
print(*slv(N, M, S))
if __name__ == '__main__':
main()
| N, M = map(int, input().split())
S = input()
index = N
count = 0
history = []
while index > 0:
start = max(0, index - M)
for i, c in enumerate(S[start:index], start=start):
if c == '0':
history.append(index - i)
index = i
count += 1
break
else:
print(-1)
exit()
print(*history[::-1]) | 1 | 139,086,374,845,262 | null | 274 | 274 |
a, b = map(int, input().split())
if a > b: a, b = b, a
while True:
if b % a == 0:
print(a)
break
else:
b = b % a
if a > b: a, b = b, a | # Euclidean algorithm
def gcd(x, y):
if x < y:
x, y = y, x
while y > 0:
r = x % y
x = y
y = r
return x
print(gcd(*map(int, input().split()))) | 1 | 7,950,555,360 | null | 11 | 11 |
def main():
import sys
input = sys.stdin.readline
n = int(input())
a = [int(i) for i in input().split()]
b = [int(i) for i in range(n)]
ab = [(x,y) for x,y in zip(a,b)]
from operator import itemgetter
ab = sorted(ab,key=itemgetter(0),reverse=True)
dp = [[-10**14]*(n+1) for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
for j in range(i+2):
if j >= 1:
dp[i+1][j] = max(dp[i][j]+ab[i][0]*abs(ab[i][1]-(n-1-(i-j))),dp[i][j-1]+ab[i][0]*abs(ab[i][1]+1-j))
if j == 0:
dp[i+1][0] = dp[i][0] + ab[i][0]*abs(ab[i][1]-(n-1-i))
print(max(dp[n]))
if __name__ == '__main__':
main() | N, *A = map(int, open(0).read().split())
A = sorted(enumerate(A), reverse=True, key=lambda x: x[1])
dp = [[0] * (N + 1) for _ in range(N + 1)]
for i, (p, a) in enumerate(A):
for j in range(i + 1):
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + a * (p - j))
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + a * (N - (i - j) - 1 - p))
print(max(dp[N])) | 1 | 33,546,568,499,168 | null | 171 | 171 |
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_3_A&lang=jp
#????????????
#????????????python???????????????????????????????????????push???pop?????????
#??????????????????????????°????????§??????????§£???????????\??£???
def rpn(formula):
stack = Stack()
for d in formula:
if d == "+":
stack.push(stack.pop() + stack.pop())
elif d == "-":
stack.push(-stack.pop() + stack.pop())
elif d == "*":
stack.push(stack.pop() * stack.pop())
else:
stack.push(int(d))
return stack.pop()
class Stack:
def __init__(self):
self.data = []
def push(self, d):
#print(self.data)
self.data.append(d)
def pop(self):
#print(self.data)
r = self.data[-1]
self.data = self.data[:-1]
return r
def main():
formula = input().split()
print(rpn(formula))
if __name__ == "__main__":
main() | #!/usr/bin/env python3
def main():
N = input()
l = len(N)
K = int(input())
ans = 0
# 最上位K桁が0の場合
# l-K_C_K * 9^K
if K == 1:
ans += (l-1) * 9
elif K == 2:
ans += (l-1) * (l-2) * 81 // 2
else:
ans += (l-1) * (l-2) * (l-3) * 729 // 6
if K == 1:
# 最上位の数以外0
ans += int(N[0])
elif K == 2:
# 最上位1桁が0ではなく,残りl-1桁中1桁だけ0以外（Nより大きくならないように注意）
if l >= 2:
# ans += int(N[0]) * (l-1) * 9 - (9 - int(N[1]))
for a in range(1,int(N[0])+1):
for b in range(l-1):
for p in range(1,10):
tmp = a * 10**(l-1) + p * 10**b
if tmp <= int(N):
ans += 1
else:
# 最上位1桁が0ではなく,残りl-1桁中2桁だけ0以外（Nより大きくならないように注意）
if l >= 3:
NN = int(N)
N0 = int(N[0])
L = 10**(l-1)
ans += (N0-1) * (l-1) * (l-2) * 81 // 2
for p in range(1,10):
for q in range(1,10):
for b in range(l-1):
for c in range(b+1,l-1):
tmp = N0 * L + p * 10**b + q * 10**c
if tmp <= NN:
ans += 1
else:
break
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 37,779,621,367,368 | 18 | 224 |
n=int(input())
while n!=0:
S=0
#print(n)
l=input().rstrip().split()
l=list(map(int,l))
#print(l)
m=sum(l)/len(l)
#print(m)
for i in range(len(l)):
S+=(l[i]-m)**2
print((S/len(l))**(1/2))
n=int(input())
| W,H,x,y,r=map(int,input().split())
print("Yes"*(r<=x<=W-r)*(r<=y<=H-r)or"No")
| 0 | null | 316,644,569,920 | 31 | 41 |
class UnionFind:
"""
class UnionFind
https://note.nkmk.me/python-union-find/
order O(log(n))
n = the number of elements
parents = the list that contains "parents" of x. be careful that it doesn't contain "root" of x.
"""
def __init__(self, n):
"""
make UnionFind
:param n: the number of elements
"""
self.n = n
self.parents = [-1] * n
def find(self, x):
"""
:param x: an element
:return: the root containing x
"""
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
"""
:param x, y: an element
"""
# root
x = self.find(x)
y = self.find(y)
if x == y:
# already same group so do nothing
return
if self.parents[x] > self.parents[y]:
# the root should be min of group
x, y = y, x
# remind that x, y is the root, x < y, then, y unions to x.
self.parents[x] += self.parents[y]
# and then y's parent is x.
self.parents[y] = x
def size(self, x):
# return the size of group
return -self.parents[self.find(x)]
def same(self, x, y):
# return whether the x, y are in same group
return self.find(x) == self.find(y)
def members(self, x):
# return members of group
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
# return all roots
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
# return how many groups
return len(self.roots())
def all_group_members(self):
# return all members of all groups
return {r: self.members(r) for r in self.roots()}
n,m= map(int,input().split())
union = UnionFind(n)
for i in range(m):
a,b = map(int,input().split())
union.union(a-1,b-1)
print(union.group_count()-1) | import collections
N,M = map(int,input().split())
road = [[] for _ in range(N+1)]
for _ in range(M):
A,B = map(int,input().split())
road[A].append(B)
road[B].append(A)
no_visit =set(range(1,N+1))
q = collections.deque([])
cnt = 0
while no_visit:
q.append(no_visit.pop())
cnt +=1
while q:
now = q.popleft()
for nxt in road[now]:
if nxt in no_visit:
q.append(nxt)
no_visit.discard(nxt)
print(cnt-1)
| 1 | 2,318,890,318,918 | null | 70 | 70 |
#!/usr/bin/env python3
n = int(input())
n /= 3
print(n**3) | n = int(input())
ab = [tuple(map(int, input().split())) for _ in range(n)]
a, b = map(list, zip(*ab))
a.sort()
b.sort(reverse=True)
a1, b1 = a[n//2], b[n//2]
a2, b2 = a[n//2-1], b[n//2-1]
if n % 2: print(b1 - a1 + 1)
else: print((b1+b2) - (a1+a2) + 1)
| 0 | null | 32,341,206,970,920 | 191 | 137 |
x, k, d = map(int,input().split())
x = abs(x)
if x>k*d:
ans = x-k*d
else:
cnt = x//d#xに最も近づくための移動回数
if (k-cnt)%2==0:
ans = x-cnt*d
else:
if x>0:
ans = abs(x-cnt*d-d)
else:
ans = abs(x-cnt*d+d)
print(ans) | x, k, d = map(int, input().split())
if abs(x) // d >= k:
if x > 0:
print(x - k * d)
else:
print(abs(k * d + x))
exit()
div = abs(x) // d
k -= div
if x > 0:
x -= div * d
else:
x += div * d
if k % 2 == 0:
print(abs(x))
else:
print(abs(abs(x) - d))
| 1 | 5,202,190,575,890 | null | 92 | 92 |
# 問題文
# 高橋君の夏休みはN日間です。
# 夏休みの宿題が M個出されており、i番目の宿題をやるにはAi日間かかります。
# 複数の宿題を同じ日にやることはできず、また、宿題をやる日には遊ぶことができません。
# 夏休み中に全ての宿題を終わらせるとき、最大何日間遊ぶことができますか？
# ただし、夏休み中に全ての宿題を終わらせることができないときは、かわりに -1 を出力してください。
# n（夏休みの日数）,m（宿題の数）：標準入力
# リストの中のA(宿題日)：リストを作成し、標準入力
n, m = map(int, input().split())
A = list(map(int, input(). split()))
# 最大で n −合計(A1+. . .+AM)日間遊ぶことができる
if n < sum(A): # 夏休みの日数より宿題日が多い場合：宿題をやる日数が足りない→終わらせることができない
print(-1)
else:
print(n-sum(A)) # その他→宿題は終わる→夏休みの日数-宿題日
# NameError: name 'N' is not defined | N, M = map(int, input().split())
print(max(-1, N-sum(map(int, input().split())))) | 1 | 32,017,521,320,772 | null | 168 | 168 |
X, N = map(int, input().split())
if N == 0:
print(X)
else:
P = list(map(int, input().split()))
A = [0]
for i in range(1, 102):
if (i in P) == False:
A.append(i)
c = 101
for j in range(len(A)):
if abs(X - A[len(A)-int(j)-1]) <= abs(X - c):
c = A[len(A)-int(j)-1]
else:
c = c
print(c)
| x, n = [int(i) for i in input().split()]
a = [int(i) for i in input().split()] if n != 0 else []
min_ = 100
cnt = 0
for i in range(100 + 2):
if abs(i - x) < min_ and not i in a:
min_ = abs(i - x)
cnt = i
print(cnt) | 1 | 14,039,982,037,260 | null | 128 | 128 |
N = int(input())
A = sorted(list(map(int, input().split())), reverse=True)
ans = 0
cnt = 1
# 最大値は一回だけ
ans += A[0]
# N-2個は、2,2,3,3,..i,i,...のように取る
flag = False
for i in range(1, len(A)-1):
ans += A[cnt]
if flag == False:
flag = True
else:
flag = False
cnt += 1
print(ans) | def merge(targ,first,mid,last):
left = targ[first:mid] + [10 ** 9 + 1]
right = targ[mid:last] + [10 ** 9 + 1]
leftcnt = rightcnt = 0
global ans
for i in range(first,last):
ans += 1
#print(left,right,left[leftcnt],right[rightcnt],targ,ans)
if left[leftcnt] <= right[rightcnt]:
targ[i] = left[leftcnt]
leftcnt += 1
else:
targ[i] = right[rightcnt]
rightcnt += 1
def mergesort(targ,first,last):
if first +1 >= last:
pass
else:
mid = (first + last) // 2
mergesort(targ,first,mid)
mergesort(targ,mid,last)
merge(targ,first,mid,last)
ans = 0
num = int(input())
targ = [int(n) for n in input().split(' ')]
mergesort(targ,0,num)
print(" ".join([str(n) for n in targ]))
print(ans) | 0 | null | 4,623,905,183,590 | 111 | 26 |
S = input()
L = len(S)
L //= 2
answer = 0
for i in range(L):
if S[i] != S[-i-1]:
answer += 1
print(answer) | h, w, z = map(int ,input().split())
s = []
for i in range(h):
s.append(list(input()))
ans = int(1e9+7)
for i2 in range(2**(h-1)):
d = [True] * (h-1)
for j2 in range(h-1):
if (i2 >> j2) & 1:
d[j2] = False
d.append(False)
val = 0
for i in range(len(d)-1):
if d[i] == False:
val += 1
#print(val,d)
l = []
lis = []
for i in range(h):
l.append(i)
if d[i] == False:
lis.append(l)
l = []
flg2 = True#横がiのときにcnt2の要素がkを超えるとFalse
flg = True#cntの要素がkを超えるとFalse
cnt = [0] * len(lis)#全体での1の個数
for i in range(w):
cnt2 = [0] * len(lis)#iでの1の個数
for j in range(len(lis)):
for k in lis[j]:
if s[k][i] == '1':#高さがkで横がiの時、
cnt[j] += 1#lis[j]を1たす
cnt2[j] += 1
if cnt[j] > z:
flg = False
if cnt2[j] > z:
flg2 = False
if flg == False:
for j in range(len(cnt)):
cnt[j] = cnt2[j]
flg = True
val += 1
#print(cnt,cnt2)
#print(i,val)
if flg2 == True:
ans = min(ans,val)
#print(val,d,lis,flg)
print(ans)
| 0 | null | 84,371,649,500,272 | 261 | 193 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
N, M, K = map(int,input().split())
uf = UnionFind(N)
f_b = [set() for _ in range(N)]
ans = []
for i in range(M):
A, B = map(int,input().split())
A -= 1
B -= 1
uf.union(A, B)
f_b[A].add(B)
f_b[B].add(A)
for i in range(K):
C, D = map(int,input().split())
C -= 1
D -= 1
if uf.same(C, D):
f_b[C].add(D)
f_b[D].add(C)
for i in range(N):
ans.append(uf.size(i) - len(f_b[i]) - 1)
print(*ans) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
A, B = input().split()
B = int(''.join(B.split('.')))
print(int(A)*B//100) | 0 | null | 38,912,421,898,840 | 209 | 135 |
N = int(input())
MOD = 10**9+7
a10 = 10**N
a9 = 9**N
a8 = 8**N
print((a10-a9-a9+a8) % MOD)
| import itertools
N = int(input())
L = []
for i in range(N):
x,y = map(int,input().split())
L.append([x,y])
cnt = 0
total = 0
for v in itertools.permutations(L):
for i in range(N-1):
x_1 = v[i][0]
y_1 = v[i][1]
x_2 = v[i+1][0]
y_2 = v[i+1][1]
total += ((x_2 - x_1) ** 2 + (y_2 - y_1) ** 2) ** 0.5
cnt += 1
print(total/cnt) | 0 | null | 75,438,010,900,252 | 78 | 280 |
line = input()
for ch in line:
n = ord(ch)
if ord('a') <= n <= ord('z'):
n -= 32
elif ord('A') <= n <= ord('Z'):
n += 32
print(chr(n), end='')
print() | # coding:utf-8
i = raw_input()
print i.swapcase()
| 1 | 1,491,551,041,288 | null | 61 | 61 |
import sys
from collections import deque
def input():
return sys.stdin.readline().strip()
def main():
H,W = map(int,input().split())
S = [list(input()) for _ in range(H)]
dp = [[float('inf') for _ in range(W)] for _ in range(H)]
def bfs(x,y):
que = deque()
que.append((x,y))
if S[y][x] == '.':
dp[y][x] = 0
else:
dp[y][x] = 1
while que.__len__():
x,y = que.popleft()
for dx,dy in ((1,0),(0,1)):
sx = x + dx
sy = y + dy
if sx == W or sy == H:
continue
if S[y][x] == '.' and S[sy][sx] == '#':
tmp = 1
else:
tmp = 0
dp[sy][sx] = min(dp[y][x]+tmp,dp[sy][sx])
if (sx,sy) not in que:
que.append((sx,sy))
bfs(0,0)
print(dp[H-1][W-1])
if __name__ == "__main__":
main() | k=int(input())
a,b=map(int,input().split())
cnt=0
for i in range(a, b+1):
if i%k==0:
cnt+=1
if cnt>0:
print('OK')
else :
print('NG')
| 0 | null | 37,986,205,305,568 | 194 | 158 |
#!/usr/bin/env python3
import sys
from itertools import chain
def solve(A: int, B: int):
answer = 6 - A - B
return answer
def main():
tokens = chain(*(line.split() for line in sys.stdin))
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
answer = solve(A, B)
print(answer)
if __name__ == "__main__":
main()
| # encoding:utf-8
while True:
a,op,b = map(str, input().split())
c = int(a)
d = int(b)
if op == '+': result = c + d
if op == '-': result = c - d
if op == '*': result = c * d
if op == '/': result = int(c / d)
if op == '?': break
print("{0}".format(result)) | 0 | null | 55,612,165,036,626 | 254 | 47 |
#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 # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
a,b = readInts()
print(a*b if (1 <= a <= 9 and 1 <= b <= 9) else '-1')
| def judge99(x):
if x <= 9:
return True
else:
return False
a, b = map(int,input().split())
if judge99(a) and judge99(b):
print(a*b)
else:
print(-1)
| 1 | 158,405,043,346,410 | null | 286 | 286 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import collections
class Process(object):
def __init__(self, name, time):
self.name = name
self.time = int(time)
def schedule(processes, quantum):
queue = collections.deque(processes)
time = 0
while len(queue) > 0:
p = queue.popleft()
rest_time = p.time - quantum
if rest_time > 0:
time += quantum
queue.append(Process(p.name, rest_time))
else:
time += p.time
print("{name} {time:d}".format(name=p.name, time=time))
def main():
[n, q] = list(map(int, input().split()))
processes = [Process(*input().split()) for i in range(n)]
schedule(processes, q)
if __name__ == "__main__":
main() | n, q = [ int( val ) for val in raw_input( ).split( " " ) ]
ps = [0]*n
t = [0]*n
for i in range( n ):
ps[i], t[i] = raw_input( ).split( " " )
qsum = 0
while t:
psi = ps.pop( 0 )
ti = int( t.pop( 0 ) )
if ti <= q:
qsum += ti
print( "{:s} {:d}".format( psi, qsum ) )
else:
t.append( ti - q )
ps.append( psi )
qsum += q | 1 | 42,233,907,260 | null | 19 | 19 |
a, b, c = map(int, input().split())
if a / c <= b:
print("Yes")
else:
print("No")
| n = int(input())
x = input().split()
y = input().split()
import math
for i in range(4):
D = 0
for j in range(n):
if i != 3:
D = D + math.pow(math.fabs(int(x[j]) - int(y[j])),i+1)
else:
compare = math.fabs(int(x[j]) - int(y[j]))
if D < compare:
D = compare
if i != 3:
print('{0:.6f}'.format(math.pow(D,1/(i+1))))
else:
print('{0:.6f}'.format(D))
| 0 | null | 1,869,459,273,660 | 81 | 32 |
from collections import deque
alfabet=deque(input())
n=int(input())
reverse=0
for i in range(n):
operation_list=list(input().split())
if int(operation_list[0])==1:
reverse+=1
else:
if int(operation_list[1])==2 and reverse%2==0:
alfabet.append(operation_list[2])
elif int(operation_list[1])==2 and reverse%2==1:
alfabet.appendleft(operation_list[2])
elif int(operation_list[1])==1 and reverse%2==0:
alfabet.appendleft(operation_list[2])
elif int(operation_list[1])==1 and reverse%2==1:
alfabet.append(operation_list[2])
if reverse%2!=0:
alfabet.reverse()
print(''.join(alfabet)) | import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
n,k=map(int,input().split())
A=sorted(list(map(int,input().split())))
F=sorted(list(map(int,input().split())),reverse=True)
# https://qiita.com/drken/items/97e37dd6143e33a64c8c#3-%E3%82%81%E3%81%90%E3%82%8B%E5%BC%8F%E4%BA%8C%E5%88%86%E6%8E%A2%E7%B4%A2%E3%81%AE%E3%81%95%E3%82%89%E3%81%AA%E3%82%8B%E5%88%A9%E7%82%B9
def is_ok(ind):
cnt=0
for i in range(n):
target=ind//F[i]
if target<A[i]:
cnt+=A[i]-target
if cnt<=k:
return True
else: return False
def bin_search_meguru():
"""
初期値のng,okを受け取り,is_okを満たす最小(最大)のokを返す
まずis_okを定義すべし
ng, okは,とり得る最小の値-1,とり得る最大の値+1
"""
# 適当にいじる
ng = -1 # ind=0が条件を満たすこともあるため
ok = A[-1]*F[0]+1 # ind=len(a)-1が条件を満たさないこともあるため
# いじらない
# okとngのどちらが大きいかわからないことを考慮
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
val=bin_search_meguru()
print(val)
resolve() | 0 | null | 110,924,940,896,832 | 204 | 290 |
import numpy as np
N = int(input())
A = list(map(int, input().split()))
A = np.argsort(A)
for a in A:
print(a+1, end=" ") | n = int(input())
l = sorted(list(enumerate(map(int,input().split()),start = 1)), key = lambda x:x[1])
print(*(l[i][0] for i in range(n))) | 1 | 181,080,150,824,218 | null | 299 | 299 |
import math
r=float(input())
print(2*r*math.pi) | import sys
import math
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
r = int(readline())
print(r * 2 * math.pi)
if __name__ == '__main__':
solve()
| 1 | 31,441,674,284,254 | null | 167 | 167 |
import numpy as np
N = int(input())
A = list(map(int, input().split()))
A = np.argsort(A)
for a in A:
print(a+1, end=" ") | import math
a,b,c=map(float,input().split())
if c<90:
e=c*math.pi/180
S=a*b*1/2*math.sin(e)
t=a**2+b**2-2*a*b*math.cos(e)
r=math.sqrt(t)
L=a+b+r
h=b*math.sin(e)
print('{:.08f}'.format(S))
print('{:.08f}'.format(L))
print('{:.08f}'.format(h))
if c==90:
e=c*math.pi/180
S=a*b*1/2*math.sin(e)
t=a**2+b**2-2*a*b*math.cos(e)
r=math.sqrt(t)
L=a+b+r
h=b
print('{:.08f}'.format(S))
print('{:.08f}'.format(L))
print('{:.08f}'.format(h))
if c>90:
e=c*math.pi/180
d=180*math.pi/180
f=d-e
S=a*b*1/2*math.sin(e)
t=a**2+b**2-2*a*b*math.cos(e)
r=math.sqrt(t)
L=a+b+r
h=b*math.sin(f)
print('{:.08f}'.format(S))
print('{:.08f}'.format(L))
print('{:.08f}'.format(h))
| 0 | null | 90,499,353,161,500 | 299 | 30 |
from collections import deque
s = deque(list(input()))
n = int(input())
normal = 0
for i in range(n):
li = input().split()
if int(li[0]) == 1:
normal ^= 1
else:
k = int(li[1]) - 1
k ^= normal
if k == 1:
s.append(li[2])
else:
s.appendleft(li[2])
print(''.join(s) if normal == 0 else ''.join(list(s)[::-1])) | S=input()
Q=int(input())
A=[list(input().split()) for i in range(Q)]
c=0
R=""
L=""
for i in range(Q):
if A[i][0]=="1":
c+=1
continue
if c%2==1 and A[i][0]=="2":
if A[i][1]=="1":
R=R+A[i][2]
elif A[i][1]=="2":
L=A[i][2]+L
elif c%2==0 and A[i][0]=="2":
if A[i][1]=="1":
L=A[i][2]+L
elif A[i][1]=="2":
R=R+A[i][2]
S=L+S+R
if c%2==1:
S=S[::-1]
print(S) | 1 | 57,254,921,366,940 | null | 204 | 204 |
from math import factorial
N = int(input())
P = [int(x) for x in input().split()]
Q = [int(x) for x in input().split()]
orderP = 1 + (P[0]-1)*factorial(N-1)
orderQ = 1 + (Q[0]-1)*factorial(N-1)
for i in range(1,N):
redP = 0
redQ = 0
for j in range(i):
if P[j] < P[i]: redP += 1
if Q[j] < Q[i]: redQ += 1
orderP += (P[i]-redP-1)*factorial(N-i-1)
orderQ += (Q[i]-redQ-1)*factorial(N-i-1)
print(abs(orderP - orderQ)) | A,B,C,K=map(int,input().split())
if A>=K:
print(K)
elif B>=K-A:
print(A)
else:
print(A-1*(K-A-B))
| 0 | null | 61,016,776,336,592 | 246 | 148 |
import sys
n = int(sys.stdin.readline())
xs = []
for _ in range(n):
v = [int(x) for x in sys.stdin.readline().split(" ")]
xs.append(v)
xs.sort(key=lambda x: x[0])
if n % 2 == 0:
m1 = n // 2 - 1
m2 = m1 + 1
a1 = xs[m1][0]
a2 = xs[m2][0]
xs.sort(key=lambda x: x[1])
b1 = xs[m1][1]
b2 = xs[m2][1]
a = (a1 + a2)
b = (b1 + b2)
c = (b - a) + 1
#print(m1, m2, a1, a2, b1, b2, "*", a, b, c)
print(c)
else:
m = (n + 1) // 2 - 1
a = xs[m][0]
xs.sort(key=lambda x: x[1])
b = xs[m][1]
c = b - a + 1
#print(m, a, b, c)
print(c) | def main():
n = int(input())
a_list = []
b_list = []
for _ in range(n):
a, b = map(int, input().split())
a_list.append(a)
b_list.append(b)
a_sorted = list(sorted(a_list))
b_sorted = list(sorted(b_list))
if n%2:
print(b_sorted[n//2]-a_sorted[n//2]+1)
else:
print((b_sorted[n//2-1]+b_sorted[n//2]-a_sorted[n//2-1]-a_sorted[n//2])+1)
if __name__ == "__main__":
main() | 1 | 17,332,912,363,210 | null | 137 | 137 |
def resolve():
N, D = map(int, input().split())
cnt = 0
for n in range(N):
x, y = map(int, input().split())
d = (x ** 2 + y ** 2) ** 0.5
if d <= D:
cnt += 1
print(cnt)
resolve() | # -*- coding: utf-8 -*-
"""
Created on Sun Apr 29 18:04:22 2018
ALDS1_3b_r リングバッファによる実装
@author: maezawa
"""
def fifo_enque(data):
global tail
global fifo
fifo[tail] = data
tail = (tail+1)%fifo_size
def fifo_deque():
global head
global fifo
data = fifo[head]
head = (head+1)%fifo_size
return data
fifo_size = 100000
fifo = [0 for _ in range(fifo_size)]
head = 0
tail = 0
n, q = list(map(int, input().split()))
for i in range(n):
s = input().split()
data = [s[0], int(s[1])]
fifo_enque(data)
current_time = 0
finished = []
fin_time = []
while True:
data = fifo_deque()
if data[1] > q:
current_time += q
data[1] -= q
fifo_enque(data)
else:
current_time += data[1]
finished.append(data[0])
fin_time.append(current_time)
if head == tail:
break
for i in range(n):
print("{} {}".format(finished[i], fin_time[i]))
| 0 | null | 2,956,340,217,002 | 96 | 19 |
N = int(input())
S = list(map(int,input().split()))
ans = 0
for x in range(N-1):
for y in range(x+1,N):
ans += S[x]*S[y]
print(ans) | import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N = I()
d = LI()
ans = 0
for i in range(N-1):
for j in range(i+1,N):
ans += d[i]*d[j]
print(ans) | 1 | 167,900,046,218,490 | null | 292 | 292 |
a = int(input())
print(a//2-(a%2==0))
| # import bisect
# from collections import Counter, defaultdict, deque
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
# import itertools
# from operator import attrgetter, itemgetter
# import math
import sys
# import numpy as np
ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n = int(input())
if n % 2 == 0:
print(n//2 - 1)
else:
print(n//2)
if __name__ == '__main__':
main() | 1 | 153,693,982,461,470 | null | 283 | 283 |
n, m = map(int, input().split())
def out(s, e):
while s < e:
print("{} {}".format(s, e))
s += 1
e -= 1
if m % 2 == 0:
out(1, m)
out(m + 1, 2 * m + 1)
else:
out(1, m + 1)
out(m + 2, 2 * m + 1) | n=int(input())
d=list(map(int,input().split()))
d2=[m**2 for m in d]
print((sum(d)**2-sum(d2))//2) | 0 | null | 98,358,445,962,710 | 162 | 292 |
from collections import deque
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, u, v = map(int, readline().split())
m = map(int,read().split())
data = list(zip(m,m))
graph = [[] for _ in range(n+1)]
for a,b in data:
graph[a].append(b)
graph[b].append(a)
def dfs(v):
dist = [None] * (n + 1)
dist[v] = 0
stack = deque([v])
while stack:
x = stack.popleft()
for y in graph[x]:
if dist[y] is None:
dist[y] = dist[x] + 1
stack.append(y)
return dist
res = 0
for i, j in zip(dfs(u), dfs(v)):
if i is None:
continue
if i <= j:
if j > res:
res = j
print(res - 1) | print("".join([_.upper() if _.islower() else _.lower() for _ in input()])) | 0 | null | 59,689,110,724,044 | 259 | 61 |
S = input()
print("Yes" if S.count("A") and S.count("A") < 3 or S.count("B") and S.count("B") < 3 else "No") | s=set(input())
if len(s)==2:print('Yes')
else:print('No') | 1 | 54,681,000,023,902 | null | 201 | 201 |
import sys
input = sys.stdin.readline
R, C, K = map(int, input().split())
D = dict()
for _ in range(K):
r, c, v = map(int, input().split())
D[(r, c)] = v
dp0 = [[0] * (C + 1) for _ in range(R + 1)]
dp1 = [[0] * (C + 1) for _ in range(R + 1)]
dp2 = [[0] * (C + 1) for _ in range(R + 1)]
dp3 = [[0] * (C + 1) for _ in range(R + 1)]
for r in range(1, R + 1):
for c in range(1, C + 1):
m = max(dp0[r - 1][c], dp1[r - 1][c], dp2[r - 1][c], dp3[r - 1][c])
dp0[r][c] = max(m, dp0[r][c - 1])
dp1[r][c] = max(m, dp1[r][c - 1])
dp2[r][c] = max(m, dp2[r][c - 1])
dp3[r][c] = max(m, dp3[r][c - 1])
if (r, c) in D:
dp1[r][c] = max(dp1[r][c], m + D[(r, c)], dp0[r][c - 1] + D[(r, c)])
dp2[r][c] = max(dp2[r][c], m + D[(r, c)], dp1[r][c - 1] + D[(r, c)])
dp3[r][c] = max(dp3[r][c], m + D[(r, c)], dp2[r][c - 1] + D[(r, c)])
print(max(dp0[-1][-1], dp1[-1][-1], dp2[-1][-1], dp3[-1][-1]))
| from collections import deque
N, M, K = map(int, input().split())
flst = []
blst = []
glooplst = [i for i in range(N+1)]
colorlst = [0]*(N+1)
countlst = [0]*(N+1)
anslst = [0]*(N+1)
d = deque()
for i in range(N+1):
flst.append([])
blst.append([])
for i in range(M):
a, b = map(int, input().split())
flst[a].append(b)
flst[b].append(a)
for i in range(K):
a, b = map(int, input().split())
blst[a].append(b)
blst[b].append(a)
for i in range(1, N+1):
if colorlst[i] == 0:
d.append(i)
colorlst[i] = 1
countlst[i] += 1
while d:
now = d.popleft()
for j in flst[now]:
if colorlst[j] == 0:
d.append(j)
colorlst[j] = 1
glooplst[j] = i
countlst[i] += 1
for i in range(1, N+1):
cnt = countlst[glooplst[i]] - len(flst[i]) -1
for j in blst[i]:
if glooplst[i] == glooplst[j]:
cnt -= 1
print(cnt, end=' ')
print()
| 0 | null | 33,459,390,892,412 | 94 | 209 |
N = int(input())
A = list(map(int, input().split()))
A = sorted(A)
count = 0
max = A[-1]
if max == 0:
print(0)
exit()
import math
V = [0]*(math.floor(math.log(max, 2))+1)
for i in range (0, N):
B = A[i]
vount = 0
while B > 0:
if B%2 == 0:
B = B//2
vount+=1
else:
B = (B-1)//2
V[vount]+=1
vount+=1
for i in range (0, len(V)):
count+=((V[i]*(N-V[i]))*(2**i))
print(count%(10**9+7)) | import sys
import math
from heapq import *
import fractions
from collections import defaultdict
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
N=int(input())
A=nl()
A.sort(reverse=True)
mod=10**9+7
keta=[0]*60
for i in range(N):
for j in range(60):
keta[j]+=((A[i]>>j)&1)
ans=0
mod_div2=[0]*60
mod_div2[0]=1
for i in range(1,60):
mod_div2[i]=(2*mod_div2[i-1])%mod
for i in range(len(A)):
keta_max=0
for j in range(60):
if((A[i]>>j)&1):
keta_max=j+1
for j in range(keta_max):
if((A[i]>>j)&1):
keta[j]-=1
ans+=mod_div2[j]*(len(A)-i-1-keta[j])
else:
ans+=mod_div2[j]*keta[j]
ans%=mod
print(ans%mod) | 1 | 123,381,637,810,170 | null | 263 | 263 |
_fib = [0] * 45
def fib(n):
if n < 2:
return 1
if _fib[n] > 0:
return _fib[n]
_fib[n] = fib(n-1) + fib(n-2)
return _fib[n]
n = int(input())
print(fib(n))
| D = int(input())
C = list(map(int, input().split()))
s = list()
for i in range(D):
s1 = list(map(int, input().split()))
s.append(s1)
t = list()
for i in range(D):
N = int(input())
t.append(N-1)
done = [0] * 26
ans = 0
for d in range(1, D+1):
td = t[d-1]
done[td] = d
ans += s[d-1][td]
for i in range(26):
ans -= C[i]*(d-done[i])
print(ans) | 0 | null | 5,036,303,529,430 | 7 | 114 |
s = input()
n = len(s)
a = 'x'*n
print(a)
| a = raw_input().lower()
s = 0
while True:
b = raw_input()
if b == 'END_OF_TEXT':
break
b = b.split()
b = map(str.lower,b)
s += b.count(a)
print s | 0 | null | 37,409,556,560,220 | 221 | 65 |
n,k = map(int,input().split())
h = list(map(int, input().split()))
if n <= k:
print(0)
exit()
h.sort()
print(sum(h[:n-k])) | import sys
N, K = map(int, sys.stdin.readline().rstrip().split())
H = [int(x) for x in sys.stdin.readline().rstrip().split()]
H.sort()
# print(H[:-K])
if K == 0:
print(sum(H))
else:
print(sum(H[:-K])) | 1 | 78,937,921,017,080 | null | 227 | 227 |
n = int(input())
def dfs(s, mx):
if len(s) == n:
print(s)
return
for c in range(ord("a"), mx+2):
dfs(s+chr(c), max(mx, c))
dfs("", ord("a")-1) | (n, k), p, c = [[*map(int, i.split())] for i in open(0)]
def solve(x, t):
visit = [0] * n
visit[x] = 1
loop = [0] * n
count = 0
ans = c[p[x] - 1]
l = True
sub = 0
while True:
x = p[x] - 1
if l:
if visit[x]:
if loop[x]:
ln = sum(loop)
if t > ln:
sub += (t//ln -1)*count*(count>0)
t %= ln
t += ln
l = False
count += c[x]
loop[x] = 1
visit[x] = 1
sub += c[x]
t -= 1
ans = max(sub, ans)
if t < 1:
return ans
print(max(solve(i, k) for i in range(n))) | 0 | null | 28,796,356,873,130 | 198 | 93 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.