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
|
|---|---|---|---|---|---|---|
while True:
h, w = map(int, input().split())
if w+h == 0:
break
line = "#"*w
for y in range(h):
print(line)
print()
| n = int(input())
a = [list(input().split()) for i in range(n)]
x = input()
#print(a)
res = 0
start = 0
for i in range(n):
if a[i][0] == x:
start = i+1
for i in range(start,n):
res += int(a[i][1])
print(res) | 0 | null | 49,123,570,630,600 | 49 | 243 |
n = int(input())
a = []
for i in range(1, n+1):
if i%3 == 0 or i%5 == 0:
continue
else:
a.append(i)
print(sum(a)) | x = input()
a, b, c = tuple(x.split())
a = int(a)
b = int(b)
c = int(c)
abc = sorted([a, b, c])
print(abc[0], abc[1], abc[2]) | 0 | null | 17,551,986,976,732 | 173 | 40 |
from itertools import permutations
input()
P = int(''.join(input().split()))
Q = int(''.join(input().split()))
s = sorted(permutations(str(P)))
pi = s.index(tuple(str(P)))
qi = s.index(tuple(str(Q)))
print(abs(pi - qi)) | import itertools
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
l = [i+1 for i in range(N)]
for i, tpl in enumerate(itertools.permutations(l, N)):
if tpl == P:
a = i
if tpl == Q:
b = i
print(abs(a-b)) | 1 | 100,209,403,040,960 | null | 246 | 246 |
n,k=map(int,input().split())
lr=[list(map(int,input().split())) for _ in range(k)]
mod=998244353
dp=[0]*(n+1)
csum=[0]*(n+2)
dp[0]=1
for i in range(n):
for j in range(k):
l,r=lr[j]
dp[i]+=csum[max(i+1-l,0)]-csum[max(i-r,0)]
dp[i]%=mod
csum[i+1]+=dp[i]+csum[i]
csum[i+1]%=mod
print(dp[n-1]) | a=input()
l=a.split(" ")
n=int(l[0])
k=int(l[1])
f=input()
fruits=f.split(" ")
for d in range(0, len(fruits)):
fruits[d]=int(fruits[d])
ans=0
b=0
while(b<k):
g=min(fruits)
ans+=g
fruits.remove(g)
b+=1
print(ans) | 0 | null | 7,194,406,016,292 | 74 | 120 |
def main():
import numpy as np
import sys
input = sys.stdin.readline
N, K = map(int,input().split())
A = np.sort(list(map(int,input().split())))
F = np.sort(list(map(int,input().split())))[::-1]
if K >= np.sum(A)*N:
print(0)
exit()
ma = A[-1]*F[0]
mi = 0
A = A*F
while ma != mi:
tgt = (ma + mi)//2
tmp = np.ceil((A-tgt)/F)
if np.sum(tmp[tmp>0]) <= K:
ma = (ma + mi)//2
else:
mi = (ma + mi)//2+1
print(ma)
if __name__ == '__main__':
main()
| N,K = map(int,input().split())
A = list(map(int,input().split()))
F = list(map(int,input().split()))
A.sort()
F.sort(reverse=True)
ng = -1
ok = 10**12+100
while ok - ng > 1:
mid = (ok + ng) // 2
if sum(max(0,a-mid//f) for a,f in zip(A,F)) <= K:
ok = mid
else:
ng = mid
print(ok)
| 1 | 165,712,391,529,802 | null | 290 | 290 |
s=input()
n=len(s)
if n%2==1:
print("No")
exit()
for i in range(n-1):
if s[i]=="h":
if s[i+1]!="i":
print("No")
exit()
elif s[i]=="i":
if s[i+1]!="h":
print("No")
exit()
else:
print("No")
exit()
print("Yes") | import collections
N = int(input())
A = list(map(int, input().split()))
cs = collections.Counter(A)
mcs = cs.most_common()
cnt = mcs[0][1]
if cnt == 1:
print('YES')
else:
print('NO') | 0 | null | 63,516,262,585,412 | 199 | 222 |
from itertools import combinations
N = int(input())
town = []
for n in range(N):
x, y = map(int,input().split())
town.append((x,y))
ans = 0
for i,j in combinations(town,2):
ans += ((i[0]-j[0])**2 + (i[1]-j[1])**2)**0.5
print (2*ans/N) | import math
N = int(input())
#https://qiita.com/jamjamjam888/items/e066b8c7bc85487c0785
xy = [map(int, input().split()) for _ in range(N)]
x, y = [list(i) for i in zip(*xy)]
l = 0
for j in range(N):
for k in range(N):
if j >= k:
continue
l += math.sqrt((x[j] - x[k])**2 + (y[j] - y[k]) ** 2)
print(l * 2/N) | 1 | 149,135,918,077,838 | null | 280 | 280 |
x = int(input())
h = x // 3600
m = (x -h*3600)//60
s = x - h*3600 - m*60
print(h, ':',m , ':', s, sep="")
| print "",
for i in range(1,int(raw_input())+1):
if i%3==0 or str(i).count('3'): print i, | 0 | null | 642,474,536,730 | 37 | 52 |
i=0
while True:
i+=1
a=input()
if a==0:
break
else:
print("Case "+str(i)+": "+str(a)) | import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
t1, t2 = list(map(int, sys.stdin.buffer.readline().split()))
a1, a2 = list(map(int, sys.stdin.buffer.readline().split()))
b1, b2 = list(map(int, sys.stdin.buffer.readline().split()))
da1 = t1 * a1
da2 = t2 * a2
db1 = t1 * b1
db2 = t2 * b2
if da1 + da2 > db1 + db2:
a1, b1 = b1, a1
a2, b2 = b2, a2
da1, db1 = db1, da1
da2, db2 = db2, da2
# b のほうがはやい
# 無限
if da1 + da2 == db1 + db2:
print('infinity')
exit()
# 1回も会わない
if da1 < db1:
print(0)
exit()
# t1 で出会う回数
cnt = abs(da1 - db1) / abs(da1 + da2 - db1 - db2)
ans = int(cnt) * 2 + 1
if cnt == int(cnt):
ans -= 1
print(ans)
| 0 | null | 65,837,669,098,432 | 42 | 269 |
k = int(input())
a, b = map(int, input().split())
while a <= b:
if a % k == 0:
print('OK')
exit()
a += 1
print('NG') | import math
K = int(input())
A, B = map(int, input().split())
largest = math.floor(B/K)*K
print("OK") if largest >= A else print("NG") | 1 | 26,639,275,446,060 | null | 158 | 158 |
N, K = map(int, input().split())
P = list(map(int, input().split()))
_c = list(map(int, input().split()))
# Cを書き換える
C = [0] * N
for i in range(N):
P[i] -= 1
C[i] = _c[P[i]]
m = 31 # bit数
# ダブリング
vertex = list()
score = list()
vertex.append(P)
score.append(C)
for b in range(1, m+1):
p_bth = [0] * N
c_bth = [0] * N
for i in range(N):
p_bth[i] = vertex[b-1][vertex[b-1][i]]
c_bth[i] = score[b-1][i] + score[b-1][vertex[b-1][i]]
vertex.append(p_bth)
score.append(c_bth)
# 桁DP
MIN = -(1 << 63)
prv = [[MIN, 0] for _ in range(N)]
nxt = [[MIN, MIN] for _ in range(N)]
for b in range(m, -1, -1):
for i in range(N):
if (K >> b) & 1:
nxt[vertex[b][i]][0] = max(nxt[vertex[b][i]][0], prv[i][0] + score[b][i])
nxt[vertex[b][i]][1] = max(nxt[vertex[b][i]][1], prv[i][1] + score[b][i])
nxt[i][0] = max(nxt[i][0], prv[i][0], prv[i][1])
else:
nxt[vertex[b][i]][0] = max(nxt[vertex[b][i]][0], prv[i][0] + score[b][i])
nxt[i][0] = max(nxt[i][0], prv[i][0])
nxt[i][1] = max(nxt[i][1], prv[i][1])
prv, nxt = nxt, prv
ans = max(max(x) for x in prv)
if ans == 0:
ans = max(C)
print(ans) | N, K = map(int,input().split())
P = list(map(int,input().split()))
C = list(map(int,input().split()))
S = []
R = -1000000001
#それぞれについての累積和の計算
for i in range(N):#このループはN個の初期マスの時のループ
t = i # tは現在の位置
cnt = 0 # 累積和
sum = [] # 累積和のリスト
res = 0
while True:#このループは一つの初期マスの累積和。最初のコマに戻るまで
t = P[t]-1
cnt += C[t]
sum.append(cnt)
if t == i:
break
#S.append(sum)
if len(sum) >= K:
res = max(sum[:K])
else:
if sum[-1] <= 0:
res = max(sum)
else:
score1 = sum[-1] * (K // len(sum) - 1) + max(sum)
score2 = sum[-1] * (K // len(sum))
r = K % len(sum)
if r != 0:
score2 += max(0, max(sum[:r]))
res = max(score1,score2)
R = max(R,res)
print(R)
| 1 | 5,319,254,079,430 | null | 93 | 93 |
s1,s2=map(str,input().split(' '))
print(s2+s1) | from collections import deque
s=input()
q=int(input())
n=0
que=deque(s)
for i in range(q):
l=input()
if l[0]=='1':
n+=1
else:
if (l[2]=='1' and n%2==0) or (l[2]=='2' and n%2==1):
que.appendleft(l[4])
else:
que.append(l[4])
ans=''.join(que)
if n%2==0:
print(ans)
else:
print(ans[::-1])
| 0 | null | 80,176,843,355,828 | 248 | 204 |
class process:
def __init__(self, name, time):
self.name = name
self.time = time
def queue(q, ps):
time = 0
while len(ps) != 0:
p = ps.pop(0)
if p.time > q:
p.time -= q
time += q
ps.append(p)
else:
time += p.time
print p.name + " " + str(time)
if __name__ == "__main__":
L = map(int, raw_input().split())
N = L[0]
q = L[1]
processes = []
for i in range(N):
L = raw_input().split()
processes.append(process(L[0], int(L[1])))
queue(q, processes) | N, X, T = map(int, input().split())
times = N // X
if N % X != 0:
times += 1
print(T * times)
| 0 | null | 2,119,398,124,578 | 19 | 86 |
k = int(input())
a = 7%k
if a == 0:
print(1)
exit()
for i in range(1,k+1):
a = (10*a + 7)%k
if a == 0:
print(i+1)
exit()
print(-1) | a,b,c,d=map(int,input().split())
while 1:
c-=b
if c<=0: print('Yes'); exit()
a-=d
if a<=0: print('No'); exit() | 0 | null | 17,909,839,891,988 | 97 | 164 |
if __name__ == '__main__':
nm = input()
nm = nm.split()
n = int(nm[0])
m = int(nm[1])
if n%2==1:
for i in range(1,m+1):
print(i,n+1-i)
if n%2==0:
t = n
f = 0
for i in range(1,m+1):
p = i-1+t-n
if p>=n-i-1 and f==0:
f = 1
n -= 1
print(i,n)
n -= 1
| # coding: utf-8
# Your code here!
n,m=input().split()
a=n*int(m)
b=m*int(n)
nlist=[a,b]
nlist.sort()
print(nlist[0]) | 0 | null | 56,694,964,794,282 | 162 | 232 |
import sys
import math
r = float( sys.stdin.readline() )
print( "{:7f} {:7f}".format( r*r*math.pi, r*2*math.pi ) ) | import math
r = float(input())
print("{0:.6f} {1:.6f}".format(math.pi*r**2, 2*math.pi*r))
| 1 | 628,171,494,460 | null | 46 | 46 |
def cmb(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
p = 10 ** 9 + 7
N = 10 ** 6 # N は必要分だけ用意する
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
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)
X, Y = map(int, input().split())
if (2*Y-X)%3 == 0:
if (2*X-Y)%3 == 0:
a = (2*Y-X)//3
b = (2*X-Y)//3
else:
print(0)
exit()
else:
print(0)
exit()
print(cmb(a+b, a, p))
| a,b,c=map(int,input().split());print("Yes"if a<b<c else"No")
| 0 | null | 75,062,111,710,670 | 281 | 39 |
n = int(input())
a = list(map(int, input().split()))
a_to_index = [0] * n
for i in range(n):
a_to_index[a[i]-1] = i + 1
a.sort()
ans = [0] * n
for index, ai in enumerate(a):
ans[index] = a_to_index[ai-1]
print(*ans)
| # C
N = int(input())
# A = list(map(int, input().split()))
order_number = {}
for num, order in enumerate(map(int, input().split())):
order_number[num+1] = order
for order, number in sorted(order_number.items(), key=lambda x: x[1]):
print(order, end=" ")
print() | 1 | 180,730,165,815,980 | null | 299 | 299 |
import itertools
N = int(input())
cities = [list(map(int, input().split())) for _ in range(N)]
patterns = itertools.permutations(cities, N)
result = 0
count = 0
for ptn in patterns:
count += 1
dis = 0
for i in range(N-1):
dis += ((ptn[i][0]-ptn[i+1][0])**2 + (ptn[i][1]-ptn[i+1][1])**2)**0.5
result += dis
print(result/count)
| import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
n = I()
lst = [None, ]
for _ in range(n):
x, y = LI()
lst.append((x,y))
per = itertools.permutations(range(1,n+1))
sm = 0
oc = math.factorial(n)
for p in per:
dist = 0
before = p[0]
for place in p[1:]:
dist += math.sqrt((lst[place][0]-lst[before][0])**2 + (lst[place][1]-lst[before][1])**2)
before = place
sm += dist
ans = sm/oc
print(ans)
main()
| 1 | 148,287,615,158,130 | null | 280 | 280 |
from functools import reduce
from fractions import gcd
mod = 10**9 + 7
n, *A = map(int, open(0).read().split())
if len(A) == 1:
print(1)
else:
l = reduce(lambda x, y: x*y // gcd(x, y), A) % mod
s = 0
for a in A:
s += l * pow(a, mod-2, mod)
s %= mod
print(s) | class Dice:
def __init__(self,top,front,right,left,back,bottom):
self.top, self.bottom=top,bottom
self.right, self.left=right,left
self.front, self.back=front,back
def turn(self,order):
if order=="N":
self.top,self.front,self.bottom,self.back=self.front,self.bottom,self.back,self.top
if order=="S":
self.top,self.front,self.bottom,self.back=self.back,self.top,self.front,self.bottom
if order=="E":
self.top,self.right,self.bottom,self.left=self.left,self.top,self.right,self.bottom
if order=="W":
self.top,self.right,self.bottom,self.left=self.right,self.bottom,self.left,self.top
d=map(int,raw_input().split())
dice=Dice(d[0],d[1],d[2],d[3],d[4],d[5])
q=input()
for i in range(q):
t,f=map(int,raw_input().split())
if t==d[0]:
if f==d[1]:
print d[2]
elif f==d[2]:
print d[4]
elif f==d[4]:
print d[3]
elif f==d[3]:
print d[1]
elif t==d[1]:
if f==d[0]:
print d[3]
elif f==d[3]:
print d[5]
elif f==d[5]:
print d[2]
elif f==d[2]:
print d[0]
elif t==d[2]:
if f==d[0]:
print d[1]
elif f==d[1]:
print d[5]
elif f==d[5]:
print d[4]
elif f==d[4]:
print d[0]
elif t==d[3]:
if f==d[0]:
print d[4]
elif f==d[4]:
print d[5]
elif f==d[5]:
print d[1]
elif f==d[1]:
print d[0]
elif t==d[4]:
if f==d[0]:
print d[2]
elif f==d[2]:
print d[5]
elif f==d[5]:
print d[3]
elif f==d[3]:
print d[0]
elif t==d[5]:
if f==d[1]:
print d[3]
elif f==d[3]:
print d[4]
elif f==d[4]:
print d[2]
elif f==d[2]:
print d[1]
else:
print "no answer"
| 0 | null | 44,204,856,816,510 | 235 | 34 |
while 1:
try:
line = raw_input()
except EOFError:
break
arr = map((lambda x: int(x)), line.split())
print len(str(arr[0]+arr[1])) | from bisect import bisect
x,n=map(int,input().split())
p=list(map(int,input().split()))
for i in range(100):
if not(x-i in p):
print(x-i)
break
if not(x+i in p):
print(x+i)
break | 0 | null | 7,020,607,780,652 | 3 | 128 |
n=int(input())
output=''
for _ in range(n):
output+='ACL'
print(output) | K = int(input())
a = "ACL"
ans = ""
for i in range(K):
ans += a
print(ans)
| 1 | 2,221,621,780,532 | null | 69 | 69 |
from math import ceil, floor
N = int(input())
half = floor(N / 2)
count = 0
for i in range(half):
count = count + 1
if N % 2 != 0:
print(count)
else:
print(count - 1) | mod = 10**9+7
N = int(input())
A = list(map(int, input().split()))
#累積和のリストを作成
S = [0]*(N+1)
ans = 0
for i in range(N):
S[i+1] = A[i] + S[i]%mod
#累積和って感じですね
for i in range(N):
sum = S[N] - S[i + 1]
if sum < 0:
sum += mod
ans += A[i] * sum
print(ans % mod) | 0 | null | 78,296,532,286,270 | 283 | 83 |
S,T=input().split()
A,B=map(int,input().split())
U=input()
if(U==S):
print("{}".format(A-1)+" {}".format(B))
else:
print("{}".format(A)+" {}".format(B-1)) | s, t = map(str,input().split())
a, b= map(int,input().split())
u= str(input())
if s==u:
a-=1
if t==u:
b-=1
print('%d %d' % (a, b)) | 1 | 72,188,184,450,672 | null | 220 | 220 |
n = int(input())
l = list(map(int,input().split()))
l.sort(reverse = True)
ans = 0
for i in range(len(l)):
for j in range(i+1,len(l)):
for k in range(j+1,len(l)):
if l[i] != l[j] != l[k] and l[i] < l[j] + l[k]:
ans +=1
print(ans) | import itertools
n = int(input())
L = list(map(int, input().split()))
comb = itertools.combinations(L, 3)
ans = 0
for i in comb:
i = list(i)
i.sort()
if i[0] + i[1] > i[2] and (i[0] != i[1] and i[1] != i[2] and i[2] != i[0]):
ans += 1
print(ans) | 1 | 4,985,564,844,260 | null | 91 | 91 |
A, B = map(int, input().split())
if A == 1 or B == 1:
print(1)
elif (A*B) % 2 == 0:
print(A*B//2)
else:
print(A*B//2+1) | a, b = (int(x) for x in input().split())
if a == 1 or b == 1:
print("1")
elif a * b % 2 == 0:
print(int(a * b / 2))
else:
print(int((a * b - 1) / 2 + 1)) | 1 | 50,827,717,995,872 | null | 196 | 196 |
x = int(input())
ans = 0
ans += 1000*(x//500)
x %= 500
ans += 5*(x//5)
print(ans) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
N,T = map(int,readline().split())
m = map(int,read().split())
AB = sorted(zip(m,m))
can_add = [0] * N
for n in range(N-1,0,-1):
x = can_add[n]
y = AB[n][1]
can_add[n-1] = x if x > y else y
dp = np.zeros(T,np.int64)
answer = 0
for i,(a,b) in enumerate(AB):
np.maximum(dp[a:], dp[:-a] + b, out = dp[a:])
x = dp.max() + can_add[i]
if answer < x:
answer = x
print(answer)
| 0 | null | 97,466,249,773,520 | 185 | 282 |
S = input()
length = len(S)
print('x' * length)
| s=input()
print("".join(["x"]*len(s))) | 1 | 72,565,626,679,712 | null | 221 | 221 |
n,m=map(int,raw_input().split())
c=map(int,raw_input().split())
dp=[[0]+[float('inf')]*n]+[[0]+[float('inf')]*n for i in xrange(m)]
for i in xrange(m):
for j in xrange(n+1):
if c[i]>j:
dp[i+1][j]=dp[i][j]
else:
dp[i+1][j]=min(dp[i][j],dp[i+1][j-c[i]]+1)
print(dp[m][n]) | a, b = input().split()
print(int(a)*int(b[0]+b[2]+b[3])//100)
| 0 | null | 8,291,295,713,660 | 28 | 135 |
N = int(input())
P = 0
A = list(map(int,input().split()))
for i in range(N):
P = P ^ A[i]
ans = [A[i] ^ P for i in range(N)]
print(" ".join(map(str,ans))) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
As = list(mapint())
ALL = 0
for a in As:
ALL ^= a
ans = [ALL^a for a in As]
print(*ans) | 1 | 12,531,577,140,008 | null | 123 | 123 |
n = int(input())
ans = 0
for a in range(1,n):
for b in range(1,n):
c = n-a*b
if c <= 0:
break
ans += 1
print(ans) | n = int(input())
count = 0
if n%2==0:
for i in range(int(n/2)-1):
count += int((n-1)/(i+1))
count += int(n/2)
else:
for i in range(int(n/2)):
count += int((n-1)/(i+1))
count += int(n/2)
print(count)
| 1 | 2,586,621,912,860 | null | 73 | 73 |
n = int(input())
P = list(map(int, input().split()))
ans = 1
x = P[0]
for p in P:
if x > p:
ans += 1
x = p
print(ans) | # -*- coding: utf-8 -*-
from collections import deque
################ DANGER ################
test = ""
#test = \
"""
9 6 1
1 2
2 3
3 4
4 5
5 6
4 7
7 8
8 9
ans 5
"""
"""
5 4 1
1 2
2 3
3 4
3 5
ans 2
"""
"""
5 4 5
1 2
1 3
1 4
1 5
ans 1
"""
########################################
test = list(reversed(test.strip().splitlines()))
if test:
def input2():
return test.pop()
else:
def input2():
return input()
########################################
n, taka, aoki = map(int, input2().split())
edges = [0] * (n-1)
for i in range(n-1):
edges[i] = tuple(map(int, input2().split()))
adjacencyL = [[] for i in range(n+1)]
for edge in edges:
adjacencyL[edge[0]].append(edge[1])
adjacencyL[edge[1]].append(edge[0])
################ DANGER ################
#print("taka", taka, "aoki", aoki)
#import matplotlib.pyplot as plt
#import networkx as nx
#G = nx.DiGraph()
#G.add_edges_from(edges)
#nx.draw_networkx(G)
#plt.show()
########################################
takaL = [None] * (n+1)
aokiL = [None] * (n+1)
takaL[taka] = 0
aokiL[aoki] = 0
takaQ = deque([taka])
aokiQ = deque([aoki])
for L, Q in ((takaL, takaQ), (aokiL, aokiQ)):
while Q:
popN = Q.popleft()
for a in adjacencyL[popN]:
if L[a] == None:
Q.append(a)
L[a] = L[popN] + 1
#print(L)
print(max(aokiL[i] for i in range(1, n+1) if takaL[i] < aokiL[i]) - 1)
| 0 | null | 101,520,442,220,420 | 233 | 259 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)
INF = 10 ** 9 + 1 # sys.maxsize # float("inf")
MOD = 10 ** 9 + 7
def debug(*x):
print(*x, file=sys.stderr)
def solve(N, K, AS):
for i in range(K, N):
# debug("i: i,AS[i-K],AS[K]", i, AS[i-K], AS[K])
if AS[i - K] < AS[i]:
print("Yes")
else:
print("No")
def main():
# parse input
N, K = map(int, input().split())
AS = list(map(int, input().split()))
solve(N, K, AS)
# tests
T1 = """
5 3
96 98 95 100 20
"""
TEST_T1 = """
>>> as_input(T1)
>>> main()
Yes
No
"""
T3 = """
15 7
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9
"""
TEST_T3 = """
>>> as_input(T3)
>>> main()
Yes
Yes
No
Yes
Yes
No
Yes
Yes
"""
def _test():
import doctest
doctest.testmod()
g = globals()
for k in sorted(g):
if k.startswith("TEST_"):
doctest.run_docstring_examples(g[k], g)
def as_input(s):
"use in test, use given string as input file"
import io
f = io.StringIO(s.strip())
g = globals()
g["input"] = lambda: bytes(f.readline(), "ascii")
g["read"] = lambda: bytes(f.read(), "ascii")
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
if sys.argv[-1] == "-t":
print("testing")
_test()
sys.exit()
main()
| def linear_search(A, n, key):
A.append(key)
i = 0
while A[i] != key:
i += 1
A.pop()
return i != n
n = int(input())
S = list(map(int, input().split()))
q = int(input())
T = list(map(int, input().split()))
ans = 0
for t in T:
if linear_search(S, n, t):
ans += 1
print(ans)
| 0 | null | 3,586,539,813,142 | 102 | 22 |
import sys
readline = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
import numpy as np
#N = 2 * 10 ** 5
#X = np.random.randint(0, 2, N)
#Y = int('0b' + ''.join(X.astype(str).tolist()), 0)
N = int(input())
X = input()
Y = int('0b' + X, 0)
X = np.array(list(X), int)
p = int(X.sum())
m1 = Y % (p + 1)
m2 = Y % max(1, p - 1)
count = np.zeros((N + 1, ))
for n in range(1, N):
i = np.array(list(bin(n))[2:], int).sum()
count[n] = 1 + count[n % i]
ans = [0] * N
for n in range(1, N + 1):
flag = 0
if X[n - 1]:
z = m2 - pow(2, N - n, max(1, p - 1))
z %= max(1, p - 1)
if p - 1 == 0:
flag = 1
else:
z = pow(2, N - n, p + 1) + m1
z %= p + 1
if p == 0:
z = 0
ans[n - 1] = int(count[z] + 1)
if z == 0 and flag:
ans [n - 1] = 0
print('\n'.join(map(str, ans))) | import math
r = float(raw_input())
s = r * r * math.pi
l = 2 * r * math.pi
print '%f %f' %(s,l) | 0 | null | 4,465,015,059,890 | 107 | 46 |
n = int(input()) % 10
if n == 3:
print('bon')
elif n == 0 or n == 1 or n == 6 or n == 8:
print('pon')
else:
print('hon') | N = input ()
P = '0168'
H = '24579'
if N[-1] in P:
print ('pon')
elif N[-1] in H:
print ('hon')
else:
print ('bon') | 1 | 19,146,839,789,320 | null | 142 | 142 |
import math
x1,y1,x2,y2 = map(float,raw_input().split())
a = math.sqrt((x1-x2)**2+(y1-y2)**2)
print '%f'%a | from collections import deque
import math
import copy
#https://qiita.com/ophhdn/items/fb10c932d44b18d12656
def max_dist(input_maze,startx,starty,mazex,mazey):
input_maze[starty][startx]=0
que=deque([[starty,startx]])
# print(que)
while que:
# print(que,input_maze)
y,x=que.popleft()
for i,j in [(1,0),(0,1),(-1,0),(0,-1)]:
nexty,nextx=y+i,x+j
if (nexty>=0) & (nextx>=0) & (nextx<mazex) & (nexty<mazey):
dist=input_maze[nexty][nextx]
if dist!=-1:
if (dist>input_maze[y][x]+1) & (dist > 0):
input_maze[nexty][nextx]=input_maze[y][x]+1
que.append([nexty,nextx])
# print(que)
# print(max(list(map(lambda x: max(x),copy_maze))))
return max(list(map(lambda x: max(x),copy_maze)))
h,w =list(map(int,input().split()))
maze=[list(input()) for l in range(h)]
# Maze preprocess
for y in range(h):
for x in range(w):
if maze[y][x]=='.':
maze[y][x]=math.inf
elif maze[y][x] == '#':
maze[y][x]=int(-1)
results = []
for y in range(h):
for x in range(w):
if maze[y][x]==math.inf:
copy_maze = copy.deepcopy(maze)
max_dist_result = max_dist(copy_maze,x,y,w,h)
results.append(int(max_dist_result))
#print(max_dist_result)
print(max(results))
| 0 | null | 47,239,749,241,630 | 29 | 241 |
import sys, bisect, math, itertools, string, queue, copy
# import numpy as np
# import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations, combinations_with_replacement
from heapq import heappop, heappush
from fractions import gcd
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
def main():
s = list(input())
n = len(s)
for i in range(n):
if s[i] == '?':
s[i] = 'D'
print(''.join(s))
if __name__ == "__main__":
main() | t=list(input())
if t[0]=="?":
if len(t)<=2:
t[0]="D"
elif t[1]=="P":
t[0]="D"
else:
t[0]="P"
for i in range(1,len(t)):
if t[i]=="?":
if i+1==len(t):
t[i]="D"
break
if t[i-1]=="P":
t[i]="D"
else:
if t[i+1]=="P":
t[i]="D"
else:
t[i]="P"
b=""
for i in range(len(t)):
b+=t[i]
print(b)
| 1 | 18,346,636,122,514 | null | 140 | 140 |
N, M = map(int, input().split())
odd_head, odd_tail = 1, 0
even_head, even_tail = 0, 0
if M & 1:
odd_tail = M + 1
even_head = M + 2
even_tail = M + 2 + M - 1
else:
odd_tail = 1 + (M - 1)
even_head = M + 1
even_tail = M + 1 + M
while odd_tail - odd_head > 0:
print(odd_head, odd_tail)
odd_head += 1
odd_tail -= 1
while even_tail - even_head > 0:
print(even_head, even_tail)
even_head += 1
even_tail -= 1 | dim = int(input())
a, b = list(map(int, input().split())), list(map(int, input().split()))
dif = [ abs(x-y) for x, y in zip(a, b)]
print("%lf\n%lf\n%lf\n%lf" % (sum(dif),
sum([i ** 2 for i in dif]) ** (1 / 2),
sum([i ** 3 for i in dif]) ** (1 / 3),
max(dif)
))
| 0 | null | 14,534,661,842,592 | 162 | 32 |
def is_prime(x):
if x == 1:
return 0
l = x ** 0.5
n = 2
while n <= l:
if x % n == 0:
return 0
n += 1
return 1
import sys
def solve():
N = int(input())
cnt = 0
for i in range(N):
cnt += is_prime(int(input()))
print(cnt)
solve() | import math
n = int(input())
cnt = 0
for i in range(n):
x = int(input())
if x == 2:
cnt += 1
elif x <= 1\
or x % 2 == 0:
continue
else:
j = 3
prime = "yes"
while j <= math.sqrt(x):
if x % j == 0:
prime = "no"
break
else:
j += 2
if prime == "yes":
cnt += 1
print(cnt) | 1 | 11,394,222,784 | null | 12 | 12 |
import sys
def hantei(N,M,X,A,l):
skill = [0] * M
money = 0
for i in range(N):
if l[i] == '1':
money += A[i][0]
for j in range(M):
skill[j] += A[i][j+1]
for k in skill:
if k < X:
return -1
sys.exit()
return money
N,M,X = map(int, input().split())
A = [list(map(int, input().split())) for i in range(N)]
mny = 12 * (10 ** 5) + 1
for i in range(1,2**N):
l = bin(i)[2:].zfill(N)
if hantei(N,M,X,A,l) != -1 and hantei(N,M,X,A,l) < mny:
mny = hantei(N,M,X,A,l)
a = l
if mny == 12 * (10 ** 5) + 1:
print(-1)
else:
print(mny) | from itertools import product as prod
N,M,X=map(int,input().split())
B=[list(map(int,input().split())) for _ in range(N)]
ans=float('INF')
for v in prod(range(2),repeat=N):
scores=[0]*M
cost=0
for i in range(N):
if v[i]==1:
cost+=B[i][0]
for j in range(M):
scores[j]+=B[i][1+j]
if min(scores)>=X:
ans=min(ans,cost)
print(ans if ans!=float('INF') else -1) | 1 | 22,459,309,569,930 | null | 149 | 149 |
#!/usr/bin/env python
n = int(input())
if n%2 == 1:
print(0)
exit()
mp = tmp = 0
while True:
if 5**tmp > n:
break
mp = tmp
tmp += 1
ans = 0
for i in range(1, mp+1):
ans += n//(2*(5**i))
print(ans)
| import sys
def input():
return sys.stdin.readline().strip()
n = int(input())
s = []
for _ in range(n):
s.append(input())
'''
N = sum([len(i) for i in s])
R = sum([i.count('(') for i in s])
if N % 2 == 1 or s.count('(') != N // 2:
print('No')
exit()
'''
bothleft = []
bothright = []
bothneutral = [0]
left = [0]
right = [0]
for i in s:
lnum = 0
now = 0
for j in range(len(i)):
if i[j] == '(':
now -= 1
else:
now += 1
lnum = max([lnum, now])
rnum = 0
now = 0
for j in range(len(i) - 1, -1, -1):
if i[j] == ')':
now -= 1
else:
now += 1
rnum = max([rnum, now])
if lnum > 0:
if rnum > 0:
if lnum > rnum:
bothleft.append((rnum, lnum - rnum))
elif rnum > lnum:
bothright.append((lnum, rnum - lnum))
else:
bothneutral.append(lnum)
else:
left.append(lnum)
elif rnum > 0:
right.append(rnum)
bothneutral = max(bothneutral)
bothleft.sort()
bothright.sort()
lsum = sum(left)
for i in range(len(bothleft)):
if bothleft[i][0] > lsum:
print('No')
exit()
lsum += bothleft[i][1]
if bothneutral > lsum:
print('No')
exit()
rsum = sum(right)
for i in range(len(bothright)):
if bothright[i][0] > rsum:
print('No')
exit()
rsum += bothright[i][1]
if lsum != rsum:
print('No')
exit()
print('Yes') | 0 | null | 69,966,721,325,392 | 258 | 152 |
_, s, _, t = [[*map(int, o.split())] for o in open(0)]
print(sum(i in s for i in t))
| if(int(input()) >= 30):
print('Yes')
else:
print('No') | 0 | null | 2,908,956,685,312 | 22 | 95 |
N=int(input())
for line in range(N):
a,b,c = (int(i) for i in input().split())
if (a**2+b**2==c**2) or (b**2+c**2==a**2) or (c**2+a**2==b**2):
print('YES')
else:
print('NO') | def main():
mod=1000000007
s=int(input())
m=s*2
inv=lambda x: pow(x,mod-2,mod)
Fact=[1] #階乗
for i in range(1,m+1):
Fact.append(Fact[i-1]*i%mod)
Finv=[0]*(m+1) #階乗の逆元
Finv[-1]=inv(Fact[-1])
for i in range(m-1,-1,-1):
Finv[i]=Finv[i+1]*(i+1)%mod
def comb(n,r):
if n<r:
return 0
return Fact[n]*Finv[r]*Finv[n-r]%mod
ans=0
num=s//3
for i in range(1,num+1):
n=s-i*3
ans+=comb(n+i-1,n)
ans%=mod
print(ans)
if __name__=='__main__':
main() | 0 | null | 1,626,594,710,158 | 4 | 79 |
n = int(input())
s = input()
ans = s.count("ABC")
print(ans) | l = range(1, 10)
for i in ["%dx%d=%d" % (x, y, x*y) for x in l for y in l]:
print i | 0 | null | 49,572,421,411,392 | 245 | 1 |
def BubbleSort(C,N):
for i in range(N):
j = N-1
while True:
if j == 0:
break
a,b = list(C[j]),list(C[j-1])
if a[1] < b[1]:
tmp = C[j-1]
C[j-1] = C[j]
C[j] = tmp
j -= 1
return C
def SelectionSort(D,N):
for i in range(N):
minj = i
for j in range(i,N):
a,b = list(D[j]),list(D[minj])
if a[1] < b[1]:
minj = j
tmp = D[i]
D[i] = D[minj]
D[minj] = tmp
return D
n = int(input())
d = input().split()
d2 = list(d)
d = BubbleSort(d,n)
for i in range(len(d)-1):
print(d[i],end = ' ')
print(d[-1])
print('Stable')
d2 = SelectionSort(d2,n)
for i in range(len(d2)-1):
print(d2[i],end = ' ')
print(d2[-1])
if d2 == d:
print('Stable')
else:
print('Not stable') | N=int(input())
A=input().split()
B=A[:]
S=A[:]
def BubbleSort(A, N):
count = 0
flag = True
while flag:
flag = False
for j in range(N-1, 0, -1):
if A[j][1] < A[j-1][1]:
A[j], A[j-1] = A[j-1], A[j]
count += 1
flag = True
return A
def SelectionSort(A, N):
count = 0
for i in range(N):
minj = i
for j in range(i, N):
if A[j][1] < A[minj][1]:
minj = j
A[i], A[minj] = A[minj], A[i]
count += 1
return A
b = BubbleSort(B, N)
s = SelectionSort(S, N)
print(*b)
print("Stable")
print(*s)
if b == s:
print("Stable")
else:
print("Not stable") | 1 | 25,385,028,228 | null | 16 | 16 |
al = "abcdefghijklmnopqrstuvwxyz"
k = int(input())
def dfs(s: "char", i):
if(len(s)==k):
print(s)
else:
for j in range(i+1):
if al[j]==al[i]:
dfs(s+al[j], i+1)
else:
dfs(s+al[j], i)
def main():
#sの後ろを変えていくdfs
dfs("", 0)
if __name__ == '__main__':
main()
| n=int(input())
def make(floor,kind,name): #floor=何階層目か,kind=何種類使ってるか
if floor==n+1:
print(name)
return
num=min(floor,kind+1)
for i in range(num):
use=0 #新しい文字使ってるか
if kind-1<i:
use=1
make(floor+1,kind+use,name+chr(i+97))
make(1,0,"") | 1 | 52,404,716,174,772 | null | 198 | 198 |
n = int(input())
l = list(map(int,input().split()))
mod = 10**9+7
ones = [0]*60
ans = 0
for i in range(n):
x = l[i]
for j in range(60):
ones[j] += (x>>j)&1
ans = (ans + (n-1)*x)%mod
# print(ans)
for i in range(60):
ans = (ans - ones[i]*(ones[i]-1)*2**i)%mod
print(ans) | n = int(input())
a = list(map(int, input().split()))
mod = 10**9 + 7
ans = 0
for keta in range(61):
now = 0
for x in a:
if x & (1 << keta):
now += 1
ans += (now*(n-now))*2**keta
ans %= mod
print(ans)
| 1 | 122,451,802,047,778 | null | 263 | 263 |
import math
r = float(input())
a = math.pi * r**2
b = math.pi * r * 2
print(str(a) + " " + str(b)) | from collections import deque
def read():
N, u, v = list(map(int, input().strip().split()))
G = [list() for i in range(N+1)]
for i in range(N-1):
a, b = list(map(int, input().strip().split()))
G[a].append(b)
G[b].append(a)
return N, u, v, G
def bfs(N, G, start):
depth = [-1 for i in range(N+1)]
depth[start] = 0
q = deque()
q.append(start)
while(len(q) > 0):
s = q.popleft()
for t in G[s]:
if depth[t] == -1:
depth[t] = depth[s] + 1
q.append(t)
return depth
def solve(N, u, v, G):
depth_u = bfs(N, G, u)
depth_v = bfs(N, G, v)
most_deepest_node = u
for i in range(1, N+1):
if depth_u[i] < depth_v[i]:
if depth_v[i] > depth_v[most_deepest_node]:
most_deepest_node = i
neighbor_node = G[most_deepest_node][0]
step_u = depth_u[neighbor_node]
step_v = depth_v[neighbor_node]
return step_v
if __name__ == '__main__':
inputs = read()
print('%d' % solve(*inputs))
| 0 | null | 59,108,601,294,852 | 46 | 259 |
x,y = list(map(int,input().split()))
print(x*y) | from math import gcd
def setwise_coprime_check_fun(A_list, N):
gcd_all = A_list[0]
for i in range(N - 1):
gcd_all = gcd(gcd_all, A_list[i + 1])
if gcd_all == 1:
break
return gcd_all
def preprocess_fun(A_max):
p_flg = [True] * (A_max + 1)
D = [0] * (A_max + 1)
p_flg[0] = False
p_flg[1] = False
for i in range(2, A_max + 1, 1):
if p_flg[i]:
for j in range(i, A_max + 1, i):
p_flg[j] = False
D[j] = i
return D
def pairwise_coprime_check(A_list, D, A_max):
p_count = [0] * (A_max + 1)
for A in A_list:
temp = A
d = 0
while temp != 1:
if p_count[D[temp]] == 1 and d != D[temp]:
return 0
p_count[D[temp]] = 1
d = D[temp]
temp = temp // D[temp]
return 1
## 標準入力
N = int(input())
A_list = list(map(int, input().split(" ")))
# 整数の最大値を取得
A_max = max(A_list)
# 本体
if(setwise_coprime_check_fun(A_list, N) != 1):
print("not coprime")
else:
D = preprocess_fun(A_max)
if pairwise_coprime_check(A_list, D, A_max) == 1:
print("pairwise coprime")
else:
print("setwise coprime") | 0 | null | 9,936,516,072,548 | 133 | 85 |
n = int(input())
ret = 0
for i in range(n+1):
"""
if i % 3 == 0 and i % 5 == 0:
ret.append('FizzBuzz')
elif i % 3 == 0:
ret.append('Fizz')
elif i % 5 == 0:
ret.append('Buzz')
else:
"""
if i % 3 != 0 and i % 5 != 0:
ret += i
print(ret) | n = int(input())
ans = 0
for i in range(1, n + 1):
if i % 3 != 0 and i % 5 != 0:
ans += i
else:
continue
print(ans) | 1 | 34,661,515,910,120 | null | 173 | 173 |
input()
numbers = input().split()
numbers.reverse()
print(" ".join(numbers)) | n = int(raw_input())
num = map(int, raw_input().split())
num.reverse()
print " ".join(map(str, num))
| 1 | 986,507,324,540 | null | 53 | 53 |
N = int(input())
A = list(map(int, input().split()))
ans = 0
for i in range(N - 1):
if A[i] > A[i + 1]:
ans += A[i] - A[i + 1]
A[i + 1] = max(A[i], A[i + 1])
print(ans)
| x = int(input())
a = x // 500
x = x - a * 500
b = x // 5
print(1000*a+5*b) | 0 | null | 23,544,728,247,290 | 88 | 185 |
tmp = "abcdefghijklmnopqrstuvwxyz"
alph = list(tmp)
alphcount = [0]*26
while True:
try:
letter = input()
letterarray = list(letter.lower())
# print(letterarray)
except:
break
for x in letterarray:
for i in range(26) :
if (x == alph[i]):
alphcount[i] += 1
else :
continue
for i in range(26):
print(str(alph[i])+" : "+str(alphcount[i]))
| N = int(input())
D = list(map(int,input().split()))
cnt = 0
for i in range(N):
cnt += D[i]**2
tot = 0
for i in range(N):
tot += D[i]
tot = tot**2
tot -= cnt
print(tot//2) | 0 | null | 85,194,180,767,830 | 63 | 292 |
n = int(input())
a = 0
b = 0
for i in range(n):
A,B = map(str,input().split())
if A>B:
a += 3
elif B>A:
b += 3
else:
a += 1
b += 1
print('%d %d' % (a,b))
| n = int(raw_input())
tp = 0; hp = 0
for i in range(n):
tw,hw = raw_input().split()
if tw == hw:
tp += 1
hp += 1
elif tw > hw:
tp += 3
elif tw < hw:
hp += 3
print '%s %s' % (tp,hp) | 1 | 2,000,429,776,488 | null | 67 | 67 |
import sys
N = int(input())
A = list(map(int, input().split()))
cusum = [0 for i in range(N+1)]
cusum[N] = A[N]
if N == 0 and A[0] > 1:
print(-1)
sys.exit()
for i in range(N-1, -1, -1):
cusum[i] = cusum[i+1] + A[i]
# print(cusum)
pre_node = 1
ans = 1
for i in range(1, N+1):
node = (pre_node - A[i-1]) * 2
if node < A[i]:
ans = -1
break
pre_node = min(node, cusum[i])
ans += pre_node
print(ans)
| n = int(input())
S = input().split()
q = int(input())
T = input().split()
count = 0
for i in T:
if i in S:
count += 1
print(count) | 0 | null | 9,389,566,500,270 | 141 | 22 |
from operator import itemgetter
N = int(input())
def checkNonnegative(brankets):
curup = 0
for (minup , up) in sorted(brankets , key= itemgetter(0) , reverse = True):
if curup + minup < 0:
return False
curup += up
return True
def canArrangeBranket(brankets):
totup = 0
left_brankets = []
right_brankets = []
for branket in brankets:
up = 0
minup = 0
for c in list(branket):
if c == '(':
up += 1
else:
up -= 1
minup = min(minup , up)
totup += up
if up >= 0:
left_brankets.append((minup , up))
else:
right_brankets.append((minup - up , - up))
if totup != 0:
return False
return checkNonnegative(left_brankets) and checkNonnegative(right_brankets)
branketList = []
for i in range(N):
l = input()
branketList.append(l)
if canArrangeBranket(branketList):
print("Yes")
else:
print("No")
| import sys
def input(): return sys.stdin.readline().strip()
mod = 998244353
def main():
"""
各トークンを(最下点、最終的な高さ)に分けるのはできた。
そしてそれらを最下点位置が浅い順に並べるのも悪くはなかった、増加パートに関しては。
減少パートは減少度合が小さい順に付け加えたとしても高さが負に潜り込むケースがある。
（例）高さ3から下るとして、(-1, -1), (-2, 0), (-3, -2)が各トークンとすると
この順にくっつけると(-3, -2)を加えるときにアウトだが、
(-2, 0), (-3, -2), (-1, -1)の順だったらOK
なので下る場合には増加パートとは違う方法でくっつけないといけない。
結論としては、これは左右反転させれば増加していることになるので、右からくっつけるようにすればいい。
"""
N = int(input())
S_up = []
S_down = []
for _ in range(N):
s = input()
max_depth = 0
height = 0
for c in s:
if c == '(':
height += 1
else:
height -= 1
max_depth = min(max_depth, height)
if height > 0: S_up.append((max_depth, height - max_depth))
else: S_down.append((-(height - max_depth), -max_depth))
S_up.sort(key=lambda x: (x[0], x[1]))
S_down.sort(key=lambda x: (x[0], x[1]))
height_left = 0
while S_up:
d, h = S_up.pop()
#print("({}, {})".format(d, h))
if height_left + d < 0:
print("No")
return
height_left += d+h
height_right = 0
while S_down:
d, h = S_down.pop()
#print("({}, {})".format(d, h))
if height_right + d < 0:
print("No")
return
height_right += d+h
if height_left != height_right: print("No")
else: print("Yes")
if __name__ == "__main__":
main()
| 1 | 23,820,340,301,308 | null | 152 | 152 |
import sys
n = int(input())
a = list(map(int, input().split()))
if n%2 == 0:
dp = [[-10**20 for _ in range(2)] for _ in range(n)]
dp[0][0] = a[0]
dp[0][1] = 0
dp[1][1] = a[1]
for i in range(1, n):
if i%2 == 0:
dp[i][0] = dp[i-2][0] + a[i]
dp[i][1] = max(dp[i-1][0], dp[i-1][1])
else:
dp[i][0] = dp[i-1][0]
if i > 1:
dp[i][1] = max(dp[i-2][1] + a[i], dp[i-3][0] + a[i])
else:
dp = [[-10**20 for _ in range(3)] for _ in range(n)]
dp[0][0] = a[0]
dp[0][1] = 0
dp[1][1] = a[1]
dp[0][2] = 0
dp[1][2] = 0
dp[2][2] = a[2]
for i in range(1, n):
if i%2 == 0:
if i < n-1:
dp[i][0] = dp[i-2][0] + a[i]
else:
dp[i][0] = dp[i-1][0]
dp[i][1] = max(dp[i-1][1], dp[i-2][0])
if i > 2:
dp[i][2] = max(dp[i-2][2] + a[i], dp[i-4][0] + a[i], dp[i-3][1] + a[i])
else:
dp[i][0] = dp[i-1][0]
if i > 1:
dp[i][1] = max(dp[i-2][0] + a[i], dp[i-2][1] + a[i])
dp[i][2] = max(dp[i-1][2], dp[i-2][1], dp[i-3][0])
print(max(dp[n-1])) | n = int(input())
a = list(map(int, input().split()))
ret = 0
if n % 2 == 0:
dp = [[0] * 2 for _ in range(n)]
dp[0][0] = a[0]
for i in range(1, n):
dp[i][0] = dp[i-1][0] if i % 2 == 1 else dp[i-1][0] + a[i]
dp[i][1] = dp[i - 1][1] if i % 2 == 0 \
else max(dp[i-2][0], dp[i-2][1]) + a[i]
ret = max(dp[-1])
else:
dp = [[0] * 3 for _ in range(n)]
dp[0][0] = a[0]
for i in range(1, n):
dp[i][0] = dp[i-1][0] if i % 2 == 1 else dp[i-1][0] + a[i]
dp[i][1] = dp[i - 1][1] if i % 2 == 0 \
else max(dp[i-2][0], dp[i-2][1]) + a[i]
dp[i][2] = dp[i - 1][1] if i % 2 == 1 \
else max(dp[i-3][0], dp[i-2][1], dp[i-2][2]) + a[i]
ret = max(dp[-1][1], dp[-1][2], dp[-2][0])
print(ret)
| 1 | 37,570,074,863,142 | null | 177 | 177 |
import sys
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 = 10 ** 9 + 7
h, w = LI()
if h == 1 or w == 1:
print(1)
else:
if (h * w) % 2 == 0:
print(int(h * w / 2))
else:
print(int(h * w / 2 + 1)) | n = int(input())
A = list(map(int, input().split()))
SWAP = 0
def conquer(A, left, mid, right):
L, R = A[left:mid], A[mid:right]
# L, Rの末尾にINFTYを入れないと、L[-1] or R[-1]が評価されない
INFTY = 2 ** 30
L.append(INFTY)
R.append(INFTY)
# i : position in L, j : position in R
i, j = 0, 0
swap_times = 0
# 元のArrayを変えたいため、kを生成
for k in range(left, right):
# print(i, j, L, R, A)
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
swap_times += 1
return swap_times
def divide(A, left, right):
# print(left, right)
# A[right-left]が2つ以上の場合に
if left+1 < right:
mid = (left+right)//2
countL = divide(A, left, mid)
countR = divide(A, mid, right)
return conquer(A, left, mid, right) + countL + countR
return 0
def mergeSort(A):
return divide(A, 0, len(A))
swap = mergeSort(A)
print(" ".join([ str(i) for i in A]))
print(swap)
| 0 | null | 25,402,964,070,496 | 196 | 26 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10**9 + 7
#from decimal import *
H, W = MAP()
S = [input() for _ in range(H)]
dy = (1, 0, -1, 0)
dx = (0, -1, 0, 1)
def diff_max(start_y, start_x):
check = [[-1]*W for _ in range(H)]
check[start_y][start_x] = 0
q = deque([(start_y, start_x)])
while q:
y, x = q.popleft()
for i in range(4):
ny = y + dy[i]
nx = x + dx[i]
if 0 <= ny < H and 0 <= nx < W:
if check[ny][nx] == -1 and S[ny][nx] == ".":
check[ny][nx] = check[y][x] + 1
q.append((ny, nx))
return max([max(x) for x in check])
ans = -INF
for i in range(H):
for j in range(W):
if S[i][j] == ".":
ans = max(ans, diff_max(i, j))
print(ans)
| # https://note.nkmk.me/python-union-find/
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]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M, K = map(int, input().split())
par = [-1]*N
#直接友達になっている人数とブロックしている人数をカウント
num = [0]*N
uf = UnionFind(N)
for _ in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
#友達関係をつなげる
uf.union(a, b)
#直接友達なのでカウントする
num[a] += 1
num[b] += 1
for _ in range(K):
c, d = map(int, input().split())
c -= 1
d -= 1
# print(f"c{c}, d{d}, uf.same(c, d) {uf.same(c, d)}")
#同じグループに属している場合、size()にカウントされるのでnumを増やす
if uf.same(c, d):
num[c] += 1
num[d] += 1
# print(num)
for i in range(N):
#直接友達関係の人と同じグループでブロックしている人、自分自身を除く人数が候補となる
print(uf.size(i)-1-num[i], end=" ") | 0 | null | 77,846,185,381,692 | 241 | 209 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n = int(readline())
inc = []
dec = []
for _ in range(n):
s = readline().rstrip().decode()
d, r = 0, 0
for m in s:
d += (1 if m == '(' else -1)
r = max(r, -d)
(dec if d < 0 else inc).append((d, r))
inc.sort(key=lambda x: x[1])
dec.sort(key=lambda x: x[0] + x[1])
p1 = 0
p2 = 0
flag = True
for i in inc:
flag &= i[1] <= p1
p1 += i[0]
for d in dec:
flag &= p2 >= d[0] + d[1]
p2 -= d[0]
flag &= p1 == p2
print('Yes' if flag else 'No')
| n = int(input())
li = []
for _ in range(n):
s = input()
count = 0
while True:
if count + 1 >= len(s):
break
if s[count] == '(' and s[count+1] == ')':
s = s[:count] + s[count+2:]
count = max(0, count-1)
else:
count += 1
li.append(s)
li2 = []
for i in li:
count = 0
for j in range(len(i)):
if i[j] == ')':
count += 1
else:
break
li2.append((count, len(i) - count))
li3 = []
li4 = []
for i in li2:
if i[0] <= i[1]:
li3.append(i)
else:
li4.append(i)
li3.sort()
li4.sort(key = lambda x: x[1], reverse = True)
now = [0,0]
for l,r in li3:
if l == 0 and r == 0:
pass
elif l == 0:
now[1] += r
else:
now[1] -= l
if now[1] < 0:
print('No')
exit()
now[1] += r
for l,r in li4:
if l == 0 and r == 0:
pass
elif r == 0:
now[1] -= l
if now[1] < 0:
print('No')
exit()
else:
now[1] -= l
if now[1] < 0:
print('No')
exit()
now[1] += r
if now[0] == 0 and now[1] == 0:
print('Yes')
else:
print('No')
| 1 | 23,549,334,581,500 | null | 152 | 152 |
S = input()
T = input()
len_s = len(S)
len_t = len(T)
result = len_t
i = 0
while (i <= len_s - len_t):
diff = 0
for j, c in enumerate(T):
if (c != S[i + j]):
diff += 1
result = min(result, diff)
i += 1
print(result)
| s = input()
t = input()
n = len(s) - len(t)
l = len(t)
res = 0
for i in range(n+1):
cnt = 0
for j in range(l):
if s[i+j] == t[j]:
cnt += 1
res = max(res, cnt)
print(l - res) | 1 | 3,684,205,237,718 | null | 82 | 82 |
s=input()
t=input()
a = len(s)
b = len(t)
l = []
for i in range(a-b+1):
cnt = 0
c = s[i:i+b]
for x, y in zip(c, t):
if x != y:
cnt +=1
l.append(cnt)
print(min(l)) | s = input()
t = input()
c = 0
ctemp = 0
for i in range((len(s)-len(t))+1):
for j in range(len(t)):
if s[j+i] == t[j]:
ctemp += 1
c = max(c,ctemp)
ctemp = 0
ans = len(t) - c
print(ans) | 1 | 3,640,204,112,428 | null | 82 | 82 |
k = int(input())
s = str(input())
if len(s) > k:
print(s[:k], end='')
print("...")
else:
print(s)
| def merge(a,left,mid,right):
count=0
L=a[left:mid]+[float("inf")]
R=a[mid:right]+[float("inf")]
i,j=0,0
for k in range(left,right):
count+=1
if L[i]<=R[j]:
a[k]=L[i]
i+=1
else:
a[k]=R[j]
j+=1
return count
def mergeSort(a,left,right):
if left+1<right:
mid=(left+right)//2
countl=mergeSort(a,left,mid)
countr=mergeSort(a,mid,right)
return merge(a,left,mid,right)+countl+countr
return 0
n=int(input())
a=list(map(int,input().split()))
ans=mergeSort(a,0,n)
print(" ".join(map(str,a)))
print(ans)
| 0 | null | 9,827,841,163,938 | 143 | 26 |
n = int(input())
a = 100
time = 0
while a < n:
a += a // 100
time += 1
print(time) | import sys
from operator import or_
input=sys.stdin.readline
class SegTree():
def __init__(self, N, e=float("inf"), operator_func=min):
self.e = e
self.size = N
self.node = [self.e] * (2*N)
self.op = operator_func
def set_list(self, l):
for i in range(self.size):
self.node[i+self.size-1] = l[i]
for i in range(self.size-1)[::-1]:
self.node[i] = self.op(self.node[2*i+1], self.node[2*i+2])
def update(self, k, x):
k += self.size - 1
self.node[k] = x
while k >= 0:
k = (k - 1) // 2
self.node[k] = self.op(self.node[2*k+1], self.node[2*k+2])
def get(self, l, r):
x = self.e
l += self.size; r += self.size
a, b = [], []
while l<r:
if l&1:
a += [l-1]; l += 1
if r&1:
r -= 1; b += [r-1]
l >>= 1; r >>= 1
for i in a+(b[::-1]):
x = self.op(x, self.node[i])
return x
def main():
N = int(input())
S = list(input())[:-1]
trees = {chr(97+i):SegTree(N, e=0, operator_func=or_) for i in range(26)}
for i, s in enumerate(S):
trees[s].update(i, 1)
Q = int(input())
for _ in range(Q):
mode, i, v = input().split()
if mode=="1":
i = int(i)-1
trees[S[i]].update(i, 0)
trees[v].update(i, 1)
S[i] = v
else:
i = int(i)-1
v = int(v)
ans = sum(trees[chr(97+j)].get(i, v) for j in range(26))
print(ans)
if __name__ == "__main__":
main() | 0 | null | 44,585,610,240,320 | 159 | 210 |
import math
a,b,x = map(int,input().split())
if x > a*a*b/2:
tan = 2*(a*a*b - x)/(a*a*a)
elif x <= a*a*b/2:
tan = a*b*b/(2*x)
print(math.degrees(math.atan(tan))) | import sys
import math
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
a,b,x = map(int, input().split())
s = a * b
theta = 0
if a * a * b / 2 < x:
theta = math.atan(2 * (a**2 * b - x) / a**3)
else:
theta = math.atan((a * b**2) / (2 * x))
deg = math.degrees(theta)
print('{:.10f}'.format(deg))
| 1 | 162,765,335,753,228 | null | 289 | 289 |
while 1 > 0:
formula = raw_input()
a, op, b = formula.split()
if op == "?":
break
a = int(a)
b = int(b)
if op == "+":
print a + b
elif op == "-":
print a - b
elif op == "*":
print a * b
elif op == "/":
print a / b | while True:
a = input()
if "?" in a:
break
print(eval(a.replace("/", "//"))) | 1 | 698,875,256,494 | null | 47 | 47 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
#from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
def mapline(t = int):
return map(t, sysread().split())
def mapread(t = int):
return map(t, read().split())
def generate_inv(n,mod):
"""
逆元行列
n >= 2
Note: mod must bwe a prime number
"""
ret = [0, 1]
for i in range(2,n+1):
next = -ret[mod%i] * (mod // i)
next %= mod
ret.append(next)
return ret
def run():
N, *A = mapread()
maxA = max(A)
L = maxA.bit_length()
subs = [0] * L
for k in range(L):
sum = 0
for a in A:
if (a >> k) & 1:
sum += 1 << k
sum %= mod
subs[k] = sum
sumA = 0
for a in A:
sumA += a
sumA %= mod
ret = 0
ret += (sumA * N) % mod
ret += (sumA * N) % mod
sub_sum = 0
for a in A:
sums = 0
for k in range(L):
if (a >> k) & 1:
sums += subs[k] * 2
sums %= mod
sub_sum += sums
sub_sum %= mod
ret -= sub_sum
ret %= mod
inv = generate_inv(2, mod)
ret *= inv[2]
ret %= mod
print(ret)
if __name__ == "__main__":
run()
| import numpy as np
N=int(input())
A=np.array([int(x) for x in input().split()])
ans=0
M=pow(10,9)+7
for i in range(100):
one=int(np.sum((A>>i)&1))
zero=N-one
ans+=(one*zero)*pow(2,i)
ans%=M
#print(one,zero)
print(ans) | 1 | 122,652,338,770,830 | null | 263 | 263 |
# -*- coding: utf-8 -*-
S = input()
if 'RRR' in S:
print("3")
elif 'RR' in S:
print("2")
elif 'R' in S:
print("1")
else:
print("0") | 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))
| 0 | null | 2,459,397,608,078 | 90 | 20 |
X = int(input())
for a in range(-1000, 1000):
for b in range(-1000, 1000):
if a ** 5 - b ** 5 == X:
print(a, b)
break
else:
continue
break
| import sys
input=sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
import numpy as np
def main():
x=II()
for i in range(-300,300):
for j in range(-300,300):
if i**5==x+j**5:
print(i,j)
exit()
if __name__=="__main__":
main()
| 1 | 25,445,639,734,970 | null | 156 | 156 |
n=int(input())
if n%2==1:
print("0")
exit()
count=0
for i in range(1,30):
count+=n//(2*5**i)
print(count) | import copy
import random
import sys
import time
from collections import deque
t1 = time.time()
readline = sys.stdin.buffer.readline
global NN
NN = 26
def evaluate(D, C, S, out, k):
score = 0
last = [0 for _ in range(NN)]
for d in range(len(out)):
last[out[d]] = d + 1
for i in range(NN):
score -= (d + 1 - last[i]) * C[i]
score += S[d][out[d]]
for d in range(len(out), min(D, len(out) + k)):
for i in range(NN):
score -= (d + 1 - last[i]) * C[i]
return score
def compute_score(D, C, S, out):
score = 0
last = [0 for _ in range(NN)]
for d in range(len(out)):
p = out[d]
last[p] = d + 1
last[out[d]] = d + 1
for i in range(NN):
score -= (d + 1 - last[i]) * C[i]
score += S[d][out[d]]
return score
def solve(D, C, S, k):
out = deque()
for _ in range(D):
max_score = -10 ** 8
best_i = 0
for i in range(NN):
out.append(i)
score = evaluate(D, C, S, out, k)
if max_score < score:
max_score = score
best_i = i
out.pop()
out.append(best_i)
return out
# 1箇所ランダムに変える
def random_change(D, C, S, out, score):
new_out = copy.deepcopy(out)
d = random.randrange(0, D)
new_out[d] = random.randrange(0, NN)
new_score = compute_score(D, C, S, new_out)
if new_score > score:
score = new_score
out = new_out
return out, score
# N箇所ランダムに変える
def random_changeN(D, C, S, out, score):
N = 2
new_out = copy.deepcopy(out)
for _ in range(N):
d = random.randrange(0, D)
new_out[d] = random.randrange(0, NN)
new_score = compute_score(D, C, S, new_out)
if new_score > score:
score = new_score
out = new_out
return out, score
# 2つswap
def random_swap2(D, C, S, out, score):
d1 = random.randrange(0, D - 1)
d2 = random.randrange(d1 + 1, min(d1 + 16, D))
new_out = copy.deepcopy(out)
new_out[d1], new_out[d2] = out[d2], out[d1]
new_score = compute_score(D, C, S, out)
if new_score > score:
score = new_score
out = new_out
return out, score
# ３つswap
def random_swap3(D, C, S, out, score):
d1 = random.randrange(0, D - 1)
d2 = random.randrange(d1 + 1, min(d1 + 8, D))
d3 = random.randrange(max(d1 - 8, 0), d1 + 1)
new_out = copy.deepcopy(out)
new_out[d1], new_out[d2], new_out[d3] = out[d2], out[d3], out[d1]
new_score = compute_score(D, C, S, out)
if new_score > score:
score = new_score
out = new_out
return out, score
def main():
D = int(readline())
C = list(map(int, readline().split()))
S = [list(map(int, readline().split())) for _ in range(D)]
# ランダムな初期値
# out = [random.randrange(0, NN) for _ in range(D)]
# 貪欲法で初期値を決める
# k = 18 # kを大きくして，局所解から遠いものを得る
k = 26 # kを大きくして，局所解から遠いものを得る
out = solve(D, C, S, k)
# 初期値を数カ所変える
# np = 0.2 # 変えすぎ？
# np = 0.1
np = 0.05
n = int(D * np)
queue = [random.randrange(0, D) for _ in range(n)]
for q in queue:
out[q] = random.randrange(0, NN)
score = compute_score(D, C, S, out)
for cnt in range(10 ** 10):
bl = [random.randint(0, 1) for _ in range(5)]
for b in bl:
if b:
out, score = random_change(D, C, S, out, score)
# out, score = random_changeN(D, C, S, out, score)
else:
# out, score = random_swap2(D, C, S, out, score)
out, score = random_swap3(D, C, S, out, score)
t2 = time.time()
if t2 - t1 > 1.85:
break
ans = [str(i + 1) for i in out]
print("\n".join(ans))
main()
| 0 | null | 62,629,036,716,132 | 258 | 113 |
#! python3
a, b, c = [int(x) for x in input().strip().split(' ')]
r = 0
for i in range(a, b+1):
if c % i == 0:
r += 1
print(r) | print(int(input())*3.1415*2) | 0 | null | 16,082,506,681,332 | 44 | 167 |
import sys
input = sys.stdin.readline
n = int(input())
L = [int(x) for x in input().split()]
cnt = 0
def Merge(S, l, m, r):
global cnt
cnt += r - l
L = S[l:m] + [float('inf')]
R = S[m:r] + [float('inf')]
i, j = 0, 0
for k in range(l, r):
if L[i] < R[j]:
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
return
def MergeSort(S, l, r):
if r - l > 1:
m = (l + r) // 2
MergeSort(S, l, m)
MergeSort(S, m, r)
Merge(S, l, m, r)
return
MergeSort(L, 0, n)
print(*L)
print(cnt)
| n=int(input())
A=tuple(map(int, input().split()))
cnt=0
def merge_sort(A,cnt):
m=len(A)
if m == 1:
return A,cnt
else:
mid=(m+1)//2
A1=tuple(A[:mid])
A2=tuple(A[mid:])
A1,cnt=merge_sort(A1,cnt)
A2,cnt=merge_sort(A2,cnt)
n1=len(A1)
n2=len(A2)
i1=0
i2=0
ans=[0]*(n1+n2)
j=0
while j < n1+n2:
if i1 == n1:
ans[j]=A2[i2]
i2+=1
cnt+=1
elif i2 == n2:
ans[j]=A1[i1]
i1+=1
cnt+=1
elif A1[i1] < A2[i2]:
ans[j]=A1[i1]
i1+=1
cnt+=1
else:
ans[j]=A2[i2]
i2+=1
cnt+=1
j += 1
return ans,cnt
sorted_A,cnt=merge_sort(A,0)
print(*sorted_A)
print(cnt)
| 1 | 114,804,122,170 | null | 26 | 26 |
import sys
ERROR_INPUT = 'input is invalid'
def main():
n = get_length()
arr = get_array(length=n)
sourtLi, count = bubbleSort(li=arr, length=n)
print(*sourtLi)
print(count)
return 0
def get_length():
n = int(input())
if n < 0 or n > 100:
print(ERROR_INPUT)
sys.exit(1)
else:
return n
def get_array(length):
nums = input().split(' ')
return [str2int(string=n) for n in nums]
def str2int(string):
n = int(string)
if n < 0 or n > 100:
print(ERROR_INPUT)
sys.exit(1)
else:
return n
def bubbleSort(li, length):
count = 0
for n in range(length):
for n in range(1, length - n):
if li[n] < li[n - 1]:
li[n], li[n - 1] = li[n - 1], li[n]
count += 1
return li, count
main() | def bubble_sort(array):
isEnd = False
count_swap = 0
while isEnd is False:
isEnd = True
for j in reversed(range(1,len(array))):
if array[j - 1] > array[j]:
tmp = array[j - 1]
array[j - 1] = array[j]
array[j] = tmp
count_swap += 1
isEnd = False
return count_swap
def print_array(array):
print(str(array)[1:-1].replace(', ', ' '))
def main():
N = int(input())
array = [int(s) for s in input().split(' ')]
count = bubble_sort(array)
print_array(array)
print(count)
if __name__ == '__main__':
main() | 1 | 16,612,893,450 | null | 14 | 14 |
def main():
n = int(input())
for i in range(n):
Array = list(map(int,input().split()))
Array.sort()
if Array[2]**2 == Array[0]**2 + Array[1]**2:
print("YES")
else:
print("NO")
if __name__ == '__main__':
main() | def main():
n = int(input())
for _ in range(n):
len_list = map(int, input().split())
check_tri(len_list)
def check_tri(len_list):
import itertools
import math
flag = False
for tmp in list(itertools.permutations(len_list)):
if (pow(tmp[0], 2) + pow(tmp[1], 2)) == pow(tmp[2], 2):
flag = True
break
if flag == True:
print('YES')
else:
print('NO')
if __name__ == '__main__':
main() | 1 | 286,186,980 | null | 4 | 4 |
def main():
n = int(input())
s = input()
ans = 0
for i in range(n):
if i == 0:
ans += 1
mae = s[i]
else:
if s[i] != mae:
ans += 1
mae = s[i]
print(ans)
if __name__ == "__main__":
main()
| N = int(input())
S = input()
ans = 1
for i in range(N-1):
if(S[i] != S[i+1]):
ans += 1
print(ans) | 1 | 170,264,163,994,070 | null | 293 | 293 |
a,b=map(int,input().split())
ans=0
if a<=3:
ans+=(4-a)*10**5
if b<=3:
ans+=(4-b)*10**5
if a==b==1:
ans+=4*10**5
print(ans) | XY= list(map(int,input().split()))
X=XY[0]
Y=XY[1]
if X==1:
syokinx=300000
elif X==2:
syokinx=200000
elif X==3:
syokinx=100000
else:
syokinx=0
if Y==1:
syokiny=300000
elif Y==2:
syokiny=200000
elif Y==3:
syokiny=100000
else:
syokiny=0
if X==1 and Y==1:
syokinz=400000
else:
syokinz=0
print(syokinx+syokiny+syokinz)
| 1 | 141,125,540,413,678 | null | 275 | 275 |
n = input()
if len(n) < 3:
print(1000 - int(n))
else:
hasuu = n[len(n) - 3:]
if hasuu == '000':
print('0')
else:
print(1000-int(hasuu)) | n,k=map(int,input().split())
mod=10**9+7
ans=0
l=[0]*(k+1)
for i in range(k,0,-1):
l[i]=pow(k//i,n,mod)
for j in range(2*i,k+1,i):
l[i]-=l[j]
l[i]=pow(l[i],1,mod)
ans+=l[i]*i
ans=pow(ans,1,mod)
print(ans) | 0 | null | 22,756,538,608,892 | 108 | 176 |
# 全探索
n=int(input())
class People:
def __init__(self):
self.type=None
peoples=[People() for i in range(n+1)]
def change_10to2(i):
ans=format(i, '#0' + str(n + 3) + 'b')[2:]
return ans
def set_people_type(binary_list,peoples):
for i,people in enumerate(peoples):
if i!=0:
people.type=binary_list[i]
def get_statement():
shougen={}
for i in range(1,n+1):
ai=int(input())
ans=[]
for j in range(ai):
kumi=[int(k) for k in input().split()]
ans.append(kumi)
shougen[str(i)]=ans
return shougen
shougens=get_statement()
def shougen_dicide(peoples,shougens):
for i in range(1,n+1):
shougen=shougens[str(i)]
for shou in shougen:
people,type=shou
people=int(people)
type=str(type)
# 正直者のとき
if peoples[i].type=="1":
if peoples[people].type!=type:
return False
# #嘘つきのとき
# else:
# if peoples[people].type==type:
# return False
return True
ans=0
for i in range(2**n):
binary_list=change_10to2(i)
set_people_type(binary_list,peoples)
if shougen_dicide(peoples,shougens):
ans=max(ans,binary_list.count("1"))
print(ans)
| def main():
N = int(input())
shougen = []
for _ in range(N):
A = int(input())
shougen.append([list(map(int, input().split())) for _ in range(A)])
ans = 0
for i in range(2**N):
state = [1]*N
for j in range(N):
if (i >> j) & 1:
state[j] = 0
flag = True
for k in range(N):
if not flag:
break
if state[k] == 1:
for ele in shougen[k]:
if state[ele[0]-1] != ele[1]:
flag = False
break
if flag:
ans = max(ans, sum(state))
print(ans)
if __name__ == '__main__':
main() | 1 | 121,791,187,987,640 | null | 262 | 262 |
import sys
read = sys.stdin.buffer.read
#input = sys.stdin.readline
#input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
import math
def main():
k=II()
ans=0
li=[0]*(k+1)
for a in range(1,k+1):
for b in range(1,k+1):
li[math.gcd(a,b)]+=1
for i in range(1,k+1):
for c in range(1,k+1):
if li[i]!=0:
ans+=li[i]*math.gcd(i,c)
print(ans)
if __name__ == "__main__":
main()
| import heapq
def solve():
N = int(input())
A = list(sorted(map(int, input().split()), reverse=True))
C = [-A[0]]
ans = 0
for a in A[1:]:
K = heapq.heappop(C)
ans += -K
heapq.heappush(C, -a)
heapq.heappush(C, -a)
print(ans)
solve() | 0 | null | 22,327,525,101,170 | 174 | 111 |
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
A = int(input())
B = int(input())
for i in range(1, 4):
if i not in (A, B):
print(i)
| n=int(input())
m=int(input())
print(6-m-n) | 1 | 110,817,533,449,348 | null | 254 | 254 |
H = int(input())
count = 0
answer = 0
while(H > 1):
H //= 2
answer += 2**count
count += 1
answer += 2**count
print(answer) | N = int(input())
arr = [int(n) for n in input().split()]
swap_cnt = 0
for i in range(0, N):
minj = i
for j in range(i + 1, N):
if arr[j] < arr[minj]:
minj = j
if (i != minj):
arr[i], arr[minj] = arr[minj], arr[i]
swap_cnt += 1
print(' '.join(map(str, arr)))
print(swap_cnt)
| 0 | null | 39,864,783,418,020 | 228 | 15 |
d = int(input())
c = [0] + list(map(int, input().split()))
s = [0]
for i in range(d):
s.append([0] + list(map(int, input().split())))
t = [0]
for i in range(d):
t.append(int(input()))
sati = [0] * (d+1)
last = [0] * 27
for i in range(1, d+1):
sati[i] = sati[i-1] + s[i][t[i]]
unsati = 0
last[t[i]] = i
for j in range(1, 27):
unsati += c[j] * (i - last[j])
sati[i] -= unsati
for i in range(1, d+1):
print(sati[i]) | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
D = int(input())
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
T = list(int(input()) for _ in range(D))
sat = 0
last = [0] * 26
for d in range(D):
t = T[d] - 1
sat += S[d][t]
dsat = 0
for i in range(26):
if i == t:
continue
dsat += C[i] * ((d + 1) - last[i])
last[t] = d + 1
sat -= dsat
print(sat)
if __name__ == '__main__':
resolve()
| 1 | 9,989,159,015,380 | null | 114 | 114 |
# coding: utf-8
import sys
from collections import deque
n, q = map(int, input().split())
total_time = 0
tasks = deque(map(lambda x: x.split(), sys.stdin.readlines()))
for task in tasks:
task[1] = int(task[1])
while tasks:
t = tasks.popleft()
if t[1] <= q:
total_time += t[1]
print(t[0], total_time)
else:
t[1] -= q
total_time += q
tasks.append(t) | n,q = map(int,input().split())
A = [list(map(str,input().split())) for i in range(n)]
time = 0
flag = 1
while len(A) > 0:
if int(A[0][1]) <= q: #プロセスが完了する場合
time += int(A[0][1])
print(A[0][0],time)
del A[0]
else: #プロセスが完了しない場合
time += q
A[0][1] = str(int(A[0][1])-q)
A.append(A[0])
del A[0]
| 1 | 39,960,140,670 | null | 19 | 19 |
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))
| M=10**9+7
x,y=map(int,input().split())
ans=0
if (x+y)%3==0:
a=(2*y-x)//3
b=(2*x-y)//3
if a>=0 and b>=0:
f1,f2=1,1
for i in range(a+1,a+b+1):
f1*=i
f1%=M
for i in range(1,b+1):
f2*=i
f2%=M
ans=f1*pow(f2,M-2,M)
print(ans%M)
| 0 | null | 74,681,809,823,322 | 12 | 281 |
n = int(input());div=[];ans=[]
for i in range(1,int(n**0.5)+2):
if n%i == 0:
div.append(i);div.append(n//i)
for i in div:
if i == 1:
continue
tmp = n
while tmp % i == 0:
tmp //= i
if tmp % i ==1:
ans.append(i)
n -= 1
for i in range(1,int(n**0.5)+2):
if n%i == 0:
ans.append(i);ans.append(n//i)
print(len(set(ans))-1) |
def main():
a, b = map(int, input().split(" "))
print(a*b)
if __name__ == "__main__":
main() | 0 | null | 28,666,786,612,362 | 183 | 133 |
def solve(string):
x, k, d = map(int, string.split())
x = abs(x)
if k % 2:
x = min(x - d, x + d, key=abs)
k -= 1
k, d = k // 2, d * 2
if x < k * d:
return str(min(x % d, abs((x % d) - d)))
else:
return str(x - k * d)
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
| # coding=utf-8
if __name__ == '__main__':
N, K = map(int, input().split())
sunuke = [0] * N
#print(sunuke)
for i in range(K):
D = int(input())
li = list(map(int, input().split()))
for j in range(D):
sunuke[li[j] - 1] += 1
#print(sunuke)
print(sunuke.count(0))
| 0 | null | 14,970,492,476,480 | 92 | 154 |
n = int(input())
x = 100000
for i in range(n):
x = x*1.05
if x % 1000 == 0:
pass
else:
x = x//1000
x = x+1
x = x*1000
print('{:.0f}'.format(x))
| base, rate = 100, 0.05
for _ in range(int(input())):
increment = base * rate
base += round(increment + (0 if increment.is_integer() else 0.5))
print(base * 1000) | 1 | 983,551,620 | null | 6 | 6 |
import sys
stdin = sys.stdin
ni = lambda: int(ns())
ns = lambda: stdin.readline().rstrip()
na = lambda: list(map(int, stdin.readline().split()))
# code here
N, R = na()
if N >= 10:
print(R)
else:
print(R + 100*(10-N))
| N, R = map(int, input().split())
if 10<=N:
print(R)
elif N<10:
x = R+(100*(10-N))
print(x)
| 1 | 63,298,096,414,510 | null | 211 | 211 |
import fractions as math
input_line = list(map(int,input().split(' ')))
ans = input_line[0] * input_line[1] // math.gcd(input_line[0], input_line[1])
print(ans)
| import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
from collections import Counter
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, K, S = map(int, input().split())
if S == 10 ** 9:
for i in range(N):
if i < N - K:
print(S - 1)
else:
print(S)
exit()
for i in range(N):
if i < K:
print(S)
else:
print(S + 1)
| 0 | null | 101,871,510,675,964 | 256 | 238 |
import itertools
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
l = [i+1 for i in range(N)]
for i, tpl in enumerate(itertools.permutations(l, N)):
if tpl == P:
a = i
if tpl == Q:
b = i
print(abs(a-b)) | import itertools
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
for i, l in enumerate(itertools.permutations(range(1, n + 1))):
if list(l) == p:
a = i
if list(l) == q:
b = i
print(abs(a - b))
| 1 | 100,617,775,598,560 | null | 246 | 246 |
x,y=list(map(int, input().split()))
x,y=list(map(int, input().split()))
if y==1:
print(1)
else:
print(0) | import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
n = ini() % 10
if n in [2, 4, 5, 7, 9]:
print("hon")
elif n == 3:
print("bon")
else:
print("pon")
| 0 | null | 71,907,546,260,772 | 264 | 142 |
import math
a,b,c=map(float,input().split())
c*=math.pi/180
print(.5*a*b*math.sin(c))
print(a+b+math.sqrt(a*a+b*b-2*a*b*math.cos(c)))
print(b*math.sin(c))
| import math
a, b, c = [float(line) for line in input().split()]
S = 1 / 2 * a * b * math.sin(math.radians(c))
c = math.sqrt((a ** 2) + (b ** 2) - (2 * a * b * math.cos(math.radians(c))))
L = a + b + c
H = S / (a * (1 / 2))
print(S, L, H)
| 1 | 172,552,322,440 | null | 30 | 30 |
"""
桁DPで解ける
dp[i][j][k][l] => i桁目まで見る。i桁目がjであるような数字の数。kは0でない数の個数のメモ。lは未満フラグ。
"""
N = input()
K = int(input())
dp = [[[[0]*(2) for _ in range(5)]for _ in range(10)]for _ in range(len(N))]
#初期化
x = int(N[0])
for i in range(x+1):
if i == 0:
dp[0][i][0][1] += 1
else:
if i<x:
flag = 1
else:
flag = 0
dp[0][i][1][flag] += 1
for i in range(len(N)-1):
x = int(N[i+1])
for j in range(10):
for k in range(4):
for l in range(2):
if l:
r = 10
else:
r = x+1
for m in range(r):
if l==0 and m==x:
flag = 0
else:
flag = 1
if m == 0:
cnt = k
else:
cnt = k+1
dp[i+1][m][cnt][flag] += dp[i][j][k][l]
ans = 0
for j in range(10):
ans += sum(dp[-1][j][K])
print(ans) | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#inf = 10**17
#mod = 10**9 + 7
n = input().rstrip()
k = int(input())
ln = len(n)
# dp[i][j]:左からi桁まで見たとき0でない桁がj個ある場合の数
dp1 = [[0]*(k+1) for _ in range(ln+1)]
dp2 = [[0]*(k+1) for _ in range(ln+1)]
dp2[0][0] = 1
cnt = 0
for i in range(ln):
if n[i] != '0':
if cnt < k:
cnt += 1
dp2[i+1][cnt] = 1
else:
dp2[i+1][cnt] = dp2[i][cnt]
for i in range(ln):
dp1[i+1][0] = 1
for j in range(1, k+1):
dp1[i+1][j] += dp1[i][j] + dp1[i][j-1] * 9
if n[i] != '0':
dp1[i+1][j] += dp2[i][j-1] * (int(n[i])-1)
if j < k:
dp1[i+1][j] += dp2[i][j]
print(dp1[-1][k] + dp2[-1][k])
if __name__ == '__main__':
main() | 1 | 76,215,557,508,716 | null | 224 | 224 |
while 1:
a, op, b = raw_input().split(' ')
if op == '?':break
print eval("%s %s %s"%(a, op, b)) | from math import ceil
n = int(input())
print(ceil(n/2) - 1) | 0 | null | 77,248,093,102,458 | 47 | 283 |
from time import time
from random import random
limit_secs = 2
start_time = time()
D = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for _ in range(D)]
def calc_score(t):
score = 0
S = 0
last = [-1] * 26
for d in range(len(t)):
S += s[d][t[d]]
last[t[d]] = d
for i in range(26):
S -= c[i] * (d - last[i])
score += max(10 ** 6 + S, 0)
return score
def solution1():
return [i % 26 for i in range(D)]
def solution2():
t = None
score = -1
for i in range(26):
nt = [(i + j) % 26 for j in range(D)]
if calc_score(nt) > score:
t = nt
return t
def solution3():
t = []
for _ in range(D):
score = -1
best = -1
t.append(0)
for i in range(26):
t[-1] = i
new_score = calc_score(t)
if new_score > score:
best = i
score = new_score
t[-1] = best
return t
def optimize0(t):
return t
def optimize1(t):
score = calc_score(t)
while time() - start_time + 0.15 < limit_secs:
d = int(random() * D)
q = int(random() * 26)
old = t[d]
t[d] = q
new_score = calc_score(t)
if new_score < score:
t[d] = old
else:
score = new_score
return t
t = solution3()
t = optimize0(t)
print('\n'.join(str(e + 1) for e in t))
| import numpy as np
import sys
read = sys.stdin.read
D = int(input())
CS = np.array(read().split(), np.int32)
C = CS[:26]
S = CS[26:].reshape((-1, 26))
del CS
last = np.zeros((26, ))
ans = []
def getContestType_at_d(d):
s = -10000000
for i in range(26):
mask = np.ones((26, ))
mask[i] = 0
tmp = S[d][i] - np.sum(C * (d + 1 - last) * mask)
if s < tmp:
s = tmp
t = i
last[t] = d + 1
return t + 1, s
for d in range(D):
s = -10000000
for i in range(26):
mask = np.ones((26, ))
mask[i] = 1
score = S[d][i] - np.sum(C * (d + 1 - last) * mask)
if s < score:
s = score
t = i
last[t] = d + 1
ans.append(t + 1)
print('\n'.join(map(str, ans))) | 1 | 9,663,944,219,044 | null | 113 | 113 |
n = int(input())
x = int(n / 1.08)
if int(x * 1.08) == n:
print(x)
elif int((x-1) * 1.08) == n:
print(x-1)
elif int((x+1) * 1.08) == n:
print(x+1)
else:
print(':(') | import sys
K,X = map(int,input().split())
if not ( 1 <= K <= 100 and 1 <= X <= 10**5 ): sys.exit()
print('Yes') if 500 * K >= X else print('No') | 0 | null | 112,027,756,670,888 | 265 | 244 |
print(['No', 'Yes']['7' in input()]) | import math
import sys
import os
from operator import mul
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
N = list(_S())
ans = 'No'
for s in N:
if s == '7':
ans = 'Yes'
break
print(ans) | 1 | 34,335,638,906,748 | null | 172 | 172 |
N=int(input())
A=list(map(int,input().split()))
a=0
s=[]
for i in A:
if i<a:
s.append(a-i)
else:
a=i
print(sum(s))
| import math
x = int(input())
for i in range(1, 121):
for j in range(-120, 121):
if i**5 - j**5 == x:
print(i, j)
quit(0)
| 0 | null | 15,128,270,956,450 | 88 | 156 |
import os
def main():
k, x = map(int, input().split())
if x <= 500 * k:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| import numpy as np
N = int(input())
mod = 10**9 + 7
A = np.array(input().split(), int)
ans = 0
for i in range(60):
b = np.count_nonzero(A >> i & 1)
ans += 2**i*(b*(N-b))
ans %= mod
c = np.count_nonzero(A >> i & 1)
print(ans)
| 0 | null | 110,367,036,877,240 | 244 | 263 |
A, B, M = map(int,input().split())
A = [a for a in map(int,input().split())]
B = [b for b in map(int,input().split())]
C = []
for m in range(M):
C.append([c for c in map(int,input().split())])
ans = min(A) + min(B)
for c in C:
if (A[c[0]-1]+B[c[1]-1]-c[2])<ans:
ans = A[c[0]-1]+B[c[1]-1]-c[2]
print(ans) | a,b,m = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ans = []
for i in range(m):
x,y,c = map(int, input().split())
ans += [A[x-1] + B[y-1] - c]
ans += [min(A) + min(B)]
print(min(ans)) | 1 | 53,830,088,716,794 | null | 200 | 200 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.