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
|
|---|---|---|---|---|---|---|
s = input()
t = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]
print(7-int(t.index(s)))
|
import itertools
line1 = input().split()
rei = input().split()
rei =list(map(int,rei))
den =input().split()
den =list(map(int,den))
cupon =[list(map(int,input().split())) for i in range(int(line1[2]))]
rei_mi = min(rei)
den_mi =min(den)
no_total =rei_mi +den_mi
for s in range(int(line1[2])):
yes_total =int(rei[cupon[s][0]-1]) +int(den[cupon[s][1]-1]) - cupon[s][2]
if no_total > yes_total:
no_total =yes_total
print(no_total)
| 0 | null | 94,046,362,868,624 | 270 | 200 |
S=input()
ans,n=0,len(S)
dp=[0]*(2019)
s,dp[0],k=0,1,1
for i in range(1,n+1):
s=(s+int(S[-i])*k)%2019
k=(k*10)%2019
ans+=dp[s]
dp[s]+=1
print(ans)
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
r = int(readline())
print(r * r)
return
if __name__ == '__main__':
main()
| 0 | null | 88,169,185,480,542 | 166 | 278 |
x, k, d = [int(i) for i in input().split()]
if x < 0:
x = -x
l = min(k, x // d)
k -= l
x -= l * d
if k % 2 == 0:
print(x)
else:
print(d - x)
|
n=int(input())
x=list(map(float,input().split()))
y=list(map(float,input().split()))
a=0
for i in range(n):
a+=abs(x[i]-y[i])
print('{:.6f}'.format(a))
b=0
for i in range(n):
b+=(x[i]-y[i])**2
print('{:.6f}'.format(b**(1/2)))
c=0
for i in range(n):
c+=abs((x[i]-y[i]))**3
print('{:.6f}'.format(c**(1/3)))
d=[]
for i in range(n):
d.append(abs(x[i]-y[i]))
print('{:.6f}'.format(max(d)))
| 0 | null | 2,748,371,399,810 | 92 | 32 |
n, k = map(int, input().split())
s, p, r = map(int, input().split())
dic = {"p":p, "r":r, "s":s}
t = input()
ans = 0
for i in range(k):
bef = "a"
for j in range(i, n, k):
if bef == t[j]:
bef = "a"
else:
ans += dic[t[j]]
bef = t[j]
print(ans)
|
N, K = [int(x) for x in input().split()]
r, s, p = [int(x) for x in input().split()]
win_point = {
'r': r,
's': s,
'p': p,
}
next_hands = {
'r': ['s', 'p'],
's': ['r', 'p'],
'p': ['r', 's'],
}
enemy_hands = input()
def can_win(enemy_hand, my_hands):
# 勝てる場合にはTrueと勝てる手を教えてくれる
if enemy_hand == 'r' and 'p' in my_hands:
return True, 'p'
if enemy_hand == 's' and 'r' in my_hands:
return True, 'r'
if enemy_hand == 'p' and 's' in my_hands:
return True, 's'
# 勝てる手がない場合
return False, None
point = 0
for index in range(K):
now_hands = ['r', 'p', 's']
for i in range(index, N, K):
win, hand = can_win(enemy_hands[i], now_hands)
if win:
point += win_point[hand]
now_hands = next_hands[hand]
else:
# 勝てない場合次似邪魔しない手を選ぶ
# 勝てない回の次は必ず勝てるため全手出せる前提とする
now_hands = ['r', 'p', 's']
print(point)
| 1 | 107,357,279,715,410 | null | 251 | 251 |
def main():
N = int(input())
if N%2==0:
print(N//2-1)
else:
print((N-1)//2)
if __name__ == '__main__':
main()
|
def main():
x = int(input())
if x >= 30:
print('Yes')
else:
print("No")
if __name__ == main():
main()
| 0 | null | 79,240,003,996,340 | 283 | 95 |
def calc(n, k):
length = len(n)
dp = [[[0]*(k + 1) for _ in range(2)] for _ in range(length+1)]
dp[0][0][0] = 1
for i in range(length):
max_digit = int(n[i])
for flag_less in range(2):
for non_zero in range(4):
range_digit = 9 if flag_less else max_digit
for d in range(range_digit+1):
flag_less_next = 0
non_zero_next = non_zero
if flag_less == 1 or d < max_digit:
flag_less_next = 1
if d != 0:
non_zero_next = non_zero + 1
if non_zero_next < k + 1:
dp[i+1][flag_less_next][non_zero_next] += dp[i][flag_less][non_zero]
return dp[length][0][k]+dp[length][1][k]
n = input()
k = int(input())
print(calc(n, k))
|
N=int(input())
K=int(input())
import sys
sys.setrecursionlimit(10**6)
def solve(N, K):
if K==1:
l=len(str(N))
ans=0
for i in range(l):
if i!=l-1:
ans+=9
else:
ans+=int(str(N)[0])
#print(ans)
return ans
else:
nextK=K-1
l=len(str(N))
ini=int(str(N)[0])
res=ini*(10**(l-1))-1
#print(res)
if l>=K:
ans=solve(res, K)
nextN=int(str(N)[1:])
ans+=solve(nextN, nextK)
return ans
else:
return 0
ans=solve(N,K)
print(ans)
| 1 | 75,869,813,548,682 | null | 224 | 224 |
n = int(input())
print(n//2 + (n % 2)*1)
|
import math
n = int(input())
m = n//2
if n % 2 == 0:
print(m)
else:
print(m+1)
| 1 | 59,322,906,715,390 | null | 206 | 206 |
n = int(input())
a = list(map(int, input().split()))
ma = max(a)
dp = [0]*(ma+1)
for i in sorted(a):
if 1 <= dp[i]:
dp[i] += 1
continue
for j in range(1, ma//i + 1):
dp[j * i] += 1
ans=0
for i in a:
if dp[i] == 1:
ans += 1
print(ans)
|
def main():
N = int(input())
A = list(map(int, input().split()))
L = [0] * (10**6+1)
for a in A:
L[a] += 1
ans = 0
Ng = [False] * (10**6+1)
for a, cnt in enumerate(L):
if cnt:
for i in range(a*2, 10**6+1, a):
Ng[i] = True
for a, (cnt, ng) in enumerate(zip(L, Ng)):
if cnt == 1 and not ng:
ans += 1
print(ans)
main()
| 1 | 14,517,210,619,968 | null | 129 | 129 |
#from collections import deque
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**6)
#def mypopleft(que, index):
# if len(que) > index:
# return que.pop(index)
# else:
# return []
def main():
# input
n = int(input())
graph = []
for i in range(n):
u, k, *tmp = [int(i) for i in readline().split()]
graph.append(tmp)
#print(graph)
d = [-1]*n
#que = deque([1])
que = [1]
#count = 0
d[0] = 0
check = []
while True:
v = que.pop(0)
#print(v)
#count += 1
#print(d)
for u in graph[v-1]:
#print(u)
if d[u-1] == -1:
d[u-1] = d[v-1] + 1
que.append(u)
if len(que) == 0:
break
for i in range(n):
print("{} {}".format(i+1, d[i]))
if __name__ == "__main__":
main()
|
n=int(input())
G=[[0,[],0,-1]]
for i in range(n):
v=[int(j) for j in input().split(" ")]
u=v.pop(0)
k=v.pop(0)
G.append([k,v,0,-1])
distance=0
dis_list=[1]
G[1][3]=0
G[1][2]=1
while len(dis_list)!=0:
distance+=1
dis_list_cash=[]
for i in dis_list:
k=G[i][0]
v=G[i][1]
for j in range(k):
if G[v[j]][2]==0:
G[v[j]][2]=1
G[v[j]][3]=distance
dis_list_cash.append(v[j])
dis_list=dis_list_cash
for i in range(1,n+1):
print(str(i)+" "+str(G[i][3]))
| 1 | 4,115,818,540 | null | 9 | 9 |
h, w = map(int, input().split())
mat = [[] for _ in range(h)]
for i in range(h):
mat[i] = input()
dp = [[float("inf")] * w for _ in range(h)]
if mat[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
for i in range(h):
for j in range(w):
if mat[i][j - 1] != mat[i][j]:
left = dp[i][j - 1] + 1
else:
left = dp[i][j - 1]
if mat[i - 1][j] != mat[i][j]:
top = dp[i - 1][j] + 1
else:
top = dp[i - 1][j]
dp[i][j] = min(dp[i][j], left, top)
print((dp[h - 1][w - 1] + 1) // 2)
|
while True:
a,b,c=input().split()
a = int(a)
c = int(c)
if b=='?':
break
elif b=='+':
print(a+c)
elif b=='-':
print(a-c)
elif b=='*':
print(a*c)
elif b=='/':
print(a//c)
| 0 | null | 25,043,903,347,848 | 194 | 47 |
import math
import itertools
# 与えられた数値の桁数と桁値の総和を計算する.
def calc_digit_sum(num):
digits = sums = 0
while num > 0:
digits += 1
sums += num % 10
num //= 10
return digits, sums
n = int(input())
distances = []
for _ in range(n):
points = list(map(int, input().split()))
distances.append(points)
total = 0
routes = list(itertools.permutations(range(n), n))
for route in routes:
distance = 0
for index in range(len(route)-1):
idx1 = route[index]
idx2 = route[index+1]
distance += math.sqrt((distances[idx1][0] - distances[idx2][0]) ** 2 + (distances[idx1][1] - distances[idx2][1]) ** 2)
total += distance
print(total / len(routes))
|
from __future__ import division, print_function
from sys import stdin
from math import hypot, sqrt
x1, y1, x2, y2 = (float(s) for s in stdin.readline().split())
print('{:.4f}'.format(hypot(x1-x2, y1-y2)))
| 0 | null | 74,048,493,378,080 | 280 | 29 |
print("Yes" if int(input())%9 == 0 else "No")
|
print('No') if int(input())%9 else print('Yes')
| 1 | 4,386,408,007,180 | null | 87 | 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=" ")
|
from collections import deque
N, M, K = map(int, input().split())
friend = [list(map(int, input().split())) for _ in range(M)]
block = [list(map(int, input().split())) for _ in range(K)]
f = [set() for _ in range(N + 1)]
b = [set() for _ in range(N + 1)]
for i, j in friend:
f[i].add(j)
f[j].add(i)
for i, j in block:
b[i].add(j)
b[j].add(i)
stack = deque()
ans = [0] * (N + 1)
visited = [0] * (N + 1)
for i in range(1, N + 1):
if visited[i]:
continue
# setは{}で書く
link = {i}
stack.append(i)
visited[i] = 1
while stack:
n = stack.pop()
# nのフレンド全員について
for j in f[n]:
if visited[j] == 0:
stack.append(j)
visited[j] = 1
# link(set)に追加
link.add(j)
for i in link:
# 全体-既にフレンドの人数-ブロックした人数-自分自身
# set同士で積集合をとる
ans[i] = len(link) - len(link & f[i]) - len(link & b[i]) - 1
print(*ans[1:])
| 1 | 61,626,032,236,052 | null | 209 | 209 |
X,K,D=input().split(' ')
x,k,d=abs(int(X)),int(K),int(D)
x_par=x%d
x_num=int((x-x_par)/d)
s=0
if x_num<=k:
x_div=x-x_num*d
k-=x_num
if k%2==0:
s=abs(x_div)
else:
s=x_div-d
else:
s=x-d*k
print(abs(s))
|
X, K, D = map(int, input().split())
absX = abs(X)
step = min(K, (absX // D))
if K > step:
extra = - D * ((K - step) % 2)
else:
extra = 0
print(abs(absX - step * D + extra))
| 1 | 5,156,238,211,712 | null | 92 | 92 |
n = int(raw_input())
for i in range(n):
num = map(int, raw_input().split())
num.sort(reverse=True)
if num[0]**2 == num[1]**2 + num[2]**2:
print "YES"
else:
print "NO"
|
ans = []
for i in range(int(input())):
a, b, c = map(int, input().split())
lst = [a, b, c]
lst.sort()
if lst[2]**2 == lst[0]**2 + lst[1]**2:
ans.append("YES")
else:
ans.append("NO")
for i in ans:
print(i)
| 1 | 308,525,888 | null | 4 | 4 |
x = int(input())
r = 0
divider = ((500,1000), (5, 5))
for i in divider:
x, remain = divmod(x, i[0])
r += x * i[1]
x = remain
print(r)
|
'''
問題：
高橋君は金色の硬貨が好きです。
自分が持っている 500円硬貨 1枚につき 1000、
5円硬貨 1枚につき 5の嬉しさ を得ます。
高橋君は X 円を持っています。
これを高橋君の嬉しさが最大になるように両替したとき、高橋君の嬉しさはいくらになりますか？
(なお、利用できる硬貨は 500 円玉、100 円玉、50 円玉、10 円玉、5円玉、1 円玉の 6 種類とします。)
'''
'''
Xは整数
0 ≦ X ≦ 1,000,000,000
'''
class Yorokobi:
def __init__(self, money, yorokobi):
self.money = money
self.yorokobi = yorokobi
def calc_yorokobi(self, credit): # credit （残金？）を入力として受け取り、喜びを計算して返す
return (credit // self.money) * self.yorokobi
# 標準入力から X の値を取得する
input_x = int(input())
yorokobi_500 = Yorokobi(500, 1000)
yorokobi_5 = Yorokobi(5, 5)
result = 0 # 結果格納用
if input_x >= 500:
result += yorokobi_500.calc_yorokobi(input_x) # 高橋君 500円の喜び
result += yorokobi_5.calc_yorokobi(input_x % 500) # 高橋君 5円の喜び
else:
result += yorokobi_5.calc_yorokobi(input_x)
print(result)
# ret1 = input_x // 500 # 500円で割った商
# ret2 = ret1 * 1000 # 高橋君 500円の喜び
# ret3 = input_x - (ret1 * 500) # X円から500円の枚数分を引いたお金
# ret4 = ret3 // 5 # （X円から500円の枚数分を引いたお金）÷ 5
# ret5 = ret4 * 5 # 高橋君 5円の喜び
# print(ret2 + ret5)
| 1 | 42,660,140,930,692 | null | 185 | 185 |
import copy
def main():
N = int(input())
A = list(map(int, input().split()))
A.sort()
A_max = A[N-1]
div_count = [0] * (A_max + 1)
for a in A:
for n in range(a, A_max+1, a):
div_count[n] += 1
exists = [False] * (A_max + 1)
for a in A:
exists[a] = True
result = 0
for i, d in enumerate(div_count):
if d == 1 and exists[i]:
result += 1
print(result)
main()
|
x1,y1,x2,y2=map(float,input().split())
a=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)
print(a**(1/2))
| 0 | null | 7,229,580,663,490 | 129 | 29 |
import math
n = int(input())
a = list(map(int,input().split()))
g = 1
mod = 10**9 + 7
ans = 0
for i in range(n):
u = (g*a[i])//math.gcd(g,a[i])
ans *= u//g
ans %= mod
ans += u//a[i]
ans %= mod
g = u
print(ans)
|
def get_ints():
return map(int, input().split())
n, m = get_ints()
print('Yes' if n == m else 'No')
| 0 | null | 85,914,877,257,760 | 235 | 231 |
import math
a, b, x = [int(n) for n in input().split()]
v = a**2 * b /2
#print(v, x)
if v == x:
theta = math.atan(b/a)
elif v > x:
theta = math.atan(a*(b**2)/(2*x))
elif v < x:
theta = math.atan(2/a*(b-x/a**2))
print(math.degrees(theta))
|
import sys
from operator import itemgetter
import math
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().split())
def lmi(): return list(map(int, input().split()))
def lmif(n): return [list(map(int, input().split())) for _ in range(n)]
def ss(): return input().split()
def main():
a, b, x = mi()
V = a**2 * b
if V // 2 < x:
X = 2*x / a**2 - b
Y = b - X
ans = math.degrees(math.asin(Y/math.sqrt(a**2 + Y**2)))
else:
X = 2*x / (a*b)
ans = math.degrees(math.asin(b/math.sqrt(X**2 + b**2)))
print(ans)
return
main()
| 1 | 163,442,504,121,638 | null | 289 | 289 |
a = input()
b = input()
c = ['1', '2', '3']
for i in c:
if i != a and i != b:
print(i)
|
from calendar import day_name
s = input()
for i in range(7):
if s == day_name[i][:3].upper():
ans = 6 - i
if ans == 0: ans += 7
print(ans)
break
| 0 | null | 122,016,352,845,700 | 254 | 270 |
N = int(input())
S = input()
A = ['']
for i in S:
if i != A[-1]:
A.append(i)
print(len(''.join(A)))
|
a,b,c = map(int,raw_input().split())
if a>b:
tmp = a
a = b
b = tmp
if b>c:
tmp = b
b = c
c = tmp
if a>b:
tmp = a
a = b
b = tmp
print "%d %d %d" %(a,b,c)
| 0 | null | 85,035,790,925,668 | 293 | 40 |
# Pythonのスライスは最後が開区間だから癖がある
t = input()
for i in range(int(input())):
cmd = list(input().split())
cmd[1] = int(cmd[1])
cmd[2] = int(cmd[2])
if cmd[0] == "print":
print(t[cmd[1] : cmd[2]] + t[cmd[2]])
elif cmd[0] == "reverse":
tmp = t[cmd[1] : cmd[2]] + t[cmd[2]]
tmp = tmp[::-1]
t = t[:cmd[1]] + tmp + t[cmd[2]+1:]
elif cmd[0] == "replace":
t = t[:cmd[1]] + cmd[3] + t[cmd[2]+1:]
|
str_1=input()
q=int(input())
for _ in range(q):
lst=list(input().split())
res = (lst[0])
a = int(lst[1])
b = int(lst[2])+1
if res=='print':
print(str_1[a:b])
elif res=='replace':
str_1=str_1[:a]+lst[3]+str_1[b:]
elif res=='reverse':
str_1=str_1[:a] + str_1[a:b][::-1] + str_1[b:]
| 1 | 2,060,615,655,200 | null | 68 | 68 |
n,m = map(int,input().split())
kakeru = [list(map(int,input().split())) for _ in range(n)]
kakerareru = [int(input()) for _ in range(m)]
for a in range(n):
kotae = 0
for b in range(m):
kotae += kakeru[a][b]*kakerareru[b]
print(kotae)
|
n, m = [int(_) for _ in input().split()]
a = []
for _ in range(n):
a.append([int(_) for _ in input().split()])
b = []
for _ in range(m):
b.append(int(input()))
for ai in a:
print(sum([a_c * b_c for a_c, b_c in zip(ai, b)]))
| 1 | 1,163,390,674,320 | null | 56 | 56 |
from collections import deque
D = set()
N = int(input())
for i in range(N):
c, s = input().split()
if c == "insert":
D.add(s)
elif c == "find":
if (s in D):
print("yes")
else:
print("no")
|
s = input()
depth_list = [0]*len(s)
max_depth = [0]*len(s)
d = 0
for i, c in enumerate(s):
if c == "\\":
d -= 1
elif c == "/":
d += 1
depth_list[i] = d
m_d = d
for i in range(len(s)-1, -1, -1):
if s[i] == "\\":
d += 1
elif s[i] == "/":
d -= 1
max_depth[i] = m_d
m_d = max(m_d, d)
d = 0
m_d = 0
water = 0
puddles = [0]
for i, n in enumerate(depth_list):
up = min(m_d, max_depth[i])
if d < up and d != n or d == up and d > n:
water += 0.5
if d < n:
d = n
water += max(0, up - d)
d = n
m_d = max(m_d, d)
if d == up and sum(puddles) < int(water):
m_d = d
puddles.append(int(water - sum(puddles)))
print(int(water))
print(str(len(puddles)-1)+(" "if len(puddles)>1 else "")+" ".join([str(n) for n in puddles[1:]]))
| 0 | null | 72,053,913,340 | 23 | 21 |
def atc_154b(S: str) -> str:
return "x" * len(S)
S_input = input()
print(atc_154b(S_input))
|
s = input()
s = 'x'*len(s)
print(s)
| 1 | 72,815,831,608,078 | null | 221 | 221 |
n = int(input())
x = list(map(int, input().split()))
result = 0
for i in range(n - 1):
if x[i] > x[i + 1]:
result += (x[i] - x[i + 1])
x[i + 1] = x[i]
print(result)
|
n=int(input())
a=[int(k) for k in input().split()]
sum=0;
max=a[0];
for aa in a:
if aa<max:
sum=sum+max-aa
else:
max=aa
print(sum)
| 1 | 4,550,579,234,090 | null | 88 | 88 |
N = int(input())
S = list(input())
R = []
G = []
for i in range(N):
if S[i] == "R":
R.append(i)
elif S[i] == "G":
G.append(i)
r = len(R)
g = len(G)
ans = r * g * (N - r - g)
for i in R:
for j in G:
a = 2 * i - j
b = 2 * j - i
c = i + j
if 0 <= a < N and S[a] == "B":
ans -= 1
if 0 <= b < N and S[b] == "B":
ans -= 1
if c % 2 == 0 and S[c//2] == "B":
ans -= 1
print(ans)
|
H, N = [int(s) for s in input().split()]
A = [int(s) for s in input().split()]
print('Yes' if H - sum(A) <= 0 else 'No')
| 0 | null | 57,033,037,026,112 | 175 | 226 |
N = int(input())
L = [int(i) for i in input().split()]
count = 0
L.sort()
for i in range(N) :
for j in range(i+1,N) :
for k in range(j+1,N) :
if L[i]!=L[j]!=L[k]:
if ((L[i]+L[j]>L[k]) and (L[j]+L[k]>L[i]) and (L[i]+L[k]>L[j])) :
count += 1
print(count)
|
N = int(input())
L = list(map(int, input().split()))
L.sort()
ans = 0
if N >= 3 :
for i in range(0, N - 1) :
for j in range(1, N - 1 - i) :
for k in range(2, N - i):
if L[i] < L[i+j] < L[i+k] and L[i] + L[i+j] > L[i+k]:
ans += 1
print(ans)
| 1 | 5,019,299,545,708 | null | 91 | 91 |
def main():
n = int(input())
As = list(map(int, input().split()))
ans = 1
if 0 in As:
print(0)
return
for a in As:
ans *= a
if ans > 10**18:
print(-1)
return
print(ans)
if __name__ == '__main__':
main()
|
N = int(input())
a_list = list(map(int, input().split()))
all_xor = 0
res = []
for a in a_list:
all_xor ^= a
for a in a_list:
res.append(a ^ all_xor)
print(*res)
| 0 | null | 14,324,403,557,818 | 134 | 123 |
n,k = map(int,input().split())
p = list(map(int,input().split()))
ps = [p[0]] + [0]*(n-1)
for i in range(1,n):
ps[i] = ps[i-1] + p[i]
maxs = ps[k-1]
for i in range(1,n-k+1):
maxs = max(maxs,ps[i+k-1]-ps[i-1])
print((maxs+k)/2)
|
n,k = map(int,input().split())
p = [int(x) for x in input().split()]
sum1 = sum(p[:k])
num = k-1
max1 = sum1
for i in range(k,n):
sum1 = sum1 - p[i-k] + p[i]
if sum1 >= max1:
max1 = sum1
num = i
#print(max1,sum1,i)
sum2 = sum(p[num-k+1:num+1])
def goukei(j):
return 1/2 * j * (j+1)
print(float((goukei(sum2)-goukei(k-1))/(sum2 -k +1)))
| 1 | 75,083,340,552,352 | null | 223 | 223 |
import math
s = int(input())
maxn = s//3
ans=0
for i in range(1,maxn+1):
b = s-3*i
ans += math.factorial(b+i-1)//(math.factorial(b)*math.factorial(i-1))
print(ans%(10**9+7))
|
S=int(input())
dp=[]#答えの方
assim=[]#累積和
mod=10**9+7
for i in range(2001):
if i<3:
dp.append(0)
elif i==3:
dp.append(1)
else:
dp.append((assim[-3])%mod)
if i==0:
assim.append(0)
else:
assim.append((assim[-1]+dp[-1])%mod)
print(assim[S])
| 1 | 3,276,067,041,688 | null | 79 | 79 |
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")
|
from sys import stdin, setrecursionlimit
def main():
input = stdin.buffer.readline
n, r = map(int, input().split())
if n >= 10:
print(r)
else:
print(r + 100 * (10 - n))
if __name__ == "__main__":
setrecursionlimit(10000)
main()
| 0 | null | 57,935,923,509,002 | 198 | 211 |
N = int(input())
def digitSum(n):
s = str(n)
array = list(map(int, s))
return sum(array)
if digitSum(N) % 9 == 0:
print("Yes")
else:
print("No")
|
n,m,l = [int(x) for x in input().split()]
a = [[int(x) for x in input().split()] for y in range(n)]
b = [[int(x) for x in input().split()] for y in range(m)]
c = [[0 for x in range(l)] for y in range(n)]
for i in range(n):
for j in range(l):
for k in range(m):
c[i][j] += a[i][k] * b[k][j]
for i in range(n):
print(" ".join(map(str,c[i])))
| 0 | null | 2,935,042,349,380 | 87 | 60 |
# A - DDCC Finals
def main():
X, Y = map(int, input().split())
prize_table = {1: 300000, 2: 200000, 3: 100000}
prize = 0
for rank in (X, Y):
if rank in prize_table:
prize += prize_table[rank]
if X == Y and X == 1:
prize += 400000
print(prize)
if __name__ == "__main__":
main()
|
X, Y = map(int, input().split())
def solver(X, Y):
if X == 1 and Y == 1:
print(1000000)
return
a = 0
if X == 1:
a += 300000
if X == 2:
a += 200000
if X == 3:
a += 100000
if Y == 1:
a += 300000
if Y == 2:
a += 200000
if Y == 3:
a += 100000
print(a)
solver(X, Y)
| 1 | 140,164,667,071,740 | null | 275 | 275 |
a,b,c,k = map(int,input().split())
s = 0
if k <= a:
s = k
elif k <= a + b:
s = a
else:
s = a - (k - a - b)
print(s)
|
A,B,C,K = map(int,input().split())
if A>=K: print(K)
else:
K-=A
if B>=K: print(A)
else:
K-=B
print(A-K)
| 1 | 21,694,984,142,752 | null | 148 | 148 |
A, B, K = map(int, input().split())
if A <= K:
B -= K - A
if B < 0:
B = 0
A = 0
else:
A -= K
print(A, B)
|
N, M, Q = map(int, input().split())
L = list(tuple(map(int, input().split())) for _ in range(Q))
ans = 0
A = []
def dfs():
global A, ans
if len(A) == N:
res = sum(t[3] for t in L if A[t[1]-1] - A[t[0]-1] == t[2])
ans = max(ans, res)
else:
for a in range(A[-1] if A else 1, M + 1):
A.append(a)
dfs()
A.pop()
dfs()
print(ans)
| 0 | null | 65,927,361,768,908 | 249 | 160 |
from collections import deque
INFTY = 10**6
N,u,v = map(int,input().split())
G = {i:[] for i in range(1,N+1)}
for _ in range(N-1):
a,b = map(int,input().split())
G[a].append(b)
G[b].append(a)
du = [INFTY for _ in range(N+1)]
du[u] = 0
que = deque([(0,u)])
hist = [0 for _ in range(N+1)]
hist[u] = 1
while que:
c,i = que.popleft()
for j in G[i]:
if hist[j]==0:
que.append((c+1,j))
du[j] = c+1
hist[j] = 1
dv = [INFTY for _ in range(N+1)]
dv[v] = 0
que = deque([(0,v)])
hist = [0 for _ in range(N+1)]
hist[v] = 1
while que:
c,i = que.popleft()
for j in G[i]:
if hist[j]==0:
que.append((c+1,j))
dv[j] = c+1
hist[j] = 1
cmax = 0
for i in range(1,N+1):
if du[i]<dv[i]:
cmax = max(cmax,dv[i])
print(cmax-1)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
INF = float('inf')
N, u, v = map(int, input().split())
u, v = u-1, v-1
adjL = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, input().split())
a, b = a-1, b-1
adjL[a].append(b)
adjL[b].append(a)
def bfsMinCosts(adjList, vSt, INF):
numV = len(adjList)
costs = [INF] * numV
costs[vSt] = cost = 0
vs = [vSt]
while vs:
cost += 1
v2s = []
for v in vs:
for v2 in adjList[v]:
if costs[v2] == INF:
costs[v2] = cost
v2s.append(v2)
vs = v2s
return costs
costUs = bfsMinCosts(adjL, u, INF)
costVs = bfsMinCosts(adjL, v, INF)
ans = 0
for x in range(N):
if costUs[x] < costVs[x]:
if costVs[x] > ans:
ans = costVs[x]
print(ans-1)
| 1 | 117,084,496,147,836 | null | 259 | 259 |
n=int(input())
x=100000
for i in range(n):
x*=1.05
if x%1000>0:
x=x-(x%1000)+1000
else:
pass
print(int(x))
|
from collections import Counter
def main():
n = int(input())
S = [input() for _ in range(n)]
S_c = Counter(S)
num = list(S_c.values()).count(max(list(S_c.values())))
anss = S_c.most_common()[:num]
for ans in sorted(anss):
print(ans[0])
if __name__ == '__main__':
main()
| 0 | null | 34,886,084,825,788 | 6 | 218 |
s = input()
k = int(input())
l=len(s)
s+='?'
ch = 1
ans=0
j=0
for i in range(l):
if s[i]==s[i+1]:
ch+=1
else:
ans+=ch//2
if j==0:
st=ch
if s[i+1]=='?':
gl=ch
ch=1
j=1
ans*=k
if st%2==1 and gl%2==1 and s[0]==s[l-1]:
ans+=k-1
if st==l:
ans=l*k//2
print(ans)
|
import sys
s = sys.stdin.readline().rstrip()
k = int(sys.stdin.readline())
cnt = 0
i = 0
l = len(s)
if len(set(s)) == 1:
print(int(l*k/2))
exit()
while i < l-1:
if s[i] == s[i+1]:
cnt += 1
i += 2
continue
i += 1
cnt1 = 0
i1 = 0
s *= 2
while i1 < l*2-1:
if s[i1] == s[i1+1]:
cnt1 += 1
i1 += 2
continue
i1 += 1
print((cnt1 - cnt)*(k-1) + cnt)
| 1 | 176,188,789,346,248 | null | 296 | 296 |
# coding: utf-8
# Here your code !
count=0
def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = [0 for i in xrange(n1 + 1)]
R = [0 for i in xrange(n2 + 1)]
for i in xrange(n1):
L[i] = A[left + i]
for i in xrange(n2):
R[i] = A[mid + i]
L[n1] = 1<<32 - 1
R[n2] = 1<<32 - 1
i = 0
j = 0
for k in xrange(left, right):
count += 1
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[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)
if __name__ == "__main__":
n = int(raw_input())
refA = map(int, raw_input().split())
A = list(refA)
mergeSort(A, 0, n)
print " ".join(map(str,A))
print count
|
X, K, D = map(int, input().split())
t = X // D
if abs(t) >= K:
if X > 0:
print(abs(X-(D*K)))
elif X < 0:
print(abs(X+(D*K)))
exit(0)
nokori = K - t
if X-(D*t) <= 0:
if nokori % 2 == 0:
print(abs(X-(D*t)))
else:
print(abs(X-(D*(t-1))))
else:
if nokori % 2 == 0:
print(abs(X-(D*t)))
else:
print(abs(X-(D*(t+1))))
| 0 | null | 2,698,173,631,722 | 26 | 92 |
N, X, T = map(int, input().split())
ans = T * (N // X)
ans = ans if (N % X) is 0 else ans + T
print(ans)
|
l=[0]+[int(i) for i in input()]
l.reverse()
su=0
for i in range(len(l)):
if l[i]>5:
l[i]=10-l[i]
l[i+1]+=1
elif l[i]==5 and l[i+1]>4:
l[i+1]+=1
su+=l[i]
print(su)
| 0 | null | 37,800,144,826,532 | 86 | 219 |
k=int(input())
se=0
for i in range(k):
se=se*10
se+=7
i+=1
if se%k==0:
print(i)
exit()
se%=k
print('-1')
|
def my_eval(ar,str):
res = True
n = len(str)
# print(n)
# print("start")
for i in range(n):
# print(i)
if(ar[str[i][0]] == 1):
# print(str[i][0])
# print(str[i][1])
# print(str[i][2])
# print(ar[str[i][1]-1])
# print(ar[str[i][1]-1] == str[i][2])
# print(ar)
# print()
if(ar[str[i][1]] != str[i][2]):
res = False
# print("end")
# print()
return res
if __name__ == "__main__":
# 全探索
n = int(input())
str = []
for i in range(n):
a = int(input())
for j in range(a):
x = list(map(int,input().split()))
x.insert(0,i+1)
str.append(x)
ar = [0] * (n+1)
res = 0
# print(str)
count = 0
for i in range(2**n):
count = 0
for j in range(n):
if(i >> j & 1 == 1):
ar[j+1] = 1
count += 1
else:
ar[j+1] = 0
# print(ar)
if(my_eval(ar,str)):
res = max(res,count)
print(res)
| 0 | null | 63,926,885,945,948 | 97 | 262 |
n = int(input())
ans = ''
while n > 0:
n -= 1
ans += chr(97 + n % 26)
n //= 26
print(ans[::-1])
|
import string
n = int(input())
alphabet = list(string.ascii_lowercase)
ans = ''
while n > 0:
ans = alphabet[(n-1) % 26] + ans
n = (n-1) // 26
print(ans)
| 1 | 11,837,940,747,866 | null | 121 | 121 |
# local search is all you need
# 「日付 d とコンテストタイプ q をランダムに選び、d 日目に開催するコンテストをタイプ q に変更する」を実装する
from time import time
t0 = time()
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def exit(*argv, **kwarg):
print(*argv, **kwarg)
sys.exit()
def mina(*argv, sub=1): return list(map(lambda x: x - sub, argv))
# 受け渡されたすべての要素からsubだけ引く.リストを*をつけて展開しておくこと
def a_int(): return int(read())
def ints(): return list(map(int, read().split()))
def read_col(H):
'''H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_tuple(H):
'''H is number of rows'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from functools import reduce
from random import randint
def score(D, C, S, T):
last = [-1] * 26
# scores = [0]
score = 0
for d in range(D):
# scores.append(scores[-1] + S[d][T[d]])
score += S[d][T[d]]
last[T[d]] = d
for i in range(26):
# scores[-1] -= C[i] * (d - last[i])
score -= C[i] * (d - last[i]) # この場で一番罰則が大きいやつを使うとか？
return score
D = a_int()
C = ints()
S = read_tuple(D)
def maximizer(newT, bestT, bestscore):
tmpscore = score(D, C, S, newT)
if tmpscore > bestscore:
return newT, tmpscore
else:
return bestT, bestscore
def ret_init_T():
'''greedyで作ったTを初期値とする。
return
----------
T, score ... 初期のTとそのTで得られるscore
'''
def _make_T(n_days):
# editorialよりd日目の改善は、改善せずにd+n_days経過したときの関数にしたほうが
# 最終的なスコアと相関があるんじゃない？
T = []
last = [-1] * 26
for d in range(D):
ma = -INF
for i in range(26):
tmp = S[d][i]
for j in range(n_days):
tmp += C[i] * (d + j - last[i])
if tmp > ma:
t = i
ma = tmp
last[t] = d # Tを選んだあとで決める
T.append(t)
return T
T = _make_T(0)
sco = score(D, C, S, T)
for i in range(1, 20):
T, sco = maximizer(_make_T(i), T, sco)
return T, sco
bestT, bestscore = ret_init_T()
def add_noise(T):
'''日付dとコンテストqをランダムに選びd日目に開催するコンテストのタイプをqに変更する'''
ret = T.copy()
d = randint(0, D - 1)
q = randint(0, 25)
ret[d] = q
return ret
t1 = time()
bestT, bestscore = maximizer(add_noise(bestT), bestT, bestscore)
dt = time() - t1
times = (1.95 - (time() - t0)) // dt
for _ in range(int(times)):
bestT, bestscore = maximizer(add_noise(bestT), bestT, bestscore)
# while time() - t0 < 1.92:
# # while time() - t0 < 5:
# bestT, bestscore = maximizer(add_noise(bestT), bestT, bestscore)
# print(bestscore)
# print(bestscore)
# print(t0, t1, dt, times, time() - t0)
# print(score(D, C, S, T))
print(*mina(*bestT, sub=-1), sep='\n')
|
d=int(input())
C=[int(i) for i in input().split()]
s=[[int(i) for i in input().split()] for q in range(d)]
sco=0
L=[0 for i in range(26)]
ans=[]
#calc
for i in range(d):
mayou=0
est=s[i][0]+C[0]*(i+1-L[0])
for p in range(1,26):
if s[i][p]+C[p]*(i+1-L[p]) > est:
mayou=p
est=s[i][p]+C[p]*(i+1-L[p])
ans.append(mayou)
L[mayou]=i+1
print(mayou+1) #output
| 1 | 9,669,928,288,218 | null | 113 | 113 |
n, m, l = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(m)]
for i in a:
c = []
for j in zip(*b):
c.append(sum([k * l for k, l in zip(i, j)]))
print(*c)
|
n = int(input())
s = list(map(int,input().split()))
count = 0
def merge(a, left, mid, right):
global count
l = a[left:mid] + [float("inf")]
r = a[mid:right] + [float("inf")]
i = 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 += right - left
def mergeSort(a, left, right):
if left + 1 < right:
mid = right + (left - right)//2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(s, 0, n)
print(*s)
print(count)
| 0 | null | 769,153,925,540 | 60 | 26 |
n, m, x = map(int, input().split())
bk = [list(map(int, input().split())) for _ in range(n)]
pr = 10 ** 7
for i in range(2 ** n):
ef = [0] * (m + 1)
for j in range(n):
if i >> j & 1:
ef = [p + q for (p, q) in zip(ef, bk[j])]
for k in range(1, m + 1):
if ef[k] < x:
break
if k == m:
pr = min(pr, ef[0])
print(pr if pr != 10 ** 7 else -1)
|
r,c=map(int,input().split())
a = []
for i in range(r):
a.append(list(map(int, input().split())))
a[i]+=[sum(a[i])]
print(*a[i])
a=list(zip(*a[::-1]))
for i in range(c):print(sum(a[i]),end=' ')
print(sum(a[c]))
| 0 | null | 11,838,472,624,850 | 149 | 59 |
t = int(input())
print(str(t//3600)+':'+str(t%3600//60)+':'+str(t%60))
|
S = int(input());print('{0}:{1}:{2}'.format(S//3600, S%3600//60, S%60))
| 1 | 330,779,820,300 | null | 37 | 37 |
import sys
I=sys.stdin.readlines()
N,M,L=map(int,I[0].split())
a,b,c=0,0,0
D=[[L+1]*N for i in range(N)]
for i in range(M):
a,b,c=map(int,I[i+1].split())
a,b=a-1,b-1
D[a][b]=c
D[b][a]=c
for i in range(N):
D[i][i]=0
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])
D2=[[N*N+2]*N for i in range(N)]
for i in range(N):
D2[i][i]=0
for j in range(N):
if D[i][j]<=L:
D2[i][j]=1
for k in range(N):
for i in range(N):
for j in range(N):
D2[i][j]=min(D2[i][j],D2[i][k]+D2[k][j])
Q=int(I[M+1])
for i in range(Q):
a,b=map(int,I[i+2+M].split())
if N<D2[a-1][b-1]:
print(-1)
else:
print(D2[a-1][b-1]-1)
|
from scipy.sparse.csgraph import floyd_warshall
N,M,L = list(map(int, input().split()))
edges = [[0] * N for _ in range(N)]
for _ in range(M):
A,B,C = list(map(int, input().split()))
edges[A-1][B-1] = C
edges[B-1][A-1] = C
Q = int(input())
queries = []
for _ in range(Q):
queries.append(list(map(int,input().split())))
# use flord warshall to find min path between all towns
edges = floyd_warshall(edges)
# if the two towns can be travelled to on one tank, add to our fuel graph with distance 1
for i in range(N):
for j in range(N):
if edges[i][j] <= L:
edges[i][j] = 1
else:
edges[i][j] = 0
# use flord warshall to find min number of fuel tanks to travel between two towns
edges = floyd_warshall(edges)
for query in queries:
s = query[0] - 1
t = query[1] - 1
num_tanks = edges[s][t] - 1
if num_tanks != float('inf'):
print(int(num_tanks))
else:
print("-1")
| 1 | 172,977,400,736,534 | null | 295 | 295 |
c = 1
while True:
a = int(raw_input())
if a == 0:
break
print "Case %d: %d" % (c,a)
c = c + 1
|
import sys,math,collections,itertools
input = sys.stdin.readline
N=int(input())
a=list(map(int,input().split()))
xa=a[0]
for i in range(1,len(a)):
xa ^= a[i]
b = []
for ai in a:
b.append(xa^ai)
print(*b)
| 0 | null | 6,543,236,187,998 | 42 | 123 |
a = input().split()
i = 0
for j in range(int(a[0]),int(a[1])+1):
if (int(a[2]) % j) == 0:
i = int(i) + 1
print(i)
|
A, B, K = map(int, input().split())
if K >= A+B:
print("0 0")
elif K <= A:
print("{} {}".format(A-K, B))
elif K > A:
print("0 {}".format(B-(K-A)))
| 0 | null | 52,310,527,226,560 | 44 | 249 |
A,B = input().split()
A = int(A)
B = int(B[0])*100 + int(B[2])*10 + int(B[3])
ans = A*B
ans //= 100
print(ans)
|
n,m =map(int,input().split())
if n <= m:
print('unsafe')
else:
print("safe")
| 0 | null | 22,783,017,038,860 | 135 | 163 |
import math
n = int(input())
a = n/2
print(math.ceil(a)-1)
|
n=int(input())
a=[int(x) for x in input().rstrip().split()]
now=1
mod=10**9+7
def lcm(a,b):#最小公倍数
ori_a=a
ori_b=b
while b!=0:
a,b=b,a%b
return (ori_a*ori_b)//a
for i in a:
now=lcm(i,now)
# print(now)
print(sum([now//i for i in a])%mod)
| 0 | null | 120,349,042,647,060 | 283 | 235 |
n,m=map(int,input().split())
AC=[0]*n
WA=[0]*n
for i in range(m):
t=input().split()
p, s= int(t[0]), t[1]
if s=='AC':
AC[p-1]=1
elif s=='WA' and AC[p-1]==0:
WA[p-1]+=1
ac, wa=0,0
for i in range(n):
if AC[i]:
ac+=1
wa+=WA[i]
print(ac, wa)
|
N, M = map(int, input().split())
pSs = [list(map(str, input().split())) for _ in range(M)]
#%%
ACs = [False for _ in range(N)]
WAs = [0 for _ in range(N)]
for pS in pSs:
problem = int(pS[0]) -1
answer = pS[1]
if ACs[problem] == True:
continue
else:
if answer == "WA":
WAs[problem] += 1
else:
ACs[problem] = True
num_WA = 0
for i, WA in enumerate(WAs):
if ACs[i] == True:
num_WA += WA
print(sum(ACs), num_WA)
| 1 | 92,912,120,817,334 | null | 240 | 240 |
list= map(int,raw_input().split())
if list[0]<list[1] & list[1]<list[2]:
print "Yes"
else:
print "No"
|
def main():
x = input()
x1, x2, x3 = x.split(' ')
a = int(x1)
b = int(x2)
c = int(x3)
if a < b < c:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| 1 | 399,480,043,698 | null | 39 | 39 |
import math
a, b, x = map(int, input().split())
if a*a*b == x:
print(0)
elif a*a*b <= 2*x:
print(90-math.degrees(math.atan(a*a*a/(2*a*a*b-2*x))))
else:
print(90-math.degrees(math.atan(2*x/(a*b*b))))
|
import math
N = int(input())
Ans = math.ceil(N/2)
print(Ans)
| 0 | null | 110,920,359,308,890 | 289 | 206 |
n = int(input())
lst = list(input())
r = lst.count('R')
count = 0
for i in range(0, r):
if lst[i] == 'R':
count += 1
print(r-count)
|
n, s = input(), input()
print(s[:s.count("R")].count("W"))
| 1 | 6,345,278,780,556 | null | 98 | 98 |
class Stack:
def __init__(self, n):
self.A = [0 for i in range(n)]
self.len = n
self.top = 0
def is_empty(self):
return self.top == 0
def is_full(self):
return self.top == self.len - 1
def push(self, x):
if not self.is_full():
self.top += 1
self.A[self.top] = x
def pop(self):
if not self.is_empty():
x = self.A[self.top]
self.top -= 1
return x
def top_element(self):
if not self.is_empty():
return self.A[self.top]
if __name__ == '__main__':
S1 = Stack(20005) # for \
S2 = Stack(10005) # for ponds
line = raw_input()
for i in range(len(line)):
if line[i] == '\\':
S1.push(i)
elif line[i] == '/':
if S1.is_empty():
continue
j = S1.pop()
cnt = 0 # total area of ponds that can be merged
# no more ponds can be merged if S2.top_element()[0] < j, why?
# because '/' is clearly increasing toward the stack top
# and '\' is increasing toward the stack top, too
# if not, there exists a pond that should have been merged
while not S2.is_empty() and S2.top_element()[0] > j:
cnt += S2.pop()[1]
S2.push((j, cnt + i - j))
else:
pass
l = []
cnt = 0
while not S2.is_empty():
x = S2.pop()
cnt += x[1]
l.append(x)
l.reverse()
print cnt
print len(l),
for x in l:
print x[1],
print
|
input_string = input()
total_area = 0
num_lake = 0
lake_areas = []
v_lakes = [] # (湖の始まりidx, 湖の面積)
idx_stack = [] #地形管理
for i, c in enumerate(input_string):
if c == "\\":
idx_stack.append(i)
elif c == "/" and idx_stack:
poped_i = idx_stack.pop()
total_area += i - poped_i
tmp_area = i - poped_i
while v_lakes and v_lakes[-1][0] > poped_i:
tmp_area += v_lakes.pop()[1]
v_lakes.append((poped_i, tmp_area))
#print(v_lakes)
print(total_area)
ans = [area[1] for area in v_lakes]
print(len(v_lakes), *ans)
| 1 | 59,182,433,202 | null | 21 | 21 |
def main():
import collections
N, P = map(int, input().split())
S = input()[::-1]
ans = 0
if P == 2 or P == 5:
for i, s in enumerate(S):
if int(s) % P == 0:
ans += N - i
else:
mod = [0] * P
mod[0] = 1
current = 0
X = 1
for s in S:
current = (current + int(s) * X) % P
ans += mod[current]
mod[current] += 1
X = X * 10 % P
print(ans)
if __name__ == '__main__':
main()
|
N, P = map(int, input().split())
S = [int(x) for x in input()]
if P == 2:
ans = 0
for i in range(N):
if S[N-1-i] % 2 == 0:
ans += N-i
elif P == 5:
ans = 0
for i in range(N):
if S[N-1-i] % 5 == 0:
ans += N-i
else:
ans = 0
cnt = [0] * P
cnt[0] = 1
dec_mod, pre_mod = 1, 0
for i in range(N):
mod = (S[N-1-i] * dec_mod + pre_mod) % P
ans += cnt[mod]
cnt[mod] += 1
dec_mod = dec_mod * 10 % P
pre_mod = mod
print(ans)
| 1 | 58,291,235,926,502 | null | 205 | 205 |
for a in [1,2,3,4,5,6,7,8,9]:
for b in [1,2,3,4,5,6,7,8,9]:
print ("{0}x{1}={2}".format(a,b,a*b))
|
[print('{}x{}={}'.format(i, j, i * j)) for i in range(1, 10) for j in range(1, 10)]
| 1 | 67,100 | null | 1 | 1 |
N = int(input())
X = input()
cnt = X.count('1')
if cnt == 1:
for x in X[:-1]:
if x == '0':
print(1)
else:
print(0)
if X[-1] == '1':
print(0)
else:
print(2)
exit()
M = 0
for x in X:
M <<= 1
if x == '1':
M += 1
def solve(n):
ret = 1
while n > 0:
ret += 1
n %= bin(n).count('1')
return ret
ans = []
p = M % (cnt + 1)
m = M % (cnt - 1)
for i in range(N):
if X[i] == '0':
ans.append(solve((p + pow(2, N - i - 1, cnt + 1)) % (cnt + 1)))
else:
ans.append(solve((m - pow(2, N - i - 1, cnt - 1)) % (cnt - 1)))
print(*ans, sep='\n')
|
n=int(input())
x=input()
p=x.count('1')
#愚直に解く関数を定義
def solve(n):
count=0
while n:
popcount=bin(n).count('1')
n%=popcount
count+=1
return count+1
#popcount(x)が0,1だった場合に対応
if p==0:
for i in range(n):
print(1)
exit()
elif p==1:
z=x.index('1')
t=pow(2,n-z-1,p+1)
for i in range(n):
if i==z:
print(0)
else:
tmp=(t+pow(2,n-i-1,p+1))%(p+1)
print(solve(tmp))
exit()
#2^i mod(p+1),2^i mod(p-1)のリストを作成
a,b=[],[]
for i in range(n):
a.append(pow(2,i,p+1))
b.append(pow(2,i,p-1))
#x mod(p+1),x mod(p-1)を計算
a1,b1=0,0
for i in range(n):
if x[-1-i]=='1':
a1+=a[i]
b1+=b[i]
#本計算
for i in range(n):
if x[i]=='1':
tmp=(b1-b[-1-i])%(p-1)
else:
tmp=(a1+a[-1-i])%(p+1)
print(solve(tmp))
| 1 | 8,279,951,014,300 | null | 107 | 107 |
MOD = 1000000007
n, k = map(int, input().split())
rsw = [0]*(n+2)
for i in range(1,n+2):
rsw[i] = (rsw[i-1]+i-1)%MOD
rsw_e = [0]*(n+2)
for i in range(1,n+2):
rsw_e[i] = (rsw_e[i-1]+n-(i-1))%MOD
res = 0
for i in range(k,n+2):
start = rsw[i]
end = rsw_e[i]
res += (end-start+1)%MOD
print(res%MOD)
|
# -*- config: utf-8 -*-
if __name__ == '__main__':
while 1:
try:
nums = map(int,raw_input().split())
s = sum(nums)
print len(str(s))
except:
break
| 0 | null | 16,489,905,316,490 | 170 | 3 |
X, K, D = map(int, input().split())
X = abs(X)
r = X % D
t = X // D
if t >= K:
ans = abs(X - K * D)
elif (K - t) % 2 == 0:
ans = r
else:
ans = D - r
print(ans)
|
import re
def main():
S , T =map(str, input().split())
print (T+S)
if __name__ == '__main__':
main()
| 0 | null | 54,074,294,766,690 | 92 | 248 |
from statistics import pstdev
while True:
data_count = int(input())
if data_count == 0:
break
print(pstdev(int(x) for x in input().split()))
|
import math
while 1:
n=input()
if n==0:
break
s=map(int,raw_input().split())
m=0.0
for i in range(n):
m+=s[i]
m=m/n
a=0.0
for i in range(n):
a+=(s[i]-m)**2
a=(a/n)**0.5
print a
| 1 | 194,356,333,320 | null | 31 | 31 |
import sys
import math
a = []
for l in sys.stdin:
a.append(int(l))
h = a[0]
n = 0
while h > 1:
h = math.floor(h / 2)
n = n + 1
print(2 ** (n + 1) - 1)
|
import sys
import numpy as np
import math as mt
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
cnt = 1
while n != 1:
n = n//2
cnt += 1
print(sum(2**i for i in range(cnt)))
| 1 | 80,221,225,772,068 | null | 228 | 228 |
def resolve():
k = int(input())
a, b = list(map(int, input().split()))
for i in range(a, b + 1):
if i % k == 0:
print('OK')
return
print('NG')
resolve()
|
n,m=map(int,input().split())
a=list(map(int,input().split()))
def func(n):
ret=0
n=n/2
while n.is_integer():
ret+=1
n=n/2
return ret
b=func(a[0])
for i in range(1,n):
if b==func(a[i]):
continue
else:
print(0)
exit(0)
from fractions import gcd
lcmn=a[0]//2
for i in range(1,n):
lcmn=(lcmn*a[i]//2)//gcd(lcmn,a[i]//2)
print((1+m//lcmn)//2)
| 0 | null | 63,972,141,265,630 | 158 | 247 |
health, attack = map(int, input().split())
damage = list(map(int, input().split()))
if health <= sum(damage):
print('Yes')
else:
print('No')
|
H,N= map(int, input().split())
list = list(map(int, input().split())) #Aiを入力
for i in list:
H=H-i
if H<=0:
print('Yes')
else:
print('No')
| 1 | 78,303,211,656,488 | null | 226 | 226 |
n, m = map(int, input().split())
mat = []
for i in range(n):
mat.append(list(map(int, input().split())))
vec = []
for i in range(m):
vec.append(int(input()))
for i in range(n):
e = 0
for j in range(m):
e += mat[i][j] * vec[j]
print(e)
|
N, M = map(int, raw_input().split())
matrix = []
array = []
for n in range(N):
tmp = map(int, raw_input().split())
if len(tmp) > M:
print 'error'
matrix.append(tmp)
for m in range(M):
tmp = input()
array.append(tmp)
for n in range(N):
multi = 0
for m in range(M):
multi += matrix[n][m] * array[m]
print multi
| 1 | 1,144,607,690,340 | null | 56 | 56 |
N,X,Y = list(map(int,input().split()))
ans_dict={}
for n in range(1,N):
ans_dict[n]=0
for n1 in range(1,N+1):
for n2 in range(n1+1,N+1):
ans_1 = abs(n1-n2)
ans_2 = abs(n1-X)+abs(n2-Y)+1
ans_3 = abs(n2-X)+abs(n1-Y)+1
ans=min(ans_1,ans_2,ans_3)
ans_dict[ans]+=1
for k in ans_dict.keys():
print(ans_dict[k])
|
def solve():
N,X,Y = [int(i) for i in input().split()]
distance_cnt = {}
for i in range(1, N+1):
for j in range(i+1, N+1):
distance = min(j-i, abs(X-i)+abs(Y-j)+1)
distance_cnt[distance] = distance_cnt.get(distance, 0) + 1
for i in range(1, N):
print(distance_cnt.get(i, 0))
if __name__ == "__main__":
solve()
| 1 | 44,236,545,612,478 | null | 187 | 187 |
n, d = map(int, input().split())
x, y = zip(*[list(map(int, input().split())) for i in range(n)])
ans = 0
for i in range(n):
if x[i]**2 + y[i]**2 <= d**2:
ans += 1
print(ans)
|
nd=input().split()
n=int(nd[0])
d=int(nd[1])
count=0
z=d*d
for i in range(0,n):
xy=input().split()
x=int(xy[0])
y=int(xy[1])
if(x*x+y*y<=z):
count+=1
print(count)
| 1 | 5,895,273,245,908 | null | 96 | 96 |
import array
N = int(input())
A = array.array('L', list(map(int, input().split())))
MAX = 10**5+1
X = array.array('L', [0]) * MAX
Y = array.array('L', range(MAX))
for i in range(len(A)): X[A[i]] += 1
Q = int(input())
cur = sum(array.array('L', (X[i]*Y[i] for i in range(len(X)))))
for i in range(Q):
[b, c] = list(map(int, input().split()))
cur = cur - X[b]*b + X[b]*c
print(cur)
X[c] += X[b]
X[b] = 0
|
a,b=map(int,input().split())
def gcd(x, y):
while y:
x, y = y, x % y
return x
l=gcd(a,b)
print(int(a*b/l))
| 0 | null | 62,660,649,194,272 | 122 | 256 |
def solve():
r = int(input())
print(r*r)
if __name__ == '__main__':
solve()
|
S = list(map(str, input().split()))
print(S[1] + S[0])
| 0 | null | 123,846,445,065,420 | 278 | 248 |
import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
M1, D1 = map(int, readline().split())
M2, D2 = map(int, readline().split())
if M1 != M2:
print('1')
else:
print('0')
if __name__ == '__main__':
main()
|
a = input().split()
print(' '.join(sorted(a)))
| 0 | null | 62,524,711,008,100 | 264 | 40 |
s = input()
num = int(input())
for i in range(num):
L = input().split()
if L[0] == 'print':
print(s[int(L[1]):int(L[2])+1])
elif L[0] == 'reverse':
ts = s[int(L[1]):int(L[2])+1]
s = s[:int(L[1])] + ts[:: -1] + s[int(L[2])+1:]
elif L[0] == 'replace':
s = s[:int(L[1])] + L[3] + s[int(L[2])+1:]
|
string = input()
q = int(input())
for i in range(q):
order = list(input().split())
a, b = int(order[1]), int(order[2])
if order[0] == "print":
print(string[a:b+1])
elif order[0] == "reverse":
string = string[:a] + (string[a:b+1])[::-1] + string[b+1:]
else:
string = string[:a] + order[3] + string[b+1:]
| 1 | 2,093,304,379,738 | null | 68 | 68 |
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
S = sys.stdin.buffer.readline().decode().rstrip()
N = len(S)
# ピッタリ払う
dp0 = [INF] * (N + 1)
# 1 多く払う
dp1 = [INF] * (N + 1)
dp0[0] = 0
dp1[0] = 1
for i, c in enumerate(S):
dp0[i + 1] = min(dp0[i] + int(c), dp1[i] + 10 - int(c))
dp1[i + 1] = min(dp0[i] + int(c) + 1, dp1[i] + 10 - int(c) - 1)
# print(dp0)
# print(dp1)
print(dp0[-1])
|
N = list(map(int, input()))
# print(N)
ans = 0
DP = [0] *2
DP[0] = 0
DP[1] = 1
for i in N:
a, b = DP[0] ,DP[1]
DP[0] = a + i if a+i < b +(10-i) else b +(10-i)
DP[1] = a + i+1 if a + i+1 < b + (9-i) else b + (9-i)
# print(DP)
print(DP[0] if DP[0] <= DP[1]+1 else DP[1] +1)
| 1 | 70,685,000,791,818 | null | 219 | 219 |
r = int(input())
answer = r ** 2
print(answer)
|
n = int(input())
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
# その数自身
ans = 1
# 1以外のn-1の約数
ans += len(make_divisors(n-1)) - 1
d = make_divisors(n)
for k in range(1,(len(d)+1)//2):
i = d[k]
j = n//i
while j % i == 0:
j //= i
if j % i == 1:
ans += 1
print(ans)
| 0 | null | 93,810,706,466,400 | 278 | 183 |
a,b,c = map(int,input().split())
an = c-a-b
ab = a*b
if an <= 0:
print("No")
else:
an = an*an
if an-4*ab > 0:
print("Yes")
else:
print("No")
|
ab = list(map(int,input().split()))
ab.sort()
print(str(ab[0])*ab[1])
| 0 | null | 68,033,999,626,672 | 197 | 232 |
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
a, b, x = map(int, readline().split())
if a*a*b/2 < x:
tan = 2 * b / a - 2 * x / (a ** 3)
ans = math.degrees(math.atan(tan))
print(ans)
else:
tan = a * b * b / x / 2
ans = math.degrees(math.atan(tan))
print(ans)
if __name__ == '__main__':
solve()
|
#!/usr/bin/env python
#coding: UTF-8
import sys
import math
i= sys.stdin.readline()
a,b,c = map(int,i.split())
d = math.cos(math.radians(c))
c = math.sin(math.radians(c))
S = 0.5*a*b*c
L = math.sqrt(a**2+b**2-2*a*b*d)+a+b
h = S*2/a
print S,L,h
| 0 | null | 81,736,948,270,140 | 289 | 30 |
from itertools import groupby
s = input()
k = int(input())
if len(set(s)) == 1:
print(len(s)*k//2)
exit()
g = [len(list(v)) for _, v in groupby(s)]
ans = sum(i//2 for i in g)*k
if s[0] != s[-1]:
print(ans)
exit()
a, *_, b = g
ans -= (a//2 + b//2 - (a+b)//2)*(k-1)
print(ans)
|
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
S = input()
k = I()
from itertools import groupby
x = y = 0
g = [len(list(v)) for k,v in groupby(S)]
for c in g:
x += c//2
if S[-1] == S[0]:
if g[-1]%2 == 0 or g[0]%2 == 0:
pass
elif len(S) == 1:
y = k//2
elif len(S) == g[0]:
y = k//2
else:
y = k-1
print(x * k + y)
| 1 | 175,619,408,648,770 | null | 296 | 296 |
k = int(input())
ans = k * "ACL"
print(ans)
|
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
print("YES" if A+T*V>= B+T*W and A-T*V <= B-T*W else "NO")
| 0 | null | 8,633,282,100,242 | 69 | 131 |
N = int(input())
S = input()
ans = S.count('ABC')
print(ans)
|
# -*-coding:utf-8
import fileinput
import math
def main():
for line in fileinput.input():
a, b, c = map(int, line.strip().split())
if(a < b and b <c):
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| 0 | null | 49,852,839,894,352 | 245 | 39 |
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
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)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
a = [input() for i in range(n)]
sp,sm = [],[]
for i in range(n):
p = 0
m = 0
for j in a[i]:
if j == "(":
p += 1
else:
p -= 1
if p < m:
m = p
if p > 0:
sp.append((m,p))
else:
sm.append((m,p))
sp.sort(reverse = True)
sm.sort(key = lambda x:x[0]-x[1])
k = 0
for m,p in sp:
if k+m < 0:
print("No")
return
k += p
for m,p in sm:
if k+m < 0:
print("No")
return
k += p
if k != 0:
print("No")
else:
print("Yes")
return
#Solve
if __name__ == "__main__":
solve()
|
n=int(input())
R=[int(input()) for i in range(n)]
mini=10**10
maxi=-10**10
for r in R:
maxi=max([maxi,r-mini])
mini=min([mini,r])
print(maxi)
| 0 | null | 11,725,457,726,048 | 152 | 13 |
from bisect import bisect_left
N, M = map(int, input().split())
s = input()
safe = []
cnt = 0
for i, m in enumerate(s):
if m=='1':
cnt += 1
if cnt==M:
print(-1)
break
else:
safe += [i]
cnt = 0
else:
ps = N
ans = []
while ps!=0:
ind = bisect_left(safe,ps-M)
ans += [ps-safe[ind]]
ps = safe[ind]
print(*ans[::-1])
|
for a,b,c in[sorted(map(int,raw_input().split()))for i in range(input())]:
print"NO"if c*c-a*a-b*b else"YES"
| 0 | null | 69,802,353,494,368 | 274 | 4 |
import math
def merge(S, left, mid, right) -> int:
# n1 = mid - left
# n2 = right - mid
L = S[left: mid]
R = S[mid: right]
# for i in range(n1):
# L.append(S[left + i])
L.append(math.inf)
# for i in range(n2):
# R.append(S[mid + i])
R.append(math.inf)
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[j]:
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
return right - left
def merge_sort(S, left, right):
count = 0
if left + 1 < right:
mid = int((left + right) / 2)
count += merge_sort(S, left, mid)
count += merge_sort(S, mid, right)
count += merge(S, left, mid, right)
return count
def main():
n = int(input())
S = list(map(int, input().split()))
count = 0
count = merge_sort(S, 0, n)
print(*S)
print(count)
if __name__ == "__main__":
main()
|
N = int(raw_input())
count = 0
A_str = raw_input().split()
A = map(int, A_str)
def merge(left, right):
global count
sorted_list = []
l_index = 0
r_index = 0
while l_index < len(left) and r_index < len(right):
count += 1
if left[l_index] <= right[r_index]:
sorted_list.append(left[l_index])
l_index += 1
else:
sorted_list.append(right[r_index])
r_index += 1
if len(left) != l_index:
sorted_list.extend(left[l_index:])
count += len(left[l_index:])
if len(right) != r_index:
sorted_list.extend(right[r_index:])
count += len(right[r_index:])
return sorted_list
def mergeSort(A):
if len(A) <= 1:
return A
mid = len(A) // 2
left = A[:mid]
right = A[mid:]
left = mergeSort(left)
right = mergeSort(right)
return list(merge(left, right))
print ' '.join(map(str, mergeSort(A)))
print count
| 1 | 111,980,862,308 | null | 26 | 26 |
n,m =map(int,input().split())
if n <= m:
print('unsafe')
else:
print("safe")
|
def main():
S, W = map(int, input().split())
cond = S <= W
print('unsafe' if cond else 'safe')
if __name__ == '__main__':
main()
| 1 | 29,216,515,523,340 | null | 163 | 163 |
nS = int(input())
S = list(map(int,input().split()))
nQ = int(input())
Q = list(map(int,input().split()))
cnt = 0
for i in range(nQ):
copy_S = S.copy()
copy_S.append(Q[i])
j = 0
while copy_S[j] != Q[i]:
j += 1
if j < len(copy_S)-1 : cnt += 1
print(cnt)
|
n=map(str,raw_input().split())
a=[]
ai=0
for i in n:
if i=="+" :
a.append(a[ai-1]+a[ai-2])
a.pop(ai-1);a.pop(ai-2)
ai-=1
elif i=="-":
a.append(a[ai-2]-a[ai-1])
a.pop(ai-1);a.pop(ai-2)
ai-=1
elif i=="*":
a.append(a[ai-1]*a[ai-2])
a.pop(ai-1);a.pop(ai-2)
ai-=1
else:
a.append(int(i))
ai+=1
print(a[0])
| 0 | null | 53,634,966,922 | 22 | 18 |
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
def bubblesort(l):
for index in range(len(l)-1, 0, -1):
for low in range(index):
if l[low] > l[low+1]:
tmp = l[low+1]
l[low+1] = l[low]
l[low] = tmp
return l
bubblesort(P)
sum = 0
for i in range(K):
sum = sum + P[i]
print(sum)
|
def main(n,m,s):
#i初期化
i = n
tmp = []
while i > 0 :
for j in range(m,-1,-1):
if j == 0 :
i = -1
break
if i-j >= 0 :
if s[i-j] == '0':
i -= j
tmp.append(j)
break
if i == 0:
for l in reversed(tmp):
print(l,end=' ')
else:
print(-1)
n,m = map(int,input().split())
s = input()
main(n,m,s)
| 0 | null | 74,987,048,363,876 | 120 | 274 |
K = int(input())
string = "ACL"
print(string * K)
|
k=int(input())
if k==1:
print('ACL')
elif k==2:
print('ACLACL')
elif k==3:
print('ACLACLACL')
elif k==4:
print('ACLACLACLACL')
elif k==5:
print('ACLACLACLACLACL')
| 1 | 2,175,330,175,392 | null | 69 | 69 |
a,b,c=map(int,input().split());print('Yes'if a<b<c else'No')
|
a, b, c = [int(w) for w in input().split()]
print("Yes" if a < b and b < c else "No")
| 1 | 383,579,414,636 | null | 39 | 39 |
N=int(input())
P=list(map(int,input().split()))
x=N+1
cnt=0
for i in range(N):
if P[i]<x:
cnt+=1
x=P[i]
print(cnt)
|
import sys
input = sys.stdin.readline
def solve(N):
res = 0
flg = 0
for n in reversed(N):
if flg == 2:
if n >= 5:
flg = 1
else:
flg = 0
m = flg + n
if m == 5:
res += 5
flg = 2
elif m < 5:
res += m
flg = 0
else:
res += (10 - m)
flg = 1
return res + flg%2
N = list(map(int, input().strip()))
print(solve(N))
# N = 1
# q = 0
# while True:
# p = solve(list(map(int, str(N))))
# if abs(p-q) > 1:
# print(N, "OK")
# exit()
# q = p
# N += 1
| 0 | null | 77,876,628,767,938 | 233 | 219 |
def main():
N, M = tuple([int(_x) for _x in input().split()])
A = [int(_x) for _x in input().split()]
total = sum(A)
if total % (4*M) == 0:
min_vote = total // (4 * M)
else:
min_vote = 1 + total // (4 * M)
cnt = 0
for vot in A:
if vot >= min_vote:
cnt += 1
if (cnt >= M):
print("Yes")
else:
print("No")
main()
|
n, k = map(int, input().split())
p = list(map(int,input().split()))
q = [(x+1)/2 for x in p]
q1 = sum(q[:k])
ans = q1
for i in range(n-k):
x = q1-q[i] +q[i+k]
q1 = x
if ans < x:
ans = x
print(ans)
| 0 | null | 56,593,240,589,830 | 179 | 223 |
import sys
input = sys.stdin.readline
h,n = map(int,input().split())
ab = [list(map(int,input().split()))for i in range(n)]
amx = 0
for i in range(n):
if amx < ab[i][0]:
amx = ab[i][0]
#dp[i] = モンスターの削る体力がiの時の魔力の消費の最小値
dp = [float('inf')]*(amx + h + 1)
dp[0] = 0
for i in range(amx + h + 1):
for m in ab:
if i-m[0] >= 0:
dp[i] = min(dp[i], dp[i-m[0]] + m[1])
ans = float('inf')
for i in range(h,amx + h + 1):
ans = min(ans, dp[i])
print(ans)
|
h,n = map(int,input().split())
M = []
max_val = 0
for _ in range(n):
a,b = map(int,input().split())
max_val = max(max_val,a)
M.append((a,b))
dp = [float('inf')]*(h+1+max_val)
dp[0] = 0
for i in range(1,h+1+max_val):
for j in range(n):
dp[i] = min(dp[i-M[j][0]] + M[j][1],dp[i])
print(min(dp[h:-1]))
| 1 | 81,376,201,903,108 | null | 229 | 229 |
# coding: utf-8
import string
d = {}
for ch in list(string.ascii_lowercase):
d[ch] = 0
while True:
try:
s = list(input().lower())
except EOFError:
break
for ch in s:
if ch.isalpha():
d[ch] += 1
else:
pass
for k, v in sorted(d.items()):
print('{} : {}'.format(k, v))
|
def main():
N = input_int()
S = input()
validitylist = [False] * N
validitylist[0] = True
for i in range(1, N):
if S[i-1] != S[i]:
validitylist[i] = True
print(len([i for i in validitylist if i is True]))
def input_int():
return int(input())
def input_int_tuple():
return map(int, input().split())
def input_int_list():
return list(map(int, input().split()))
main()
| 0 | null | 85,751,842,160,398 | 63 | 293 |
n = int(input())
A = list(map(int, input().split()))
from collections import defaultdict
dic = defaultdict(int)
dic[0] = 3
ans = 1
mod = 1000000007
for a in A:
ans *= dic[a]
ans = ans % mod
dic[a] -= 1
dic[a+1] += 1
print(ans)
|
mod = 10 ** 9 + 7
n = int(input())
a = map(int, input().split())
cnt = [0] * (n + 1)
cnt[-1] = 3
ret = 1
for x in a:
ret = ret * cnt[x - 1] % mod
cnt[x - 1] -= 1
cnt[x] += 1
print(ret)
| 1 | 129,576,051,129,928 | null | 268 | 268 |
import sys
n=input()
house=[[[],[],[]],[[],[],[]],[[],[],[]],[[],[],[]]]
for i in range(4):
for j in range(3):
for k in range(10):
house[i][j].append(0)
for i in range(n):
b,f,r,v=map(int,raw_input().split())
house[b-1][f-1][r-1]+=v
for i in range(4):
for j in range(3):
for k in range(10):
sys.stdout.write(' %d'%house[i][j][k])
print('')
if i!=3:
print('#'*20)
|
x,y = list(map(int, input().split()))
ans=0
prize=[0, 300000, 200000, 100000, 0]
if x ==1 and y == 1:
print(1000000)
else:
print(prize[min(x,4)] + prize[min(y,4)])
| 0 | null | 70,835,734,347,378 | 55 | 275 |
n = int(input())
for _ in range(n):
num = sorted(map(int, input().split()))
print("YES" if num[2]**2 == num[1]**2 + num[0]**2 else "NO")
|
data = []
try:
while True:
data.append(raw_input())
except EOFError:
pass
n = int(data[0])
if n <= 1000:
for i in range(1, n+1):
x, y, z = data[i].split()
x, y, z = int(x), int(y), int(z)
if x <= 1000 and y <= 1000 and z <= 1000:
if (z * 0.8 == x and z * 0.6 == y
or z * 0.8 == y and z * 0.6 == x
or y * 0.8 == x and y * 0.6 == z
or y * 0.8 == z and y * 0.6 == x
or x * 0.8 == z and x * 0.6 == y
or x * 0.8 == y and x * 0.6 == z):
print "YES"
else:
print "NO"
| 1 | 278,356,200 | null | 4 | 4 |
def area_cal(input_fig):
stack = []
# area = [[面積計算が始まった位置, 面積],・・・]
area = []
total = 0
for i in range(len(input_fig)):
fig = input_fig[i]
if fig == "\\":
stack.append(i)
elif fig == "/" and stack:
j = stack.pop()
width = i - j
total += width
while area and area[-1][0] > j:
width += area[-1][1]
area.pop()
area.append([i,width])
return area, total
input_fig = input()
area, total = area_cal(input_fig)
print(total)
if area:
print(len(area),*list(zip(*area))[1])
else:
print(0)
|
# coding: utf-8
def areas_calc(strings):
stack1 = []
stack2 = []
total_m = 0
for i, s in enumerate(strings):
if s == "\\":
stack1.append(i)
elif s == "_":
continue
elif s == '/':
if len(stack1) > 0:
previous_i = stack1.pop()
m = i - previous_i
total_m += m
while len(stack2) > 0:
stacked_i, stacked_m = stack2.pop()
if previous_i < stacked_i:
m += stacked_m
else:
stack2.append((stacked_i, stacked_m))
stack2.append((previous_i, m))
break
else:
stack2.append((previous_i, m))
print(total_m)
k = len(stack2)
for_output = [str(k)] + [str(m) for i, m in stack2]
print(' '.join(for_output))
if __name__ == "__main__":
areas_calc(input())
| 1 | 54,897,223,170 | null | 21 | 21 |
def gcd(x, y):
if x % y == 0:
return y
else:
return gcd(y, x % y)
x, y = map(int, input().split())
print(gcd(x, y))
|
x, y = map(int, input().split())
def gcd(x, y):
if x % y == 0:
return y
elif x % y == 1:
return 1
else:
return gcd(y, x % y)
if x >= y:
n = gcd(x, y)
print(n)
else:
n = gcd(y, x)
print(n)
| 1 | 7,129,532,930 | null | 11 | 11 |
l = list(input())
h = [0]
for i in range(len(l)):
if l[i] == "\\":
h.append(h[i]-1)
elif l[i] == "/":
h.append(h[i]+1)
else:
h.append(h[i])
A = 0
k = 0
L = []
i = 0
if "".join(l[5:65]) + (" ") == "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ " and "".join(l[1:61]) + (" ") != "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ " :
print("1"+"\n"+ "1" + " " + "1")
else:
while i in range(len(l)):
if l[i] == "\\" and h[i] <= max(h[i+1:len(l)+2]):
s = 0
a = h[i]
s += 0.5
i += 1
while h[i] < a:
s += a - (h[i] + h[i+1])*0.5
i += 1
A += int(s)
k += 1
L.append(int(s))
else:
i += 1
print(A)
print(k,end="")
if len(L) >0:
print(" ",end="")
print(" ".join(map(str, L)))
else:
print("")
|
import sys
from collections import deque
def test():
EleList = deque()
sublist = []
output = []
areas_from_left = list(sys.stdin.readline())
sum = 0
depth = 0
for element in areas_from_left:
if element == '\\':
depth += 1
EleList.append(element)
elif element == '_':
if EleList:
EleList.append(element)
elif element == '/':
depth -= 1
if EleList:
for pop_count in range(len(EleList)):
pop_ele = EleList.pop()
if pop_ele == '\\' and EleList:
for i in range(pop_count+2):
EleList.append('_')
break
lake = pop_count + 1
sum += lake
if len(EleList) == 0:
if len(sublist) == 0:
output.append(lake)
else:
tmp = 0
for i in sublist:
tmp += i[0]
output.append(tmp + lake)
sublist.clear()
else:
if not sublist or sublist[len(sublist)-1][1] < depth:
sublist_element = [0,0]
sublist_element[0] = lake
sublist_element[1] = depth
sublist.append(sublist_element)
else:
sublist_element = [lake,depth]
while True:
if not sublist:
break
tmp = sublist.pop()
if tmp[1] > depth:
sublist_element[0] += tmp[0]
else:
sublist.append(tmp)
break
sublist.append(sublist_element)
#print(f"{output}{sublist}")
output_sublist = []
for tmp in sublist:
output_sublist.append(tmp[0])
output = output + output_sublist
length = len(output)
print(sum)
if length != 0:
print(f"{length} ",end='')
else:
print(length)
for i in range(length - 1):
print(f"{output[i]} ",end='')
if output:
print(output[length-1])
if __name__ == "__main__":
test()
| 1 | 59,930,145,760 | null | 21 | 21 |
N=int(input())
ans = []
for i in range(1,N+1):
if i % 3 == 0 and i % 5 == 0:
continue
elif i % 3 == 0 and i % 5 != 0:
continue
elif i % 5 == 0 and i % 3 != 0:
continue
else:
ans.append(i)
print(sum(ans))
|
n,m=map(int, input().split())
alist=[list(map(int, input().split())) for i in range(m)]
ans=-1
for i in range(999,-1,-1):
if len(str(i))==n:
x=True
stri=str(i)
for j in range(m):
if stri[alist[j][0]-1]!=str(alist[j][1]):
x=False
if x:
ans=i
print(ans)
| 0 | null | 47,650,490,008,730 | 173 | 208 |
size = [int(i) for i in input().split()]
matrix = [[0 for i in range(size[1])] for j in range(size[0])]
vector = [0 for i in range(size[1])]
for gyou in range(size[0]):
x = [int(i) for i in input().split()]
matrix[gyou] = x
for retsu in range(size[1]):
x = int(input())
vector[retsu] = x
for gyou in range(size[0]):
print(sum(map(lambda val1, val2: val1 * val2, matrix[gyou], vector)))
|
def bubble_sort(alist):
"""Sort alist by bubble sort.
Returns (number of swap operations, sorted list)
>>> bubble_sort([5, 3, 2, 4, 1])
([1, 2, 3, 4, 5], 8)
"""
size = len(alist)
count = 0
for i in range(size-1):
for j in reversed(range(i+1, size)):
if alist[j] < alist[j-1]:
count += 1
alist[j-1], alist[j] = alist[j], alist[j-1]
return (alist, count)
def run():
_ = int(input()) # flake8: noqa
nums = [int(i) for i in input().split()]
(sorted_list, num_swap) = bubble_sort(nums)
print(" ".join([str(i) for i in sorted_list]))
print(num_swap)
if __name__ == '__main__':
run()
| 0 | null | 592,532,141,548 | 56 | 14 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.