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 = list()
for i in range(10):
s.append(input())
s.sort(reverse = True)
for i in range(3):
print s[i]
|
N, M = map(int, input().split(' '))
ac_set = set()
wa_cnt_list = [0] * N
ac_cnt, wa_cnt = 0, 0
for i in range(M):
num, res = input().split(' ')
num = int(num) - 1
if num not in ac_set:
if res == 'AC':
ac_cnt += 1
wa_cnt += wa_cnt_list[num]
ac_set.add(num)
else:
wa_cnt_list[num] += 1
print(ac_cnt, wa_cnt)
| 0 | null | 46,885,789,907,356 | 2 | 240 |
n = int(raw_input())
numbers = map(int, raw_input().split())
print min(numbers), max(numbers), sum(numbers)
|
hoge = int(input())
l = [int(i) for i in input().split()]
mn = min(l)
mx = max(l)
sm = sum(l)
print(mn,mx,sm)
| 1 | 738,640,861,482 | null | 48 | 48 |
mod=10**9+7
n,k=map(int,input().split())
cnt=[0]*k
for i in range(k,0,-1):
cnt[i-1]=pow(k//i,n,mod)
for j in range(i*2,k+1,i):
cnt[i-1]-=cnt[j-1]
cnt[i-1]%=mod
ans=0
for i in range(k):
ans+=cnt[i]*(i+1)%mod
print(ans%mod)
|
n,k = map(int,input().split())
MOD = 10**9+7
# g[i]:gcd(A1,A2,,,An)=iとなる数列の個数
g = [0 for _ in range(k)]
for i in range(k,0,-1):
g[i-1] = pow(k//i,n,MOD)
#ここまででg[x]=gcdがxの倍数となる数列の個数となっているので、
#ここからgcdが2x,3x,,,となる数列の個数を引いていく。
for j in range(2,k+1):
if i*j > k:
break
g[i-1] -= g[i*j-1]
g[i-1] %= MOD
#print(g)
ans = 0
for i in range(k):
ans += (i+1)*g[i]
ans %= MOD
print(ans)
| 1 | 36,588,792,911,330 | null | 176 | 176 |
'''
参考
https://marco-note.net/abc-175-work-log/
'''
N, K = map(int, input().split()) # コマ数、最大移動可能回数
P = list(map(int, input().split())) # 移動先のコマ番号
C = list(map(int, input().split())) # そのコマに立ち寄った時に加算される得点
ans = -float('inf') # 解を-∞で初期化
for piece in range(N): # 各コマについて、スタート地点とした場合の得点を調べる
S = [] # 累積和
mov = P[piece] - 1 # 1回目の移動：移動先（indexなので-1する）
S.append(C[mov]) # 1回目の移動：得点
while mov != piece: # 2回目以降の移動（スタート地点に戻ったらループ終了）
mov = P[mov] - 1 # 2回目以降：移動先
S.append(S[-1] + C[mov]) # 2回目以降：得点（最終要素に加算した値をリストに追加）
if K <= len(S): # 【パターン1】与えられた移動可能回数では一巡できない
score = max(S[:K]) # 得点=移動可能回数までの最大得点
elif S[-1] <= 0: # 【パターン2】一巡できるが一巡してしまうと得点が減る
score = max(S) # 得点=一巡するまでの最大得点
else:
score_a = S[-1] * (K // len(S)) # 【パターン3-1】与えられた移動可能回数で廻れるだけ廻る
rem = K % len(S)
if rem != 0:
score_a += max(0, max(S[:rem]))
score_b = S[-1] * (K // len(S) - 1) # 【パターン3-2】1周少なく廻りあとは最高得点のところで止める
score_b += max(S)
score = max(score_a, score_b)
ans = max(ans, score)
print(ans)
|
W,H,x,y,r=[int(x) for x in input().split()]
print("No" if x < r or y < r or (x+r) > W or (y+r) > H else "Yes")
| 0 | null | 2,874,789,303,622 | 93 | 41 |
from collections import defaultdict
n = int(input())
results = defaultdict(lambda: 0)
for _ in range(n):
s = input()
results[s] += 1
for judge in ['AC', 'WA', 'TLE', 'RE']:
print(judge, ' x ', results[judge])
|
from time import perf_counter
t0 = perf_counter()
import sys
sys.setrecursionlimit(300000)
from collections import defaultdict
from random import randint
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI0(): return map(lambda s: int(s) - 1, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
def LMI0(): return list(map(lambda s: int(s) - 1, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')
D = I()
C = LMI()
S = [LMI() for _ in range(D)]
# 初期解の生成
last = defaultdict(int)
ans0 = []
for d in range(D):
m = -INF
ans = -1
for i in range(26):
lans = S[d][i]
for j in range(26):
if i == j:
lans -= C[j] * (d + 1 - d - 1)
else:
lans -= C[j] * (d + 1 - last[j])
if lans > m:
m = lans
ans = i
ans0.append(ans)
T = ans0
last = [[i + 1] * 26 for i in range(D)]
for d in range(D):
i = T[d]
j = 0
for dd in range(d, D):
last[dd][i] = j
j += 1
def eval(d, q):
i = T[d]
val = S[d][q] - S[d][i]
contrib = 0
if d == 0:
j = 1
else:
j = last[d - 1][i] + 1
for dd in range(d, D):
if dd > d and last[dd][i] == 0:
break
contrib += j - last[dd][i]
last[dd][i] = j
j += 1
val -= contrib * C[i]
contrib = 0
j = 0
for dd in range(d, D):
if last[dd][q] == 0:
break
contrib += last[dd][q] - j
last[dd][q] = j
j += 1
val += contrib * C[q]
T[d] = q
return val
# TLまで焼きなましで1点更新
i = 0
while perf_counter() - t0 < 1.8:
for _ in range(30):
d = randint(0, D - 1)
q = randint(0, 25)
i = T[d]
val = eval(d, q)
if val < 0:
if randint(0, (i + 1) ** 2) == 0:
pass
else:
eval(d, i)
i += 1
for t in T:
print(t + 1)
| 0 | null | 9,112,618,905,148 | 109 | 113 |
X = int(input())
ans = X//500*1000
X = X % 500
ans += X//5*5
print(ans)
|
X = int(input())
ans = 0
if X >= 500:
ans += (X//500)*1000
ans += ((X%500)//5)*5
else:
ans += (X//5)*5
print(ans)
| 1 | 42,524,026,435,110 | null | 185 | 185 |
s = input()
iters = len(s) // 2
count=0
for i in range(iters):
if s[i] != s[-(i+1)]:
count+=1
print(count)
|
# 147 B
s = input()
k = s[::-1]
n = 0
for i in range(len(s)):
if s[i] != k[i]:
n += 1
# print(s[i])
print(n // 2)
| 1 | 120,012,759,078,300 | null | 261 | 261 |
N = int(input())
S = input()
ris = [i for i, s in enumerate(S) if s == "R"]
gis = [i for i, s in enumerate(S) if s == "G"]
bis = [i for i, s in enumerate(S) if s == "B"]
all = len(ris) * len(gis) * len(bis)
cnt = 0
for i in range(N):
for j in range(i+1, N):
k = 2*j - i
if 0 <= k < N:
if S[i] != S[j] and S[i] != S[k] and S[j] != S[k]:
cnt += 1
ans = all - cnt
print(ans)
|
import sys
from operator import mul
from functools import reduce
from collections import Counter
n = int(input())
s = input()
c = Counter(s)
if len(c) != 3:
print(0)
sys.exit()
ans = reduce(mul, c.values())
for i in range(n - 1):
x, y, z = i, i + 1, i + 2
while z <= n - 1:
if s[x] != s[y] and s[x] != s[z] and s[y] != s[z]:
ans -= 1
y += 1
z += 2
print(ans)
| 1 | 35,938,576,076,260 | null | 175 | 175 |
S=str(input())
if S.count('R')==0:
print(0)
if S.count('R')==1 :
print(1)
if S.count('R')==2 and not S.count('RR') ==1:
print(1)
if S.count('RR')==1 and not S.count('RRR')==1:
print(2)
if S.count('RRR')==1:
print(3)
|
s=list(input())
count=0
if 'R' in s:
count+=1
for i in range(len(s)-1):
if s[i]==s[i+1] and s[i]=='R':
count+=1
print(count)
| 1 | 4,846,772,469,952 | null | 90 | 90 |
X,N=map(int,input().split())
if N>0:
P=list(map(int,input().split()))
for i in range(N+1):
if X-i not in P:
print(X-i)
break
elif X+i not in P:
print(X+i)
break
else:
print(X)
|
import math
h,w = map(int,input().split())
if w < h:
h,w = w,h
if h==1:
print(1)
else:
ans = math.ceil((h*w)/2)
print(max(1,ans))
| 0 | null | 32,623,664,677,890 | 128 | 196 |
import sys
sys.setrecursionlimit(10**9)
def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))
INF=10**20
def main():
N,K=mi()
P=list(mi())
C=list(mi())
ans = -INF
for i in range(N):
start = i + 1
stack = [start]
score_his = [0]
scores = 0
depth = 1
seen = {}
while stack:
if depth > K: break
current = stack.pop()
if current in seen:
loop_start_depth = seen[current]
loop_end_depth = depth - 1
loop_scores = score_his[-1] - score_his[loop_start_depth-1]
loop_len = loop_end_depth - loop_start_depth + 1
if loop_scores < 0: break
# print(start,score_his)
# print(loop_start_depth,loop_end_depth,loop_scores,loop_len)
rest_count = K - depth + 1
available_loop_count = rest_count // loop_len
res1 = (available_loop_count-1) * loop_scores + scores
# print("a",rest_count,available_loop_count,res1)
res2 = res1
rest_loop_len = rest_count % loop_len + loop_len
# print("b",rest_loop_len)
ress = [res1,res2]
for j in range(rest_loop_len):
score = C[P[current-1]-1]
res2 += score
ress.append(res2)
current = P[current-1]
# print("ress",ress)
score_his.append(max(ress))
break
score = C[P[current-1]-1]
scores += score
score_his.append(scores)
seen[current] = depth
stack.append(P[current-1])
depth += 1
ans = max(ans,max(score_his[1:]))
print(ans)
if __name__ == "__main__":
main()
|
N, K = map(int, input().split())
P = list(map(lambda x: int(x) - 1, input().split()))
C = list(map(int, input().split()))
maxscore = -(10 ** 18)
for st in range(N):
cumsum = [0]
now = st
while(P[now] != st):
now = P[now]
cumsum.append(cumsum[-1] + C[now])
cumsum.append(cumsum[-1] + C[st])
m = len(cumsum) - 1
loopsum = cumsum[-1]
if loopsum < 0:
maxscore = max(maxscore, max(cumsum[1:min(K + 1, m + 1)]))
continue
score = (K // m - 1) * loopsum
extended_cumsum = cumsum + [cumsum[i] + loopsum for i in range(1, K % m + 1)]
score += max(extended_cumsum)
maxscore = max(maxscore, score)
print(maxscore)
| 1 | 5,394,466,709,760 | null | 93 | 93 |
num = int(input())
dp = { 0: 1, 1: 1 }
def fibonacci(n):
if not n in dp:
dp[n] = fibonacci(n - 1) + fibonacci(n - 2)
return dp[n]
print(fibonacci(num))
|
# -*- coding: utf_8 -*-
n = int(input()) + 1
arr = [-1] * n
arr[0] = 1
arr[1] = 1
for i in range(2, len(arr)):
arr[i] = arr[i - 1] + arr[i - 2]
print(arr[n - 1])
| 1 | 1,869,061,196 | null | 7 | 7 |
while True:
H,W = list(map(int, input().split()))
if (H == 0) and (W == 0):
break
else:
for n in range(0, H):
s = ""
for m in range(0, W):
s += "#"
print(s)
print("")
|
while True:
h,w = map(int,input().split())
if h == w == 0:
break
for x in range(int(h)):
for y in range(int(w)):
print("#",end="")
print("")
print("")
| 1 | 773,228,083,742 | null | 49 | 49 |
all = [suit + ' ' + str(rank) for suit in 'SHCD' for rank in range(1, 14)]
for _ in range(int(input())):
all.remove(input())
for card in all:
print(card)
|
# input()
# int(input())
# map(int, input().split())
# list(map(int, input().split()))
# list(map(int, list(input()))) # スペースがない数字リストを読み込み
import math
import fractions
import sys
import bisect
import heapq # 優先度付きキュー(最小値取り出し)
import collections
from collections import Counter
from collections import deque
import pprint
sr = lambda: input()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""
def factorization(n):
arr = []
temp = n
if n == 1:
return arr
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
# a^n
def power(a,n,mod):
x = 1
while n:
if n & 1:
x *= a % mod
n >>= 1
a *= a % mod
return x % mod
# n*(n-1)*...*(l+1)*l
def kaijo(n, l, mod):
if n == 0:
return 1
a = n
tmp = n-1
while(tmp >= l):
a = a*tmp%mod
tmp -= 1
return a
inf = 10**18
mod = 10**9+7
n = ir()
a = lr()
dp = [0 for i in range(60)]
for num in a:
for j in range(60):
if ((num >> j) & 1):
dp[j]+=1
ans = 0
for i in range(60):
k = dp[i]
tmp = k*(n-k)*power(2,i,mod)%mod
ans = (ans+tmp)%mod
print(ans)
| 0 | null | 62,270,187,244,798 | 54 | 263 |
n, m = map(int,input().split())
A = list(map(int,input().split()))
sum = 0
count = 0
for a in A:
sum += a
for a in A:
if a >= sum/(4*m):
count += 1
if count >= m:
print('Yes')
else:
print('No')
|
N = input()
ans = 'Yes' if '7' in N else 'No'
print(ans)
| 0 | null | 36,551,631,722,928 | 179 | 172 |
X = int(input())
flag = False
for i in range(-120, 120):
for j in range(-120, 120):
if i ** 5 - j ** 5 == X:
print(i, j)
flag = True
break
if flag:
break
|
import sys
n = int(input())
for i in range(-200,200):
for j in range(-200,200):
if i ** 5 - j ** 5 == n:
print(i,j)
sys.exit()
| 1 | 25,586,700,874,968 | null | 156 | 156 |
def MI(): return map(int, input().split())
N,X,T=MI()
if N%X!=0:
ans=(N//X+1)*T
else:
ans=N//X*T
print(ans)
|
N, X, T = map(int,input().split())
add = 0
if N % X > 0:
add = 1
ans = int(N//X + add)*T
print(ans)
| 1 | 4,296,374,799,222 | null | 86 | 86 |
N = int(input())
P = list(map(int,input().split()))
num = 1
min_P = P[0]
for i in range(1,N):
if P[i] < min_P:
min_P = P[i]
num += 1
print(num)
|
n,s = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
mod = 998244353
dp = [[0 for i in range(s+1)] for j in range(n+1)]
dp[0][0] = 1
for i in range(n):
for x in range(s+1):
dp[i+1][x] = 2*dp[i][x]
if x-a[i] >= 0:
dp[i+1][x] += dp[i][x-a[i]]
dp[i+1][x] %= mod
print(dp[n][s])
| 0 | null | 51,508,747,592,382 | 233 | 138 |
def main():
a, b, c, d = map(int, input().split())
if c % b == 0:
e = c // b
else:
e = c // b + 1
if a % d == 0:
f = a // d
else:
f = a // d + 1
if e > f:
ans = "No"
else:
ans = "Yes"
print(ans)
if __name__ == "__main__":
main()
|
from collections import deque
def init_tree(x, par):
for i in range(x + 1):
par[i] = i
def find(x, par):
q = deque()
q.append(x)
while len(q) > 0:
v = q.pop()
if v == par[v]:
return v
q.append(par[v])
def union(x, y, par, rank):
px, py = find(x, par), find(y, par)
if px == py:
return
if rank[px] < rank[py]:
par[px] = py
return
elif rank[px] == rank[py]:
rank[px] += 1
par[py] = px
n, m, k = map(int, input().split())
par = [0] * (n + 1)
rank = [0] * (n + 1)
init_tree(n, par)
eg = [[] for _ in range(n + 1)]
for _ in range(m):
a, b = map(int, input().split())
union(a, b, par, rank)
eg[a].append(b)
eg[b].append(a)
for _ in range(k):
a, b = map(int, input().split())
eg[a].append(b)
eg[b].append(a)
xs = [0] * (n + 1)
ys = [0] * (n + 1)
for i in range(1, n + 1):
p = find(i, par)
xs[p] += 1
for v in eg[i]:
if p == find(v, par):
ys[i] += 1
ans = [-1] * (n + 1)
for i in range(1, n + 1):
ans[i] += xs[find(i, par)] - ys[i]
print(*ans[1:])
| 0 | null | 45,575,147,999,346 | 164 | 209 |
n=int(input())
s=0
for i in str(n):
s+=int(i)
if(s%9==0):
print("Yes")
else:
print("No")
|
N = input()
answer = 0
for keta in N:
answer = (answer + int(keta))%9
if not answer:
print("Yes")
else:
print("No")
| 1 | 4,452,565,663,770 | null | 87 | 87 |
N,K,S = map(int,input().split())
cur = 1 if S==10**9 else S+1
ans = [S]*K +[cur]*(N-K)
print(*ans)
|
def solve():
n=int(input())
a=list(map(int,input().split()))
cnt=[0]*(int(1e5)+9)
s=0
for i in range(0,n) :
s+=a[i]
cnt[a[i]]+=1
q=int(input())
for q in range(0,q) :
b,c=map(int,input().split())
ct=cnt[b]
s+=ct*(c-b)
cnt[b]=0
cnt[c]+=ct
print(s)
solve()
| 0 | null | 51,632,577,866,078 | 238 | 122 |
N = int(input())
c = input()
W = 0
R = c.count('R')
if R == 0 or R == N:
print(0)
exit()
ans = N
t = 0
for i in range(N):
if c[i] == 'W':
W += 1
else:
R -= 1
t = max(R,W)
ans = min(ans, t)
print(ans)
|
n = int(input())
k = input()
a = k.count("R")
b = k[:a].count("W")
print(b)
| 1 | 6,316,206,924,900 | null | 98 | 98 |
ABC = input().split()
a = int(ABC[0])
b = int(ABC[1])
c = int(ABC[2])
i = 0
while a<=b:
if c%a==0:
i = i+1
a = a+1
print(i)
|
# coding=utf-8
a, b, c = map(int, raw_input().rstrip().split())
print sum([1 if not c % i else 0 for i in range(a, b+1)])
| 1 | 552,211,690,446 | null | 44 | 44 |
import sys
input = sys.stdin.readline
def readstr():
return input().strip()
def readint():
return int(input())
def readnums():
return map(int, input().split())
def readstrs():
return input().split()
def main():
N = readint()
X = readstr()
s = sum(tuple(map(int, X)))
s1 = s + 1
s2 = s - 1 if s != 1 else 1
m1 = int(X, 2) % s1
m2 = int(X, 2) % s2
t1 = [1]
t2 = [1]
for i in range(N):
t1.append(t1[i] * 2 % s1)
t2.append(t2[i] * 2 % s2)
for i in range(N):
ans = 0
if X[i] == '0':
x = (m1 + t1[(N - i - 1)]) % s1
else:
if s == 1:
print(0)
continue
else:
x = (m2 - t2[(N - i - 1)]) % s2
d = sum(tuple(map(int, bin(x)[2:])))
ans += 1
while x:
x %= d
d = sum(tuple(map(int, bin(x)[2:])))
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
import sys
def top_k_sort(data, k=3, reverse=True):
data.sort(reverse=True)
return data[:k]
def main():
data = []
for line in sys.stdin:
data.append(int(line))
for h in top_k_sort(data):
print(h)
if __name__ == '__main__':
main()
| 0 | null | 4,086,029,214,410 | 107 | 2 |
X, Y= map(int, input().strip().split())
if Y%2==0 and 2*X<=Y and Y<=4*X:print('Yes')
else:print('No')
|
x,y =map(int,input().split())
if y-2*x >=0 and (y-2*x)%2 ==0 and 4*x-y >=0 and (4*x-y)%2 ==0:
print('Yes')
exit()
print('No')
| 1 | 13,816,837,258,212 | null | 127 | 127 |
# -*- coding: utf-8 -*-
import math
N, M = map(int, input().split())
A = list(map(int, input().split()))
for i in range(M):
N -= A[i]
if N >= 0:
print(N)
else:
print(-1)
|
a,b,c=map(int,input().split())
k=int(input())
f=0
for i in range(1,k+1):
d=c*(2**i)
e=b*(2**(k-i))
if a<e<d:
f=1
print('Yes' if f else 'No')
| 0 | null | 19,530,897,942,880 | 168 | 101 |
kotae = [1,2,3]
A = int(input())
B = int(input())
kotae.remove(A)
kotae.remove(B)
print(kotae[0])
|
a = 0
a += int(input())
a += int(input())
print(6 - a)
| 1 | 110,351,671,970,220 | null | 254 | 254 |
import sys
import math
input = lambda: sys.stdin.readline().rstrip()
N,X, T = map(int, input().split())
print(math.ceil(N/X)*T)
|
import math
n = int(input())
print(2 * n * math.pi)
| 0 | null | 17,913,286,349,018 | 86 | 167 |
import sys
n = int( sys.stdin.readline() )
s = [ False ] * 13
h = [ False ] * 13
c = [ False ] * 13
d = [ False ] * 13
for i in range( 0, n ):
pattern, num = sys.stdin.readline().split( " " )
if "S" == pattern:
s[ int( num )-1 ] = True
elif "H" == pattern:
h[ int( num )-1 ] = True
elif "C" == pattern:
c[ int( num )-1 ] = True
elif "D" == pattern:
d[ int( num )-1 ] = True
for i in range( 0, 13 ):
if not s[i]:
print( "S {:d}".format( i+1 ) )
for i in range( 0, 13 ):
if not h[i]:
print( "H {:d}".format( i+1 ) )
for i in range( 0, 13 ):
if not c[i]:
print( "C {:d}".format( i+1 ) )
for i in range( 0, 13 ):
if not d[i]:
print( "D {:d}".format( i+1 ) )
|
s = []
h = []
c = []
d = []
for i in range(1, 14):
s.append('S ' + str(i))
h.append('H ' + str(i))
c.append('C ' + str(i))
d.append('D ' + str(i))
n = int(input())
i = 1
while i <= n:
a = str(input())
if (a in s):
s.remove(a)
elif (a in h):
h.remove(a)
elif (a in c):
c.remove(a)
elif (a in d):
d.remove(a)
i += 1
if (len(s) > 0):
print('\n'.join(s))
if (len(h) > 0):
print('\n'.join(h))
if (len(c) > 0):
print('\n'.join(c))
if (len(d) > 0):
print('\n'.join(d))
| 1 | 1,025,537,216,352 | null | 54 | 54 |
S = list(input())
n = len(S)
k = int(input())
if len(set(S)) == 1:
print((n * k) // 2)
exit()
res = 0
i = 0
while i < n - 1:
if S[i] == S[i + 1]:
res += 1
i += 1
i += 1
if S[0] != S[-1]:
print(res * k)
else:
i = 1
while S[0] == S[i]:
i += 1
j = 1
while S[-1] == S[-1 - j]:
j += 1
if i % 2 == 0 or j % 2 == 0:
print(res * k)
else:
print(res * k + (k - 1))
|
import numpy as np
S = input()
K = int(input())
seq = []
init = 1
def seq_count(strings, lst):
init = 1
for i in range(len(strings)-1):
if strings[i] == strings[i+1]:
init += 1
else:
lst.append(init)
init = 1
lst.append(init)
seq_count(S, seq)
if S[0] != S[-1]:
array = np.array(seq)
ans = array // 2
print(int(np.sum(ans))*K)
else:
seq2 = seq[1:-1]
array = np.array(seq2)
part_ans = array // 2
if len(seq) > 1:
print(int(np.sum(part_ans))*K+((seq[0]+seq[-1])//2)*(K-1)+(seq[0]//2)+(seq[-1]//2))
else:
print((seq[0]*K)//2)
| 1 | 175,098,218,467,520 | null | 296 | 296 |
A, V = map(int, input().split())
B, W = map(int, input().split())
T = int(input())
ans = 'YES' if abs(B - A) <= (V - W) * T else 'NO'
print(ans)
|
mod = int(1e9+7)
def add(a, b):
c = a + b
if c >= mod:
c -= mod
return c
def mul(a, b):
return (a * b) % mod
def my_pow(a, b):
if b == 0:
return 1
elif b % 2 == 1:
return mul(a, my_pow(a, b-1))
else:
temp = my_pow(a, b/2)
return mul(temp, temp)
def my_inv(a):
return my_pow(a, mod-2)
def modInverse(a, m) :
m0 = m
y = 0
x = 1
if (m == 1) :
return 0
while (a > 1) :
# q is quotient
q = a // m
t = m
# m is remainder now, process
# same as Euclid's algo
m = a % m
a = t
t = y
# Update x and y
y = x - q * y
x = t
# Make x positive
if (x < 0) :
x = x + m0
return x
def main():
n = int(raw_input())
arr = [int(x) for x in raw_input().split()]
answer = {}
for i in range(n):
cnt = {}
x = arr[i]
i = 2
while i * i <= x:
while x % i == 0:
x /= i
cnt[i] = cnt.get(i, 0) + 1
i += 1
if x != 1:
cnt[x] = cnt.get(x, 0) + 1
for key in cnt:
answer[key] = max(answer.get(key, 0), cnt[key])
lcm = 1
for prime in answer:
for _ in range(answer[prime]):
lcm = mul(lcm, prime)
#print(lcm)
ans = 0
#print(my_pow(22, 3))
for x in arr:
#print(my_inv(x))
ans = add(ans, mul(lcm, my_inv(x)))
ans = int(ans)
print(ans)
main()
"""
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9+7;
ll add(ll a, ll b) {
return (a + b) % MOD;
}
ll divi(ll a, ll b) {
return (a / b) % MOD;
}
ll mul(ll a, ll b) {
return (a * b) % MOD;
}
// Return a ^ b
int my_pow(int a, int b) {
if (b == 0) {
return 1;
}
else if (b % 2 == 1) {
return mul(a, my_pow(a, b-1));
}
else {
int temp = my_pow(a, b/2);
return mul(temp, temp);
}
}
int my_inv(int a) {
return my_pow(a, MOD-2);
}
int main() {
int n;
scanf("%d", &n);
vector<int> arr(n);
map<int, int> answer;
//cout << "test" << endl;
for (int i = 0; i < n; i++) {
map<int, int> cnt;
scanf("%d", &arr[i]);
int x = arr[i];
//cout << x << endl;
for (int i = 2; i * i <= x; i++) {
while (x % i == 0) {
cnt[i] += 1;
x /= i;
}
}
if (x != 1) {
cnt[x] += 1;
}
//cout << "test_x" << endl;
for (pair<int, int> p : cnt) {
answer[p.first] = max(answer[p.first], p.second);
}
}
//cout << "test2" << endl;
ll lcm = 1;
for (pair<int, int> p : answer) {
int prime = p.first;
int k = p.second;
for (int i = 0; i < k; i++) {
lcm = mul(lcm, prime);
}
}
ll ans = 0;
//cout << "test1" << endl;
for (int i = 0; i < n; i++) {
ans = add(ans, mul(lcm, my_inv(arr[i])));
}
//cout << "test2" << endl;
printf("%lld", ans);
return 0;
}
"""
| 0 | null | 51,312,999,152,470 | 131 | 235 |
n = int(input())
r = n % 27
if r == 13 or r == 26:
print(':(')
elif r ==0:
x = int(100*n/108)
print(x)
else:
for i in range(1, 25):
if 1.08*(i-1) < r <= 1.08*i:
break
x = int(100*(n - i)/108) + i
print(x)
|
while True:
m, f, r = map(int, input().split())
if m == -1 and f== -1 and r == -1:
break
mf = m + f
if m == -1 or f == -1 or mf < 30:
print('F')
elif mf < 50:
if r < 50:
print('D')
else:
print('C')
elif mf < 65:
print('C')
elif mf < 80:
print('B')
else:
print('A')
| 0 | null | 63,577,109,692,480 | 265 | 57 |
def main():
log_no, cut_max = [int(x) for x in input().split()]
logs = [int(x) for x in input().split()]
bin_l, bin_r = 0, 10 ** 9
while bin_r - bin_l > 1:
bin_mid = (bin_l + bin_r) // 2
cut_count = sum((log - 1) // bin_mid for log in logs)
if cut_count <= cut_max:
bin_r = bin_mid
else:
bin_l = bin_mid
print(bin_r)
if __name__ == '__main__':
main()
|
from collections import Counter
n=int(input())
a=list(map(int,input().split()))
i_l=[]
j_l=[]
for i in range(n):
i_l.append(i+a[i])
j_l.append(i-a[i])
ci=Counter(i_l)
cl=Counter(j_l)
ans=0
for k,v in ci.items():
ans+=v*cl[k]
print(ans)
| 0 | null | 16,214,274,328,830 | 99 | 157 |
n = int(input().split()[0])
c = list(map(int,input().split()))
minimum = [ i for i in range(n+1) ]
for i in range(2,n+1):
for j in c:
if j <= i and minimum[i-j] + 1 < minimum[i]:
minimum[i] = minimum[i-j]+1
print(minimum[n])
|
def gcd(a, b):
if a==0:
return b
else:
return gcd(b%a, a)
X = int(input())
LCM = X*360/gcd(360, X)
print(int(LCM/X))
#a, b = map(int, input().split())
#print(gcd(a, b))
| 0 | null | 6,645,614,045,610 | 28 | 125 |
def merge(a, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = a[left:left + n1] + [SENTINEL]
R = a[mid:mid + n2] + [SENTINEL]
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 merge_sort(a, left, right):
if left + 1 < right:
mid = (left + right) // 2
merge_sort(a, left, mid)
merge_sort(a, mid, right)
merge(a, left, mid, right)
SENTINEL = 1000000001
n = int(input())
a = list(map(int, input().strip().split()))
count = 0
merge_sort(a, 0, len(a))
print(' '.join(map(str, a)))
print(count)
|
#!/usr/bin/env python3
def main():
n = input()
l = len(n)
k = int(input())
dp0 = [0 for j in range(4)]
dp1 = [0 for j in range(4)]
dp1[0] = 1
for i in range(l):
d = int(n[i])
if d == 0:
for j in [3, 2, 1]:
dp0[j] += dp0[j - 1] * 9
else:
for j in [3, 2, 1]:
dp0[j] += dp0[j - 1] * 9
dp0[j] += dp1[j - 1] * max(0, d - 1)
dp0[j] += dp1[j]
dp0[0] += dp1[0]
dp1 = [0] + dp1[0:3]
print(dp0[k] + dp1[k])
if __name__ == "__main__":
main()
| 0 | null | 38,114,558,613,600 | 26 | 224 |
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
n,k = LI()
p = LI()
for i,x in enumerate(p):
if x%2 == 0:
x = x//2+0.5
else:
x = x//2+1
p[i] = x
nowsum = sum(p[:k])
ans = nowsum
for i in range(k,n):
nowsum = nowsum - p[i-k] + p[i]
# print(p,lst)
ans = max(ans,nowsum)
print(ans)
main()
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
s = sum(p[:k])
ret = s
for i in range(k, n):
s += p[i] - p[i - k]
ret = max(ret, s)
print((ret + k) / 2.0)
| 1 | 74,871,741,911,770 | null | 223 | 223 |
a,b = input().split()
#print(a,b)
A = int(a)
x,y = b.split('.')
B = int(x)*100+int(y)
print(int(A*B)//100)
|
r, c = map(int, input().split())
table = [cc + [sum(cc)] for cc in (list(map(int, input().split())) for _ in range(r))]
table.append(list(map(sum, zip(*table))))
for line in table:
print(*line)
| 0 | null | 9,006,841,321,402 | 135 | 59 |
import sys
from io import StringIO
import unittest
import os
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
# 実装を行う関数
def resolve(test_def_name=""):
n, k = map(int, input().split())
ans = 0
min_num = 0
desk_list = list(reversed(range(n + 1)))
max_num = 0
ack_list = list(range(n + 1))
for i in range(1, n + 1):
min_num = (min_num + desk_list.pop()) % (pow(10, 9) + 7)
max_num = (max_num + ack_list.pop()) % (pow(10, 9) + 7)
if k <= i:
ans = (ans + max_num - min_num + 1) % (pow(10, 9) + 7)
print(ans+1)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """3 2"""
output = """10"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """200000 200001"""
output = """1"""
self.assertIO(test_input, output)
def test_input_3(self):
test_input = """141421 35623"""
output = """220280457"""
self.assertIO(test_input, output)
# 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
def tes_t_1original_1(self):
test_input = """データ"""
output = """データ"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
|
s = input()
f = False
chk = ''
for i in range(5):
chk += 'hi'
if s == chk:
print('Yes')
f = True
break
if not f:
print('No')
| 0 | null | 43,085,134,782,372 | 170 | 199 |
A, B, C, D = map(int, input().split())
while A > 0 and C > 0:
A -= D
C -= B
if C <= 0:
print('Yes')
else:
print('No')
|
import math
A, B, C, D = map(int, input().split())
#on which turn do they die
takahashi = math.ceil(A / D)
aoki = math.ceil(C / B)
#print(takahashi)
#print(aoki)
if takahashi >= aoki:
print("Yes")
else:
print("No")
| 1 | 29,870,316,195,820 | null | 164 | 164 |
mod = 10**9 + 7
N = int(input())
A = [int(i) for i in input().split()]
# bitにしてor
# 一桁だけの時、111000なら3 * 3
maxl = 0
textlist = []
for i in range(N):
tmp = str(bin(A[i]))
tmp = tmp[2:]
length = len(tmp)
if maxl < length:
maxl = length
textlist.append(tmp)
zeros = {}
ones = {}
for i in range(maxl):
zeros[i] = 0
ones[i] = 0
for i in range(N):
tmp = textlist[i]
length = len(tmp)
if maxl < length:
maxl = length
for j in range(length):
if tmp[-j-1]== '1':
ones[j] += 1
for i in range(maxl):
zeros[i] = N-ones[i]
result = 0
n2 = 1
for i in range(maxl):
result = (result + n2 * (zeros[i] * ones[i])) % mod
n2 = (n2 * 2) % mod
print(result)
|
N = int(input())
s = input()
w = 0
r = s.count('R')
ans = min(N, r)
for i in range(N):
if s[i] == 'R':
r -= 1
else:
w += 1
ans = min(ans, max(w, r))
print(ans)
| 0 | null | 64,437,716,088,682 | 263 | 98 |
N=str(input())
if '7' in N:
print("Yes")
else:
print("No")
|
import math
k = int(input())
a, b = list(map(int, input().split()))
mul = math.floor(b/k) * k
if(mul >= a and (mul >= a and mul <= b)):
print('OK')
else:
print('NG')
| 0 | null | 30,427,859,335,968 | 172 | 158 |
k = int(input())
a,b = map(int, input().split())
for i in range(1,1000):
if a<= k*i <= b:
print("OK")
exit()
else:
pass
print("NG")
|
k = int(input())
ab = input().split()
a = int(ab[0])
b = int(ab[1])
l = 0
ans = 0
while l < a:
l += k
while l <= b:
ans += 1
l += k
if ans == 0:
print("NG")
else:
print("OK")
| 1 | 26,715,349,309,308 | null | 158 | 158 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter
import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(readline())
def read_int_n():
return list(map(int, readline().split()))
def read_float():
return float(readline())
def read_float_n():
return list(map(float, readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def ep(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.perf_counter()
ret = f(*args, **kwargs)
e = time.perf_counter()
ep(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, U, V, AB):
g = defaultdict(list)
for a, b in AB:
g[a].append(b)
g[b].append(a)
def dfs(u):
s = [u]
d = {u: 0}
while s:
u = s.pop()
for v in g[u]:
if v in d:
continue
d[v] = d[u] + 1
s.append(v)
return d
du = dfs(U)
dv = dfs(V)
ans = 0
for v in sorted(du.keys()):
if du[v] < dv[v]:
ans = max(ans, dv[v] - 1)
return ans
def main():
N, U, V = read_int_n()
AB = [read_int_n() for _ in range(N-1)]
print(slv(N, U, V, AB))
if __name__ == '__main__':
main()
|
import math
x1,y1,x2,y2=(float(x) for x in input().split())
print('{:.05f}'.format(math.sqrt((x2-x1)**2+(y2-y1)**2)))
| 0 | null | 58,591,445,389,372 | 259 | 29 |
r = int(input())
print(round(r * r / 1))
|
X = int(input())
K = 0
while ((X * K) % 360 != 0) or (K == 0):
K += 1
print(K)
| 0 | null | 78,947,563,175,388 | 278 | 125 |
import sys
sys.setrecursionlimit(10**6)
n,m=map(int,input().split())
s=input()
ans=[]
def f(i,j):
if i==0:
print(" ".join(map(str,ans[::-1])))
return
if j>i:
j=i
while s[i-j]=="1":
j-=1
if j==0:
print(-1)
return
ans.append(j)
f(i-j,m)
f(n,m)
|
N = int(input())
S = str(input())
#print(N,S)
stack = []
while len(S) > 0:
if len(stack) == 0:
stack.append(S[0])
S = S[1:]
elif S[0] == stack[-1]:
S = S[1:]
elif S[0] != stack[-1]:
stack.append(S[0])
S = S[1:]
#print(S,stack)
print(len(stack))
| 0 | null | 154,072,244,047,618 | 274 | 293 |
n = int(input())
x = list(map(int,input().split()))
y = list(map(int,input().split()))
i = 0
p1 = 0
p2 = 0
p3 = 0
p4 = 0
for _ in range(n):
if x[i] > y[i]:
p1 = (x[i] - y[i]) + p1
else:
p1 = (y[i] - x[i]) + p1
i = i + 1
print('{:.8f}'.format(p1))
i = 0
for _ in range(n):
p2 = ((x[i] - y[i]))**2 + p2
i = i + 1
print('{:.8f}'.format(p2**(1/2)))
i = 0
for _ in range(n):
if x[i] > y[i]:
p3 = ((x[i] - y[i]))**3 + p3
else:
p3 = ((y[i] - x[i]))**3 + p3
i = i + 1
print('{:.8f}'.format(p3**(1/3)))
i = 0
M = 0
for _ in range(n):
if x[i] > y[i]:
p4 = x[i] - y[i]
if M < p4:
M = p4
else:
p4 = y[i] - x[i]
if M < p4:
M = p4
i = i + 1
print('{:.8f}'.format(M))
|
import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp
INF = inf
MOD = 1000000007
x, n = [int(i) for i in input().split()]
P = [int(i) for i in input().split()]
tmp = 0
res = 0
P = np.array(P) - x
while True:
if not -res in P:
res *= -1
break
if not res in P:
break
res += 1
res += x
print(res)
| 0 | null | 7,143,206,937,400 | 32 | 128 |
import math
N = int(input())
#https://qiita.com/jamjamjam888/items/e066b8c7bc85487c0785
xy = [map(int, input().split()) for _ in range(N)]
x, y = [list(i) for i in zip(*xy)]
l = 0
for j in range(N):
for k in range(N):
if j >= k:
continue
l += math.sqrt((x[j] - x[k])**2 + (y[j] - y[k]) ** 2)
print(l * 2/N)
|
def cub():
x = input()
print x ** 3
cub()
| 0 | null | 74,713,879,282,410 | 280 | 35 |
str = input().split();
a = int(str[0]);
b = int(str[1]);
c = int(str[2]);
if a < b & b < c:
print("Yes");
else:
print("No");
|
in_str = input().split(" ")
a = int(in_str[0])
b = int(in_str[1])
c = int(in_str[2])
if a < b:
if b < c:
print("Yes")
else:
print("No")
else:
print("No")
| 1 | 396,250,259,078 | null | 39 | 39 |
n,x,t=map(int,input().split())
count = n // x
if n % x == 0:
pass
else:
count += 1
print(count * t)
|
import math
a,b = map(int,input().split())
def lcm(a,b):
y = a*b / math.gcd(a,b)
return int(y)
print(lcm(a,b))
| 0 | null | 58,531,371,090,830 | 86 | 256 |
S = input()
if S[len(S) - 1] == 's':
print(S + 'es')
else:
print(S + 's')
|
S,W = map(int,input().split())
print(("safe","unsafe")[W >= S])
| 0 | null | 15,879,490,337,860 | 71 | 163 |
N = int(input())
for i in range(N):
a,b,c = map(int,input().split())
if a*a + b*b == c*c or b*b+c*c == a*a or a*a+c*c == b*b:
print("YES")
else:
print("NO")
|
import sys
def gcm(a,b):
return gcm(b,a%b) if b else a
for s in sys.stdin:
a,b=map(int,s.split())
c=gcm(a,b)
print c,a/c*b
| 0 | null | 513,497,500 | 4 | 5 |
n = input()
a = map(int, raw_input().split())
for i in range(n):
key = a[i]
j = i - 1
while j >= 0 and a[j] > key:
a[j + 1] = a[j]
j -= 1
a[j + 1] = key
print(" ".join(map(str, a)))
|
from collections import deque
s = list(input())
q = int(input())
d = deque()
for i in s:
d.append(i)
c = 1
for _ in range(q):
t = list(input().split())
if t[0] == '1':
c *= -1
else:
if t[1] == '1':
if c == 1:
d.appendleft(t[2])
else:
d.append(t[2])
else:
if c == 1:
d.append(t[2])
else:
d.appendleft(t[2])
print(''.join(list(d)[::c]))
| 0 | null | 28,680,744,347,850 | 10 | 204 |
import sys
n = int(sys.stdin.readline())
lines = sys.stdin.readlines()
#n = int(input())
#import collections
#dll = collections.deque()
class Node:
def __init__(self,v):
self.val = v
self.prev = None
self.next = None
class DLL():
def __init__(self):
self.tail = Node(None)
self.tail.next = self.tail
self.tail.prev = self.tail
def insert(self,x):
n = Node(x)
pre = self.tail.next
n.next = pre
n.prev = self.tail
pre.prev = n
self.tail.next = n
def delete(self,x):
node = self.tail.next
while node != self.tail:
if node.val == x:
p = node.prev
n = node.next
p.next = n
n.prev = p
return
node = node.next
def deleteFirst(self):
pre = self.tail.next
if pre == self.tail:
return
node = self.tail.next
p = node.prev
n = node.next
p.next = n
n.prev = p
def deleteLast(self):
if self.tail.next == self.tail:
return
node = self.tail.prev
p = node.prev
n = node.next
p.next = n
n.prev = p
def inspect(self):
node = self.tail.next
ret = []
while node != self.tail:
ret.append(str(node.val))
node = node.next
print(" ".join(ret))
dll=DLL()
for i in range(n):
q = lines[i]
if q[0] == "i":
dll.insert(int(q.split()[1]))
elif q[6] == " ":
dll.delete(int(q.split()[1]))
elif q[6] == "L":
dll.deleteLast()
elif q[6] == "F":
dll.deleteFirst()
dll.inspect()
#print(" ".join(map(str,dll)))
|
def main():
a = list(map(int, input().split()))
D = a[0]
T = a[1]
S = a[2]
time = D / S
print("Yes" if time <= T else "No")
if __name__ == '__main__':
main()
| 0 | null | 1,804,021,419,056 | 20 | 81 |
import decimal
def multply(a: str, b: str) -> int:
return int(decimal.Decimal(a) * decimal.Decimal(b))
a, b = input().split()
print(multply(a, b))
|
N = int(input())
g = 0
for n in range(1, N + 1):
if n % 2 == 0:
g += 1
ANS = (N - g) / N
print(ANS)
| 0 | null | 96,891,026,475,690 | 135 | 297 |
from math import gcd
from itertools import product
from functools import reduce
l1 = [i for i in range(1, int(input()) + 1)]
print(sum(reduce(gcd, l) for l in product(l1, repeat=3)))
|
import math
k = int(input())
ans =0
da =0
for i in range(1,k+1):
for j in range(1,k+1):
for n in range(1,k+1):
da = math.gcd(i,j)
ans += math.gcd(da,n)
print(ans)
| 1 | 35,393,886,667,782 | null | 174 | 174 |
s = input()
N = [int(c) for c in s]
add = 0
for i in range(len(N)):
num = N[i]
add += num
if add % 9 == 0:
print('Yes')
else:
print('No')
|
import sys
read = sys.stdin.read
#readlines = sys.stdin.readlines
from math import ceil
def main():
n = tuple(map(int, tuple(input())))
if sum(n) % 9 == 0:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| 1 | 4,413,803,657,302 | null | 87 | 87 |
import math
(x1,y1,x2,y2) = map(float,raw_input().split())
print math.hypot(x2-x1,y2-y1)
|
n = int(input())
card =[i+" "+str(j) for i in ["S","H","C","D"] for j in range(1,14)]
for i in range(n):
card.remove(input())
for i in card:
print(i)
| 0 | null | 607,674,394,780 | 29 | 54 |
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
h, w, k = na()
s = nsn(h)
ans = inf
for bits in range(2 ** (h - 1)):
binf = "{0:b}".format(bits)
res = sum([int(b) for b in binf])
divcnt = res + 1
cnt = [0] * divcnt
flag = True
j = 0
while j < w:
cur = 0
for i in range(h):
if (s[i][j] == '1'):
cnt[cur] += 1
if bits >> i & 1:
cur += 1
if max(cnt) > k:
if flag:
res = inf
break
res += 1
for i in range(divcnt):
cnt[i] = 0
flag = True
else:
flag = False
j += 1
ans = min(ans, res)
print(ans)
|
import copy
h, w, k = map(int, input().split())
s = [[0] * w for _ in range(h)]
for i in range(h):
inp = input()
for j in range(w):
s[i][j] = int(inp[j])
# 最終的に出力する操作回数の最小値
ans = h + w - 2
for i in range(2 ** (h-1)):
# bit全探索によるcutの仕方
cutIdx = [0] * (h-1)
for j in range(h-1):
cutIdx[j] = (i >> j) & 1
#print('cI : ', cutIdx)
# cutする場所を示したリスト
div = []
cut_row_begin, cut_row_end = 0, 1
for j in range(h-1):
if cutIdx[j] == 0:
# cutしない
cut_row_end += 1
else:
# cutする
div.append((cut_row_begin, cut_row_end))
cut_row_begin = cut_row_end
cut_row_end += 1
div.append((cut_row_begin, cut_row_end))
#print('div: ', div)
# 既にここまででcutされている回数
cnt = sum(cutIdx)
#print(cnt)
# divごとのホワイトチョコの数をカウント
whiteCnt = [0] * len(div)
# まずは1列目をチェック
for a in range(len(div)):
cal = 0
for b in range(div[a][0], div[a][1]):
cal += s[b][0]
whiteCnt[a] = cal
#print('wC : ', whiteCnt)
# もしこの時点でwhiteCntの要素でkを超えるものがあるとき
# その横の切り方は不可能なのでbreak
if max(whiteCnt) > k:
continue
# Wが1ならそこで終わり
if w == 1:
ans = min(ans, cnt)
# 次行のホワイトチョコ数を保持
search = [0] * len(div)
# 2列目以降を同様にチェックしていく
for a in range(1, w):
# その次行のホワイトチョコの数
for b in range(len(div)):
cal = 0
for c in range(div[b][0], div[b][1]):
cal += s[c][a]
search[b] = cal
# その行単体でmax値とkを比べる
# オーバーしていればcut不可
if max(search) > k:
break
# greedy
for b in range(len(div)):
if whiteCnt[b] + search[b] > k:
# cut対象
cnt += 1
whiteCnt = copy.copy(search)
break
else:
whiteCnt[b] += search[b]
#print('cnt: ', cnt)
ans = min(ans, cnt)
print(ans)
| 1 | 48,581,659,824,458 | null | 193 | 193 |
l,R, d = map(int, input().split())
a =0
for i in range(l,R+1):
if i % d == 0:
a = a+1
print(a)
|
class SegmentTree:
def __init__(self,n):
self.siz = 1
while self.siz < n: self.siz *= 2
self.node = [0]*(2*self.siz-1)
def update(self,i,x):
i += self.siz-1
self.node[i] = x
while i > 0:
i = (i-1)//2
self.node[i] = self.node[i*2+1] | self.node[i*2+2]
def query(self,a,b,k=0,l=0,r=-1):
if r < 0: r = self.siz
if r <= a or b <= l: return 0
if a <= l and r <= b: return self.node[k]
vl = self.query(a,b,k*2+1,l,(l+r)//2)
vr = self.query(a,b,k*2+2,(l+r)//2,r)
return vl | vr
n = int(input())
st = SegmentTree(n)
s = list(input())
def f(c): return 1<<(ord(c) - ord("a"))
for i in range(n): st.update(i,f(s[i]))
q = int(input())
for _ in range(q):
typ,x,y = input().split()
if typ == "1":
i,c = int(x)-1,y
if s[i] == c: continue
st.update(i,f(c))
s[i] = c
else:
l,r = int(x)-1,int(y)
print(bin(st.query(l,r)).count("1"))
| 0 | null | 34,867,761,393,110 | 104 | 210 |
H, N = map(int, input().split())
A = []
max_A = 0
for i in range(N):
A.append(tuple(map(int, input().split())))
max_A = max(max_A, A[i][0])
INF = 10**9
dp = [INF] * (2 * 10 ** 4 + 1)
dp[0] = 0
for i in range(2 * 10 ** 4):
for a, b in A:
if i + a <= 2 * 10 ** 4:
dp[i+a] = min(dp[i]+b, dp[i+a])
print(min(dp[H:]))
|
import math
import collections
#2,4,5,7,9 hon
#0,1,6,8 pon
#3, bon
N = int(input())
a = N%10
B = [0,1,6,8]
if a == 3:
print('bon')
elif a in B:
print('pon')
else:
print('hon')
| 0 | null | 50,486,928,924,860 | 229 | 142 |
def solution(arr):
count = 0
for i, j in arr:
if i == j:
count += 1
else:
count = 0
if count == 3:
return 'Yes'
return 'No'
n = int(input())
arr = []
for _ in range(n):
arr.append([ int(i) for i in input().split()])
print(solution(arr))
|
cont = True
while cont:
data = input().split(" ")
a = int(data[0])
b = int(data[2])
op = data[1]
if op == "?":
cont = False
elif op == "+":
print(a+b)
elif op == "-":
print(a-b)
elif op == "*":
print(a*b)
else:
print(int(a/b))
| 0 | null | 1,572,078,209,910 | 72 | 47 |
#B
N, K = map(int,input().split())
P = list(map(int, input().split()))
P_sort=sorted(P)
P_sum=0
for i in range(K):
P_sum+=P_sort[i]
print(P_sum)
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
sortPrice = sorted(p)
# print(sortPrice)
price = []
for i in range(0, k):
price.append(sortPrice[i])
print(sum(price))
| 1 | 11,591,297,097,900 | null | 120 | 120 |
n = int(input())
x = 0
for i in range(1, n + 1):
if i % 5 == 0 or i % 3 == 0:
pass
else:
x += i
print(x)
|
import sys
input = sys.stdin.readline
from bisect import bisect, bisect_left
from itertools import accumulate
def main():
def check(x):
count = 0
for a in aaa:
if x <= a:
count += n
else:
count += n - bisect_left(aaa, x - a)
return count >= m
n, m = map(int, input().split())
aaa = list(map(int, input().split()))
aaa.sort()
acc = [0] + list(accumulate(aaa))
sum_a = acc[-1]
l, r = 0, 200001
while l + 1 < r:
mid = (l + r) // 2
if check(mid):
l = mid
else:
r = mid
# 合計がlより大きい組み合わせの和と組数を求める→Mに足りない分だけ合計がlの組を採用
ans = 0
count = 0
for a in aaa:
if l <= a:
ans += sum_a + a * n
count += n
else:
omit = bisect(aaa, l - a)
if omit < n:
ans += sum_a - acc[omit] + a * (n - omit)
count += n - omit
ans += l * (m - count)
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 71,476,360,337,550 | 173 | 252 |
s=str(input())
w=["SUN","MON","TUE","WED","THU","FRI","SAT"]
for i in range(7):
if w[i]==s:
print(7-i)
break
|
N, M = map(int, input().split())
A = list(map(int, input().split()))
cnt = 0
sumA = sum(A)
for a in A:
if a >= sumA / 4 / M:
cnt += 1
if cnt >= M:
print('Yes')
else:
print('No')
| 0 | null | 85,520,531,763,810 | 270 | 179 |
N, K = map(int, input().split())
P = list(map(int, input().split()))
C = list(map(int, input().split()))
G = [-1 for i in range(N+1)]
for i, v in enumerate(P):
G[i+1] = (v, C[v-1])
ans = -float("inf")
for i in range(1, N+1):
loop = []
S = i
visited = [False for i in range(N+1)]
while visited[S] == False:
loop.append(G[S][-1])
visited[S] = True
S = G[S][0]
circle_sum = sum(loop)
this_case_ans = -float("inf")
if circle_sum < 0:
pass_sum = 0
for i in range(len(loop)):
pass_sum += loop[i]
this_case_ans = max(this_case_ans, pass_sum)
ans = max(ans, this_case_ans)
continue
else:
L = len(loop)
for i in range(1, L):
loop[i] += loop[i-1]
loop.insert(0, -float("inf"))
for i in range(1, L+1):
loop[i] = max(loop[i], loop[i-1])
loop[0] = 0
if K//L > 0:
this_case_ans = max(K//L * circle_sum +
loop[K % L], (K//L-1)*circle_sum + loop[-1])
else:
for i in range(1, K+1):
this_case_ans = max(this_case_ans, loop[i])
ans = max(ans, this_case_ans)
print(ans)
|
import numpy as np
import numba
from numba import njit, b1, i4, i8, f8
@njit((i8,i8,i8[:],i8[:]), cache=True)
def main(N,K,P,C):
INF = 1<<30
ans = -INF
for i in range(N):
score = 0
now = i
visited = np.full(N,-1,np.int64)
scores = np.zeros(N,np.int64)
visited[now] = 0
for j in range(1,K+1):
now = P[now]
score += C[now]
ans = max(ans, score)
if visited[now]>=0:
cyc = j - visited[now]
up = score - scores[now]
break
scores[now] = score
visited[now] = j
else:
continue
if up<=0:
continue
cnt = j+1
if K-cyc>=j:
score += (K-cyc-j)//cyc * up
ans = max(ans, score)
cnt += (K-cyc-j)//cyc*cyc
for j in range(cnt,K+1):
now = P[now]
score += C[now]
ans = max(ans, score)
return ans
N, K = map(int, input().split())
P = np.array(list(map(lambda x:int(x)-1, input().split())))
C = np.array(list(map(int, input().split())))
print(main(N,K,P,C))
| 1 | 5,427,075,635,872 | null | 93 | 93 |
s=input()
for i in range(len(s)):
if s=="hi"*i:
print("Yes")
exit()
print("No")
|
# https://atcoder.jp/contests/abc145/tasks/abc145_d
class Combination: # 計算量は O(n_max + log(mod))
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
f = 1
self.fac = fac = [f]
for i in range(1, n_max+1): # 階乗(= n_max !)の逆元を生成
f = f * i % mod # 動的計画法による階乗の高速計算
fac.append(f) # fac は階乗のリスト
f = pow(f, mod-2, mod) # 階乗から階乗の逆元を計算。フェルマーの小定理より、 a^-1 = a^(p-2) (mod p) if p = prime number and p and a are coprime
# python の pow 関数は自動的に mod の下での高速累乗を行ってくれる
self.facinv = facinv = [f]
for i in range(n_max, 0, -1): # 上記の階乗の逆元から階乗の逆元のリストを生成（＝ facinv ）
f = f * i % mod
facinv.append(f)
facinv.reverse()
# "n 要素" は区別できる n 要素
# "k グループ" はちょうど k グループ
def __call__(self, n, r): # self.C と同じ
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def C(self, n, r):
if not 0 <= r <= n: return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
X, Y = map(int, input().split())
if (2*Y- X) % 3 or (2*X- Y) % 3:
print(0)
exit()
x = (2*Y - X) // 3
y = (2*X - Y) // 3
n = x + y
r = x
mod = 10**9 + 7
f = 1
for i in range(1, n + 1):
f = f*i % mod
fac = f
f = pow(f, mod-2, mod)
facinv = [f]
for i in range(n, 0, -1):
f = f*i % mod
facinv.append(f)
facinv.append(1)
comb = Combination(n)
print(comb.C(n,r))
| 0 | null | 101,952,080,703,980 | 199 | 281 |
import sys
n, m, l = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
matrixA = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( n ) ]
matrixB = [ [ int( val ) for val in sys.stdin.readline().split( " " ) ] for row in range( m ) ]
matrixC = [ [ sum( matrixA[i][k] * matrixB[k][j] for k in range( m ) ) for j in range( l ) ] for i in range( n ) ]
for i in range( n ):
print( " ".join( map( str, matrixC[i] ) ) )
|
if __name__ == '__main__':
n, m, l = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for j in range(n)]
B = [[int(i) for i in input().split()] for j in range(m)]
B = list(map(list, zip(*B))) # trace
C = [[sum(map(lambda x,y: x*y, A[i], B[j])) for j in range(l)] for i in range(n)]
for i in C:
print(' '.join([str(x) for x in i]))
| 1 | 1,436,961,048,222 | null | 60 | 60 |
N, K = map(int, input().split())
MOD = 10 ** 9 + 7
ans = 0
ctr = [0] * (K + 1)
for x in reversed(range(1, K + 1)):
ctr[x] = pow(K // x, N, MOD)
for y in range(2 * x, K + 1, x):
ctr[x] -= ctr[y]
ans = 0
for n in range(1, K + 1):
ans += n * ctr[n]
ans %= MOD
print(ans)
|
number = int(input())
print(number**2)
| 0 | null | 90,630,942,969,952 | 176 | 278 |
n,k = map(int,input().split())
r,s,p = map(int,input().split())
t = list(input())
for i in range(n-k):
if t[k+i] == t[i]:
t[k+i] = 0
x = t.count('r')*p+ t.count('s')*r+t.count('p')*s
print(x)
|
N,K = map(int,input().split())
R,S,P = map(int,input().split())
T = list(input())
POINT = {"r":P,"s":R,"p":S}
GET = [False] * N
ANS = 0
for i in range(N):
t = T[i]
if i <= K-1:
ANS += POINT[t]
GET[i] = True
else:
if not GET[i-K] or t != T[i-K]:
ANS += POINT[t]
GET[i] = True
print(ANS)
| 1 | 106,446,444,455,988 | null | 251 | 251 |
n=int(input())
s=[input() for _ in range(n)]
d0={}
d1={}
ma=0
mab=0
for si in s:
a,b=0,0
for x in si:
if x=='(':
b+=1
else:
b-=1
a=min(b,a)
a=-a
if b>=0:
if a in d0:
d0[a].append([a,b])
else:
d0[a]=[[a,b]]
ma=max(ma,a)
else:
if a+b in d1:
d1[a+b].append([a,b])
else:
d1[a+b]=[[a,b]]
mab=max(mab,a+b)
now=0
for i in range(ma+1):
if i not in d0:continue
if now>=i:
for a,b in d0[i]:
now+=b
else:
print('No')
exit()
for i in range(mab,-1,-1):
if i not in d1:continue
for a,b in d1[i]:
if now>=a:
now+=b
else:
print('No')
exit()
if now==0:
print('Yes')
else:
print('No')
|
n,inc,dec=int(input()),[],[]
for _ in range(n):
s,d,r=input(),0,0
for c in s:
d=d+(1 if c=='(' else -1)
r=max(r,-d)
(dec if d<0 else inc).append((d,r))
inc.sort(key=lambda x:x[1])
dec.sort(key=lambda x:x[0]+x[1])
p1,p2,ok=0,0,True
for s in inc:
ok&=s[1]<=p1
p1+=s[0]
for s in dec:
ok&=p2>=s[0]+s[1]
p2-=s[0]
ok&=p1==p2
print('Yes'if ok else'No')
| 1 | 23,518,064,745,120 | null | 152 | 152 |
n,m,k = list(map(int,input().split(" ")))
a = list(map(int,input().split(" ")))
b = list(map(int,input().split(" ")))
cnt = 0
ans = 0
j = m
t = sum(b)
for i in range(n+1):
while j>0:
if t>k: #aのみの場合の処理が足りない（常にjでスキップされてしまう）
j -= 1
t -= b[j]
else:break
if t<=k:ans = max(ans,i+j)
if i==n:break
t += a[i]
print(ans)
|
X, Y, Z = list(map(int, input().split()))
print(Z, X, Y)
| 0 | null | 24,378,295,368,196 | 117 | 178 |
m={"S":[], "D":[], "H":[], "C":[]}
for i in range(int(input())):
mark, num=input().split()
m[mark].append(int(num))
for j in ["S", "H", "C", "D"]:
nai=set(range(1,14))-set(m[j])
for k in nai:
print(j, k)
|
card = []
suit = ["S","H","C","D"]
for s in suit:
for i in range(1,14):
card.append(s + " " + str(i))
n = int(input())
for i in range(n):
card.remove(input())
for c in card:
print(c)
| 1 | 1,055,618,654,356 | null | 54 | 54 |
n,x,mod = map(int,input().split())
num = []
ans = cnt = 0
ch = x
while True:
if ch not in num:
num.append(ch)
else:
st = ch
break
ch *= ch
ch %= mod
index = num.index(st)
if (len(num)-index) != 0:
rest = (n-index)%(len(num)-index)
qu = (n-index)//(len(num)-index)
else:
rest = n
qu = 0
if n <= index + 1:
ans = sum(num[:n])
else:
ans = sum(num[:index]) + sum(num[index:index+rest]) + sum(num[index:])*qu
print(ans)
|
n, x, m = map(int, input().split())
a = x
li = [a]
exists = dict()
i = 1
for i in range(2, n + 1):
a = a * a % m
if a in exists:
break
li.append(a)
exists[a] = i
ans = sum(li)
if i != n:
loop, left = divmod(n - i + 1, i - exists[a])
ans += loop * sum(li[exists[a]-1:]) + sum(li[exists[a]-1:exists[a]-1+left])
print(ans)
| 1 | 2,808,609,281,852 | null | 75 | 75 |
#!/usr/bin/env python3
N = int(input().split()[0])
xlt_list = []
for _ in range(N):
x, l = list(map(int, input().split()))
xlt_list.append((x, l, x + l))
xlt_list = sorted(xlt_list, key=lambda x: x[2])
count = 0
before_t = -float("inf")
for i, xlt in enumerate(xlt_list):
x, l, t = xlt
if x - l >= before_t:
count += 1
before_t = t
ans = count
print(ans)
|
n=int(input())
cnt=0
Arm=[]
for i in range(n):
x,l=map(int,input().split())
Arm.append([x+l,x-l])
Arm.sort()
dis=-float('inf')
for i in range(n):
if dis<=Arm[i][1]:
cnt+=1
dis=Arm[i][0]
print(cnt)
| 1 | 89,757,878,890,538 | null | 237 | 237 |
N, K = map(int, input().split())
kMod = 10**9+7
ans = 0
for k in range(K, N+2):
lb = (k-1) * k // 2
ub = (N+1-k + N) * k // 2
ans += (ub-lb+1)
ans %= kMod
print(ans)
|
N = int(input())
A_ls = input().split(' ')
A_set = { i for i in A_ls }
if len(A_set) == N:
print('YES')
else:
print('NO')
| 0 | null | 53,534,379,336,118 | 170 | 222 |
#Exhaustive Search (bit全探索ver)
n = int(input())
A = list(map(int,input().split()))
q = int(input())
m = list(map(int,input().split()))
count_list = []
for i in range(1<<n):
copy_A = A.copy()
count = 0
for j in range(n):
mask = 1 << j
if mask & i != 0:
count += A[j]
count_list.append(count)
for k in m:
if k in count_list:
print('yes')
else:
print('no')
|
n = int(raw_input())
A = map(int, raw_input().strip().split(' '))
q = int(raw_input())
M = map(int, raw_input().strip().split(' '))
def ans(i, m):
if m == 0:
return 1
if i >= n or m > sum(A):
return 0
res = ans(i + 1, m) or ans(i + 1, m - A[i])
return res
for j in range(0, q):
if ans(0, M[j]):
print "yes"
else:
print"no"
| 1 | 100,568,898,460 | null | 25 | 25 |
n, k = map(int, input().split())
a_nums = list(map(int, input().split()))
f_point = sum(a_nums[:k])
for i in range(n - k):
if a_nums[i] < a_nums[i + k]:
print("Yes")
else:
print("No")
|
n,k = map(int, input().split())
a_list = list(map(int, input().split()))
for i in range(len(a_list)):
if i+k > len(a_list)-1:
break
if a_list[i] < a_list[i+k]:
print("Yes")
else:
print("No")
| 1 | 7,082,704,367,830 | null | 102 | 102 |
class Dice:
def __init__(self,labels):
self.stat = labels
def roll_E(self):
self.stat[0],self.stat[2],self.stat[3],self.stat[5] = self.stat[3],self.stat[0],self.stat[5],self.stat[2]
def roll_N(self):
self.stat[0],self.stat[1],self.stat[5],self.stat[4] = self.stat[1],self.stat[5],self.stat[4],self.stat[0]
def roll_S(self):
self.stat[0],self.stat[1],self.stat[5],self.stat[4] = self.stat[4],self.stat[0],self.stat[1],self.stat[5]
def roll_W(self):
self.stat[0],self.stat[2],self.stat[5],self.stat[3] = self.stat[2],self.stat[5],self.stat[3],self.stat[0]
def get_top(self):
return self.stat[0]
dice = Dice(input().split())
commands = input()
for command in commands:
if command == "E":
dice.roll_E()
elif command == "N":
dice.roll_N()
elif command == "S":
dice.roll_S()
elif command == "W":
dice.roll_W()
print(dice.get_top())
|
class Dice():
def __init__(self,ary):
self.top = ary[0]
self.south = ary[1]
self.east = ary[2]
self.west = ary[3]
self.north = ary[4]
self.bottom = ary[5]
def get_top(self):
return self.top
def rotate_north(self):
self.top,self.south,self.north,self.bottom = self.south,self.bottom,self.top,self.north
def rotate_south(self):
self.top,self.south,self.north,self.bottom = self.north,self.top,self.bottom,self.south
def rotate_west(self):
self.top,self.west,self.bottom,self.east = self.east,self.top,self.west,self.bottom
def rotate_east(self):
self.top,self.west,self.bottom,self.east = self.west,self.bottom,self.east,self.top
dice = Dice(list(map(int,input().split())))
for i in input():
if i == "N":
dice.rotate_north()
elif i == "E":
dice.rotate_east()
elif i == "W":
dice.rotate_west()
elif i == "S":
dice.rotate_south()
top=dice.get_top()
print(top)
| 1 | 231,575,600,538 | null | 33 | 33 |
import collections
N=int(input())
P=[input() for i in range(N)]
c=collections.Counter(P)
print(len(c))
|
A1, A2, A3 = [int(s) for s in input().split(' ')]
print('win' if A1+A2+A3 < 22 else 'bust')
| 0 | null | 74,565,394,797,888 | 165 | 260 |
def abc144_e():
import numpy as np
N, K = map(int, input().split())
A = np.array(input().split(), dtype=np.int64)
F = np.array(input().split(), dtype=np.int64)
A = np.sort(A)
F = np.sort(F)[::-1]
low = -1
up = 10**12
while up - low > 1:
v = (up + low) // 2
x = A - v // F
if x[x > 0].sum() > K:
low = v
else:
up = v
print(up)
if __name__ == '__main__':
abc144_e()
|
import sys
input = sys.stdin.readline
MI=lambda:map(int,input().split())
LI=lambda:list(map(int,input().split()))
N,K=MI()
A=LI()
A.sort(reverse=True)
F=LI()
F.sort()
def check(x):
# x分以内に食べきれるための修行回数はK回以下か
k=0
for i in range(N):
k+=max(int(0--(A[i]-x//F[i])//1),0)
return k<=K
ok=10**13
ng=-1
while abs(ok-ng)>1:
mid=(ok+ng)//2
if check(mid):
ok=mid
else:
ng=mid
print(ok)
| 1 | 165,211,155,752,132 | null | 290 | 290 |
a, b, c, k = map(int, input().split())
ans = 0
if a >= k:
ans = k * 1
else:
ans = a * 1 + max(0, (k - a)) * 0 + max(0, (k - a - b)) * (-1)
print(ans)
|
# B - Easy Linear Programming
A,B,C,K = map(int,input().split())
while True:
ans = 0
ans += min(A,K)
K -= min(A,K)
if K<=0:
break
K -= B
if K<=0:
break
ans -= K
break
print(ans)
| 1 | 21,790,560,538,460 | null | 148 | 148 |
x = map(int, raw_input().split())
if x[0] > x[1]:
print "a > b"
elif x [0] == x[1]:
print "a == b"
else:
print "a < b"
|
from collections import Counter
from itertools import combinations
N, X, Y = map(int, input().split(' '))
c = Counter()
for i, j in combinations(range(1, N + 1), r=2):
c[min(j - i, abs(X - i) + 1 + abs(j - Y))] += 1
for n in range(1, N):
print(c[n])
| 0 | null | 22,227,874,580,608 | 38 | 187 |
print((1000 - int(input())%1000)%1000)
|
n = int(input())
a = 10000
ans = (a - n) % 1000
print(ans)
| 1 | 8,538,536,633,760 | null | 108 | 108 |
def main():
S = input()
lst = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]
ans = 7 - lst.index(S)
print(ans)
if __name__ == "__main__":
main()
|
N = int(input())
A = list(map(int, input().split()))
bitlist = [0] * 60
for i in A:
for index, num in enumerate(reversed(bin(i)[2:])):
if num == "1":
bitlist[index] += 1
ans = 0
for bit, num in enumerate(bitlist):
ans += num * (N-num) * (2 ** bit)
ans %= (10**9+7)
print(ans)
| 0 | null | 127,672,132,511,012 | 270 | 263 |
from numba import jit
import numpy as np
n=10**7
@jit("i8[:](i8)")
def Make(n):
return np.array([i for i in range(n)])
@jit ("i8(i8[:])")
def f(a):
mod=10**9+7
ans=0
for i in a:
ans+=i
ans%=mod
return ans
k=Make(n)
f(k)
a,b=map(int,input().split())
print(a*b)
|
n,x,y=map(int,input().split())
a=[0]*n
# x-=1
# y-=1
for i in range(1,n+1):
for j in range(i+1,n+1):
s=min(j-i,abs(x-i)+abs(y-j)+1)
a[s-1]+=1
s=10000000
for i in range(n-1):
print(a[i])
| 0 | null | 30,047,103,191,250 | 133 | 187 |
from collections import Counter
N = int(input())
A = list([int(x) for x in input().split()])
result = dict(Counter(A))
for i in range(1, N+1):
if i in result:
print(result[i])
else:
print(0)
|
x=int(input())
for m in range(1,180):
if 360*m%x==0:
print(360*m//x)
exit(0)
| 0 | null | 22,791,505,652,300 | 169 | 125 |
#!/usr/bin/env python3
def main():
A, B, C, D = map(int, input().split())
print('Yes' if - (-A // D) >= -(-C // B) else 'No')
if __name__ == '__main__':
main()
|
a,b,c,d = map(int, input().split())
for i in range(100): # 繰り返し処理したい、とりあえず100回以上の繰り返しはないから100回繰り返す
c -= b # 青木くんの体力cから高橋くんの攻撃力bぶん引く
# print('青木体力', c) # 残り体力を確認する時は先頭の#を外す
if c <= 0: # 青木くん体力が0以下になったら
print('Yes') # 高橋くんの勝ちなのでYes
break # 体力が0になったら繰り返しも終了
a -= d # 次に高橋くんの体力aから青木くんの攻撃力dを引く
# print('高橋体力',a) # 残り体力を確認する時は先頭の#を外す
if a <= 0: # 高橋くん体力が0以下になったら
print('No') # 青木くん勝利でNo
break # 体力が0になったら繰り返しも終了
# どちらの体力も残ってたら次の繰り返し
| 1 | 29,616,292,860,822 | null | 164 | 164 |
MOD = 10**9 + 7
MAX = 10**6
X, Y = map(int, input().split())
m, n = 2*Y-X, 2*X-Y
if (X+Y) % 3 != 0 or m%3!=0 or n%3!=0 or m<0 or n<0:
print(0)
exit()
m //= 3
n //= 3
fac, inv = [0]*MAX, [0]*MAX
fac[0] = 1
for i in range(1, MAX):
fac[i] = fac[i-1] * i % MOD
inv[-1] = pow(fac[-1], MOD-2, MOD)
for i in range(MAX-2, 0, -1):
inv[i] = inv[i+1] * (i+1) % MOD
def com(n, k):
if n<k:return 0
if n<0 or k<0:return 0
if n==k or k==0:return 1
return int(fac[n] * (inv[k]*inv[n-k]%MOD) % MOD)
print(com(n=m+n,k=n))
|
from math import factorial as fac
x,y=map(int,input().split())
a=2*y-x
b=2*x-y
mod=10**9+7
if a>=0 and b>=0 and a%3==0 and b%3==0:
a=a//3
b=b//3
a1=1
a2=1
n3=10**9+7
for i in range(a):
a1*=a+b-i
a2*=i+1
a1%=n3
a2%=n3
a2=pow(a2,n3-2,n3)
print((a1*a2)%n3)
else:
print(0)
| 1 | 150,042,160,429,122 | null | 281 | 281 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n, m, k = map(int, input().split())
uf = UnionFind(n)
friend = [set([]) for i in range(n)]
for i in range(m):
ai, bi = map(int, input().split())
ai -= 1; bi -= 1
uf.union(ai, bi)
friend[ai].add(bi)
friend[bi].add(ai)
block = [set([]) for i in range(n)]
for i in range(k):
ci, di = map(int, input().split())
ci -= 1; di -= 1
block[ci].add(di)
block[di].add(ci)
for i in range(n):
uf.find(i)
ans = []
for i in range(n):
num = uf.size(i) - len(friend[i]) - 1
for j in block[i]:
if uf.find(i) == uf.find(j):
num -= 1
ans.append(num)
print(' '.join(map(str, ans)))
|
from collections import deque
import copy
H, W = map(int, input().split())
route = []
for _ in range(H):
route.append(input())
wall = set()
start = set()
for y, r in enumerate(route):
for x, w in enumerate(r):
if w == '.':
start.add((x, y))
score = -1
ssize = [(-1,0),(0,-1),(1,0),(0,1)]
for xy in start:
d = deque()
d.append((xy+(0,)))
step = 0
can = copy.deepcopy(start)
can.remove(xy)
while len(d) > 0:
now = d.popleft()
step = now[2]
for xs, ys in ssize:
nxt = (now[0]+xs, now[1]+ys)
if nxt in can:
d.append(nxt+(step+1,))
can.remove(nxt)
score = max(step, score)
print(score)
| 0 | null | 78,070,778,507,290 | 209 | 241 |
def fibonacciDP(i):
if i == 0:
return 1
elif i == 1:
return 1
else:
if dp[i-1] is None and dp[i-2] is None:
dp[i-1] = fibonacciDP(i-1)
dp[i-2] = fibonacciDP(i-2)
elif dp[i-1] is None:
dp[i-1] = fibonacciDP(i-1)
elif dp[i-2] is None:
dp[i-2] = fibonacciDP(i-2)
return dp[i-1]+ dp[i-2]
def fibonacci(i):
if i == 0:
return 1
elif i == 1:
return 1
else:
return fibonacci(i-1)+fibonacci(i-2)
n = int(input())
dp = [None]*n
print(fibonacciDP(n))
|
if __name__ == "__main__":
s = int(input())
m = s // 60
h = str(m // 60)
m = str(m % 60)
s = str(s % 60)
print(h + ":" + m + ":" + s)
| 0 | null | 160,296,287,814 | 7 | 37 |
cube = input()
print(cube**3)
|
def main():
N, P = map(int, input().split())
S = input()
if P == 2 or P == 5:
ans = 0
for i in range(N):
if int(S[i]) % P == 0:
ans += (i + 1)
print(ans)
exit()
sum_rem = [0] * N
sum_rem[0] = int(S[N - 1]) % P
ten = 10
for i in range(1, N):
a = (int(S[N - 1 - i]) * ten) % P
sum_rem[i] = (a + sum_rem[i - 1]) % P
ten = (ten * 10) % P
ans = 0
count = [0] * P
count[0] = 1
for i in range(N):
ans += count[sum_rem[i]]
count[sum_rem[i]] += 1
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 29,160,770,813,940 | 35 | 205 |
(N,) = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
numLeafs = A
if not (0 <= numLeafs[0] <= 1):
print(-1)
exit()
# Bound max non-leaves by how many expansions the previous level can do
maxNonLeafs = [None for i in range(N + 1)]
maxNonLeafs[0] = 1 - numLeafs[0]
for i in range(1, N + 1):
maxNonLeafs[i] = 2 * maxNonLeafs[i - 1] - numLeafs[i]
if maxNonLeafs[i] < 0:
print(-1)
exit()
# Tighten max non-leaves by how many available children are on next level
maxNonLeafs[N] = 0
for i in range(N - 1, -1, -1):
maxNonLeafs[i] = min(maxNonLeafs[i], maxNonLeafs[i + 1] + numLeafs[i + 1])
count = 0
for i in range(N + 1):
count += maxNonLeafs[i] + numLeafs[i]
print(count)
|
import sys
import math
import fractions
input = lambda: sys.stdin.readline().rstrip()
mod = 10**9 + 7
def factorize(n):
b = 2
fct = dict()
while b * b <= n:
while n % b == 0:
n //= b
if b in fct:
fct[b] += 1
else:
fct[b] = 1
b = b + 1
if n > 1:
if b in fct:
fct[n] += 1
else:
fct[n] = 1
return fct
def divmod(x, mod=10**9 + 7):
return pow(x, mod - 2, mod)
def solve():
N = int(input())
A = list(map(int, input().split()))
B = [[1] for _ in range(N)]
fac_list = dict()
for i in range(N):
d = factorize(A[i])
for k, v in d.items():
fac_list[k] = max(fac_list.get(k, 0), v)
lcm = 1
for k, v in fac_list.items():
lcm *= (k**v)
lcm %= mod
ans = 0
for i in range(N):
ans += divmod(A[i])
ans %= mod
ans *= lcm
ans %= mod
print(ans)
if __name__ == '__main__':
solve()
| 0 | null | 53,066,768,093,270 | 141 | 235 |
r,c = [int(i) for i in input().split()]
a = [[0 for i in range(c+1)] for j in range(r+1)]
for i in range(r):
a[i] = [int(j) for j in input().split()]
for i in range(r):
rowSum = 0
for j in range(c):
rowSum += a[i][j]
a[i].append(rowSum)
for i in range(c+1):
columnSum = 0
for j in range(r):
columnSum += a[j][i]
a[r][i] = columnSum
for i in range(r+1):
for j in range(c):
print(a[i][j],end=' ')
print(a[i][c])
|
a, b, k = map(int, input().split())
if a >= k:
a = a - k
else:
b = b + a - k
a = 0
if b < 0:
b = 0
print(str(a) + " " + str(b))
| 0 | null | 52,759,079,397,322 | 59 | 249 |
print(int(input()) * 3.142 * 2)
|
import math
def is_prime(n):
if n % 2 == 0 and n > 2:
return False
return all(n % i for i in range(3, int(math.sqrt(n)) + 1, 2))
while True:
try:
n = int(raw_input())
total = 0
for k in range(n):
if is_prime(int(raw_input())):
total +=1
print total
except EOFError:
break
| 0 | null | 15,707,098,499,044 | 167 | 12 |
import math
from functools import reduce
n,m = map(int, input().split())
A = list(map(int, input().split()))
def lcm_base(x,y):
return x*y//math.gcd(x,y)
def lcm(target_list):
return reduce(lcm_base, target_list)
A_gcd = reduce(math.gcd, A)
flg = True
for a in A:
if a//A_gcd%2==0:
flg = False
break
if flg:
min_x = int(lcm(A))//2
ans = m//min_x - m//(2*min_x)
print(ans)
else:
print(0)
|
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def main():
from math import ceil
n, m, *a = map(int, open(0).read().split())
c = 0
t = a[0]
while t % 2 == 0:
c += 1
t = t // 2
for x in a[1:]:
d = 0
while x % 2 == 0:
d += 1
x = x // 2
if d != c:
print(0)
break
t = lcm(t, x)
else:
ans = ceil(m // 2 ** (c-1) // t / 2)
print(ans)
if __name__ == "__main__":
main()
| 1 | 101,700,789,340,480 | null | 247 | 247 |
s = str(input())
t = ''
for c in s:
if 65 <= ord(c) and ord(c) <= 90:
t += c.lower()
elif 97 <= ord(c) and ord(c) <= 122:
t += c.upper()
else:
t += c
print(t)
|
def convert(s):
o = ord(s)
if o >= 65 and o <= 90:
return s.lower()
elif o >= 97 and o <= 122:
return s.upper()
return s
def main():
strings = input()
answer = ""
for s in strings:
s = s
answer += convert(s)
print(answer)
if __name__ == "__main__":
main()
| 1 | 1,529,625,512,260 | null | 61 | 61 |
def LinearSearch1(S, n, t):
for i in range(n):
if S[i] == t:
return i
break
else:
return -1
"""
def LinearSearch2(S, n, t):
S.append(t)
i = 0
while S[i] != t:
i += 1
S.pop()
if i == n:
return -1
else:
return i
"""
n = int(input())
S = [int(s) for s in input().split()]
q = int(input())
T = {int(t) for t in input().split()}
ans = sum(LinearSearch1(S, n, t) >= 0 for t in T)
print(ans)
|
def resolve():
rate = int(input())
if rate < 600:
print('8')
elif rate < 800:
print('7')
elif rate < 1000:
print('6')
elif rate < 1200:
print('5')
elif rate < 1400:
print('4')
elif rate < 1600:
print('3')
elif rate < 1800:
print('2')
else:
print('1')
if __name__ == "__main__":
resolve()
| 0 | null | 3,380,259,732,882 | 22 | 100 |
n,k = list(map(int, input().split()))
mod = int(1e9+7)
def init_cmb(Nmax):
#mod = 10**9+7 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range(2, Nmax + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
return g1, g2
g1,g2 = init_cmb(n+10)
def cmb(n, r, modn=mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % modn
# ci = 0 である個数が m となるような数列の数は、 nCm ×n−m Hm = nCm * n-1Cn-m-1
# 0 <= m < n で足算する
ans = 0
for i in range(min(k+1,n)):
wk = cmb(n,i) * cmb(n-1, n-i-1) % mod
ans = (ans + wk ) % mod
print(ans)
|
n,k=map(int,input().split())
mi = min(n-1,k)
di = 10**9+7
def pow_k(x,i):
if i==0:
return 0
K=1
while i>1:
if i % 2 != 0:
K = (K*x)%di
x = (x*x)%di
i //= 2
return (K * x)%di
lis = [i for i in range(n+1)]
lisr = [i for i in range(n+1)]
lis[0]=1
for i in range(1,n+1):
lis[i]=(lis[i-1]*lis[i])%di
lisr[i] = pow_k(lisr[i],di-2)
lisr[0]=1
for i in range(1,n+1):
lisr[i]=(lisr[i-1]*lisr[i])%di
#print(lis,lisr)
su = 1
for i in range(1,mi+1):
pl = ((((lis[n-1]*lisr[i])%di)*lisr[n-1-i])%di)
plu = (pl*((((lis[n]*lisr[i])%di)*lisr[n-i])%di))%di
su+=plu
su%=di
print(su)
| 1 | 66,791,167,879,108 | null | 215 | 215 |
from math import floor
A= input().split()
p = int(A[0])
q = round(float(A[1])*100)
t = p*q
t //= 100
print(t)
|
def abc169c_multiplication3():
a, b = input().split()
a = int(a)
b = int(b[0] + b[2] + b[3])
print(a * b // 100)
abc169c_multiplication3()
| 1 | 16,589,114,491,080 | null | 135 | 135 |
import math
N = int(input())
A = list(map(int, input().split()))
A = sorted(A)
maxA = A[len(A)-1]
valid = [True] * (maxA+1)
for i in range(len(A)):
if valid[A[i]] == False:
continue
if i != 0 and A[i-1] == A[i]:
valid[A[i]] = False
else:
for j in range(A[i]*2, maxA+1, A[i]):
valid[j] = False
count = 0
for i in range(len(A)):
if valid[A[i]] == True:
count += 1
print(count)
|
from collections import Counter
N = int(input())
A = [int(i) for i in input().split()]
num = set(A)
count = Counter(A)
dp = [True] * (10**6 + 1)
for a in num:
for n in range(a+a, 10**6+1, a):
dp[n] = False
ans = 0
for a in num:
if count[a] == 1 and dp[a] == True:
ans += 1
print(ans)
| 1 | 14,321,198,594,542 | null | 129 | 129 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.