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 = raw_input()
A = map(int, raw_input().split())
for i, key in enumerate(A):
j = i - 1
while(j >= 0 and A[j] > key):
A[j+1] = A[j]
j -= 1
A[j+1] = key
for x in A:
print x,
print | n = int(input())
A = [0]
A.extend(list(map(int,input().split())))
B = {}
pair = 0
for i in range(1,n+1):
if i+A[i] in B:
B[i+A[i]] += 1
else:
B[i+A[i]] = 1
for j in range(2,n+1):
if j-A[j] in B:
pair += B[j-A[j]]
print(pair) | 0 | null | 12,979,154,838,998 | 10 | 157 |
n = int(input())
a = 0
while(a < n):
a += 1000
print(a - n) | #!/usr/bin/python3
n = int(input())
if(n%1000==0):
print("0")
else:
ans = n%1000
print(1000-ans) | 1 | 8,383,957,872,632 | null | 108 | 108 |
ct=0
def merge(A,left,mid,right):
global ct
n1=mid-left
n2=right-mid
l=[A[left+i] for i in xrange(n1)]
r=[A[mid+i] for i in xrange(n2)]
l.append(float('inf'))
r.append(float('inf'))
i=0
j=0
for k in xrange(left,right):
ct+=1
if l[i]<=r[j]:
A[k]=l[i]
i=i+1
else:
A[k]=r[j]
j=j+1
def mergesort(A,left,right):
if left+1<right:
mid=(left+right)/2
mergesort(A,left,mid)
mergesort(A,mid,right)
merge(A,left,mid,right)
n=input()
s=map(int,raw_input().split())
mergesort(s,0,n)
i=0
s=map(str,s)
print(" ".join(s))
print(ct) | N = int(input())
S, T = list(map(str, input().split()))
A = ''
for i in range(N):
A += S[i]
A += T[i]
print(A) | 0 | null | 56,293,258,295,910 | 26 | 255 |
import sys
input = sys.stdin.readline
n, (s, t) = int(input()), input()[:-1].split()
print(''.join(s[i] + t[i] for i in range(n))) | import math
pages = int(input())
print(math.ceil(pages/2)) | 0 | null | 85,261,353,682,342 | 255 | 206 |
n = int(input())
s = input()
cnt = s.count('ABC')
print(cnt) | N = int(input())
dic = {}
for _ in range(N):
s = input()
if s in dic:
dic[s] += 1
else:
dic[s] = 1
num = 0
for key in dic:
num = max(num, dic[key])
ans = []
for key in dic:
if dic[key] == num:
ans.append(key)
ans.sort()
for a in ans:
print(a) | 0 | null | 84,781,301,333,792 | 245 | 218 |
def calcGaps(n):
gaps = [1]
while 3 * gaps[-1] + 1 < n:
gaps.append(3 * gaps[-1] + 1)
return gaps[::-1]
def insertionSort(a, n, gap, cnt):
for i in range(gap, n):
v = a[i]
j = i - gap
while j >= 0 and a[j] > v:
a[j + gap] = a[j]
j = j - gap
cnt += 1
a[j + gap] = v
return a, cnt
def shellSort(a, n):
cnt = 0
Gaps = calcGaps(n)
for gap in Gaps:
a, cnt = insertionSort(a, n, gap, cnt)
print(len(Gaps))
print(*Gaps)
print(cnt)
print(*a, sep='\n')
n = int(input())
A = [int(input()) for _ in range(n)]
shellSort(A, n)
| cnt = 0
m = 0
g = []
def insertion_sort(a, n, g):
# cnt+=1 のときにローカルスコープの外を見にいくようにするため
global cnt
for i in range(g, n):
v = a[i]
k = i - g
while k >= 0 and a[k] > v:
a[k+g] = a[k]
k -= g
cnt += 1
a[k+g] = v
def shell_sort(a, n):
global m, g
h = 1
while h <= n:
g.append(h)
h = h * 3 + 1
g.reverse()
m = len(g)
for i in range(m):
insertion_sort(a, n, g[i])
n = int(input())
a = [int(input()) for i in range(n)]
shell_sort(a, n)
print(m)
print(*g)
print(cnt)
for i in a:
print(i)
| 1 | 29,798,688,480 | null | 17 | 17 |
n = int(input())
minv = int(input())
maxv = -1000000000
for i in range(1,n):
r = int(input())
m = r-minv
if maxv < m < 0:
maxv = m
minv = r
elif maxv < m:
maxv = m
elif m < 0:
minv = r
print(maxv) | n = int(input().rstrip())
R = [0 for _ in range(n)]
for i in range(n):
R[i] = int(input().rstrip())
margin = - 10**9
min_R = R[0]
for j in range(1, n):
margin = max(margin, R[j] - min_R)
min_R = min(min_R, R[j])
print(margin)
| 1 | 13,460,064,310 | null | 13 | 13 |
import math
r = float(input())
pi =math.pi
print('%.10f %.10f'%(r*r*pi,2*r*pi))
| n=input()
s1= input()
count=0
for i in range(len(s1)-2):
if(s1[i]=='A' and s1[i+1]=='B' and s1[i+2]=='C'):
count=count+1
print(count) | 0 | null | 50,165,971,414,710 | 46 | 245 |
X, Y = [int(v) for v in input().split()]
ans = "No"
for c in range(X + 1):
t = X - c
if 2 * c + 4 * t == Y:
ans = "Yes"
break
# if ans == "No":
# for t in range(X + 1):
# c = X - t
# if 2 * c + 3 * t == Y:
# ans = "Yes"
# break
print(ans) | mod = 10 ** 9 + 7
n, k = map(int, input().split())
binomial = [1]
cum = 1
for i in range(1, n + 2):
cum *= i
cum = cum % mod
binomial.append(cum)
inv = []
tmp = pow(cum, mod - 2, mod)
inv.append(tmp)
for j in range(n + 1, 0, -1):
tmp = j * tmp % mod
inv.append(tmp)
inv.reverse()
def comb(n, k):
return binomial[n] * inv[n - k] % mod * inv[k] % mod if n >= k else 0
k = min(k, n - 1)
ans = 0
for m in range(k + 1):
tmp = comb(n, m) * binomial[n - 1] * inv[n - 1 - m] * inv[m]
ans += tmp % mod
ans %= mod
print(ans) | 0 | null | 40,543,123,634,218 | 127 | 215 |
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a_sums, b_sums = [0], [0]
for i in range(n):
a_sums.append(a_sums[i] + a[i])
for i in range(m):
b_sums.append(b_sums[i] + b[i])
ans = 0
j = m
for i in range(n + 1):
if a_sums[i] > k:
break
while a_sums[i] + b_sums[j] > k:
j -= 1
ans = max(ans, i + j)
print(ans) | import bisect
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a2 = [0] * (n + 1)
b2 = [0] * (m + 1)
for i in range(0, n):
a2[i+1] = a[i] + a2[i]
for i in range(0, m):
b2[i+1] = b[i] + b2[i]
ans = 0
for i in range(n+1):
tmp = bisect.bisect_right(b2, k-a2[i]) - 1
if a2[i] + b2[tmp] <= k and tmp >= 0:
ans = max(ans, i+tmp)
print(ans) | 1 | 10,691,241,472,210 | null | 117 | 117 |
from itertools import accumulate
R, C, K = map(int, input().split())
vss = [[None]*C for _ in range(R)]
for _ in range(K):
r, c, v = map(int, input().split())
vss[r-1][c-1] = v
dp = []
for y in range(R):
ndp = []
for x in range(C):
tmp = []
uemax = 0
if y > 0:
uemax = max(dp[x])
if vss[y][x] is None:
if x > 0:
left = ndp[-1]
tmp.append(left[0] if left[0] > uemax else uemax)
tmp.append(left[1])
tmp.append(left[2])
tmp.append(left[3])
else:
tmp.append(uemax)
tmp.append(0)
tmp.append(0)
tmp.append(0)
else:
v = vss[y][x]
if x > 0:
left = ndp[-1]
tmp.append(left[0] if left[0] > uemax else uemax)
tmp.append(max(left[0]+v, left[1], uemax+v))
tmp.append(left[1]+v if left[1]+v > left[2] else left[2])
tmp.append(left[2]+v if left[2]+v > left[3] else left[3])
else:
tmp.append(uemax)
tmp.append(uemax + v)
tmp.append(0)
tmp.append(0)
ndp.append(tmp)
dp = ndp
print(max(dp[-1]))
| R,C,K=map(int,input().split())
V=[[0 for _ in range(C)] for _ in range(R)]
for i in range(K):
r,c,v=map(int,input().split())
V[r-1][c-1]=v
dp=[[0 for _ in range(4)] for _ in range(C+1)]
for i in range(R):
ndp=[[0 for _ in range(4)] for _ in range(C+1)]
for j in range(C):
ndp[j][0]=max(dp[j])
for j in range(C):
v=V[i][j]
for n in range(1,4):
ndp[j][n]=max(ndp[j-1][n-1]+v,dp[j][3]+v,ndp[j-1][n])
dp=ndp
print(max(dp[C-1]))
| 1 | 5,563,038,221,950 | null | 94 | 94 |
MODINT = 10**9+7
n, k = map(int, input().split())
ans = 0
"""
dp[i] = gdc がi となる場合のgcdの総和
"""
dp = [0] * (k+100)
for i in range(k, 0, -1):
dp[i] = pow(k//i, n, MODINT)
for j in range(i*2, k+1, i):
dp[i] -= dp[j]
ans += (dp[i]*i)%MODINT
print(ans%MODINT) | n = int(input())
hon = [2, 4, 5, 7, 9]
bon = [3]
pon = [1, 6, 0]
if int(str(n)[-1]) in hon:
print("hon")
elif int(str(n)[-1]) in bon:
print("bon")
else:
print("pon") | 0 | null | 28,049,278,611,630 | 176 | 142 |
import sys
N = int(sys.stdin.readline().strip())
X = sys.stdin.readline().strip()
def popcount(n):
cnt = 0
while n > 0:
cnt += n & 1
n //= 2
return cnt
def f(n):
cnt = 0
while n != 0:
n = n % popcount(n)
cnt += 1
return cnt
#nX = int(X, 2)
pcnt = X.count('1')
MOD1 = pcnt + 1
MOD2 = pcnt - 1
nXp = 0
nXm = 0
pow1 = [1] * N
pow2 = [0] * N
for i in range(1, N):
pow1[i] = (pow1[i-1] * 2) % MOD1
if MOD2 != 0:
pow2[0] = 1
for i in range(1, N):
pow2[i] = (pow2[i-1] * 2) % MOD2
for i in range(N):
if X[i] == '1':
nXp += pow1[N-1-i]
nXp %= MOD1
if MOD2 != 0:
for i in range(N):
if X[i] == '1':
nXm += pow2[N-1-i]
nXm %= MOD2
for i in range(0, N):
if X[i] == '0':
k = (nXp + pow1[N-1-i]) % MOD1
print(f(k) + 1)
else:
if MOD2 == 0:
print(0)
else:
k = (nXm - pow2[N-1-i]) % MOD2
print(f(k) + 1) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def popcnt(n):
return bin(n).count("1")
def mod(n, cnt):
if n == 0:
return cnt
n = n % popcnt(n)
cnt += 1
return mod(n, cnt)
n = int(readline())
x2 = list(readline().decode().rstrip())
x10 = int(''.join(x2), 2)
c = x2.count('1')
mod1 = x10 % (c + 1)
mod2 = x10 % (c - 1) if c - 1 != 0 else 0
for i in range(n):
if x2[i] == '0':
t = (mod1 + pow(2, n - i - 1, c + 1)) % (c + 1)
else:
if c - 1 != 0:
t = (mod2 - pow(2, n - i - 1, c - 1)) % (c - 1)
else:
print(0)
continue
print(mod(t, 1))
| 1 | 8,221,269,546,062 | null | 107 | 107 |
N = int(input())
A = [0]*N
B = [0]*N
for n in range(N):
A[n],B[n] = map(int,input().split())
A.sort()
B.sort()
if N % 2 == 1:
print(B[N//2]-A[N//2]+1)
else:
Am = (A[N//2]+A[N//2-1])/2
Bm = (B[N//2]+B[N//2-1])/2
print(int((Bm-Am)*2)+1) | n = int(input())
a, b = [0] * n, [0] * n
for i in range(n):
a[i], b[i] = map(int, input().split())
a.sort()
b.sort()
if n % 2:
min_m, max_m = a[n // 2], b[n // 2]
ans = max_m - (min_m - 1)
else:
min_m2 = a[n // 2] + a[n // 2 - 1]
max_m2 = b[n // 2] + b[n // 2 - 1]
ans = max_m2 - min_m2 + 1
print(ans) | 1 | 17,387,068,666,980 | null | 137 | 137 |
N = int(input())
num = list(range(N+1))
for i in range(3, N+1, 3):
num[i] = 0
for i in range(5, N+1, 5):
num[i] = 0
print(sum(num)) | n = int(input())
sum = 0
for i in range(1, n + 1):
if i % 3 != 0 and i % 5 != 0:
sum = sum + i
print(sum) | 1 | 35,048,690,639,918 | null | 173 | 173 |
n = int(input())
a = list(map(int, input().split()))
ruiseki = 0
count = 0
for i in range(n-1):
ruiseki += a[i]
count += ruiseki * a[i+1]
mod = 10**9 + 7
if count >= mod:
print(count%mod)
else:
print(count) | n, m, x = map(int, input().split())
price = []
ability = []
for _ in range(n):
lst = []
lst = [int(i) for i in input().split()]
price.append(lst[0])
ability.append(lst[1:m + 1])
#print(price)
#print(ability)
min_price = float('inf')
for i in range(2 ** n):
flag = True
total = 0
obtain = [0] * m
for j in range(n):
if ((i >> j) & 1):
total += price[j]
for k in range(m):
obtain[k] += ability[j][k]
for j in range(m):
if obtain[j] < x:
flag = False
break
if flag:
if total < min_price:
min_price = total
if min_price == float('inf'):
print(-1)
else:
print(min_price) | 0 | null | 13,110,058,825,024 | 83 | 149 |
from collections import deque
N = int(input())
g = [[] for _ in range(N)]
hen = []
dic = {}
for i in range(N-1):
#iが辺のID
a,b = map(int,input().split())
a -= 1; b -= 1
g[a].append((b,i))
g[b].append((a,i))
#これが答え。辺の本数だけ空を用意する。
ans = [0 for _ in range(N-1)]
Q = deque([])
Q.append(0)
used = [0 for _ in range(N)] #訪れた頂点をここに記録
used[0] = 1
#pre = [-1 for _ in range(N)]
while Q:
v = Q.popleft()
#p = pre[v] #vの親
c = -1
for i in range(len(g[v])): #vとvの親が繋がっている色を探す。
TO = g[v][i][0]
ID = g[v][i][1]
if used[TO] == 1:
c = ans[ID]
k = 1
for i in range(len(g[v])): #vとつながっている親以外の色を塗っていく。
TO = g[v][i][0]
ID = g[v][i][1]
if used[TO] == 1:
continue
if k == c:
k += 1
ans[ID] = k
k += 1
Q.append(TO)
used[TO] = 1
#bfs(0,0,-1) #根を0として、仮想親の-1から仮想色0で繋がっている。
print(max(ans))
for i in ans:
print(i) | N = int(input())
height = [int(i) for i in input().split()]
box = [0]
for x in range(1 ,N):
if(height[x] >= height[x-1] + box[x-1]):
box.append(0)
if(height[x] < height[x-1] + box[x-1]):
box.append(- height[x] + height[x-1] + box[x-1])
sum = 0
for t in box:
sum += t
print(sum) | 0 | null | 70,594,706,166,820 | 272 | 88 |
S = input()
for i in range(len(S)):
print("x",end ="") | import numpy as np
h,w=map(int,input().split())
s=[input() for _ in range(h)]
dp=np.zeros((h,w),np.int64)
if s[0][0]=='#':
dp[0,0]=1
for i in range(h):
for j in range(w):
if (i,j)==(0,0):
continue
elif i==0:
if s[i][j-1]=='.' and s[i][j]=='#':
dp[i,j]=dp[i,j-1]+1
else:
dp[i,j]=dp[i,j-1]
elif j==0:
if s[i-1][j]=='.' and s[i][j]=='#':
dp[i,j]=dp[i-1,j]+1
else:
dp[i,j]=dp[i-1,j]
else:
dp[i,j]=min(dp[i,j-1]+1 if s[i][j-1]=='.' and s[i][j]=='#' else dp[i,j-1],dp[i-1,j]+1 if s[i-1][j]=='.' and s[i][j]=='#' else dp[i-1,j])
print(dp[-1,-1])
#print(dp) | 0 | null | 61,031,308,960,702 | 221 | 194 |
N=int(input())
S={}
for n in range(N):
s=input()
S[s]=S.get(s,0)+1
maxS=max(S.values())
S=[k for k,v in S.items() if v==maxS]
print('\n'.join(sorted(S)))
| n = int(input())
s_l = [ input() for _ in range(n) ]
d = {}
for s in s_l:
try:
d[s] += 1
except:
d[s] = 1
max_c = max([ v for _,v in d.items() ])
ans = [ i for i, v in d.items() if v == max_c ]
for i in sorted(ans):
print(i) | 1 | 69,627,278,558,540 | null | 218 | 218 |
import sys
lines = [line for line in sys.stdin]
gs =['S','H','C','D']
js = list(map(str,range(1,14)))
all=[g + " " +j for g in gs for j in js]
for g in lines[1:]:
g=g.strip()
all.remove(g)
for g in all:
print(g) | from sys import stdin
input = stdin.readline
n = int(input())
A = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
set_m = set([])
for i in range(2 ** n):
tmp = 0
for j in range(n):
if (i >> j) & 1:
tmp += A[j]
set_m.add(tmp)
for i in m:
if i in set_m:
print("yes")
else:
print("no")
| 0 | null | 556,647,804,398 | 54 | 25 |
n=int(input())
a=sorted(list(map(int,input().split())))
c=0
for i in range(n-1):
c+=a[-1-(i+1)//2]
print(c)
| import numpy as np
from numba import njit
N = np.array([int(_) for _ in input()])
def solve(N):
p, q = 0, 1
for x in N:
p, q = min(p + x, q + 10 - x), min(p + x + 1, q + 9 - x)
print(p)
solve(N)
| 0 | null | 39,930,653,777,912 | 111 | 219 |
n = int(input())
ns = list(map(int, input().split()))
print(min(ns), max(ns), sum(ns))
| listed = []
nmin = 0
nmax = 0
nsum = 0
n = int(input())
if n > 0 and n <= 10000:
listed = list(map(int, input().split(maxsplit=n-1)))
nmin = listed[0]
nmax = listed[0]
for i in listed:
if i >= -1000000 and i <= 1000000:
if nmin > i:
nmin = i
if nmax < i:
nmax = i
nsum += i
else:
pass
else:
pass
print("{0} {1} {2}".format(nmin, nmax, nsum)) | 1 | 735,819,577,248 | null | 48 | 48 |
s = input()
S = s.swapcase()
print(S)
| old_char = raw_input()
new_char = ""
for i in old_char:
if i.islower():
new_char += i.upper()
elif i.isupper():
new_char += i.lower()
else:
new_char += i
print new_char | 1 | 1,509,884,936,600 | null | 61 | 61 |
M1, D1 = map(int, input().split())
M2, D2 = map(int, input().split())
if M1!=M2:
print('1')
else:
print('0')
| a, b = map(int,input().split())
c, d = map(int,input().split())
if d == 1:
print("1")
else:
print("0")
| 1 | 124,584,747,231,140 | null | 264 | 264 |
data = list(map(int, input().split()))
a,b = max(data), min(data)
r = a % b
while r != 0:
a = b
b = r
r = a % b
print(b) | def main():
a, b = tuple(map(int,input().split()))
print(gcd(a, b))
def gcd(x, y):
# x > y となるように並べ替え
if x < y:
(x, y) = (y, x)
return x if y == 0 else gcd(y, x%y)
if __name__ == '__main__':
main()
| 1 | 8,015,879,868 | null | 11 | 11 |
#!/usr/bin/env pypy3
import collections
import itertools as it
import math
#import numpy as np
# = input()
# = int(input())
a1, a2, a3 = map(int, input().split())
# = list(map(int, input().split()))
# = [int(input()) for i in range(N)]
#
# c = collections.Counter()
print('bust' if a1 + a2 + a3 >= 22 else 'win')
| N = int(input())
if N % 9 == 0:
ans = 'Yes'
else:
ans = 'No'
print(ans) | 0 | null | 61,579,944,281,220 | 260 | 87 |
n, m, k = map(int, input().split())
friendships = [[] for _ in range(n)]
for _ in range(m):
a, b = map(int, input().split())
friendships[a-1].append(b-1)
friendships[b-1].append(a-1)
blockships = [[] for _ in range(n)]
for _ in range(k):
c, d = map(int, input().split())
blockships[c-1].append(d-1)
blockships[d-1].append(c-1)
# assign users (id) for connected component, according to friendships
# also increment a counter for size of each component
component_id = [-1]*n
component_size = dict()
stack_to_visit = [(node, node) for node in range(n)]
while stack_to_visit:
node, parent_id = stack_to_visit.pop()
if component_id[node] != -1:
continue
component_id[node] = parent_id
component_size[parent_id] = component_size.get(parent_id, 0) + 1
for other in friendships[node]:
stack_to_visit.append((other, parent_id))
# calculate number of suggestions for each node
for node in range(n):
suggestions = 0
current_id = component_id[node]
suggestions += component_size[current_id] - 1
suggestions -= len(friendships[node])
suggestions -= sum(int(component_id[other] == current_id) for other in blockships[node])
print(suggestions, end=" ") | import sys
n, m, l = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
matrixA = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( n ) ]
matrixB = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( m ) ]
matrixC = [ [ sum( matrixA[i][k] * matrixB[k][j] for k in range( m ) ) for j in range( l ) ] for i in range( n ) ]
for i in range( n ):
print( " ".join( map( str, matrixC[i] ) ) ) | 0 | null | 31,459,136,541,074 | 209 | 60 |
import math
N, D = [int(x) for x in input().split()]
Z = []
for i in range(N):
Z.append([int(x) for x in input().split()])
ans = 0
for i in range(N):
if math.sqrt(Z[i][0]**2 + Z[i][1]**2) <= D:
ans += 1
print(ans)
| def main():
a, b, c = map(int, input().split())
if a + b + c > 21:
print("bust")
else:
print("win")
if __name__ == "__main__":
main()
| 0 | null | 62,626,823,098,698 | 96 | 260 |
bit=[0]*9
fa=[1]*9
for n in range(1,9):fa[n]=fa[n-1]*n
def up(id):
while id<9:
bit[id]+=1
id+=id&(-id)
def qr(id):
res=0
while id:
res+=bit[id]
id-=id&(-id)
return res
x=int(input())
s=list(map(int,input().split()))
z=list(map(int,input().split()))
v=''
for n in s:
a=qr(n)
vl=n-1-a
v+=str(vl)
up(n)
v=v[::-1]
r1=0
for n in range(len(v)):
r1+=int(v[n])*fa[n]
r2=0
v=''
bit=[0]*9
for n in z:
a=qr(n)
vl=n-1-a
v+=str(vl)
up(n)
v=v[::-1]
for n in range(len(v)):
r2+=int(v[n])*fa[n]
print(abs(r1-r2)) | from collections import deque
s = list(input())
q = int(input())
d = deque()
for i in s:
d.append(i)
c = 1
for _ in range(q):
t = list(input().split())
if t[0] == '1':
c *= -1
else:
if t[1] == '1':
if c == 1:
d.appendleft(t[2])
else:
d.append(t[2])
else:
if c == 1:
d.append(t[2])
else:
d.appendleft(t[2])
print(''.join(list(d)[::c]))
| 0 | null | 79,179,098,132,448 | 246 | 204 |
n = int(input())
a = 0
b = 0
d1 = 0
d2 = 0
for i in range(n):
d1,d2 = map(int,input().split())
if(a==0 and d1 ==d2):
a+=1
elif(a==1 and d1 ==d2):
a+=1
elif(a==2 and d1 ==d2):
b +=1
break
else:
a =0
if(b>=1):
print("Yes")
else:
print("No") |
def main():
N = int(input())
zoro = []
for i in range(N):
a, b = map(int, input().split())
if a == b:
zoro.append(1)
if i >= 2:
if zoro[i-2] == zoro[i-1] and zoro[i-1] == zoro[i]:
print('Yes')
return
else:
zoro.append(0)
print('No')
main()
| 1 | 2,454,912,202,350 | null | 72 | 72 |
n, m = map(int, input().split())
class UnionFind():
def __init__(self, n):
self.n = n
self.parent = [int(x) for x in range(n)]
self.tree_size = [1 for _ in range(n)]
def unite(self, x, y):
x_root = self.find(x)
y_root = self.find(y)
if self.same(x_root, y_root):
return
if self.size(x_root) >= self.size(y_root):
self.parent[y_root] = x_root
self.tree_size[x_root] += self.tree_size[y_root]
else:
self.parent[x_root] = y_root
self.tree_size[y_root] += self.tree_size[x_root]
def find(self, x):
if self.parent[x] == x:
return x
else:
next = self.find(self.parent[x])
self.parent[x] = next
return next
def size(self, x):
return self.tree_size[self.find(x)]
def same(self, x, y):
if self.find(x) == self.find(y):
return True
else:
return False
uf = UnionFind(n)
for _ in range(m):
a, b = map(int, input().split())
uf.unite(a-1, b-1)
# print([uf.size(i) for i in range(n)])
print(max([uf.size(i) for i in range(n)]))
| from math import pi
print(2 * pi * int(input()), end='\n\r')
| 0 | null | 17,821,220,058,630 | 84 | 167 |
s = input()
week = ["MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"]
for i in range(6):
if s == week[i]:
print(6 - i)
if s == "SUN":
print("7")
| n, m = map(int, input().split())
submissions = [list(input().split()) for _ in range(m)]
count_penalty = [0] * (n + 1)
count_ac = [0] * (n + 1)
for i in range(m):
ploblem = int(submissions[i][0])
if submissions[i][1] == "AC":
count_ac[ploblem] = 1
elif count_ac[ploblem] != 1 and submissions[i][1] == "WA":
count_penalty[ploblem] += 1
for i in range(n + 1):
if count_ac[i] != 1:
count_penalty[i] = 0
print("{} {}".format(count_ac.count(1), sum(count_penalty)))
| 0 | null | 113,686,545,508,700 | 270 | 240 |
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))
| from collections import deque
def getMaxDistance(s,startY,startX):
d = deque()
distances = [[0 for _ in range(w)] for j in range(h)]
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
maxDistance = 0
d.append(startX)
d.append(startY)
while d:
x = d.popleft()
y = d.popleft()
if s[y][x]=='#': continue
maxDistance = max(maxDistance, distances[y][x])
for i in range(4):
xx = x + dx[i]
yy = y + dy[i]
if not (0 <= yy < h and 0 <= xx < w): continue
if s[yy][xx] != '.': continue
if distances[yy][xx] != 0: continue
if xx == startX and yy == startY: continue
d.append(xx)
d.append(yy)
distances[yy][xx] = distances[y][x] + 1
return maxDistance
h,w=map(int,input().split())
s=[list(input()) for _ in range(h)]
maxDistance = 0
for i in range(h):
for j in range(w):
maxDistance = max(maxDistance, getMaxDistance(s,i,j))
print(maxDistance) | 1 | 94,518,696,478,998 | null | 241 | 241 |
def resolve():
s = input()
print(s[:3])
if 'unittest' not in globals():
resolve()
| s = input()
print(s[:3]) | 1 | 14,859,471,581,578 | null | 130 | 130 |
import math
N, K = map(int,input().split())
A = list(map(int,input().split()))
B = [0] * (N + 1)
M = [0] * (N + 1)
for i in range(N):
B[i + 1] = B[i] + math.log10(A[i])
for i in range(K, N + 1):
M[i] = B[i] - B[i - K]
for i in range(K + 1, N + 1):
if M[i - 1] + 1e-10 < M[i]:
print("Yes")
else:
print("No") | n, k = map(int, input().split())
al = list(map(int, input().split()))
for i in range(k, n):
if al[i-k] < al[i]:
print('Yes')
else:
print('No') | 1 | 7,090,381,357,952 | null | 102 | 102 |
N = int(input())
def sb(n):
if n == 1:
return {1: 0}
else:
dic = {}
tmp = n
for i in range(2, int(n ** 0.5) + 1):
if tmp % i == 0:
dic[i] = 0
while tmp % i == 0:
dic[i] += 1
tmp //= i
if tmp != 1:
dic[tmp] = 1
if dic == {}:
dic[n] = 1
return dic
ans = 0
for key in sb(N):
v = sb(N)[key]
dv = 1
while v - dv >= 0:
v -= dv
dv += 1
ans += 1
print(ans)
| N=int(input())
S,T=map(list,input().split())
U=[]
for i in range(N):
U.append("")
for i in range(N):
U[i]=S[i]+T[i]
print(''.join(U)) | 0 | null | 64,472,379,445,602 | 136 | 255 |
z = input()
a= z.split()
if int(a[0]) < int(a[1]) < int(a[2]):
print('Yes')
else:
print('No') | import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
x = list(map(int, readline().split()))
print(x.index(0) + 1)
if __name__ == '__main__':
solve()
| 0 | null | 6,888,729,438,150 | 39 | 126 |
n = int(input())
s, t = input().split()
ans = ''
for si, ti in zip(s, t):
ans += si + ti
print(ans) | n = int(input())
s, t = input().split()
for i in range(n):
print(s[i], t[i], sep="", end="")
print("")
| 1 | 111,885,301,034,640 | null | 255 | 255 |
a,b = map(int,input().split())
print(a*b if a < 10 and b < 10 else -1) | N = list(map(int, input().strip().split()))
state=-1
if(N[0]>=1 and N[0] <=9 and N[1]>=1 and N[1] <=9):
state=N[0]*N[1]
print(state) | 1 | 157,874,069,494,788 | null | 286 | 286 |
import sys
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7
N, M = rl()
if N == M:
print('Yes')
else:
print('No') | n, k = map(int, input().split())
# from collections import OrderedDict
# d = OrderedDict()
# a = list(input().split())
# b = list(map(int, input().split()))
# print(r + max(0, 100*(10-n)))
# print("Yes" if 500*n >= k else "No")
# s = input()
# a = int(input())
# b = int(input())
# c = int(input())
print("Yes" if n == k else "No") | 1 | 83,513,359,635,538 | null | 231 | 231 |
n = int(input())
mod = 10**9+7
ls = list(map(int,input().split()))
di = [i**2 for i in ls]
print((((sum(ls)**2)-(sum(di)))//2)%mod) | N=int(input())
A=list(map(int,input().split()))
mod=10**9+7
B=[0]
for i in range(1,N+1):
B.append(A[i-1]+B[i-1])
ans=0
for i in range(N-1):
ans+=A[i]*(B[N]-B[i+1])
ans%=mod
print(int(ans)) | 1 | 3,813,729,579,618 | null | 83 | 83 |
n = int(input())
table = [0] * (n + 1)
for i in range(1, n+1):
for j in range(i, n+1, i):
table[j] += 1
ans = 0
for i in range(n+1):
ans += table[i] * i
print(ans)
| K=int(input())
num=7
ans=-1
for n in range(pow(10,7)):
if num%K==0:
ans=n+1
break
shou=num//K
num-=K*shou
num=int(str(num)+'7')
print(ans)
| 0 | null | 8,535,771,545,758 | 118 | 97 |
n = int(input())
d = 'abcdefghijklm'
def conv(s):
s = list(map(lambda x: d[x], s))
return ''.join(s)
def dfs(s):
if len(s) == n:
print(conv(s))
else:
mx = max(s)+1
for i in range(mx+1):
dfs(s+[i])
dfs([0]) | n = int(input())
alp = [chr(ord("a") + x) for x in range(26)]
def dfs(S):
if len(S) == n:
print(S)
else:
max_s = ord(max(S)) - 96
#print(max_s)
for i in range(max_s + 1):
dfs(S + alp[i])
dfs("a") | 1 | 52,489,274,816,230 | null | 198 | 198 |
from itertools import combinations
import math
N = int(input())
x = []
y = []
for i in range(N):
_x, _y = map(int, input().split())
x.append(_x)
y.append(_y)
s = 0
for c in combinations(zip(x, y), 2):
s += math.sqrt((c[0][0] - c[1][0]) ** 2 + (c[0][1] - c[1][1]) ** 2)
print(s * 2 / N) | import math
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]
count = N * (N - 1) // 2
t = 0.0
for i in range(N):
for j in range(i + 1, N):
x1 = XY[i][0]
y1 = XY[i][1]
x2 = XY[j][0]
y2 = XY[j][1]
t += math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
print(t / count * (N - 1)) | 1 | 148,886,324,528,572 | null | 280 | 280 |
n = int(input())
a = list(map(int, input().split()))
from collections import Counter
c = Counter(a)
vals = [True]*(max(a)+1)
ans = 0
m = max(a)+1
for i in range(1, m):
if i not in c:
continue
if c[i]>=2:
vals[i] = False
for j in range(2*i, m, i):
vals[j] = False
ans = 0
for i in range(1, max(a)+1):
if vals[i] and i in c:
ans += 1
print(ans) | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, k = list(map(int, readline().split()))
comb1 = [0] * (n + 1)
comb2 = [0] * (n + 1)
comb1[0] = 1
comb2[0] = 1
for i in range(1, n + 1):
comb1[i] = comb1[i - 1] * (n + 1 - i)
comb2[i] = comb2[i - 1] * (n - i)
comb1[i] %= MOD
comb2[i] %= MOD
inv = pow(i, MOD - 2, MOD)
comb1[i] *= inv
comb2[i] *= inv
comb1[i] %= MOD
comb2[i] %= MOD
r = min(k, n - 1)
ans = 0
for i in range(r + 1):
ans += comb1[n - i] * comb2[n - 1 - i]
ans %= MOD
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 40,911,525,681,248 | 129 | 215 |
n = int(input())
count_list = [0] * 4
for i in range(n):
text = input()
if text == "AC":
count_list[0] += 1
elif text == "WA":
count_list[1] += 1
elif text == "RE":
count_list[3] += 1
else:
count_list[2] += 1
print("AC x " + str(count_list[0]))
print("WA x " + str(count_list[1]))
print("TLE x " + str(count_list[2]))
print("RE x " + str(count_list[3])) | def pon():
a = int(input()) % 10
if a in [2, 4, 5, 7, 9]:
print("hon")
elif a in [0, 1, 6, 8]:
print("pon")
else:
print("bon")
pon() | 0 | null | 13,987,638,025,560 | 109 | 142 |
[a,b,c]=raw_input().split()
x=int(a)
y=int(b)
z=int(c)
ans=[]
for n in range(x,y+1):
if z%n==0:
ans.append(n)
print len(ans) | n=input()
count=n.count("7")
if count!=0:
print("Yes")
else:
print("No") | 0 | null | 17,483,807,702,802 | 44 | 172 |
M = 1046527
POW = [pow(4, i) for i in range(13)]
def insert(dic, string):
# i = 0
# while dic[(hash1(string) + i*hash2(string)) % M]:
# i += 1
# dic[(hash1(string) + i*hash2(string)) % M] = string
dic[get_key(string)] = string
def find(dic, string):
# i = 0
# while dic[(hash1(string) + i*hash2(string)) % M] and dic[(hash1(string) + i*hash2(string)) % M] != string:
# i += 1
# return True if dic[(hash1(string) + i*hash2(string)) % M] == string else False
# print(dic[get_key(string)], string)
return True if dic[get_key(string)] == string else False
def get_num(char):
if char == "A":
return 1
elif char == "C":
return 2
elif char == "G":
return 3
else:
return 4
def get_key(string):
num = 0
for i in range(len(string)):
num += POW[i] * get_num(string[i])
return num
def main():
n = int(input())
dic = [None] * POW[12]
# print(dic)
for i in range(n):
order, string = input().split()
if order == "insert":
insert(dic, string)
else:
if find(dic, string):
print('yes')
else:
print('no')
if __name__ == "__main__":
main()
| N=int(input())
p=[list(map(str,input().split())) for _ in range(N)]
X=input()
flag=0
cnt=0
for i in range(N):
if flag==1:
cnt=cnt+int(p[i][1])
if p[i][0]==X:
flag=1
print(cnt) | 0 | null | 48,730,892,597,970 | 23 | 243 |
def main():
global s,ide_ele,num,seg
n = int(input())
s = list(input())
for i in range(n):
s[i] = ord(s[i])-97
ide_ele = 0
num = 2**(n-1).bit_length()
seg = [[ide_ele for _ in range(2*num)] for _ in range(26)]
for i in range(n):
seg[s[i]][i+num-1] = 1
for a in range(26):
for i in range(num-2,-1,-1) :
seg[a][i] = max(seg[a][2*i+1],seg[a][2*i+2])
q = int(input())
for _ in range(q):
QUERY = list(input().split())
QUERY[0], QUERY[1] = int(QUERY[0]), int(QUERY[1])
if QUERY[0] == 1:
x = ord(QUERY[2])-97
k = QUERY[1]-1
pre = s[k]
s[k] = x
k += num-1
seg[pre][k] = 0
seg[x][k] = 1
while k:
k = (k-1)//2
seg[pre][k] = max(seg[pre][k*2+1],seg[pre][k*2+2])
seg[x][k] = max(seg[x][k*2+1],seg[x][k*2+2])
if QUERY[0] == 2:
P, Q = QUERY[1]-1, int(QUERY[2])
if Q <= P:
print(ide_ele)
break
P += num-1
Q += num-2
ans = ide_ele
for i in range(26):
res = ide_ele
p,q = P,Q
while q-p > 1:
if p&1 == 0:
res = max(res,seg[i][p])
if q&1 == 1:
res = max(res,seg[i][q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = max(res,seg[i][p])
else:
res = max(max(res,seg[i][p]),seg[i][q])
ans += res
print(ans)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
# sys.setrecursionlimit(100000)
def main():
N = int(input().strip())
return (N//2) + N % 2
if __name__ == "__main__":
print(main()) | 0 | null | 60,543,811,067,368 | 210 | 206 |
n=int(input())
if n%2 == 0:
n=n-1
print(int(n/2)) | from itertools import product
n = int(input())
xy = []
for _ in range(n):
a = int(input())
tmp = [list(map(int, input().split())) for _ in range(a)]
xy.append(tmp)
ans = 0
for bit in product([0, 1], repeat=n):
for i, liar in enumerate(bit):
if liar and any(bit[x - 1] != y for x, y in xy[i]):
break
else:
ans = max(ans, sum(bit))
print(ans)
| 0 | null | 137,401,639,485,250 | 283 | 262 |
n = int(input())
a = list(map(int, input().split(" ")))
for lil_a in a[-1:0:-1]:
print("%d "%lil_a, end="")
print("%d"%a[0]) | n = int(input())
s = list(map(str,input()))
ans = [chr((ord(s[i])-ord("A")+n)%26+ord("A")) for i in range(len(s))]
print("".join(ans)) | 0 | null | 67,820,557,819,242 | 53 | 271 |
a, b = [int(i) for i in input().split()]
if a >= b*2:
print(a - b*2)
else:
print(0) | n = int(input())
a = [int(i) for i in input().split()]
a.sort(reverse=True)
i = 1
ans = a[0]
c = 1
while c < n - 1:
k = min(2, n - 1 - c)
c += k
ans += a[i] * k
i += 1
print(ans)
| 0 | null | 87,848,269,220,668 | 291 | 111 |
n = int(input())
a = list(map(int, input().split()))
mod = 1000000007
caps = [0, 0, 0]
ans = 1
for i in range(n):
equal = []
for j in range(3):
if caps[j] == a[i]:
equal.append(j)
l = len(equal)
if l == 0:
ans = 0
break
ans = ans * l % mod
caps[equal[0]] += 1
print(ans) | import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
H, W, K = lr()
S = []
for i in range(H):
S.append([int(s) for s in sr()])
ans = 2000
idx = [0]*H
for div in range(1<<(H-1)):
g = 0
for i in range(H):
idx[i] = g
if div>>i&1:
g += 1
g += 1
c = [[0]*W for i in range(g)]
for i in range(H):
for j in range(W):
c[idx[i]][j] += S[i][j]
ok = True
for i in range(g):
for j in range(W):
if c[i][j] > K:
ok = False
if not ok:
continue
num = g-1
now = [0]*g
def add(j):
for i in range(g):
now[i] += c[i][j]
for i in range(g):
if now[i] > K:
return False
return True
for j in range(W):
if not add(j):
num += 1
now = [0]*g
add(j)
ans = min(ans, num)
print(ans)
resolve() | 0 | null | 88,876,767,202,842 | 268 | 193 |
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,k = LI()
r,s,p = LI()
t = list(S())
ans = 0
for i in t[:k]:
if i=="r":
ans += p
elif i == "s":
ans += r
elif i == "p":
ans += s
for i in range(k,n):
if t[i]=="r":
if t[i-k]=="r":
t[i] = ""
else:
ans += p
elif t[i]=="s":
if t[i-k]=="s":
t[i] = ""
else:
ans += r
elif t[i]=="p":
if t[i-k]=="p":
t[i] = ""
else:
ans += s
print(ans)
main()
| from sys import stdin
readline = stdin.readline
def i_input(): return int(readline().rstrip())
def i_map(): return map(int, readline().rstrip().split())
def i_list(): return list(i_map())
def main():
K = i_input()
print("ACL" * K)
if __name__ == "__main__":
main()
| 0 | null | 54,820,462,410,938 | 251 | 69 |
N , K ,S =map(int,input().split())
if S != 10**9:
ans = [S]*K + [10**9]*(N-K)
else:
ans = [S]*K + [1]*(N-K)
print(" ".join(map(str,ans))) | N,K,S=map(int,input().split())
ans=[S]*N
m=10**9
for i in range(N-K):
ans[i]%=m
ans[i]+=1
print(*ans) | 1 | 90,754,151,418,400 | null | 238 | 238 |
from collections import Counter
def solve(string):
n, *aqbc = map(int, string.split())
a, _, bc = aqbc[:n], aqbc[n], aqbc[n + 1:]
s = sum(a)
t = Counter(a)
ans = []
for b, c in zip(*[iter(bc)] * 2):
if b in t.keys():
s += (c - b) * t[b]
t[b], t[c] = 0, t[b] + t[c]
ans.append(s)
return "\n".join(map(str, ans))
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
| from collections import Counter
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
BC = [list(map(int, input().split())) for _ in range(Q)]
counter = Counter(A)
counter_sum = sum(k*v for k, v in counter.items())
for b, c in BC:
counter[c] += counter[b]
counter_sum -= b * counter[b]
counter_sum += c * counter[b]
counter[b] = 0
print(counter_sum)
| 1 | 12,252,987,524,512 | null | 122 | 122 |
n, k, s = map(int, input().split())
#%%
billion = 1000000000
if s == billion:
front = [s] * k
back = [1] * (n - k)
else:
front = [s] * k
back = [s+1] * (n - k)
front.extend(back)
print(*front) | # import itertools
# import math
import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
N = int(input())
# S = input()
# n, *a = map(int, open(0))
# X, K, D = map(int, input().split())
# A = list(map(int, input().split()))
# C = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
C = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
a = C.count("R")
b = C[:a].count("R")
print(a - b) | 0 | null | 48,865,124,730,708 | 238 | 98 |
i = 0
while True:
i += 1
v = input()
if v == '0':
break
print('Case %d: %s' % (i, v)) | count = 1
while True:
x = int(input())
if x is not 0:
print("Case {c}: {x}".format(c=count, x=x))
else:
break
count += 1
| 1 | 482,709,251,200 | null | 42 | 42 |
import collections
n=int(input())
s = [(input()) for _ in range(n)]
c = collections.Counter(s)
b = max(c.values())
l = [key for key in c.keys() if c[key] == b]
l.sort()
for i in l:
print(i) | print((int(input())/3)**3)
| 0 | null | 58,496,380,732,188 | 218 | 191 |
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, score
# 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
def random_change0(D, C, S, out, score):
new_out = copy.deepcopy(out)
d = random.randrange(0, 10)
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):
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 random_swap0(D, C, S, out, score):
d1 = random.randrange(0, 6)
d2 = random.randrange(6, 13)
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
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)]
# 貪欲法で初期値を決める
max_score = -10 ** 8
max_k = 0
for k in range(6):
out, score = solve(D, C, S, k)
if score > max_score:
max_score = score
max_out = out
max_k = k
# # local minimumを避けるため,outを少し変える
out = max_out
score = max_score
out, score = solve(D, C, S, max_k)
out[0] = random.randrange(NN)
for cnt in range(10 ** 10):
out, score = random_changeN(D, C, S, out, score, N=1)
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()
| import numpy as np
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
from numba import njit
def getInputs():
D = int(readline())
CS = np.array(read().split(), np.int32)
C = CS[:26]
S = CS[26:].reshape((-1, 26))
return D, C, S
def _compute_score(output, i, d, last):
mask = np.ones((26, ), np.int32)
mask[i] = 0
score = S[d][i] - np.sum(C * (d + 1 - last) * mask)
return score
def _evaluate(output, i, d, last, k):
score = _compute_score(output, i, d, last)
score -= np.sum(C * (d + k + 1 - last))
return score
def solve(k):
output = np.array([], np.int32)
last = np.zeros((26, ), np.int32)
SCORE = 0
for d in range(D):
max_score = float('-inf')
best_i = 0
for i in range(26):
output = np.append(output, i)
#score = _compute_score(output, i, d, last)
score = _evaluate(output, i, d, last, k)
if max_score < score:
max_score = score
best_i = i + 1
output = output[:-1]
output = np.append(output, best_i)
last[best_i - 1] = d + 1
SCORE += max_score
return output, SCORE
D, C, S = getInputs()
max_score = float('-inf')
for k in range(7, 14):
ans, score = solve(k)
if max_score < score:
max_score = score
ANS = ans
print('\n'.join(ANS.astype(str).tolist())) | 1 | 9,718,885,271,268 | null | 113 | 113 |
S = list(input())
print("".join(S[0:3])) | s = input()
ans = s[0:3]
print(ans) | 1 | 14,743,502,246,752 | null | 130 | 130 |
N=int(input())
S=str(input())
ls = []
for i in range(len(S)):
ls.append(S[i])
for i in range(len(S)):
x = S[i]
#print(ord(x)+N,ord("Z"))
if ord(x)+N > ord("Z"):
#print("if")
#print(ord("A")-ord("Z")+(ord(x)+N))
ls[i]=chr(ord("A")-ord("Z")+(ord(x)+N)-1)
else:
#print("else")
ls[i]=chr((ord(x)+N))
print("".join(ls))
| import sys
input = sys.stdin.readline
from string import ascii_uppercase
letters = ascii_uppercase + ascii_uppercase
shift = int(input())
s = input()[:-1]
for char in s: print(letters[letters.index(char) + shift], end = '')
print() | 1 | 134,625,410,325,150 | null | 271 | 271 |
N=int(input())
A=0
W=0
T=0
R=0
for i in range(N):
st=input()
if st=="AC":
A+=1
elif st=="WA":
W+=1
elif st=="TLE":
T+=1
else:
R+=1
print("AC x "+str(A))
print("WA x "+str(W))
print("TLE x "+str(T))
print("RE x "+str(R)) | p = 1000000007
n = int(input())
A = list(map(int, input().split()))
ans = 1
cnt = [3 if i == 0 else 0 for i in range(n+1)]
for a in A:
ans *= cnt[a]
ans %= p
if ans == 0:
break
cnt[a] -= 1
cnt[a+1] += 1
print(ans) | 0 | null | 69,739,558,293,372 | 109 | 268 |
import sys
import math
import itertools as it
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def Intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))
if __name__ == "__main__":
s = S()
n = len(s)+1
a = [0]*n
for i in range(n-1):
if s[i] == "<":
a[i+1] = max(a[i+1],a[i]+1)
for i in range(n-2,-1,-1):
if s[i] == ">":
a[i] = max(a[i],a[i+1]+1)
print(sum(a)) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
s, t = input().split()
print(t + s)
| 0 | null | 129,956,889,741,572 | 285 | 248 |
L = int(input())
l = L / 3
print(l ** 3) | while True:
a,b = map(int,input().split())
if a == 0 and b == 0:
break
if a < b:
print(a,b)
elif b < a:
print(b,a)
else:
print(a,b) | 0 | null | 23,746,219,893,022 | 191 | 43 |
import math
a, b, c = map(float, input().split())
s = a*b*math.sin(math.radians(c))/2
h = 2*s/a
l = a + b + (a**2+b**2 - 2*a*b*math.cos(math.radians(c)))**0.5
print("{0:.5f} {1:.5f} {2:.5f}".format(s,l,h)) | from collections import deque
n = int(input())
Q= deque()
for _ in range(n):
str = input()
if str == "deleteFirst":
Q.popleft()
elif str == "deleteLast":
Q.pop()
else:
cmd,key = str.split()
if cmd == "insert":
Q.appendleft(key)
elif cmd == "delete":
try:
Q.remove(key)
except:
pass
print(" ".join(list(Q)))
| 0 | null | 107,838,266,340 | 30 | 20 |
import math
import time
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
s,w=map(int,stdin.readline().split())
if(w>=s):
print("unsafe")
else:
print("safe")
| N, M = map(int, input().split())
A = list(map(int, input().split()))
sum = 0
for score in A:
sum += score
number = 0
for i in range(N):
if A[i] >= sum / (4 * M):
number += 1
else:
number += 0
print('Yes' if number >= M else 'No' ) | 0 | null | 34,108,713,381,718 | 163 | 179 |
n,m = input().split()
n = int(n)
m = int(m)
arr = list(map(int,input().split()))
minn = sum(arr)*(1/(4*m))
t = 0
for i in arr:
if i >= minn:
t += 1
#print(t)
if t >= m:
print("Yes")
else:
print("No") | n,k=map(int,input().split())
p=list(map(int,input().split()))
li=[sum(p[0:k])]
for i in range(n-k):
li.append(li[i]-p[i]+p[i+k])
print((max(li)+k)/2) | 0 | null | 56,954,307,033,402 | 179 | 223 |
n=int(input())
x=0--n//2
print(x/n) | n = int(raw_input())
intervals = [[u-l,u+l] for u,l in [map(int, raw_input().split()) for _ in range(n)] ]
intervals.sort(key = lambda x:x[1])
count = 1
i = 1
cur= intervals[0]
while(i < len(intervals)):
while(i < len(intervals) and cur[1] > intervals[i][0]): i += 1
if i < len(intervals):
cur = intervals[i]
count +=1
print count | 0 | null | 133,429,527,192,208 | 297 | 237 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 1 << 100
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, u, v = LI()
G = [[] for _ in range(n)]
for a, b in LIR(n - 1):
G[a - 1] += [b - 1]
G[b - 1] += [a - 1]
def bfs(root):
dq = deque([root])
dist = [-1] * n
dist[root] = 0
while dq:
u = dq.popleft()
for v in G[u]:
if dist[v] == -1:
dist[v] = dist[u] + 1
dq += [v]
return dist
dist_u = bfs(u - 1)
dist_v = bfs(v - 1)
ans = 0
for i in range(n):
if dist_v[i] > dist_u[i]:
ans = max(ans, dist_v[i] - 1)
print(ans)
| import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 # 998244353
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n,x,y=map(int,input().split())
x-=1; y-=1
E1=[[] for _ in range(n)]
E2=[[] for _ in range(n)]
for _ in range(n-1):
u,v=map(int,input().split())
u-=1; v-=1
E1[u].append(v)
E1[v].append(u)
E2=E1
# E2 において、y-rooted tree とみて、depth,par を計算
par=[None]*n # x の必勝頂点を判定するのに必要
par[y]=y
depth2=[None]*n
depth2[y]=0
Q=[y]
while(Q):
v=Q.pop()
for nv in E2[v]:
if(depth2[nv] is not None): continue
depth2[nv]=depth2[v]+1
par[nv]=v
Q.append(nv)
# E1の辺で、E2での距離が 3 以上のものは必勝
win=[0]*n
for v in range(n):
for nv in E1[v]:
if(par[v]==nv or par[nv]==v or par[v]==par[nv] or par[par[v]]==nv or par[par[nv]]==v): continue
win[nv]=win[v]=1
# E1 において、x-rooted tree とみて探索
# depth1 < depth2 -> 以降も探索できる
# depth1 = depth2 -> そこで捕まる
ans=depth2[x]
depth1=[None]*n
depth1[x]=0
Q=[x]
while(Q):
v=Q.pop()
if(win[v]): # 探索できる状態 & 必勝頂点にいれば勝ち
print(-1)
return
for nv in E1[v]:
if(depth1[nv] is not None): continue
depth1[nv]=depth1[v]+1
ans=max(ans,depth2[nv])
if(depth1[nv]<depth2[nv]): Q.append(nv)
print(ans-1)
resolve() | 1 | 117,410,283,386,340 | null | 259 | 259 |
input()
nums = list(map(int, input().split()))
print('{} {} {}'.format(min(nums), max(nums), sum(nums)))
| n = input()
lis = map(int, raw_input().split())
mn = lis[0]
mx = lis[0]
for t in lis:
if mn > t:
mn = t
if mx < t:
mx = t
print "%s %s %s" % (mn, mx, sum(lis)) | 1 | 735,662,835,490 | null | 48 | 48 |
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
if A < B:
if A + (V*T) >= B + (W*T):
print("YES")
else:
print("NO")
else:
if A - (V*T) <= B - (W*T):
print("YES")
else:
print("NO") | raw_input()
a = raw_input().split(" ")
a.reverse()
print " ".join(a) | 0 | null | 7,983,827,604,310 | 131 | 53 |
N ,K = map(int,input().split())
Ps = list(map(int,input().split()))
Ps.sort()
ans = 0
for i in range(K):
ans += Ps[i]
print(ans)
| s = str(input())
#print(s[0]+s[1])
hitati = "hi"
for i in range(5):
if s == hitati:
print("Yes")
exit()
else:
hitati += "hi"
print("No") | 0 | null | 32,518,993,751,200 | 120 | 199 |
S = int(input())
if S<3:
print(0)
exit()
clear = 0
memory = dict()
def hoge(S):
clear = 0
i = 3
while True:
if (S-i)==0:
clear+=1
break
elif S-i in memory:
clear += memory[S-i]
elif S-i>=3:
memory[S-i] = hoge(S-i)
clear += memory[S-i]
i += 1
return clear
print(hoge(S)%(10**9+7))
| n = int(input())
a = [i for i in range(1,n+1) if (i%3==0 or "3" in list(str(i)))]
print(" ",end="")
print(*a,sep=" ")
| 0 | null | 2,096,943,902,240 | 79 | 52 |
# coding: utf-8
s = input()
print("x" * len(s))
| import sys
# import bisect
# from collections import Counter, deque, defaultdict
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
# import itertools
# from operator import attrgetter, itemgetter
# import math
# from numba import jit
# from scipy import
# import numpy as np
# import networkx as nx
# import matplotlib.pyplot as plt
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
class SegmentTree:
def __init__(self, array, operator, identity):
self.identity = identity
self.operator = operator
self.array_size = len(array)
self.tree_height = (self.array_size - 1).bit_length()
self.tree_size = 2 ** (self.tree_height + 1)
self.leaf_start_index = 2 ** self.tree_height
self.tree = [self.identity] * self.tree_size
for i in range(self.array_size):
x = 1 << (ord(array[i]) - 96)
self.tree[self.leaf_start_index + i] = x
for i in range(self.leaf_start_index - 1, 0, -1):
self.tree[i] = self.operator(self.tree[i << 1], self.tree[i << 1 | 1])
def update(self, index, val):
x = 1 << (ord(val) - 96)
cur_node = self.leaf_start_index + index
self.tree[cur_node] = x
while cur_node > 1:
self.tree[cur_node >> 1] = self.operator(self.tree[cur_node], self.tree[cur_node ^ 1])
cur_node >>= 1
def query(self, begin, end):
if begin < 0:
begin = 0
elif begin > self.array_size:
return self.identity
if end > self.array_size:
end = self.array_size
elif end < 1:
return self.identity
res = self.identity
left = begin + self.leaf_start_index
right = end + self.leaf_start_index
while left < right:
if left & 1:
res = self.operator(res, self.tree[left])
left += 1
if right & 1:
right -= 1
res = self.operator(res, self.tree[right])
left >>= 1
right >>= 1
return res
def main():
from operator import or_
n = int(input())
s = input()
q = int(input())
seg = SegmentTree(s, or_, 0)
for i in range(q):
q1, q2, q3 = readline().split()
q1, q2 = int(q1), int(q2)
if q1 == 1:
seg.update(q2-1, q3.rstrip("\n"))
else:
q3 = int(q3)
print(bin(seg.query(q2-1, q3)).count("1"))
if __name__ == '__main__':
main()
| 0 | null | 67,873,778,195,068 | 221 | 210 |
s = input().split(" ")
r = int(s[0])
c = int(s[1])
a = [[0 for i in range(c)] for j in range(r+1)]
for i in range(r):
s = input().split(" ")
for j in range(c):
a[i][j] = int(s[j])
for i in range(c):
sk = 0
for j in range(r):
sk += a[j][i]
a[r][i] = sk
for i in range(r+1):
sk = 0
for j in range(c):
print(a[i][j],end=" ")
sk += a[i][j]
print(sk) | r, c = map(int, input().strip().split())
l = [[0 for j in range(c+1)] for i in range(r+1)]
for i in range(r):
l[i] = list(map(int, input().strip().split()))
l[i].append(sum(l[i][0:c]))
l[r] = [l[r][j] + l[i][j] for j in range(c+1)]
print(' '.join(map(str,l[i])))
print(' '.join(map(str,l[r]))) | 1 | 1,337,090,718,656 | null | 59 | 59 |
import itertools
h, w, k = map(int, input().split())
a = []
for i in range(h):
s = input()
a.append(s)
s = [[0 for i in range(w)] for i in range(h)]
ans = h+w
for grid in itertools.product([0,1], repeat=h-1):
ary = [[0]]
for i in range(h-1):
if grid[i] == 1:
ary.append([i+1])
else:
ary[-1].append(i+1)
# print (grid, ary)
wk = 0
for i in grid:
if i == 1:
wk += 1
# print (wk)
cnt = [0] * len(ary)
for j in range(w):
for ii, g in enumerate(ary):
for b in g:
if a[b][j] == '1':
cnt[ii] += 1
if any(W > k for W in cnt):
wk += 1
cnt = [0] * len(ary)
for ii, g in enumerate(ary):
for jj in g:
if a[jj][j] == '1':
cnt[ii] += 1
if any(W > k for W in cnt):
wk = h+w
break
ans = min(ans, wk)
print (ans) | a,b,c=map(int,input().split())
x="Yes" if a<b and a<c and b<c else "No"
print(x)
| 0 | null | 24,425,912,046,158 | 193 | 39 |
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 # (string,3) 3回
from collections import deque
from collections import defaultdict
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
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
dic = {'SUN':0,'MON':1,'TUE':2,'WED':3,'THU':4,'FRI':5,'SAT':6}
print(7 - dic[input()])
| week_list =["","SAT","FRI","THU","WED","TUE","MON","SUN"]
print(week_list.index(input())) | 1 | 133,003,137,172,672 | null | 270 | 270 |
def main():
import sys
input = sys.stdin.readline
inf = 1 << 60
N, M, L = map(int, input().split())
dist = [[inf] * N for _ in range(N)]
for _ in range(M):
A, B, C = map(int, input().split())
A -= 1
B -= 1
dist[A][B] = dist[B][A] = C
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(
dist[i][j],
dist[i][k] + dist[k][j]
)
g = [[inf] * N for _ in range(N)] # 到達に必要な補充回数
for A in range(N):
for B in range(N):
if dist[A][B] <= L:
g[A][B] = 1
for k in range(N):
for i in range(N):
for j in range(N):
g[i][j] = min(
g[i][j],
g[i][k] + g[k][j]
)
Q = int(input())
for _ in range(Q):
s, t = (int(x) - 1 for x in input().split())
d = g[s][t]
if d == inf:
print(-1)
else:
print(d - 1)
if __name__ == '__main__':
main()
| x, n = map(int, input().split())
p = list(map(int, input().split()))
i = 0
while True:
if x-i not in p:
print(x-i)
break
if x+i not in p:
print(x+i)
break
i += 1 | 0 | null | 93,413,595,309,540 | 295 | 128 |
# -*- coding: utf-8 -*-
import itertools
N, K = map(int, input().split())
a = [0] * (N+1)
for i in range(N+1):
a[i] = i
max_total = 0
min_total = 0
ans = 0
for k in range(K, N+2):
# 和の最大(10**100 は無視): 大きい順にk個選んだ場合
max_total = k * ((N-k+1) + N) // 2
# 和の最小(10**100 は無視): 小さい順にk個選んだ場合
min_total = k * (0 + (k-1)) // 2
# 最小と最大の間は全パターン取り得るので差が個数になる
ans += (max_total - min_total + 1)
print(ans % (10**9 + 7)) | def solve():
N, K = map(int, input().split())
mod = 10**9+7
ans = 0
for k in range(K,N+2):
ans += (N+N-k+1)*k//2-k*(k-1)//2+1
ans %= mod
return ans
print(solve()) | 1 | 32,954,460,510,632 | null | 170 | 170 |
import math
n, d = map(int, input().split(" "))
ans = 0
for i in range(n):
x, y = map(int, input().split(" "))
double = x ** 2 + y ** 2
root = math.sqrt(double)
if root <= d:
ans += 1
print(ans)
| n , d = map(int, input().split())
x = []
y = []
for i in range(n):
a = list(map(int, (input().split())))
x.append(a[0])
y.append(a[1])
ans = 0
for i in range(n):
if (x[i] ** 2 + y[i] ** 2) ** (0.5) <= d:
ans += 1
print(ans) | 1 | 5,970,111,507,798 | null | 96 | 96 |
import itertools
Row = int(input())
List = []
l=[]
for i in range (Row):
l.append(i+1)
List.append(list(map(int, input().split())))
x = 0
y = 0
mid = 0
p_list = list(itertools.permutations(l, Row))
for v in p_list:
for i in range(1,Row):
x = List[v[i]-1][0]-List[v[i-1]-1][0]
y = List[v[i]-1][1]-List[v[i-1]-1][1]
k = x*x+y*y
mid += k**0.5
res = mid / len(p_list)
print(res) | N,K = map(int,input().split())
min = 0
max = 0
ans = 0
for i in range(K,N+2):
min = i*(i-1)//2
max = i*(2*N-i+1)//2
ans += max-min+1
ans %= (10**9+7)
print(int(ans))
| 0 | null | 90,336,934,378,432 | 280 | 170 |
X=int(input())
cnt=0
for i in range(1,10**7):
cnt+=X
if cnt%360==0:
print(i)
break | import math
T_1, T_2 = map(int, input().split())
A_1, A_2 = map(int, input().split())
B_1, B_2 = map(int, input().split())
ans = 0
if T_1 * A_1 + T_2 * A_2 == T_1 * B_1 + T_2 * B_2:
print("infinity")
else:
# 速いほうをＡと仮定
if T_1 * A_1 + T_2 * A_2 < T_1 * B_1 + T_2 * B_2:
A_1, A_2, B_1, B_2 = B_1, B_2, A_1, A_2
if A_1 < B_1:
sa_12 = T_1 * A_1 + T_2 * A_2 - (T_1 * B_1 + T_2 * B_2) # 1サイクルでできる差
sa_1 = -T_1 * A_1 + T_1 * B_1 # T_1でできる差
if sa_1 % sa_12 == 0:
ans = int((sa_1 / sa_12)*2)
else:
kari = math.ceil(sa_1 / sa_12)
ans = (kari-1)*2+1
print(ans)
| 0 | null | 72,172,002,704,308 | 125 | 269 |
def get_cusum(lst):
cusum = [0] + lst
for i in range(1, len(cusum)):
cusum[i] = cusum[i] + cusum[i-1]
return cusum
def main():
n, m, k = map(int, input().split(" "))
book_a = get_cusum(list(map(int, input().split(" "))))
book_b = get_cusum(list(map(int, input().split(" "))))
ans = 0
top = m
# print(book_a)
# print(book_b)
for i in range(n + 1):
if book_a[i] > k:
break
while book_b[top] > k - book_a[i]:
top -= 1
ans = max(ans, i+top)
print(ans)
main()
| from sys import stdin
def readline_from_stdin() -> str:
return stdin.readline().rstrip
if __name__ == '__main__':
N, K, = input().split()
A = [int(i) for i in input().split()]
N, K = int(N), int(K)
for i in range(N-K):
if A[i] < A[K+i]:
print("Yes")
else:
print("No") | 0 | null | 8,915,244,894,320 | 117 | 102 |
import math
while True:
N = int(input())
if N == 0:
break
S = list(map(int, input().split()))
S2 = [x ** 2 for x in S]
V = sum(S2)/N - (sum(S)/N) ** 2
print(math.sqrt(V)) | while 1:
r=0
S=0
n=int(input())
if n==0:break
s=list(map(int,input().split()))
a=(sum(s)/n)
for i in s:
S=((a-i)**2)/n
r+=S
print(r**0.5) | 1 | 189,869,737,092 | null | 31 | 31 |
a = input()
b = a[:3]
print(b) | full = input()
num = 0
for i in full:
if num < 3:
num += 1
print(i, end="") | 1 | 14,807,239,086,980 | null | 130 | 130 |
num = int(input())
A = input().split(" ")
B = A.copy()
#bubble sort
for i in range(num):
for j in range(num-1,i,-1):
#英字ではなく、数字で比較する
m1 = int(A[j][1:])
m2 = int(A[j-1][1:])
if m1 < m2:
A[j],A[j-1] = A[j-1],A[j]
print(*A)
print("Stable")
#selection sort
for i in range(num):
minv = i
for j in range(i+1,num):
m1 = int(B[minv][1:])
m2 = int(B[j][1:])
if m1 > m2:
minv = j
B[i],B[minv] = B[minv],B[i]
print(*B)
if A == B:
print("Stable")
else:
print("Not stable")
| N=int(input())
d=list(map(int,input().split()))
a=0
for i in range(N):
for k in range(1,N-i):
a=a+d[i]*d[i+k]
print(a) | 0 | null | 84,409,184,060,026 | 16 | 292 |
#!/usr/bin/env python3
def main():
N, K = map(int, input().split())
H = sorted([int(x) for x in input().split()])
if K == 0:
print(sum(H))
elif N > K:
print(sum(H[:-K]))
else:
print(0)
if __name__ == '__main__':
main()
| 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])) | 1 | 78,781,617,629,450 | null | 227 | 227 |
from math import sqrt
N = int(input())
def f(x):
n = N
while n % x == 0:
n //= x
return n % x == 1
ans = 1
for k in range(2, int(sqrt(N)) + 1):
res = N % k
if res == 0:
k1, k2 = k, N // k
ans += 1 if f(k1) else 0
ans += 1 if k1 != k2 and f(k2) else 0
elif res == 1:
ans += 1 if k == (N - 1) // k else 2
if N >= 3:
ans += 1
print(ans)
| r = input()
if len(r) & 1:
print("No")
else:
for i in range(0, len(r), 2):
if not (r[i] == 'h' and r[i + 1]=='i'):
print("No")
exit()
print("Yes") | 0 | null | 47,298,774,648,208 | 183 | 199 |
from collections import Counter
n = int(input())
c = list(input())
count = Counter(c)
ans = float('inf')
w = 0
r = 0
if count.get('R'):
r = count['R']
ans = max(w, r)
for i in range(n):
if c[i]=='W':
w += 1
else:
r -= 1
ans =min(max(w,r), ans)
print(ans) | n = int(input())
s = input().rstrip()
i=0
j=n-1
c= 0
while i!=j:
while s[j]!='R' and j>i:
j-=1
while s[i]=='R' and j>i:
i+=1
if i!=j:
c+= 1
i+= 1
j-=1
if i>=j:
break
print(c) | 1 | 6,348,553,860,376 | null | 98 | 98 |
N, P = map(int, input().split())
S = [int(i) for i in input()]
from collections import Counter
def solve(S,N,P):
if P==2 or P==5:
ans = 0
for i in range(N):
if S[i]%P==0:
ans += i+1
return ans
cum = [0]*(N+1)
mods = [0]*N
mods[0] = 1
for i in range(1,N):
mods[i] = mods[i-1]*10%P
for i in range(N):
cum[i+1] = (cum[i]+S[N-1-i]*mods[i])%P
c = Counter(cum)
ans = 0
for v in c.values():
ans += v*(v-1)//2
return ans
print(solve(S,N,P))
| from math import ceil
def main():
width = int(input())
height = int(input())
lower_limit = int(input())
print(ceil(lower_limit / max(width, height)))
if __name__ == '__main__':
main()
| 0 | null | 73,601,544,919,620 | 205 | 236 |
# Date [ 2020-08-23 14:02:31 ]
# Problem [ e.py ]
# Author Koki_tkg
# After Contest
import sys; from decimal import Decimal
import math; from numba import njit, i8, u1, b1
import bisect; from itertools import combinations, product
import numpy as np; from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(x=0): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def lcm(a: int, b: int) -> int: return (a * b) // math.gcd(a, b)
def solve(h,w,bomb):
row = np.zeros(h, dtype=np.int64)
column = np.zeros(w, dtype=np.int64)
for y, x in bomb:
row[y] += 1
column[x] += 1
max_row = np.max(row)
max_col = np.max(column)
val = max_row + max_col
max_row_lis = np.ravel(np.where(row == row.max()))
max_col_lis = np.ravel(np.where(column == column.max()))
for r in max_row_lis:
for c in max_col_lis:
if (r, c) not in bomb:
return val
return val - 1
def Main():
h, w, m = read_ints()
bomb = set([tuple(read_ints(x=1)) for _ in range(m)])
print(solve(h, w, bomb))
if __name__ == '__main__':
Main() | h,w,m=map(int,input().split())
r=[0]*h
c=[0]*w
s=set()
for _ in range(m):
i,j=map(int,input().split())
i-=1
j-=1
r[i]+=1
c[j]+=1
s.add(i*w+j)
rmx=max(r)
cmx=max(c)
rc=[i for i in range(h) if r[i]==rmx]
cc=[j for j in range(w) if c[j]==cmx]
ans=rmx+cmx-1
for i in rc:
for j in cc:
if i*w+j not in s:
print(ans+1)
exit()
print(ans)
| 1 | 4,744,822,280,732 | null | 89 | 89 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K, *H = map(int, read().split())
H.sort(reverse=True)
print(sum(H[K:]))
return
if __name__ == '__main__':
main()
| '''
@sksshivam007 - Template 1.0
'''
import sys, re, math
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx): return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))[::-1]
toret = {}
for tup in temp:
toret[tup[0]] = tup[1]
return toret
def sortDictWithKey(passedDic):
return dict(OrderedDict(sorted(passedDic.items())))
INF = float('inf')
mod = 10 ** 9 + 7
n, k = MAP()
a = [0]*(k+1)
for i in range(k, 0, -1):
temp = pow((k//i), n, mod)
ans = temp%mod
for j in range(2, k//i + 1):
ans -= a[j*i]%mod
a[i] = ans%mod
final = 0
for i in range(len(a)):
final+=(a[i]*i)%mod
print(final%mod) | 0 | null | 58,175,202,881,138 | 227 | 176 |
x,k,d = list(map(int,input().split()))
x = abs(x)
point =x % d
num = x//d
if num<k:
rest = k - num
if rest%2==0:
pass
else:
point = d -point
else:
point = x - k*d
print(point) | x, k, d = map(int, input().split())
cur = x
numTimes = x // d
if numTimes == 0:
cur -= d
k -= 1
else:
numTimes = min(abs(numTimes), k)
if x < 0:
numTimes *= -1
cur -= numTimes * d
k -= numTimes
if k % 2 == 0:
print(abs(cur))
else:
result = min(abs(cur - d), abs(cur + d))
print(result) | 1 | 5,219,676,164,752 | null | 92 | 92 |
import math
while True:
n = int(input())
if n == 0 :
break
nums = [int(x) for x in input().split(" ")]
mean = sum(nums) / n
variance = sum([(x - mean) ** 2 for x in nums]) / n
std = math.sqrt(variance)
print(std) | from math import sqrt
sigma=[]
while True:
total=0
nval=0
n=int(input())
if n==0:
break
score_list=map(float,raw_input().split(" "))
for i in score_list:
total+=i
average=total/n
for i in score_list:
nval+=(average-i)**2
val=nval/n
sigma.append(sqrt(val))
for i in sigma:
print i | 1 | 188,271,300,796 | null | 31 | 31 |
# https://atcoder.jp/contests/abc165/tasks/abc165_c
from itertools import combinations_with_replacement
N, M, Q = map(int, input().split())
data = []
for _ in range(Q):
data.append(list(map(int, input().split())))
res = []
for A in combinations_with_replacement(range(1,M+1), N):
score = 0
for i in range(Q):
a,b,c,d = data[i]
if A[b-1] - A[a-1] == c:
score += d
res.append(score)
print(max(res)) | s=input()
li=list(s)
adana_li=[]
for i in range(3):
adana_li.append(li[i])
adana=li[0]+li[1]+li[2]
print(adana) | 0 | null | 21,272,591,665,922 | 160 | 130 |
S = input()
if S[-1] == "s":
S += "es"
else:
S += "s"
print(S) | a=input()
e=a[len(a)-1:len(a)]
if e == "s":
print(a+"es")
else:
print(a+"s") | 1 | 2,411,147,852,252 | null | 71 | 71 |
n = input()
Max = -4300000000
Min = input()
for i in range(n - 1):
IN_NOW = input()
Max = max(Max, (IN_NOW - Min))
Min = min(Min, IN_NOW)
print Max | import math
n = input()
print(math.ceil((int(n)-2)/2)) | 0 | null | 76,929,510,120,736 | 13 | 283 |
import sys
from collections import deque
def main():
N, p, q, *AB = map(int, sys.stdin.buffer.read().split())
p -= 1
q -= 1
G = [[] for _ in range(N)]
for a, b in zip(*[iter(AB)] * 2):
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
if len(G[p]) == 1 and G[p][0] == q:
print(0)
return
dist1 = [-1] * N
dist1[p] = 0
queue = deque([p])
while queue:
v = queue.popleft()
for nv in G[v]:
if dist1[nv] == -1:
dist1[nv] = dist1[v] + 1
queue.append(nv)
dist2 = [-1] * N
dist2[q] = 0
queue = deque([q])
while queue:
v = queue.popleft()
for nv in G[v]:
if dist2[nv] == -1:
dist2[nv] = dist2[v] + 1
queue.append(nv)
max_d = 0
for d1, d2 in zip(dist1, dist2):
if d1 < d2 and max_d < d2:
max_d = d2
print(max_d - 1)
return
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
n,u,v=map(int, input().split())
u-=1
v-=1
es=[[] for i in range(n)]
for i in range(n-1):
a0,b0=map(int, input().split())
es[a0-1].append(b0-1)
es[b0-1].append(a0-1)
aoki=[-1]*n
aoki[v]=0
choku=[-1]*n
choku[u]=0
from collections import deque
que=deque([])
que.append(u)
while que:
now=que.popleft()
step=choku[now]
for e in es[now]:
if choku[e]==-1:
choku[e]=step+1
que.append(e)
que=deque([])
que.append(v)
while que:
now=que.popleft()
step=aoki[now]
for e in es[now]:
if aoki[e]==-1:
aoki[e]=step+1
que.append(e)
end=None
for i in range(n):
if len(es[i])==1:
if choku[i]==0 and aoki[i]==1:
print(0)
exit()
elif end==None and aoki[i]>choku[i]:
end=(i, aoki[i])
elif aoki[i]>choku[i] and end[1]<aoki[i]:
end=(i, aoki[i])
print(end[1]-1) | 1 | 117,492,328,605,300 | null | 259 | 259 |
N = int(input())
A = list(map(int, input().split()))
ary = [0]*(N-1)
for i in reversed(range(N-1)):
if i+1 >= (N-1):
ary[i] = A[N-1]
else:
ary[i] = ary[i+1] + A[i+1]
s = 0
for i in range(N-1):
s += A[i]*ary[i]
print(s%(10**9+7)) | # python3
# -*- coding: utf-8 -*-
import sys
import math
import bisect
from fractions import gcd
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
INF = float('inf')
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
lmtx = lambda h: [list(map(int, lmis())) for _ in range(h)]
sys.setrecursionlimit(1000000000)
def lcm(a, b):
return (a * b) // gcd(a, b)
# main
n = ii()
alist = lmis()
asum = sum(alist[1:n])
sum = 0
for i in range(n-1):
sum += alist[i] * asum
asum -= alist[i+1]
print(sum % 1000000007)
| 1 | 3,811,947,837,490 | null | 83 | 83 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.