code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
N = int(input())
A = list(map(int, input().split()))
res = "APPROVED"
for i in A:
if i % 2 == 0:
if i % 3 != 0 and i % 5 != 0:
res = "DENIED"
print(res) | import sys
N = int(input())
lsA = list(map(int,input().split()))
for i in range(N):
if lsA[i] % 2 == 0:
if lsA[i] % 3 == 0 or lsA[i] % 5 == 0:
continue
else:
print('DENIED')
sys.exit()
print('APPROVED') | 1 | 69,011,884,021,344 | null | 217 | 217 |
N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H = sorted(H, reverse=True)
for i in range(min(K,len(H))):
H[i] = 0
print(sum(H)) | teki, hissatsu = list(map(int, input().split(' ')))
l = sorted(list(map(int, input().split(' '))))[:max(0, teki-hissatsu)]
print(sum(l)) | 1 | 79,223,450,010,850 | null | 227 | 227 |
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
n, k = inm()
count = 1
ans = 0
while count <= n:
count *= k
ans += 1
print(ans) | n = int(input())
cl = str(input())
cl_R = cl.count("R")
# print(cl_R)
cl_leftR = cl[:cl_R].count("R")
# print(cl_leftR)
print(cl_R-cl_leftR) | 0 | null | 35,332,678,810,880 | 212 | 98 |
import random
S=input()
r = random.randint(0,len(S)-3)
result =""
result = S[r]+S[r+1]+S[r+2]
print(result)
| n = input().split()
x = int(n[0])
y = int(n[1])
if x < y:
bf = x
x = y
y = bf
while y > 0:
r = x % y
x = y
y = r
print(str(x)) | 0 | null | 7,327,109,086,098 | 130 | 11 |
h, w = map(int, input().split())
print(1) if h == 1 or w == 1 else print((h * w) // 2 + (w * h) % 2) | import collections
N=int(input())
if N==1:
print(0)
exit()
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
c = collections.Counter(prime_factorize(N))
s=list(set(prime_factorize(N)))
ans=0
def a(n):
return (1/2)*n*(n+1)
def f(n):
ans=0
x=1
while n>=a(x):
x+=1
ans+=1
return ans
for i in s:
x=c[i]
ans+=f(x)
print(ans)
| 0 | null | 33,742,444,049,440 | 196 | 136 |
n,x,y = map(int,input().split())
ans = [0]*n
for i in range(1,n+1):
for j in range(i+1,n+1):
if i <= x and j >= y:
a = abs(j-i)-abs(y-x)+1
b = abs(i-x)+abs(j-y)+1
ans[min(a,b)] += 1
else:
c = abs(x-i)+abs(y-j)+1
d = abs(j-i)
ans[min(c,d)] += 1
for i in range(1,n):
print(ans[i])
| n,x,y = map(int, input().split())
lis = [0] * n
x -= 1
y -= 1
for i in range(n):
for j in range(i+1, n):
t = min(abs(i-j), abs(i-x)+abs(j-y)+1,abs(i-y)+abs(j-x)+1)
lis[t] += 1
for i in range(1,n):
print(lis[i]) | 1 | 44,149,305,651,848 | null | 187 | 187 |
S = input()
T = input()
max_match = 0
n = len(T)
m = len(S)
for i in range(m-n+1):
tmp = 0
for j in range(i,i+n):
if S[j] == T[j-i]:
tmp += 1
if tmp > max_match:
max_match = tmp
ans = n - max_match
print(ans) | def rvrs(base, start, end):
r = base[int(start):int(end) + 1][::-1]
return base[:int(start)] + r + base[int(end) + 1:]
def rplc(base, start, end, string):
return base[:int(start)] + string + base[int(end) + 1:]
ans = input()
q = int(input())
for _ in range(q):
ORD = list(input().split())
if ORD[0] == 'print':
print(ans[int(ORD[1]):int(ORD[2])+1])
elif ORD[0] == 'reverse':
ans = rvrs(ans, int(ORD[1]), int(ORD[2]))
elif ORD[0] == 'replace':
ans = rplc(ans, int(ORD[1]), int(ORD[2]), ORD[3])
| 0 | null | 2,891,822,108,120 | 82 | 68 |
import fractions
from functools import reduce
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
N, M = map(int, input().split())
A = list(map(int, input().split()))
for i in range(N):
A[i] = A[i] // 2
p = 0
de_2 = 0
x = A[0]
while (p == 0):
if x % 2 == 0:
x = x // 2
de_2 += 1
else:
p = 1
de = 2 ** de_2
for i in range(1, N):
if A[i] % de == 0:
if A[i] % (de * 2) != 0:
continue
else:
print("0")
quit()
else:
print("0")
quit()
lcm = lcm_list(A)
p = M // lcm
if p % 2 == 0:
ans = p // 2
else:
ans = (p + 1) // 2
print(ans)
| a,b = map(int,input().split())
print(a//b,a%b,"{:.5f}".format(a/b))
| 0 | null | 51,223,888,741,410 | 247 | 45 |
# -*- coding: utf-8 -*-
# モジュールのインポート
import sys
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
N = int(input())
x, y = [], []
for i in range(N):
x_i, y_i = list(map(int, input().split()))
x.append(x_i)
y.append(y_i)
return N, x, y
def main(N: int, x: list, y: list) -> None:
"""
メイン処理.
Args:\n
N (int): 点の数(2 <= N <= 2 * 10**5)
x (list): x座標(1 <= x_i <= 10**9)
y (list): y座標(1 <= y_i <= 10**9)
"""
# 求解処理
max_z = -sys.maxsize
min_z = sys.maxsize
max_w = -sys.maxsize
min_w = sys.maxsize
for x_i, y_i in zip(x, y):
z_i = x_i + y_i
max_z = max(max_z, z_i)
min_z = min(min_z, z_i)
w_i = x_i - y_i
max_w = max(max_w, w_i)
min_w = min(min_w, w_i)
ans = max(max_z - min_z, max_w - min_w)
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, x, y = get_input()
# メイン処理
main(N, x, y)
| n = int(input())
s = []
for i in range(n):
x, y = map(int, input().split())
s.append([x + y, x - y])
t = sorted(s)
u = sorted(s, key=lambda x: x[1])
res = 0
tmp1 = t[-1][0] - t[0][0]
tmp2 = u[-1][1] - u[0][1]
print(max(tmp1, tmp2))
| 1 | 3,444,836,574,428 | null | 80 | 80 |
class Stack:
def __init__(self, full_idx=10):
self.stack = [None] * full_idx
self.top = 0
self.MAX = full_idx
def is_empty(self):
return self.top == 0
def is_full(self):
return self.top >= self.MAX - 1
def push(self, x):
if self.is_full():
raise IndexError
self.top += 1
self.stack[self.top] = x
def pop(self):
if self.is_empty():
raise IndexError
self.top -= 1
return self.stack[self.top+1]
def main():
s = input()
s1, s2 = Stack(20000), Stack(20000)
pond = [0]
area = 0
for i in range(len(s)):
if s[i] == "\\":
s1.push(i)
s2.push([i, 0])
elif s[i] == "/":
if not s1.is_empty():
area += i - s1.pop()
if not s2.is_empty():
tup = s2.pop()
area2 = 0
while tup[1] != 0:
tup2 = s2.pop()
tup, tup2 = tup2, tup
area2 += tup2[1]
tup[1] = i - tup[0] + area2
if s2.is_empty():
pond.append(tup[1])
else:
s2.push(tup)
s3 = Stack(20000)
while not s2.is_empty():
ss = s2.pop()
if ss[1] != 0:
s3.push(ss)
while not s3.is_empty():
pond.append(s3.pop()[1])
pond[0] = len(pond) - 1
print(area)
print(" ".join([str(i) for i in pond]))
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import fractions
def lcm(A):
value = A[0]
for i in range(1, len(A)):
value = value * A[i] // fractions.gcd(value, A[i])
return value
A = list(map(int, input().split()))
print(lcm(A))
| 0 | null | 56,978,905,728,928 | 21 | 256 |
N = int(input())
xy = [list(map(int,input().split())) for i in range(N)]
print(sum(((xi-xj)**2 + (yi-yj)**2) **0.5 for xi,yi in xy for xj,yj in xy) / N)
| import itertools
N = int(input())
c = []
d = 0
for i in range(N):
x1, y1 = map(int, input().split())
c.append((x1,y1))
cp = list(itertools.permutations(c))
x = len(cp)
for i in range(x):
for j in range(N-1):
d += ((cp[i][j][0]-cp[i][j+1][0])**2 + (cp[i][j][1] - cp[i][j+1][1])**2)**0.5
print(d/x) | 1 | 148,578,939,720,608 | null | 280 | 280 |
def main(R,C,K,V):
dp = [0]*(4*R*C)
dp[1+4*0+4*C*0] = V[0][0]
for k in range(4*R*C):
n = k%4
j = k//4%C
i = k//(4*C)
if n!=0:
if i != 0 and n==1:
dp[k] = max(dp[k-4*C-n:k-4*C-n+4])+V[i][j]
if j != 0:
dp[k] = max(dp[k],dp[k-4],dp[k-5]+V[i][j])
if n==0:
if i != 0:
dp[k] = max(dp[k-4*C-n:k-4*C-n+4])
print(max(dp[-5:-1]))
if __name__ == '__main__':
R,C,K = map(int,input().split())
C += 1
rcv = [list(map(int,input().split())) for _ in range(K)]
V = [[0]*C for _ in range(R)]
for i in range(K):
r,c,v = rcv[i]
r -= 1
c -= 1
V[r][c] = v
main(R,C,K,V) | import sys
from collections import deque
import bisect
import copy
import heapq
import itertools
import math
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
def main():
R, C, K = read_values()
V = [0] * (R * C)
for _ in range(K):
r, c, v = read_values()
r -= 1
c -= 1
V[r * C + c] = v
dp = [0 for _ in range(R * C * 4)]
for i in range(R * C):
r = i // C
c = i % C
if c + 1 < C:
# not take
for k in range(4):
dp[4 * (i + 1) + k] = max(dp[4 * (i + 1) + k], dp[4 * i + k])
# take
for k in range(3):
dp[4 * (i + 1) + k + 1] = max(dp[4 * (i + 1) + k + 1], dp[4 * i + k] + V[i])
# next r
if r + 1 < R:
for k in range(4):
dp[4 * (i + C)] = max(dp[4 * (i + C)], dp[4 * i + k] + (V[i] if k < 3 else 0))
res = 0
for k in range(4):
res = max(res, dp[4 * (R * C - 1) + k] + (V[-1] if k < 3 else 0))
print(res)
if __name__ == "__main__":
main()
| 1 | 5,588,568,240,930 | null | 94 | 94 |
class Building(object):
def __init__(self):
self.floor = []
self.floor.extend([[0] * 10])
self.floor.extend([[0] * 10])
self.floor.extend([[0] * 10])
def change_resident(self, f, r, v):
self.floor[f][r] += v
def print_status(self):
for f in self.floor:
print(' {0}'.format(' '.join(map(str, f))))
if __name__ == '__main__':
# ?????????4?£??????????
buildings = []
for i in range(4):
buildings.append(Building())
# ??????????????\???
data_num = int(input())
data = []
for i in range(data_num):
data.append([int(x) for x in input().split(' ')])
# ??\?±?????????´??°
for d in data:
b = d[0]
f = d[1]
r = d[2]
v = d[3]
buildings[b-1].change_resident(f-1, r-1, v)
# ?????????????????¨???
buildings[0].print_status()
print('#' * 20)
buildings[1].print_status()
print('#' * 20)
buildings[2].print_status()
print('#' * 20)
buildings[3].print_status() | l=[[[0 for i in range(10)]for j in range(3)]for k in range(4)]
s='#'*20
n=input()
for i in range(n):b,f,r,v=map(int,raw_input().split());l[b-1][f-1][r-1]+=v
for i in range(4):
for j in range(-3,0):print ' '+' '.join(map(str,l[i][j]))
if i<3:print s | 1 | 1,100,283,975,770 | null | 55 | 55 |
#####################################################
# 組み合わせを10**9+7で割った余り、を高速に求めるアルゴリズム
# https://drken1215.hatenablog.com/entry/2018/06/08/210000
# https://qiita.com/derodero24/items/91b6468e66923a87f39f
# 全然理解できていない
MOD = 10**9 + 7
def comb(n, r):
if (r < 0 and r > n):
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % MOD
N = 10**6
# 元テーブル
g1 = [1, 1]
# 逆元テーブル
g2 = [1, 1]
# 逆元テーブル計算用テーブル
inverse = [0, 1]
for i in range(2, N + 1):
g1.append((g1[-1] * i) % MOD)
inverse.append((-inverse[MOD % i] * (MOD // i)) % MOD)
g2.append((g2[-1] * inverse[-1]) % MOD)
#####################################################
X, Y = map(int, input().split())
# X+Yが3の倍数のマスしか通りえない
if not (X + Y) % 3:
# (1,2)移動をn回、(2,1)移動をm回したとする
# n+2m = X, 2n+m = Y
# → n+m = (X+Y)/3
# n = (2n+m)-(n+m) = X - (X+Y)/3 = (-X+2Y)/3
# mも同様
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n >= 0 and m >= 0:
print(comb(n + m, n))
else:
print(0)
# X+Yが3の倍数でない場合
else:
print(0)
| x,y=map(int,input().split())
mod = 10**9+7
flflag=True
if (2*x-y)%3==0:
a=(2*x-y)//3
else:
flflag=False
if (2*y-x)%3==0:
b=(2*y-x)//3
else:
flflag=False
def kaijou(n):
ans = 1
for i in range(1,n+1):
ans*=i%mod
ans%=mod
return ans
if flflag:
N=a+b
R=min(a,b)
ans=0
if flflag==True and a>=0 and b>=0:
ans=kaijou(N)
ans1= (kaijou(N-R)*kaijou(R))%mod
print((ans*pow(ans1,mod-2,mod))%mod)
else:
print(0) | 1 | 150,500,663,657,458 | null | 281 | 281 |
N = int(input())
ls = []
for i in range(N):
s = input()
ls.append(s)
newLs = list(set(ls))
print(len(newLs))
| #!/usr/bin/env python3
#coding: utf-8
# Volume0 - 0001 (http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0001)
li = []
for x in range(10):
s = input()
s = int(s)
li.append(s)
li.sort()
li.reverse()
for y in range(3):
print(li[y]) | 0 | null | 15,170,119,161,692 | 165 | 2 |
from math import gcd
n = int(input())
s = list(map(int, input().split()))
s.sort()
dp = [0] * ((10 ** 6) + 100)
res = s[0]
for ss in s:
dp[ss] += 1
res = gcd(res, ss)
A = max(s)
pairwise = True
setwise = (res == 1)
for i in range(2, A + 1):
cnt = 0
for j in range(i, A + 1, i):
cnt += dp[j]
if cnt > 1:
pairwise = False
break
if pairwise:
print("pairwise coprime")
elif setwise:
print("setwise coprime")
else:
print("not coprime")
| import math
def div(s):
i=1
while(i<=math.sqrt(s)):
if(s%i==0):
if(s//i==i):
if(i!=1):
if(i in d):
return False
else:
d[i]=1
else:
if(i!=1):
if(i in d):
return False
else:
d[i]=1
if(s//i!=1):
if(s//i in d):
return False
else:
d[s//i]=1
i+=1
#print(d,s)
return True
n=int(input())
l=list(map(int,input().split()))
d=dict()
setwise=False
pairWise=True
pairWise&=div(l[0])
pairWise&=div(l[1])
val=math.gcd(l[0],l[1])
for i in range(2,n):
pairWise&=div(l[i])
val=math.gcd(val,l[i])
if(pairWise):
print('pairwise coprime')
elif(val==1):
print('setwise coprime')
else:
print('not coprime')
| 1 | 4,128,500,749,010 | null | 85 | 85 |
S = input()
f = S[0]
if S.count(f) == 3 :
print('No')
else :
print('Yes') |
def main():
s = input()
if s[0]==s[1]==s[2]:
print("No")
else:
print("Yes")
if __name__ == "__main__":
main() | 1 | 54,666,927,724,932 | null | 201 | 201 |
a,b,c = map(int, raw_input().split(" "))
print "Yes" if a < b < c else "No" | 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() | 0 | null | 203,676,801,182 | 39 | 14 |
# Multiplication2
import math
N = int(input())
A = sorted(list(map(int,input().split())))
ans = 1
for a in A:
ans *= a
if ans == 0:
break
elif ans > 10**18:
ans = -1
break
print(ans) | N = int(input())
A = list(map(int, input().split()))
if 0 in A:
print(0)
exit()
else:
flag = True
prd = 1
A.sort(reverse=True)
for i in range(N):
prd *= A[i]
if prd > 10**18:
flag = False
break
if flag:
print(prd)
else:
print(-1) | 1 | 16,107,164,878,350 | null | 134 | 134 |
import sys
sys.setrecursionlimit(10**9)
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,M,L = map(int,readline().split())
ABC = [list(map(int,readline().split())) for _ in range(M)]
Q = int(readline())
ST = [list(map(int,readline().split())) for _ in range(Q)]
def warshall_floyd(d):
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
INF = 10**11
d = [[INF]*N for i in range(N)]
a = [[INF]*N for i in range(N)]
for x,y,z in ABC:
if z <= L:
d[x-1][y-1] = z
d[y-1][x-1] = z
for i in range(N):
d[i][i] = 0
a[i][i] = 1
chk = warshall_floyd(d)
for i in range(N-1):
for j in range(i+1,N):
if chk[i][j] <= L:
a[i][j] = 1
a[j][i] = 1
ans = warshall_floyd(a)
for s,t in ST:
answer = ans[s-1][t-1]
if answer == INF:
print(-1)
else:
print(answer-1) | n = int(input())
A = [(a, i) for i, a in enumerate(map(int, input().split()))]
A.sort(reverse=True)
dp = [[0]*(n+1) for _ in range(n+1)]
ans = 0
for L in range(n+1):
for R in range(n+1):
if n <= L+R-1:
continue
a, i = A[L+R-1]
if 0 <= R-1:
dp[L][R] = max(dp[L][R], dp[L][R-1]+abs((n-R)-i)*a)
if 0 <= L-1:
dp[L][R] = max(dp[L][R], dp[L-1][R]+abs(i-(L-1))*a)
ans = max(ans, dp[L][R])
print(ans)
| 0 | null | 103,595,028,309,312 | 295 | 171 |
s=list(input())
print(s[0]+s[1]+s[2]) | import collections
n,x,m=map(int,input().split())
if n==1 or x==0:
print(x)
exit()
start,end,loopcnt=0,0,0
a={x:0}
wk=x
for i in range(1,m):
wk=(wk*wk)%m
if not wk in a:
a[wk]=i
else:
start=a[wk]
end=i
break
a=sorted(a.items(),key=lambda x:x[1])
koteiindex=min(n,start)
koteiwa=0
for i in range(koteiindex):
koteiwa+=a[i][0]
loopcnt=(n-koteiindex)//(end-start)
loopindex=start-1+(n-koteiindex)%(end-start)
loopwa=0
amariwa=0
for i in range(start,end):
if i<=loopindex:
amariwa+=a[i][0]
loopwa+=a[i][0]
ans=koteiwa+loopwa*loopcnt+amariwa
print(ans)
| 0 | null | 8,808,014,632,268 | 130 | 75 |
if __name__ == "__main__":
S = input()
list_s = [s for s in S]
ans = 0
if list_s[0] == 'S' and list_s[1] == 'S' and list_s[2] == 'S':
ans = 0
elif list_s[0] == 'S' and list_s[1] == 'S' and list_s[2] == 'R':
ans = 1
elif list_s[0] == 'S' and list_s[1] == 'R' and list_s[2] == 'R':
ans = 2
elif list_s[0] == 'R' and list_s[1] == 'R' and list_s[2] == 'R':
ans = 3
elif list_s[0] == 'R' and list_s[1] == 'S' and list_s[2] == 'R':
ans = 1
elif list_s[0] == 'R' and list_s[1] == 'R' and list_s[2] == 'S':
ans = 2
elif list_s[0] == 'R' and list_s[1] == 'S' and list_s[2] == 'S':
ans = 1
elif list_s[0] == 'S' and list_s[1] == 'R' and list_s[2] == 'S':
ans = 1
print(ans)
| import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
n = int(input())
A = get_nums_l()
# スキップできる回数
p = 1 if n%2==0 else 2
# log(p)
# dp[i][j][k] i==1なら次取れる スキップ回数をj回残してk個目まで見たときの最大和
dp = [ [ [0]*(n+1) for _ in range(p+1) ] for _ in range(2) ]
dp[0][0][0] = -999999999999999999
dp[0][1][0] = -999999999999999999
dp[1][0][0] = -999999999999999999
if p == 2:
dp[0][2][0] = -999999999999999999
dp[1][1][0] = -999999999999999999
# log(dp)
for k in range(n):
dp[0][0][k+1] = dp[1][0][k] + A[k]
dp[0][1][k+1] = dp[1][1][k] + A[k]
dp[1][0][k+1] = max(dp[1][1][k], dp[0][0][k])
dp[1][1][k+1] = dp[0][1][k]
if p == 2:
dp[0][2][k+1] = dp[1][2][k] + A[k]
dp[1][2][k+1] = dp[0][2][k]
#dp[1][0][k+1] = max(dp[1][0][k+1], dp[1][1][k])
dp[1][1][k+1] = max(dp[1][1][k+1], dp[1][2][k])
# for a in dp:
# for b in a:
# log(b)
ans = [dp[0][0][n], dp[0][1][n], dp[1][0][n], dp[1][1][n]]
if p == 2:
# ans.append(dp[0][2][n])
ans.append(dp[1][2][n])
print(max(ans))
| 0 | null | 21,093,900,012,262 | 90 | 177 |
def atc_158a(input_value: str) -> str:
if input_value == "AAA" or input_value == "BBB":
return "No"
return "Yes"
input_value = input()
print(atc_158a(input_value)) | r = int(input())
x = 2*3.141592 * r
print(x) | 0 | null | 42,969,676,000,228 | 201 | 167 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
?????§?????????
FX????????§????????°?????????????????¨????????????????????¨??§????????????????????????????????¨?????§????????????
????????°????????????100???????????? 1000???????????????????????????????????? 1?????? 108???????????£??????????£??????¨???
(108??? ?????? 100???) ???? 1000?????? == 8000??????????????????????????¨?????§????????????
???????????¨????????????????????? t ?????????????????? Rt (t=0,1,2,,,n???1)???
??\?????¨??????????????????????????§??????????????? Rj???Ri (????????????j>i ??¨??????) ????????§??????
?±??????????????????????
"""
import math
# ?????????
n = int(input().strip())
a = []
for i in range(n):
a.append(int(input().strip()))
min = a[0]
cnt = -1000000000
for j in range(1,n):
x = a[j] - min
if cnt < x:
cnt = x
# print("cnt={0} min={1} Rj={2}".format(cnt,min,a[j]))
if min > a[j]:
min = a[j]
print(cnt) | N = int(input())
maxv = -2*10**10
minv = int(input())
for i in range(N-1):
_ = int(input())
maxv = max(maxv,_-minv)
minv = min(minv,_)
print(maxv)
| 1 | 14,241,440,120 | null | 13 | 13 |
s=list(input().split())
a=[]
for x in s:
if x in ['+','-','*']:
c,b=str(a.pop()),str(a.pop())
b+=x+c
a+=[int(eval(b))]
else:a+=[int(x)]
print(a.pop()) | n = int(input())
import math
l=0
for i in range(1,n+1):
for j in range(1,n+1):
p=math.gcd(i,j)
for k in range(1,n+1):
l+=math.gcd(p,k)
print(l)
| 0 | null | 17,792,060,468,420 | 18 | 174 |
n = int(input())
ss = [input() for _ in range(n)]
cnt = {}
ans =0
for s in ss:
if s not in cnt:
cnt[s]=0
ans += 1
print(ans)
| A,B = map(str,input().split())
A = int(A)
B1 = int(B[0])
B2 = int(B[-2])
B3 = int(B[-1])
ans = A*(100*B1+10*B2+B3)//100
print(int(ans)) | 0 | null | 23,257,338,880,600 | 165 | 135 |
import math
a, b, c, d = map(int, input().split())
if math.ceil(c / b) <= math.ceil(a / d):
print('Yes')
else:
print('No') | t_p, t_a, a_p, a_a = map(int, input().split())
while True:
a_p -= t_a
if a_p <= 0 :
print('Yes')
exit()
t_p -= a_a
if t_p <= 0 :
print('No')
exit()
| 1 | 29,750,683,759,744 | null | 164 | 164 |
N = int(input())
S = input()
ans = S.count("R")*S.count("G")*S.count("B")
for i in range(N):
for j in range(i+1,N):
k = 2*j-i
if k<N and S[i]!=S[j]!=S[k]!=S[i]:
ans-=1
print(ans) | def main():
import re
n = int(input())
s = input()
rindex = set()
gindex = set()
bindex = set()
for i in range(n):
if s[i] == "R":
rindex.add(i)
elif s[i] == "G":
gindex.add(i)
else:
bindex.add(i)
ans = len(rindex) * len(gindex) * len(bindex)
for r in rindex:
for g in gindex:
if r > g:
gap = r - g
b1 = r + gap
b2 = g - gap
b3 = g + (gap/2)
elif r < g:
gap = g - r
b1 = g + gap
b2 = r - gap
b3 = r + (gap/2)
if b1 in bindex:
ans -= 1
if b2 in bindex:
ans -= 1
if b3 in bindex:
ans -= 1
print(ans)
if __name__ == "__main__":
main()
| 1 | 36,066,589,010,678 | null | 175 | 175 |
n,x,y = map(int, input().split())
g = [0]*(n)
for i in range(1,n+1):
for j in range(1,i):
e = abs(y-i)+1+abs(x-j)
f = i-j
g[min(e,f)]+=1
for i in g[1:]:
print(i) | H = int(input())
Ans = 0
n = 0
while True:
if H != 1:
H = H//2
Ans += 2**n
n += 1
else:
Ans += 2**n
break
print(Ans) | 0 | null | 62,118,455,893,920 | 187 | 228 |
S = list(str(input()))
S.reverse()
mod = 2019
rem = [0]*mod
num = 0
rem[num] += 1
d = 1
ans = 0
for s in S:
num += int(s) * d
num %= mod
d *= 10
d %= mod
rem[num] += 1
for r in rem:
ans += r*(r-1)//2
print(ans) | for i in range(0,9):
for j in range(0,9):
print("{0}x{1}={2}".format(i+1,j+1,(i+1)*(j+1))) | 0 | null | 15,423,373,565,402 | 166 | 1 |
x, y = (int(a) for a in input().split())
print(x*y)
| def A():
a,b = list(map(int, input().split()))
print(a*b)
A() | 1 | 15,868,493,027,770 | null | 133 | 133 |
sec=int(input())
print(":".join(map(str, [int(sec/3600), int(sec/60)%60, sec%60]))) | h = int(input())
w = int(input())
n = int(input())
all_cell = 0
count = 0
while all_cell < n:
if h > w:
all_cell += h
w -= 1
else:
all_cell += w
h -= 1
count += 1
print(count) | 0 | null | 44,475,803,570,560 | 37 | 236 |
class unionfind():
def __init__(self,n):
#親番号<0なら根
#根の場合、数値の絶対値が要素数
self.par=[-1 for i in range(n)]
def root(self,x):
par=self.par
if par[x]<0:
return x
else:
self.x = self.root(par[x])
return self.x
def unite(self,x,y):
#高いほうに低いほうをくっつける
rx=self.root(x)
ry=self.root(y)
if rx==ry:
return
else:
if self.par[rx]>self.par[ry]:
rx,ry = ry,rx
self.par[rx]+=self.par[ry]
self.par[ry] = rx
def same(self, x,y):
return self.root(x) == self.root(y)
def par_print(self):
print(self.par)
def count(self, x):
return -self.root(x)
n,m = map(int,input().split())
friend = unionfind(n)
for i in range(m):
a,b = map(int,input().split())
friend.unite(a-1,b-1)
# print(friend.par_print())
# print(friend.par_print())
ans = -min(friend.par)
print(ans) | class UnionFind(): # 0インデックス
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)]
if __name__ == "__main__":
N, M = map(int, input().split()) # N人、M個の関係
union_find = UnionFind(N)
for _ in range(M):
A, B = map(int, input().split())
A -= 1
B -= 1
union_find.union(A, B)
answer = 0
for i in range(N):
answer = max(answer, union_find.size(i))
print(answer)
| 1 | 3,979,832,349,728 | null | 84 | 84 |
X,Y,Z=map(int,input().split(" "))
tmp=Y
Y=X
X=tmp
tmp=Z
Z=X
X=tmp
print(X,Y,Z,end=" ") | n,m=map(int,input().split())
k=m//2
for i in range (0,k):
a=i+1
b=2*k+1-i
print (a,b)
c=2*k+2
k=(m+1)//2
j=1
#print(c,k)
for i in range (c,c+k):
a=i
b=c+2*k-j
j+=1
print(a,b) | 0 | null | 33,399,149,912,316 | 178 | 162 |
#1indexed
class BIT():
def __init__(self, n):
self.size = n
self.bit = [0] * (n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += i & -i
n = int(input())
s = input()
q = int(input())
bit = [BIT(n+1) for i in range(26)]
for i in range(n):
bit[ord(s[i])-97].add(i+1, 1)
s = list(s)
for _ in range(q):
query, a, b = input().split()
if query == "1":
i = int(a)
c = ord(b)-97
bit[c].add(i, 1)
bit[ord(s[i-1])-97].add(i, -1)
s[i-1] = b
else:
ans = 0
for k in range(26):
if bit[k].sum(int(b))-bit[k].sum(int(a)-1) >= 1:
ans += 1
print(ans)
| lst=[int (x) for x in input().split(' ')]
print(lst[0]*lst[1])
| 0 | null | 39,128,249,181,768 | 210 | 133 |
a,b,c=map(int,input().split())
K=int(input())
# B > A
# C > B
import sys
for i in range(K+1):
A=a
B=b*(2**i)
C=c*(2**(K-i))
#print(i,K-i,A,B,C)
if B>A and C>B:
print('Yes')
sys.exit()
else:
print('No') | N=int(input())
lis=[chr(i) for i in range(97, 97+26)]
ans=''
while N>0:
N-=1
ans+=lis[N%26]
N=N//26
print(ans[::-1]) | 0 | null | 9,380,654,021,840 | 101 | 121 |
s,t = input().split()
print(t,s,sep='') | a=input().split()
print(a[1]+a[0]) | 1 | 103,036,615,248,878 | null | 248 | 248 |
import math
x=int(input());money=100;year=0
while money < x:
money+=money//100
year+=1
print(year) | X = int(input())
money = 100
for i in range(1, 10000):
money = money * 101 // 100
if money >= X:
print(i)
exit()
| 1 | 26,926,875,817,492 | null | 159 | 159 |
N = int(input())
table = [[int(i) for i in input().split()] for N in range(N)]
a = -1
b = 10**10
c = -10**10
d = 10**10
for i in range(N):
p = table[i][0]
q = table[i][1]
if a < p+q:
a = p+q
if b > p+q:
b = p+q
if c < p-q:
c = p-q
if d > p-q:
d = p-q
print(max(a-b,c-d))
| # -*- coding: utf-8 -*-
N=int(input())
x,y=map(int,input().split())
R=x
L=x
U=y
B=y
P=[(x,y)]
for i in range(1,N):
x,y=map(int,input().split())
P.append((x,y))
if R<x:R=x
if L>x:L=x
if U<y:U=y
if B>y:B=y
p=P[0]
UR=p
dUR=abs(R-p[0])+abs(U-p[1])
UL=p
dUL=abs(L-p[0])+abs(U-p[1])
BR=p
dBR=abs(R-p[0])+abs(B-p[1])
BL=p
dBL=abs(L-p[0])+abs(B-p[1])
for p in P[1:]:
if dUR>abs(R-p[0])+abs(U-p[1]):
UR=p
dUR=abs(R-p[0])+abs(U-p[1])
if dUL>abs(L-p[0])+abs(U-p[1]):
UL=p
dUL=abs(L-p[0])+abs(U-p[1])
if dBR>abs(R-p[0])+abs(B-p[1]):
BR=p
dBR=abs(R-p[0])+abs(B-p[1])
if dBL>abs(L-p[0])+abs(B-p[1]):
BL=p
dBL=abs(L-p[0])+abs(B-p[1])
ans=abs(UR[0]-BL[0])+abs(UR[1]-BL[1])
ans2=abs(UL[0]-BR[0])+abs(UL[1]-BR[1])
if ans2>ans: ans=ans2
print(ans)
| 1 | 3,368,632,981,428 | null | 80 | 80 |
string = list(input())
times = int(input())
for i in range(times):
order = input().split()
if order[0] == "print":
print("".join(string[int(order[1]):int(order[2]) + 1]))
elif order[0] == "replace":
string[int(order[1]):int(order[2]) + 1] = order[3]
else:
string[int(order[1]):int(order[2]) + 1] = list(reversed(string[int(order[1]):int(order[2]) + 1])) | N,K=map(int,input().split())
P=list(map(int,input().split()))
X=[]
for a in P:
X.append(a/2+0.5)
gou=sum(X[0:K])
han=-32
saigou=sum(X[N-K:N])
han=saigou
for a in range(N-K-1):
if gou>han:
han=gou
gou=gou-X[a]+X[a+K]
print(han) | 0 | null | 38,411,245,144,320 | 68 | 223 |
N = input ()
P = '0168'
H = '24579'
if N[-1] in P:
print ('pon')
elif N[-1] in H:
print ('hon')
else:
print ('bon') | N = int(input())
number1 = [2,4,5,7,9]
number2 = [3]
number3 = [0,1,6,8]
if N % 10 in number1:
print('hon')
elif N % 10 in number2:
print('bon')
elif N % 10 in number3:
print('pon') | 1 | 19,336,943,237,960 | null | 142 | 142 |
s = input()
n = len(s)
t = [0]*(n+1)
tmp=0
for i in range(n):
tmp+=1
if s[i]=="<":
t[i]=tmp-1
t[i+1]=tmp
else:
tmp=0
tmp=0
for j in range(n)[::-1]:
tmp+=1
if s[j]==">":
t[j+1]=max(tmp-1,t[j+1])
t[j]=max(tmp,t[j])
else:
tmp=0
#print(t)
print(sum(t))
| s=input()
sr=s[::-1]
cntl=0
cntr=0
ll=[0]
rl=[0]
for i in range(len(s)):
if s[i]=="<":
cntl+=1
else:
cntl=0
if sr[i]==">":
cntr+=1
else:
cntr=0
ll.append(cntl)
rl.append(cntr)
rrl=rl[::-1]
ans=[]
for i in range(len(s)+1):
ans.append(max(rrl[i],ll[i]))
print(sum(ans)) | 1 | 156,306,197,756,232 | null | 285 | 285 |
n = int(input())
i,j=1,1
count=0
x = i*j
cc = n-x
while cc>=1:
cnt=0
while 1:
p = i*j
c = n - p
if c>=1:
#print(i,":",j,":",c)
j=j+1
cnt+=1
else:
j=i
break
count=count+((cnt*2)-1)
i=i+1
j=j+1
x = i*j
cc = n-x
print(count) | print(1*(input()[:2]!=input()[:2])) | 0 | null | 63,449,648,856,998 | 73 | 264 |
A = list(map(int, input().split()))
N=A[0]
R=A[1]
if N>=10:
print(R)
else:
print(100*(10-N)+R) | import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N,R = MI()
print(R if N >= 10 else R+100*(10-N))
| 1 | 63,532,377,737,308 | null | 211 | 211 |
import math
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
import itertools
t=[i for i in range(1,n+1)]
a = list(itertools.permutations(t))
def num(b,t,n):
c = 0
for i in range(len(t)):
if list(t[i]) != b:
c += 1
else:
break
return(c)
x = num(p,a,n)
y = num(q,a,n)
print(abs(x-y)) | from math import factorial
from itertools import permutations
n = int(input())
p = tuple(map(str, input().split()))
q = tuple(map(str, input().split()))
num = [str(i) for i in range(1, n+1)]
allnum = list(i for i in permutations(num, n))
print(abs(allnum.index(p) - allnum.index(q))) | 1 | 100,634,565,915,072 | null | 246 | 246 |
# -*- coding:utf-8 -*-
import sys
def exhaustive(lst, size):
result = []
for i in range(0, 1 << size):
total = 0
for j in range(0, size):
if (i & 0x01) == 1:
total += lst[j]
i = i >> 1
result.append(total)
return result
if __name__ == "__main__":
lst = [val.split() for val in sys.stdin.read().splitlines()]
n, data, m, targets = [[int(n) for n in inner_lst] for inner_lst in lst]
result = exhaustive(data, int(n[0]))
print("\n".join(["yes" if x in result else "no" for x in targets])) | def main():
n = int(input())
d_lst = list(map(int, input().split()))
ans = 0
for i in range(n - 1):
for j in range(i + 1, n):
ans += d_lst[i] * d_lst[j]
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 84,014,256,095,780 | 25 | 292 |
N = int(input())
S = [input() for i in range(N)]
S = set(S)
S = list(S)
print(len(S)) | N = int(input())
S = [str(input()) for i in range(N)]
gocha = {}
for s in S:
gocha[s] = 1
print(len(gocha)) | 1 | 30,151,316,115,978 | null | 165 | 165 |
N,D = (int(x) for x in input().split())
count = 0
for i in range(N):
x,y = (int(z) for z in input().split())
dist = x**2 + y**2
if dist <= D**2:
count += 1
print(count) | N, D = map(int, input().split())
x = [0] * N
y = [0] * N
for i in range(N):
x[i], y[i] = map(int, input().split())
c = 0
for j in range(N):
if x[j]**2 + y[j]**2 <= D**2:
c += 1
print(c) | 1 | 5,924,199,461,630 | null | 96 | 96 |
import sys
import math
for n in [int(math.log10(float(int(line.split()[0])+int(line.split()[1]))))+1 for line in sys.stdin]:
print n | import math
lst = []
while True:
try:
a, b = map(int, input().split())
lst.append(int(math.log10(a+b))+1)
except EOFError:
for i in lst:
print(i)
break | 1 | 140,168,992 | null | 3 | 3 |
def main():
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
tmp = i
for j in range(i, n):
if a[j] < a[tmp]:
tmp = j
if i != tmp:
a[i], a[tmp] = a[tmp], a[i]
ans += 1
print(*a)
print(ans)
if __name__ == '__main__':
main()
| # selection sort
N = int(input())
A = [int(i) for i in input().split()]
cnt = 0
for i in range(0, N):
min_i = i
for j in range(i+1, N):
if A[j] < A[min_i]:
min_i = j
if i != min_i:
A[i], A[min_i] = A[min_i], A[i]
cnt = cnt + 1
print(' '.join([str(i) for i in A]))
print(cnt) | 1 | 20,753,235,708 | null | 15 | 15 |
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
sys.setrecursionlimit(10**7)
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
# b,r = map(str, readline().split())
# A,B = map(int, readline().split())
br = LS()
AB = LI()
U = _S()
def main():
brAB = zip(br, AB)
tmp=[]
for c,n in brAB:
if c==U:
tmp.append(n - 1)
else:
tmp.append(n)
return str(tmp[0])+' '+str(tmp[1])
print(main())
| #!/usr/bin python3
# -*- coding: utf-8 -*-
mod = 10**9+7
n = int(input())
ret = 0
ret += pow(10,n,mod)
ret -= 2 * pow(9,n,mod)
ret %= mod
ret += pow(8,n,mod)
ret %= mod
print(ret)
| 0 | null | 37,677,477,040,828 | 220 | 78 |
#!/usr/bin/env python3
def main():
N = int(input())
print('YES' if len(set(input().split())) == N else 'NO')
if __name__ == '__main__':
main()
| #154_C
def has_duplicates(seq):
return len(seq) != len(set(seq))
n = int(input())
a = list(map(int, input().split()))
if has_duplicates(a):
print('NO')
else:
print('YES') | 1 | 74,198,604,496,192 | null | 222 | 222 |
class Queue:
queue_list = []
start = 0
def enqueue(self, a):
self.queue_list.append(a)
def dequeue(self):
assert self.start != len(self.queue_list), "オーバーフローが発生しました。"
self.start += 1
return self.queue_list[self.start - 1]
def isEmpty(self):
return self.start == len(self.queue_list)
n, q = list(map(lambda x: int(x), input().strip().split()))
queue = Queue()
for i in range(n):
queue.enqueue(input().strip().split())
sum_time = 0
while not queue.isEmpty():
name, time = queue.dequeue()
if int(time) <= q:
sum_time += int(time)
print(name + ' ' + str(sum_time))
else:
queue.enqueue([name, str(int(time) - q)])
sum_time += q
| from collections import deque
n, q = map(int, input().split())
dq = deque()
for _ in range(n):
name, time = input().split()
dq.append([name, int(time)])
cnt = 0
while dq:
qt = dq.popleft()
if qt[1] <= q:
cnt += qt[1]
print(qt[0], cnt)
else:
cnt += q
qt[1] -= q
dq.append(qt) | 1 | 43,810,177,378 | null | 19 | 19 |
# ABC160 B
x = int(input())
a,moda = divmod(x,500)
b,modb = divmod(moda,5)
print(a*1000+b*5) | n = int(input())
s = n//500
m = n%500
x = m//5
r = s*1000
c = x*5
print(r+c) | 1 | 42,789,313,745,948 | null | 185 | 185 |
D = int(input())
c = [int(i) for i in input().split()]
s = []
for i in range(D):
tmp = [int(j) for j in input().split()]
s.append(tmp)
t = []
for i in range(D):
t.append(int(input()))
sat = 0
lst = [0 for i in range(26)]
for i in range(D):
sat += s[i][t[i]-1]
lst[t[i]-1] = i + 1
for j in range(26):
sat -= c[j] * ((i + 1) - lst[j])
print(sat) | d = int(input())
c = list(map(int, input().split()))
s = [list(map(int, input().split())) for _ in range(d)]
t = [int(input()) for _ in range(d)]
last = [[0] * d for _ in range(26)] # 26xd
ans = 0
for i in range(d):
type = t[i] # 1~26
contest = c[type-1]
satisfy = s[i][type-1]
ans += satisfy
last[type-1][i:] = [i+1] * (d-i)
for j in range(26):
ans -= c[j] * ((i+1)-last[j][i])
print(ans) | 1 | 9,900,008,291,980 | null | 114 | 114 |
K = int(input())
cnt=1
Num=7%K
while cnt<=K:
if K%2==0:
print('-1')
break
if Num%K==0:
print(cnt)
break
else:
Num = (10*Num + 7)%K
cnt+=1
else:
print('-1')
| K = int(input())
if K % 2 == 0 or K % 5 == 0:
print(-1)
exit()
start = j = 7 % K
count = 1
#無限ループ
while True:
#0の時
if j == 0:
print(count)
exit()
j = 10 * j + 7
j = j % K
count += 1
#同じ数のループしているかチェック
if j == start:
print(-1)
exit() | 1 | 6,165,659,965,636 | null | 97 | 97 |
# coding: utf-8
import sys
# from operator import itemgetter
sysread = sys.stdin.readline
read = sys.stdin.read
sys.setrecursionlimit(10 ** 7)
from heapq import heappop, heappush
#from collections import defaultdict
# import math
# from itertools import product, accumulate, combinations, product
# import bisect# lower_bound etc
#import numpy as np
# from copy import deepcopy
#from collections import deque
#import numba
def run():
H, N = map(int, sysread().split())
AB = list(map(int, read().split()))
A = AB[::2]
B = AB[1::2]
Amax = max(A)
INF = float('inf')
dp = [[INF] * (H+Amax+1) for _ in range(N+1)]
dp[0][0] = 0
for i in range(N):
for j in range(H+Amax+1):
tmp = j - A[i]
if tmp >= 0:
dp[i+1][j] = min([dp[i][j], dp[i+1][tmp] + B[i]])
elif j == H and tmp < 0:
dp[i + 1][H] = min(dp[i][H], dp[i + 1][0] + B[i])
else:
dp[i+1][j] = dp[i][j]
ret = min(dp[N][H:])
print(ret)
if __name__ == "__main__":
run() | def solve():
H,N = map(int,input().split())
ap = []
mp = []
for _ in range(N):
a,b = map(int,input().split())
ap.append(a)
mp.append(b)
ap_max = max(ap)
dp = [[float('inf')] * (H+ap_max+1) for _ in range(N+1)]
for i in range(N+1):
dp[i][0] = 0
for i in range(N):
for sum_h in range(H+ap_max+1):
dp[i+1][sum_h] = min(dp[i][sum_h-ap[i]] + mp[i], dp[i][sum_h])
dp[i+1][sum_h] = min(dp[i+1][sum_h-ap[i]] + mp[i], dp[i][sum_h])
ans = float('inf')
for sum_h in range(H, H+ap_max+1):
ans = min(ans,dp[N][sum_h])
print(ans)
if __name__ == '__main__':
solve() | 1 | 81,227,604,680,530 | null | 229 | 229 |
n = int(input())
slimes = input()
fusion = [slimes[0]]
cnt = 0
for i in range(1,n):
if fusion[cnt] != slimes[i]:
fusion.append(slimes[i])
cnt += 1
print(cnt+1) | import math
N = int(input())
A = [0]*(N)
for i in range(0,N):
A[i] = math.floor((N-1)/(i+1))
print(sum(A)) | 0 | null | 86,251,845,234,968 | 293 | 73 |
n = int(input())
s = input()
x = n
for i in range(n-1):
if s[i] == s[i+1]:
x -= 1
print(x) | n = int(input())
s = input()
sl = list(s)
k = 0
cur = '0'
for i in range(n):
if sl[i] == cur:
continue
else:
k += 1
cur = sl[i]
print(k) | 1 | 170,635,310,145,622 | null | 293 | 293 |
D=int(input())
C=list(map(int,input().split()))
S=list()
for i in range(D):
S.append(list(map(int,input().split())))
t=list()
for i in range(D):
t.append(int(input()))
M=0
di=[0]*26
for d in range(D):
for i in range(26):
if i==t[d]-1:
di[i]=0
else:
di[i]+=1
M+=S[d][t[d]-1]
for i in range(26):
M-=C[i]*(di[i])
print(M) | n, k, c = map(int, input().split())
s = input()
left = [-1 for _ in range(k)]
right = [-1 for _ in range(k)]
bef = -10 ** 10
cnt = 0
for i, ss in enumerate(s):
if ss == "o" and i - bef > c:
if cnt == k:
exit()
left[cnt] = i
bef = i
cnt += 1
cnt = 0
bef = -10 ** 10
for i, ss in enumerate(s[::-1]):
if ss == "o" and i - bef > c:
if cnt == k:
exit()
right[k - 1 - cnt] = n - 1 - i
bef = i
cnt += 1
for ll, rr in zip(left, right):
if ll == rr:
print(ll + 1) | 0 | null | 25,255,049,588,260 | 114 | 182 |
#!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def ok(t, s):
N = len(t)
for i in range(N):
if t[i]:
for x, y in s[i]:
if y == 1:
if not t[x]:
return False
elif y == 0:
if t[x]:
return False
return True
def solve():
N = int(input())
s = defaultdict(list)
for i in range(N):
A = int(input())
for _ in range(A):
X, Y = map(int, input().split())
X -= 1
s[i].append((X, Y))
ans = 0
for b in range(2 ** N):
t = [0] * N
num = 0
for i in range(N):
if (b >> i) & 1:
t[i] = 1
num += 1
if ok(t, s):
ans = max(ans, num)
print(ans)
def main():
solve()
if __name__ == '__main__':
main()
| N = int(input())
testimony = [[-1]*N for i in range(N)]
count = 0
for i in range(N):
A = int(input())
for j in range(A):
x,y = map(int,input().split())
testimony[i][x-1]=y
for i in range(2**N):
honest = [0]*N
for j in range(N):
if(i>>j)&1:
honest[j]=1
flag=True
for j in range(N):
if honest[j]==1:
for k in range(N):
if testimony[j][k]==-1:
continue
if testimony[j][k]!=honest[k]:
flag=False
if flag==True:
count=max(count,honest.count(1))
print(count) | 1 | 121,471,804,310,168 | null | 262 | 262 |
n,k=map(int,input().split())
h=[int(x) for x in input().rstrip().split()]
h.sort(reverse=True)
for i in range(min(k,n)):
h[i]=0
print(sum(h))
| N,K = map(int, input().split())
H = list(map(int, input().split()))
H_sort = sorted(H)
#print (H)
if K > N:
print(0)
else:
ans = sum(H_sort[0:N-K])
print(ans) | 1 | 79,324,579,605,110 | null | 227 | 227 |
# coding: utf-8
# hello worldと表示する
#float型を許すな
#numpyはpythonで
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
from math import floor, ceil,pi,factorial,sqrt
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7
def ceiler(a,b):
return -((-a)//b)
n,k=MI()
costs=LI()
difs=LI()
costs.sort()
difs.sort(reverse=True)
lis=[0 for i in range(n)]
#print(costs)
#print(difs)
for i in range(n):
lis[i]=costs[i]*difs[i]
#print(lis)
def judge(x):
times=0
for i in range(n):
u=ceiler(lis[i]-x,difs[i])
times+=max(0,u)
#print(u)
#print(x,times<=k)
return times<=k
l,r=-1,10**13
while l+1<r:
mid=(l+r)//2
if judge(mid):
r=mid
else:
l=mid
print(r)
| import sys
input = sys.stdin.readline
class Node:
def __init__(self, val):
self.val = val
self.prev = None
self.next = None
class DoublyLinkedList:
def __init__(self):
self.sentinel = Node(None)
self.sentinel.prev = self.sentinel
self.sentinel.next = self.sentinel
def insert(self, val):
node = Node(val)
node.prev = self.sentinel
node.next = self.sentinel.next
self.sentinel.next.prev = node
self.sentinel.next = node
def delete(self, val):
self.delete_node(self.search(val))
def deleteFirst(self):
self.delete_node(self.sentinel.next)
def deleteLast(self):
self.delete_node(self.sentinel.prev)
def search(self, val):
cursor = self.sentinel.next
while cursor != self.sentinel and cursor.val != val:
cursor = cursor.next
return cursor
def delete_node(self, node):
if node == self.sentinel:
return
node.prev.next = node.next
node.next.prev = node.prev
n = int(input())
linked_list = DoublyLinkedList()
for index in range(n):
command = input().rstrip()
if command[0] == 'i':
linked_list.insert(command[7:])
elif command[6] == 'F':
linked_list.deleteFirst()
elif command[6] == 'L':
linked_list.deleteLast()
else:
linked_list.delete(command[7:])
node = linked_list.sentinel.next
output = []
while node != linked_list.sentinel:
output.append(node.val)
node = node.next
print(" ".join(map(str, output)))
| 0 | null | 82,734,403,904,060 | 290 | 20 |
input()
a = list(input().split())
print(*a[::-1])
| N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
max_num, *p = A
node_num = N-1
q = [(2*i <= node_num) + (2*i+1 <= node_num) for i in range(1, node_num+1)]
# print(q)
# print(max_1, max_2, sum(p_i*q_i for p_i, q_i in zip(p, q)))
r = max_num + sum(p_i*q_i for p_i, q_i in zip(p, q))
print(r) | 0 | null | 5,103,022,914,470 | 53 | 111 |
n = int(input())
ans = [1]*n
T = [[-1]*n for _ in range(n)]
for ni in range(n):
a = int(input())
for ai in range(a):
x, y = map(int,input().split())
T[ni][x-1] = y
mx = 0
for i in range(pow(2,n)):
tmx = -1
B = bin(i)[2:].zfill(n)
S = [i for i,b in enumerate(B) if b=='1']
for s in S:
_Ts = [i for i,t in enumerate(T[s]) if t==1]
_Tf = [i for i,t in enumerate(T[s]) if t==0]
if not (set(_Ts)<=set(S) and set(_Tf)&set(S)==set()):
tmx = 0
break
if tmx==-1: tmx=len(S)
mx = max(mx, tmx)
print(mx) | n = input()
s = list(map(str, input().split()))
news = ""
for i in range(int(n)):
news += s[0][i] + s[1][i]
print(news) | 0 | null | 117,105,132,535,688 | 262 | 255 |
# coding: utf-8
import sys
def merge(A, left, mid, right):
global count
L = A[left:mid]
R = A[mid:right]
L.append(sys.maxsize)
R.append(sys.maxsize)
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += 1
def mergeSort(A, left, right):
if left+1 < right:
mid = int((left + right)/2);
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(input().rstrip())
A = list(map(int,input().rstrip().split()))
count = 0
mergeSort(A, 0, n)
print(" ".join(map(str,A)))
print(count)
| #coding:utf-8
#1_5_B
def merge_sort(array):
if len(array) > 1:
L, countL = merge_sort(array[0:len(array)//2])
R, countR = merge_sort(array[len(array)//2:])
return merge(L, R, countL+countR)
if len(array) == 1:
return [array, 0]
def merge(L, R, count=0):
L.append(10**9+1)
R.append(10**9+1)
response = []
i = 0
j = 0
for k in range(len(L)-1 + len(R)-1):
if L[i] <= R[j]:
response.append(L[i])
i += 1
count += 1
else:
response.append(R[j])
j += 1
count += 1
return [response, count]
n = int(input())
S = list(map(int, input().split()))
numbers, count = merge_sort(S)
print(*numbers)
print(count) | 1 | 116,127,885,632 | null | 26 | 26 |
n = int(input())
p= []
AC = 0
WA = 0
TLE = 0
RE = 0
for i in range(n):
p.append(input())
for j in p :
if j == "AC":
AC += 1
elif j == "WA":
WA += 1
elif j == "TLE":
TLE += 1
else:
RE += 1
print("AC x " + str(AC))
print("WA x " + str(WA))
print("TLE x " + str(TLE))
print("RE x " + str(RE)) | n = int(input())
l = [input() for i in range(n)]
d = {k: 0 for k in ['AC', 'WA', 'TLE', 'RE']}
for s in l:
d[s] += 1
for s in ['AC', 'WA', 'TLE', 'RE']:
print('{} x {}'.format(s, d[s])) | 1 | 8,722,269,149,748 | null | 109 | 109 |
H, M = map(int, input().split())
A = list(map(int, input().split()))
for i in A:
H -= i
if H < 0:
print("-1")
else:
print(H) | S = input()
if S[-1] != 's':
S = S + 's'
elif S[-1] == 's':
S = S + 'es'
print(S) | 0 | null | 17,161,957,951,940 | 168 | 71 |
import sys
from functools import lru_cache
from collections import defaultdict
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
return int(readline())
def reads():
return map(int, readline().split())
x=read()
a=list(reads())
dic=[]
dic2=defaultdict(int)
for i in range(x):
dic.append(i+a[i])
dic2[i-a[i]]+=1
ans=0
#print(dic,dic2)
for i in dic:
ans+=dic2[i]
print(ans)
| n,m = map(int,input().split())
l = sum(map(int,input().split()))
print(max(-1, n-l))
| 0 | null | 28,986,317,848,520 | 157 | 168 |
n = int(raw_input())
points = [0, 0]
for i in xrange(n):
card_list = raw_input().split(" ")
if card_list[0] > card_list[1]:
points[0] += 3
elif card_list[0] < card_list[1]:
points[1] += 3
else:
points[0] += 1
points[1] += 1
print str(points[0]) + " " + str(points[1]) | K, X = (int(x) for x in input().split())
if K*500>=X:
print("Yes")
else:
print("No") | 0 | null | 50,310,898,964,858 | 67 | 244 |
n = int( input() )
p = tuple( map( int, input().split() ) )
q = tuple( map( int, input().split() ) )
import itertools
permutations = list( itertools.permutations( range( 1, n + 1 ) ) )
p_order = permutations.index( p )
q_order = permutations.index( q )
print( abs( p_order - q_order ) ) | import sys
from collections import deque
#import numpy as np
import math
#sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def SL(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())
def order(l):
flag = [True]*n
ret = 0
for i,item in enumerate(l):
count = 0
for j in range(n):
if item-1==j:
flag[j] = False
break
if not flag[j]:
continue
count += 1
ret += fact[n-i-1]*count
ret += 1
return ret
def solve():
a = order(p)
b = order(q)
print(abs(a-b))
return
if __name__=='__main__':
fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320]
n = I()
p = list(IL())
q = list(IL())
solve() | 1 | 100,691,205,955,900 | null | 246 | 246 |
#E
N,T=map(int,input().split())
A=[0 for i in range(N+1)]
B=[0 for i in range(N+1)]
for i in range(1,N+1):
A[i],B[i]=map(int,input().split())
dp1=[[0 for i in range(6001)] for j in range(N+1)]
dp2=[[0 for i in range(6001)] for j in range(N+2)]
for i in range(1,N+1):
for j in range(T+1):
if j>=A[i]:
dp1[i][j]=max(dp1[i-1][j],dp1[i-1][j-A[i]]+B[i])
else:
dp1[i][j]=dp1[i-1][j]
for i in range(N,0,-1):
for j in range(T+1):
if j>=A[i]:
dp2[i][j]=max(dp2[i+1][j],dp2[i+1][j-A[i]]+B[i])
else:
dp2[i][j]=dp2[i+1][j]
ans=0
for i in range(1,N+1):
for j in range(T):
ans=max(ans,dp1[i-1][j]+dp2[i+1][T-1-j]+B[i])
print(ans) | # コード整理
import sys
from operator import itemgetter
input = sys.stdin.readline
#################
# 定数
#################
TIME = 0
VAL = 1
##################
# 入力処理
##################
N, T = [int(a) for a in input().split()]
time_value = [(-1, -1)] + [tuple(int(a) for a in input().split()) for _ in range(N)]
# Sort the array in the increasing order of value
time_value.sort(key = itemgetter(VAL))
###########################
# 動的計画法（Knapsack problem）のテーブル埋め
# 時間の最大値は T - 1
##########################
dp = [[-1] * T for _ in range(N + 1)] # (N+1)行 x T列 2次元リスト
for t in range(0, T):
dp[0][t] = 0
for n in range(1, N + 1):
dp[n][0] = 0
for t in range(1, T):
if time_value[n][TIME] > t:
dp[n][t] = dp[n - 1][t]
else:
dp[n][t] = max(dp[n - 1][t],
time_value[n][VAL] + dp[n - 1][t - time_value[n][TIME]])
##########################
# DPテーブルを用いて問題を解く
##########################
# t = T - 1に食べ始める料理が N, N-1, N-2, ..., 2, 1それぞれの場合で
# 美味しさの最大値を出し、更にその最大値を取る
# 最後に食べる料理がNの場合
val_acum = time_value[N][VAL]
t = T - 1 # N以外の料理を食べるのに使える時間
max_val = val_acum + dp[N - 1][t]
for n in range(N - 1, 0, -1): # 最後に食べる料理が n = N-1, N-2, ..., 2, 1の場合
val_acum += time_value[n][VAL] # 料理 N, N-1, ..., nの美味しさ合計
t -= time_value[n + 1][TIME] # その他の料理 1, 2, ..., n-1を食べるのに使える時間
if t < 0:
break
else:
max_val = max(max_val, val_acum + dp[n - 1][t])
print(max_val)
| 1 | 151,541,181,091,442 | null | 282 | 282 |
s = input()
if s == 'RRR':
print(3)
elif s[:2] == "RR" or s[1:] == "RR":
print(2)
elif 'R' in s:
print(1)
else:
print(0) | x, k, d = map(int, input().split())
x = abs(x)
if x > k*d:
print(x-k*d)
else:
p = x//d
c = k-p
if (c%2 == 0):
print(abs(x-p*d))
else:
print(abs(d-abs(x-p*d)))
| 0 | null | 5,042,727,817,248 | 90 | 92 |
import sys
from decimal import Decimal
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
a, b, c = input().split()
print("Yes" if Decimal(a) ** Decimal(0.5) + Decimal(b) ** Decimal(0.5) < Decimal(c) ** Decimal(0.5) else "No")
if __name__ == '__main__':
resolve()
| a,b,c=map(int,raw_input().split())
if a+b >= c:
print "No"
else:
ans1 = 4 * a * b;
ans2 = (c - a - b) * (c - a - b)
if ans1 < ans2:
print "Yes"
else:
print "No" | 1 | 51,522,490,179,776 | null | 197 | 197 |
import itertools
N = int(input())
P = tuple(map(int, input().split(' ')))
Q = tuple(map(int, input().split(' ')))
ls = [ x for x in itertools.permutations(range(1, N + 1)) ]
a = [ key for key, val in enumerate(ls) if P == val ][0] + 1
b = [ key for key, val in enumerate(ls) if Q == val][0] + 1
print(abs(a - b)) | from itertools import permutations
def same(l1, l2, n):
for i in range(n):
if l1[i] != l2[i]:
return False
return True
N = int(input())
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
P = [p-1 for p in P]
Q = [q-1 for q in Q]
for i,pattern in enumerate(permutations(range(N))):
if same(P, pattern, N):
i_p = i
if same(Q, pattern, N):
i_q = i
print(abs(i_p - i_q)) | 1 | 100,924,604,776,330 | null | 246 | 246 |
N = int(input())
A = [int(x) for x in input().split()]
aa = 0
for a in A:
aa ^= a
print(' '.join([str(aa^a) for a in A])) | a, b = list(map(int, input().split()))
ret = (str(a) * b)
if a > b:
ret = (str(b) * a)
print("{}".format(ret))
| 0 | null | 48,694,779,050,960 | 123 | 232 |
n,m = map(int,input().split())
a = map(int,input().split())
x = n-sum(a)
if x >= 0:
print(x)
else:
print(-1) | import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from math import ceil
def main():
n, k, *a = map(int, read().split())
def isOK(x):
kaisu = 0
for ae in a:
kaisu += ceil(ae / x) - 1
if kaisu <= k:
return True
else:
return False
ng = 0
ok = max(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if isOK(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
| 0 | null | 19,170,595,951,164 | 168 | 99 |
n=input()
n=list(n)
if "7" in n:
print("Yes")
else:
print("No") | h,w,k = map(int,input().split())
S = [input() for _ in range(h)]
ans = float('inf')
for bit in range(1<<(h-1)):
segment = [0]*h
seg = 0
for i in range(h-1):
if bit & (1<<i):
seg += 1
segment[i+1] = seg
n = max(segment) + 1
count = n-1
k_cnt = [0]*n
for j in range(w):
tmp = [0]*n
for i in range(h):
k_cnt[segment[i]] += int(S[i][j])
tmp[segment[i]] += int(S[i][j])
if k_cnt[segment[i]] > k:
count += 1
for i in range(n):
k_cnt[i] = tmp[i]
ans = min(ans,count)
print(ans) | 0 | null | 41,351,035,485,102 | 172 | 193 |
x=input()
x=x**3
print x | ans = int(raw_input())
print ans ** 3 | 1 | 278,784,998,648 | null | 35 | 35 |
def main():
n, kk = map(int, input().split())
mod = 10**9+7
fact = [1, 1]
for i in range(2, 2*10**5+1):
fact.append(fact[-1]*i % mod)
def nCr(n, r, mod=10**9+7):
return pow(fact[n-r]*fact[r] % mod, mod-2, mod)*fact[n] % mod
ans = [1]
for k in range(1, n):
ans.append(nCr(n-1, k)*nCr(n, k) % mod)
print(sum(ans[:min(kk+1, n)]) % mod)
main()
| N, K = map(int, input().split())
def createFacArr(n, mod):
'''
二項係数計算用の配列の作成
Parameters
n : int
配列のサイズ
mod : int
あまり
Returns
fac : list
階乗のリスト
finv : list
modの逆元のリスト
ivn : list
'''
fac = [0] * n
finv = [0] * n
inv = [0] * n
fac[0], fac[1] = 1, 1
finv[0], finv[1] = 1, 1
inv[1] = 1
for i in range(2, n):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
return fac, finv
def comb(n ,k, mod, fac, finv):
'''
二項係数の計算
Parameters
n : int
元集合
k : int
元集合から選択する数
mod : int
あまり
fac : list
階乗のリスト
finv : list
逆元のリスト
Returns
c : int
nCkの組み合わせの数
'''
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
K = min(N-1, K)
ans = 0
MOD = 10 ** 9 + 7
fac, finv = createFacArr(N+100, MOD)
for i in range(K+1):
# iは0の個数
ans += comb(N, i, MOD, fac, finv) * comb(N-1, N-i-1, MOD, fac, finv) % MOD
ans %= MOD
print(ans)
| 1 | 67,187,085,474,810 | null | 215 | 215 |
x = int(input())
print("Yes" if x >= 30 else "No") | N = int(input())
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if arr == []:
arr.append([n, 1])
return arr
L1 = factorization(N - 1)
s = 1
# print(L1)
for [a, b] in L1:
s *= (b + 1)
# print(s)
def make_divisors(n):
lower_divisors, upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
for i in set(make_divisors(N))-{1}:
temp = N
while temp % i == 0:
temp //= i
if (temp-1) % i == 0:
s += 1
s -= 1
if N == 2:
print(1)
else:
print(s) | 0 | null | 23,520,213,912,548 | 95 | 183 |
# -*- coding: utf-8 -*-
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
R, C, K = map(int, readline().split())
V = [[0]*(C+1) for _ in range(R+1)]
for i in range(K):
r,c,v = map(int,readline().split())
V[r][c] = v
dp = [0] * (C+1)
dp[0] = 0
for i in range(1,R+1):
ndp = [0] * (C+1)
row = V[i]
ldp = [0] * 4
for j in range(1,C+1):
# ldp[0] = max(ldp[0], dp[j])
ldp[0] = dp[j]
for k in range(2,-1,-1):
ldp[k+1] = max(ldp[k+1], ldp[k] + row[j]) # 取る場合と取らない場合
ndp[j] = max(ldp)
dp = ndp
print(dp[C]) | H,W,k = map(int, input().split())
# アイテムが何処に何個あるか
fs = [[0]*(W+1) for i in range(H+1)]
for i in range(k):
h, w, v = map(int, input().split())
h -= 1
w -= 1
fs[h][w] = v
mvs = [(0,1),(1,0)]
dp = [[[-1<<50 for i in range(W+1)] for j in range(H+1)] for k in range(4)]
# dp[n][i][j] n個取ったときの、i,jにおけるアイテム価値の最大値
from collections import deque
q = deque([])
q.append((0,0))
dp[0][0][0] = 0
dp[1][0][0] = fs[0][0]
for h in range(H):
for w in range(W):
dp[0][h][w+1] = max(dp[0][h][w+1], dp[0][h][w])
dp[1][h][w+1] = max(dp[1][h][w+1], dp[1][h][w], dp[0][h][w] + fs[h][w+1])
dp[2][h][w+1] = max(dp[2][h][w+1], dp[2][h][w], dp[1][h][w] + fs[h][w+1])
dp[3][h][w+1] = max(dp[3][h][w+1], dp[3][h][w], dp[2][h][w] + fs[h][w+1])
for w in range(W):
mx = 0
for i in range(4):
# print("fe",i,h,w,"dp",dp[i][h][w])
mx = max(mx,dp[i][h][w])
dp[0][h+1][w] = mx
dp[1][h+1][w] = mx + fs[h+1][w]
H -= 1
W -= 1
ans0 = dp[0][H][W]
ans1 = dp[1][H][W]
ans2 = dp[2][H][W]
ans3 = dp[3][H][W]
# print(fs)
# for i in range(3):
# d = dp[i]
# for r in d:
# print(*r)
# print("----------")
print(max(ans1,ans2,ans3)) | 1 | 5,556,130,609,240 | null | 94 | 94 |
#! python3
# toggling_cases.py
x = input()
rst = ''
for c in x:
if c.isupper():
rst += c.lower()
elif c.islower():
rst += c.upper()
else:
rst += c
print(rst)
| def fina(n, fina_list):
if n <= 1:
fina_list[n] = 1
return fina_list[n]
elif fina_list[n]:
return fina_list[n]
else:
fina_list[n] = fina(n-1, fina_list) + fina(n-2, fina_list)
return fina_list[n]
n = int(input())
fina_list = [None]*(n + 1)
print(fina(n, fina_list))
| 0 | null | 752,042,202,978 | 61 | 7 |
x = 0
y = 0
for i in range(1,10):
x += 1
y = 0
for j in range(1,10):
y += 1
print("{}x{}={}".format(x,y,x*y))
| # E - Active Infants
N = int(input())
A = list(map(int,input().split()))
dp = [[] for _ in range(N+1)]
dp[0].append(0)
for i in range(N):
A[i] = [A[i],i+1]
A.sort(reverse=True)
for M in range(1,N+1):
Ai,i = A[M-1]
# x=0
dp[M].append(dp[M-1][0]+Ai*(N-(M-1)-i))
# 1<=x<=M-1
for x in range(1,M):
dp[M].append(max(dp[M-1][x-1]+Ai*(i-x),dp[M-1][x]+Ai*(N-(M-x-1)-i)))
# x=M
dp[M].append(dp[M-1][M-1]+Ai*(i-M))
print(max(dp[N])) | 0 | null | 16,757,563,874,988 | 1 | 171 |
n, k = map(int, input().split())
h = [int(i) for i in input().split()]
new_h = sorted(h)[:n - k]
if n > k:
print(sum(new_h))
else:
print(0) | n, k = map(int, input().split())
h = list(map(int, input().split()))
h.sort(reverse=True)
ans = 0
for i in range(k, n): ans += h[i]
print(ans) | 1 | 78,910,205,658,844 | null | 227 | 227 |
import math
N, M = map(int, input().split())
A_list = list(map(int, input().split()))
cnt = 0
A_sum = sum(A_list)
for i in range(N):
if A_list[i] >= math.ceil(A_sum/4/M):
cnt += 1
if cnt >= M:
print("Yes")
else:
print("No")
| x, k, d = [int(s) for s in input().split()]
x = abs(x)
q, m = divmod(x, d)
if q >= k:
x -= k * d
else:
x = m
if (k - q) & 1:
x = d - x
print(x) | 0 | null | 21,989,138,236,130 | 179 | 92 |
n,u,v = map(int,input().split())
import sys
input = sys.stdin.readline
from collections import deque
graph = [set() for _ in range(n+1)]
for _ in range(n-1):
a,b = map(int,input().split())
graph[a].add(b)
graph[b].add(a)
def bfs(graph, root):
depth = [None] * (n+1)
depth[0] = (-1,None)
d = deque()
d.append((root,0))
max_dep = 0
while(d):
child,parent = d.popleft()
depth[child] = (depth[parent][0] + 1, parent)
if( max_dep < depth[child][0] ):
max_dep = depth[child][0]
for i in graph[child]:
if i != parent:
d.append( (i,child) )
return depth,max_dep
depth_v,_ = bfs(graph, v)
now = list(depth_v[u])
u_depth = now[0]
limit = (u_depth+2)//2
while(now[0] > limit):
u = now[1]
now = depth_v[ u ]
if(len(graph[u]) == 1):
print( depth_v[u][0]//2 )
exit()
graph[u].discard( now[1] )
depth_new,max_dep = bfs(graph, u)
ans = limit + max_dep - 1
print(ans) | def dfs(c,lst):
n=len(lst)
ans=[0]*n
stack = [c-1]
check = [0]*n #チェック済みリスト
while stack != [] :
d=stack.pop()
if check[d]==0:
check[d]=1
for i in lst[d]:
if check[i]==0:
stack.append(i)
ans[i]=ans[d]+1
return(ans)
import sys
input = sys.stdin.readline
N,u,v=map(int,input().split())
ki=[[] for f in range(N)]
for i in range(N-1):
a,b = map(int,input().split())
ki[a-1].append(b-1)
ki[b-1].append(a-1)
U=dfs(u,ki)
V=dfs(v,ki)
ans=0
for i in range(N):
if V[i]>U[i]:
ans=max(ans,V[i]-1)
print(ans)
| 1 | 117,220,032,041,112 | null | 259 | 259 |
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
s=str(input())
print(s[:3])
resolve() | # -*- coding: utf-8 -*-
"""
Created on Sat Jun 13 21:27:14 2020
@author: NEC-PCuser
"""
print(input()[0:3]) | 1 | 14,863,999,339,140 | null | 130 | 130 |
x,n = map(int, input().split())
l = list(map(int, input().split()))
i = 0
if x not in l:
print(x)
while x-i in l or x+i in l:
i += 1
if x-i not in l:
print(x-i)
break
if x+i not in l:
print(x+i)
break | def isPrime(n):
i = 2
while i * i <= n:
if n % i == 0:
return False
i += 1
return True
N = int(input())
cnt = 0
for _ in range(N):
a = int(input())
if isPrime(a):
cnt += 1
print(cnt) | 0 | null | 7,097,810,557,188 | 128 | 12 |
import sys
try:
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
input = sys.stdin.readline
n = int(input())
arr = list(map(int,input().split()))
arr = list(enumerate(arr))
arr.sort(reverse = True, key = lambda x:(x[1]))
dp = [[0 for c in range(n+1)] for r in range(n+1)]
ans = 0
for r in range(n+1):
st = r-1
for c in range(n+1-r):
if r==c==0:
pass
elif r-1<0:
dp[r][c] = dp[r][c-1] + ( arr[st][1] * abs((arr[st][0]+1) - (n+1-c)) )
elif c-1<0:
dp[r][c] = dp[r-1][c] + ( arr[st][1] * abs((arr[st][0]+1) - r) )
else:
dp[r][c] = max( dp[r-1][c] + ( arr[st][1] * abs((arr[st][0]+1) - r) ),
dp[r][c-1] + ( arr[st][1] * abs((arr[st][0]+1) - (n+1-c)) )
)
ans = max(ans, dp[r][c])
st += 1
print(ans) | Z = [0,1,2,3,4,5,5,4,3,2,1,1]
X=[0,1,2,3,4,5,6,7,8,9]
def solve_dp(s):
n = len(s)
s = [int(c) for c in s]
inf = 10**9
dp = [[inf] * 2 for _ in range(n)]
d0 = s[0]
dp[0][0] = Z[d0]
dp[0][1] = Z[d0+1]
for i in range(1, n):
for j in range(2):
d = s[i] + j
for k in range(10):
if d + X[k] >= 10:
dp[i][j] = min(dp[i][j], dp[i-1][1] + X[k] + Z[d + X[k] - 10])
else:
dp[i][j] = min(dp[i][j], dp[i-1][0] + X[k] + Z[d + X[k]])
return dp[n-1][0]
if __name__ == '__main__':
s = input()
print(solve_dp(s))
| 0 | null | 52,153,587,752,520 | 171 | 219 |
x = int(input())
a, b = map(int, input().split())
ans=0
for i in range(a,b+1):
if i%x==0:
ans=1
break
if ans==1:
print('OK')
else:
print('NG') | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
r, c, k = LI()
maze = [[0] * c for _ in range(r)]
for _ in range(k):
R, C, V = LI()
maze[R-1][C-1] = V
dp1 = [[0] * (c+1) for _ in range(r+1)]
dp2 = [[0] * (c+1) for _ in range(r+1)]
dp3 = [[0] * (c+1) for _ in range(r+1)]
for i in range(1, r+1):
for j in range(1, c+1):
dp1[i][j] = max(dp1[i][j-1], dp1[i-1][j] + maze[i-1][j-1], maze[i-1][j-1], dp2[i-1][j] + maze[i-1][j-1], dp3[i-1][j] + maze[i-1][j-1])
dp2[i][j] = max(dp2[i][j-1], dp2[i-1][j], dp1[i][j-1] + maze[i-1][j-1])
dp3[i][j] = max(dp3[i][j-1], dp3[i-1][j], dp2[i][j-1] + maze[i-1][j-1])
ans = max(dp1[-1][-1], dp2[-1][-1], dp3[-1][-1])
print(ans) | 0 | null | 16,019,567,345,200 | 158 | 94 |
# encoding:utf-8
import math as ma
# math.pi
x = float(input())
pi = (x * x) * ma.pi
# Circumference
pi_line = (x + x) * ma.pi
print("{0} {1}".format(pi,pi_line)) | # -*- coding: utf-8 -*-
import sys
import os
import math
PI = math.pi
r = float(input())
s = r * r * PI
l = 2 * PI * r
print(s, l) | 1 | 641,038,857,200 | null | 46 | 46 |
def main():
x,y = map(int, input().split())
while y != 0:
if x < y: x, y = y, x
x, y = y, x % y
print(x)
main() | def gcd(a,b):
if a < b:
a,b = b,a
while b != 0:
a,b = b,a%b
return a
a,b = map(int,raw_input().split())
print gcd(a,b) | 1 | 7,434,794,468 | null | 11 | 11 |
s = input().replace('?', 'D')
print(s)
| a=input()
print(a.replace('?','D')) | 1 | 18,351,899,687,748 | null | 140 | 140 |
s = input()
st1=[]
st2=[]
st3=[]
total=0
for i in range(len(s)):
c=s[i]
if c=='\\':
st1.append(i)
elif c=='/':
if len(st1) > 0:
j = st1.pop()
a = i - j
total+=a
tmp=0
while len(st2)>0 and st2[-1]>j:
st2.pop()
tmp+=st3.pop()
st3.append(a+tmp)
st2.append(j)
print(total)
n = len(st3)
print(n,end='')
for i in range(n):
print(' '+str(st3[i]),end='')
print()
| s = input()
for x in s:
print('x', end='')
print() | 0 | null | 36,633,308,442,720 | 21 | 221 |
import bisect as bs
import math as m
a,b,x = map(int,input().split())
l = 0
r = m.pi/2
for _ in range(10000):
s = (l+r)/2
ts = m.tan(s)
if a*ts < b:
boundary = a*a*b-a*a*a*ts/2
if x > boundary:
r = s
else:
l = s
else:
boundary = a*b*b/(ts*2)
if x > boundary:
r = s
else:
l = s
print(l*180/m.pi) | import math
a, b, x = map(int, input().split())
if x >= a**2 * b / 2:
tan = (2 * (a ** 2 * b - x)) / a ** 3
else:
tan = (a*b**2) / (2 * x)
print(math.atan(tan)/ math.pi * 180)
| 1 | 164,002,097,821,820 | null | 289 | 289 |
t = int(input())
if t >= 30:
print('Yes')
else:
print('No') | N=int(input())
right=0
left=0
for i in range(N):
a,b=input().split()
if a>b:
left+=3
elif a<b:
right+=3
else:
left+=1
right+=1
print(f"{left} {right}")
| 0 | null | 3,845,776,893,046 | 95 | 67 |
n=int(input())
s = [input() for i in range(n)]
s.sort()
ans=n
for i in range(1,n):
if s[i]==s[i-1]:
ans-=1
print(ans) | N = int(input())
A = [int(i) for i in input().split()]
ans = []
for i in range(N):
ans.append([A[i],i+1])
ans.sort()
for i in range(N-1):
print(ans[i][1],end=' ')
print(ans[-1][1])
| 0 | null | 105,268,498,613,178 | 165 | 299 |
from collections import defaultdict
d = defaultdict(lambda: 0)
N = int(input())
for _ in range(N):
ord, str = input().split()
if ord == 'insert':
d[str] = 1
else:
if str in d:
print('yes')
else:
print('no') | #!/usr/bin/env python3
print("x"*len(input()))
| 0 | null | 36,411,537,353,140 | 23 | 221 |
N = input()
over = 1
eq = 0
for n in map(int, N):
o = min(eq + n + 1, over + (10 - n) - 1)
e = min(eq + n, over + (10 - n))
over = o
eq = e
print(eq)
| N=int(input())
d=[]
for x in range(N):
S=input()
d.append(S)
print(len(set(d))) | 0 | null | 50,585,706,889,232 | 219 | 165 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.