code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
N ,K = map(int,input().split())
Ps = list(map(int,input().split()))
Ps.sort()
ans = 0
for i in range(K):
ans += Ps[i]
print(ans)
|
N, K = [int(v) for v in input().split()]
P = [int(v) for v in input().split()]
print(sum(sorted(P)[:K]))
| 1 | 11,544,922,040,718 | null | 120 | 120 |
r, c = map(int, [int(_) for _ in input().split()])
ll = []
for _ in range(r):
l = [int(n) for n in input().split()]
l.append(sum(l))
ll.append(l)
l = [sum(_) for _ in zip(*ll)]
ll.append(l)
for l in ll:
print(" ".join([str(_) for _ in l]))
|
y, x = map(int, input().split())
box = []
y_sum = [[]]
for i in range(y):
box.append(list(map(int, input().split())))
box[i].append(sum(box[i]))
box_replace = list(map(list, zip(*box)))
[y_sum[0].append(sum(box_replace[i])) for i in range(x+1)]
box += y_sum
[print( " ".join(map(str, box[i])) ) for i in range(y+1)]
| 1 | 1,356,837,584,062 | null | 59 | 59 |
i=0
while True:
N=int(input())
if N==0:
break
else:
a = list(map(float,input().split()))
m=sum(a)/N
#print(m)
for i in range(N):
a[i]=(float)(a[i]-m)**2
#print(a[i])
i+=1
A=(sum(a)/N)**(1/2)
print(A)
|
while 1:
n=int(input())
if n==0:break
s=list(map(int,input().split()))
print((sum([(m-sum(s)/n)**2 for m in s])/n)**.5)
| 1 | 191,019,502,814 | null | 31 | 31 |
import math
r = input()
print "%.6f %.6f" % (math.pi * r * r, math.pi * 2 * r)
|
import math
r = input()
S = math.pi * r ** 2
L = math.pi * r * 2
print "%f %f" %(S, L)
| 1 | 657,304,750,354 | null | 46 | 46 |
N = int(input())
d = {}
for _ in range(N):
s = input()
if s in d:
d[s] += 1
else:
d[s] = 1
d = {k: v for k, v in sorted(d.items(), key=lambda item: item[1], reverse=True)}
max_count = -1
values = []
for k, v in d.items():
if max_count < v:
max_count = v
if v != max_count:
break
values.append(k)
print("\n".join(sorted(values)))
|
from collections import defaultdict, Counter
n = int(input())
lis = [input() for _ in range(n)]
a = Counter(lis)
tmp = 0
for key, value in a.items():
tmp = max(value, tmp)
ans =[]
for k, v in a.items():
if v == tmp:
ans.append(k)
for i in sorted(ans):
print(i)
| 1 | 70,323,713,527,258 | null | 218 | 218 |
import sys
sys.setrecursionlimit(10000000)
MOD = 998244353
INF = 10 ** 15
def main():
N,S = map(int,input().split())
A = list(map(int,input().split()))
dp = [[0]*(1 + S) for _ in range(N + 1)]
dp[0][0] = pow(2,N,MOD)
inv2 = pow(2,MOD - 2,MOD)
for i,a in enumerate(A):
for j in range(S + 1):
if j < a:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = (dp[i][j] + dp[i][j - a] * inv2)%MOD
print(dp[N][S])
if __name__ == '__main__':
main()
|
import time
import copy
start_time = time.time()
#input
D = int(input())
c_list = list(map(int, input().split()))
s_grid = []
for i in range(D):
array = list(map(int, input().strip().split(' ')))
s_grid.append(array)
def calculate_score(d,t,last):
score = s_grid[d][t]
last[t] = -1
for i in range(26):
score -= c_list[i]*(last[i]+1)
return score
t_list = [] #task_list
last_list = [0] * 26
for k in range(0,D):
X = -1 # k-日目に変える番号を探す
p = 0
for i in range(26): # 26通り試す
tmp = calculate_score(k,i,last_list)
if tmp > p:
X = i
p = tmp
#最大のXを投入
t_list.append(X)
last_list = [n+1 for n in last_list]
last_list[X] = 0
if time.time() - start_time > 1.9:
break
for j in range(len(t_list)):
print(int(t_list[j]) + 1)
| 0 | null | 13,762,253,312,832 | 138 | 113 |
#!/usr/bin/env python
from __future__ import division, print_function
from sys import stdin
from itertools import combinations
def enum_sum_numbers(sets, s_range, r):
for cmb in combinations(sets, r):
yield sum(cmb)
if r <= s_range:
for s in enum_sum_numbers(sets, s_range, r+1):
yield s
stdin.readline()
a = [int(s) for s in stdin.readline().split()]
stdin.readline()
ms = [int(s) for s in stdin.readline().split()]
sets = {s for s in enum_sum_numbers(a, len(a), 1)}
for m in ms:
print('yes' if m in sets else 'no')
|
inp = [i for i in input().split()]
n = int(input())
array = [[i for i in input().split()] for i in range(n)]
for i2 in range(n):
fuck =""
for i in range(1,33):
if (i<=20 and i%5==0) or i==22 or i==27 or i==28:
s = "N"
else:
s = "E"
if s == "E":
a = []
a.append(inp[3])
a.append(inp[1])
a.append(inp[0])
a.append(inp[5])
a.append(inp[4])
a.append(inp[2])
inp = a
if inp[0] == array[i2][0] and inp[1] == array[i2][1] and inp[2] != fuck:
print(inp[2])
fuck = inp[2]
elif s == "N":
a = []
a.append(inp[1])
a.append(inp[5])
a.append(inp[2])
a.append(inp[3])
a.append(inp[0])
a.append(inp[4])
inp = a
if inp[0] == array[i2][0] and inp[1] == array[i2][1] and inp[2] != fuck:
print(inp[2])
fuck = inp[2]
| 0 | null | 180,044,506,610 | 25 | 34 |
import time
START = time.time()
import random
import sys
input = sys.stdin.readline
Days = int(input())
C = list(map(int, input().split())) # 満足度低下
Ss = [list(map(int, input().split())) for _ in range(Days)]
# Ss[d][i]: d日目にiを開催したときの満足度
INF = 10**18
TIMELIMIT = 1.9
def outputToScore(T):
last = [0]*26
satisfied = 0
for d, t in enumerate(T):
t -= 1; d += 1
satisfied += Ss[d-1][t]
last[t] = d
for i, c in enumerate(C):
satisfied -= c*(d-last[i])
# print(satisfied)
return satisfied
def outputToScore2(T):
last = [0]*26
used = [[] for _ in range(26)]
satisfied = 0
for d, t in enumerate(T):
t -= 1; d += 1
satisfied += Ss[d-1][t]
used[t].append(d)
last[t] = d
for i, c in enumerate(C):
satisfied -= c*(d-last[i])
# print(satisfied)
return satisfied, used
def greedy():
last = [0]*26
T = []
for d in range(Days):
satisfied_max = -INF
selected = -1
for t in range(26):
score_t = Ss[d][t]
for j, c in enumerate(C):
if t != j:
score_t -= c*(d+1-last[j])
if score_t > satisfied_max:
satisfied_max = score_t
selected = t
T.append(selected+1)
last[selected] = d+1
return T
def modifiedScore(d, aft, Used, T):
aft -= 1
bef = T[d-1]-1
deltaSatis = Ss[d-1][aft] - Ss[d-1][bef]
# d日目のコンテストをbefからaftに変える
# bi-1 -> bi -> bi+1 を bi-1 -> bi+1
befind = Used[bef].index(d)
befday0 = 0 if befind == 0 else Used[bef][befind-1]
befday2 = Days+1 if befind == len(Used[bef])-1 else Used[bef][befind+1]
befd01 = d - befday0
befd12 = befday2 - d
befd02 = befday2-befday0
deltaSatis -= C[bef]*(befd02*(befd02-1)//2) - C[bef]*(befd01*(befd01-1)//2 + befd12*(befd12-1)//2)
# ai -> ai+1 を ai -> (insert) -> ai+1
if len(Used[aft]) > 0:
aftday0 = 0
aftday2 = Days+1
for i,a in enumerate(Used[aft]):
if a < d:
aftday0 = a
elif aftday2 == Days+1:
aftday2 = a
aftd01 = d - aftday0
aftd12 = aftday2 - d
aftd02 = aftd01 + aftd12
deltaSatis += C[aft]*(aftd02*(aftd02-1)//2) - C[aft]*(aftd01*(aftd01-1)//2 + aftd12*(aftd12-1)//2)
else:
d01 = d
d12 = Days+1 - d
deltaSatis += C[aft] * Days*(Days+1)//2 - C[aft]*(d01*(d01-1)//2 + d12*(d12-1)//2)
return deltaSatis
def update(Used, T, bef, aft, d):
Used[bef].remove(d)
inserted = False
new = []
for a in Used[aft]:
if a > d and not inserted:
inserted = True
new.append(d)
new.append(a)
if not inserted:
new.append(d)
Used[aft] = new
T[d-1] = aft+1
return T, Used
def goingup(T, Used):
d = random.randint(1, Days)
bef = T[d-1]-1
aft = random.randint(0, 25)
if bef == aft:
return T, Used
if modifiedScore(d, aft, Used, T) > 0:
T, Used = update(Used, T, bef, aft, d)
return T, Used
# T = [random.randint(1, 26) for _ in range(Days)]
def main():
T = greedy()
Satisfied, Used = outputToScore2(T)
while time.time() - START < TIMELIMIT:
T, Used = goingup(T, Used)
print(*T, sep="\n")
if __name__ == "__main__":
main()
|
n = int(input())
p = [input().split() for i in range(n)]
x = input()
ans = 0
f = False
for l in p:
if f:
ans+=int(l[1])
if l[0]==x:
f = True
print(ans)
| 0 | null | 53,258,481,590,980 | 113 | 243 |
N = int(input())
A = list(map(int, input().split()))
MOD = 10**9 + 7
def gcd(n, m):
if m == 0:
return n
return gcd(m, n % m)
def lcm(n, m):
return n * m // gcd(n, m)
L = A[0]
for a in A:
L = lcm(L, a)
ans = 0
for a in A:
ans += L // a
print(ans % MOD)
|
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)
| 1 | 87,698,099,419,132 | null | 235 | 235 |
while 1:
N = int(input())
if not N:
break
*A, = map(int, input().split())
V = sum(A)/N
print((sum((a - V)**2 for a in A)/N)**0.5)
|
std_value = []
while True:
n = int(input())
if n == 0:
break
s = [int(i) for i in input().split()]#生徒の点数
sum_value=0
s_ave = 0
for i in range(len(s)):#平均値計算
sum_value += s[i]
ave = sum_value/len(s)
for j in range(len(s)):
s_ave += (s[j]-ave)**2
std_value.append((s_ave/len(s))**(1/2))
for k in range(len(std_value)):
print("{:.8f}".format(std_value[k]))
| 1 | 196,306,505,550 | null | 31 | 31 |
from collections import deque
n,m = map(int,input().split())
to = [[] for _ in range(n)]
for i in range(m):
x, y = map(int,input().split())
to[x-1].append(y-1)
to[y-1].append(x-1)
INF = float('inf')
dist = [INF]*n
dist[0] = 0
pre = [-1]*n
que = deque([])
que.append(0)
while que:
v = que.popleft()
for u in to[v]:
if dist[u] != INF:continue
dist[u] = v + 1
pre[u] = v
que.append(u)
print("Yes")
for i in range(1,n):
print(dist[i])
|
from collections import deque
n,m = map(int, input().split())
g = [[] for _ in range(n)]
for _ in range(m):
a,b = map(int, input().split())
a,b = a-1, b-1
g[a].append(b)
g[b].append(a)
stack = deque([0])
dist = [-1]*n
dist[0] = 0
while stack:
v = stack.popleft()
for nv in g[v]:
if dist[nv] == -1:
dist[nv] = v+1
stack.append(nv)
print("Yes")
print(*dist[1:], sep= "\n")
| 1 | 20,401,369,484,000 | null | 145 | 145 |
n, x, m = map(int, input().split())
flag = [False]*m
a = []
while not flag[x]:
flag[x] = True
a.append(x)
x = pow(x, 2, m)
loop_start_idx = a.index(x)
loop_len = len(a) - loop_start_idx
loop_count = (n - loop_start_idx)//loop_len
loop_amari = (n-loop_start_idx)%loop_len
ans = sum(a[:loop_start_idx])
ans += sum(a[loop_start_idx:])*loop_count
ans += sum(a[loop_start_idx: loop_start_idx + loop_amari])
print(ans)
|
a,b=map(int,input().split())
#a,bの最大公約数
def gcd(a,b):
if(b==0):
return a
else:
return gcd(b, a%b)
#a,bの最小公倍数
def lcm(a,b):
return a*b//gcd(a,b)
print(lcm(a,b))
| 0 | null | 58,080,756,513,738 | 75 | 256 |
def resolve():
import math
print(2*math.pi*int(input()))
if '__main__' == __name__:
resolve()
|
def resolve():
import math
r = int(input())
circum = 2 * r * math.pi
print(circum)
resolve()
| 1 | 31,439,863,395,458 | null | 167 | 167 |
N=int(input())
A= list(map(int,input().split()))
B=[0 for _ in range(N)]
for a in A:
B[a-1]+=1
for b in B:
print(b)
|
s = input()
n = len(s)
n1 = (n-1)//2
n2 = (n+1)//2
if s == s[::-1]:
if s[:n1] == s[n2:]:
print("Yes")
else:
print("No")
else:
print("No")
| 0 | null | 39,488,499,254,318 | 169 | 190 |
n=int(input())
l=[0]
c=0
l=l+(list(map(int,input().split())))
try:
for i in range(1,n+1,2):
if l[i]&1:
c+=1
except:
pass
print(c)
|
x=int(input())
li=list(map(int, input().split()))
res=0
i=0
while i<x:
if li[i]%2!=0:
res+=1
i+=2
print(res)
| 1 | 7,754,767,340,780 | null | 105 | 105 |
#!/usr/bin/env python3
import collections as cl
import sys
def comb(n, r, mod=10 ** 9 + 7):
r = min(r, n-r)
upper = 1
for i in range(n, n-r, -1):
upper = (upper * i) % mod
lower = 1
for i in range(1, r+1):
lower = (lower * i) % mod
lower_inv = pow(lower, mod - 2, mod)
return (upper * lower_inv) % mod
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def main():
n, a, b = MI()
ttl = pow(2, n, 10**9+7) - 1
a_ttl = comb(n, a)
b_ttl = comb(n, b)
print((ttl - a_ttl - b_ttl) % (10**9+7))
main()
|
# D - Bouquet
n,a,b = map(int,input().split())
MOD = 10**9+7
ans = pow(2,n,MOD)-1
a,b = min(a,b),max(a,b)
tmp = 1
for i in range(1,a+1):
tmp = tmp*(n+1-i)*pow(i,-1,MOD)
tmp %= MOD
ans = (ans-tmp)%MOD
for i in range(a+1,b+1):
tmp = tmp*(n+1-i)*pow(i,-1,MOD)
tmp %= MOD
ans = (ans-tmp)%MOD
print(ans)
| 1 | 66,106,016,870,190 | null | 214 | 214 |
import math
(x1,y1,x2,y2) = map(float,raw_input().split())
print math.hypot(x2-x1,y2-y1)
|
n = int(input())
A = list(map(int, input().split()))
mod = 10**9+7
ans = 0
for i in range(61):
cnt0 = 0
cnt1 = 0
for a in A:
if (a>>i) & 1 == 0:
cnt0 += 1
else:
cnt1 += 1
ans += cnt0 * cnt1 * (2 ** i)
ans %= mod
print(ans)
| 0 | null | 61,293,014,295,132 | 29 | 263 |
def f(n):
if n == 0:
return 0
return f(n % bin(n).count("1")) + 1
def solve():
N = int(input())
X = input()
p = X.count("1")
rem_plus = 0
rem_minus = 0
for i in range(N):
k = N - i - 1
if X[i] == "0":
continue
elif p > 1:
rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1)
rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1)
for i in range(N):
k = N - i - 1
if X[i] == "0":
print(f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1)
elif p > 1:
print(f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1)
else:
print(0)
if __name__ == "__main__":
solve()
|
import sys
readline = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
import numpy as np
#N = 2 * 10 ** 5
#X = np.random.randint(0, 2, N)
#Y = int('0b' + ''.join(X.astype(str).tolist()), 0)
N = int(input())
X = input()
Y = int('0b' + X, 0)
X = np.array(list(X), int)
p = int(X.sum())
m1 = Y % (p + 1)
m2 = Y % max(1, p - 1)
count = np.zeros((N + 1, ))
for n in range(1, N):
i = np.array(list(bin(n))[2:], int).sum()
count[n] = 1 + count[n % i]
ans = [0] * N
for n in range(1, N + 1):
flag = 0
if X[n - 1]:
z = m2 - pow(2, N - n, max(1, p - 1))
z %= max(1, p - 1)
if p - 1 == 0:
flag = 1
else:
z = pow(2, N - n, p + 1) + m1
z %= p + 1
if p == 0:
z = 0
ans[n - 1] = int(count[z] + 1)
if z == 0 and flag:
ans [n - 1] = 0
print('\n'.join(map(str, ans)))
| 1 | 8,214,537,267,998 | null | 107 | 107 |
x = int(input())
c_500 = x // 500
r_500 = x % 500
c_5 = r_500 // 5
print(c_500 * 1000 + c_5 * 5)
|
X = int(input())
A = X // 500
B = X % 500
C = B // 5
ans = A * 1000 + C * 5
print(ans)
| 1 | 42,614,067,736,302 | null | 185 | 185 |
A = input()
B = input()
B = B[0:len(B)-1]
if A == B:
print('Yes')
else:
print('No')
|
s = input()
t = input()
print(['No','Yes'][s == t[:-1]])
| 1 | 21,532,138,986,490 | null | 147 | 147 |
N = 26
D = int(input())
c_list = list(map(int, input().split()))
s_table = []
for _ in range(D):
s_table.append(list(map(int, input().split())))
data = []
for _ in range(D):
data.append(int(input()) - 1)
def calc(data):
last = [-1] * N
satisfaction = 0
for i in range(D):
j = data[i]
satisfaction += s_table[i][j]
last[j] = i
for k in range(N):
satisfaction -= c_list[k] * (i - last[k])
print(satisfaction)
return satisfaction
calc(data)
|
#Scoring
import numpy as np
D = int(input())
C = np.array(list(map(int, input().split())))
S = np.zeros((D,26),int)
for i in range(D):
S[i] = list(map(int, input().split()))
t = np.zeros(D,int)
for i in range(D):
t[i] = int(input())
score = int(0)
ld = -np.ones(26,int)
tscore = np.zeros(26,int)
for i in range(D):
cid = t[i]-1
ld[cid] = i
score -= np.sum(C*(i-ld))
score += S[i,cid]
print(score)
| 1 | 9,920,883,708,160 | null | 114 | 114 |
x = input().split()
print(x[1]+x[0])
|
x,y,a,b,c=map(int,input().split())
*p,=sorted(map(int, input().split()))
*q,=sorted(map(int, input().split()))
*r,=map(int, input().split())
p=p[-x:]
q=q[-y:]
r=sorted(p+q+r)
print(sum(r[-x-y:]))
| 0 | null | 74,196,927,885,042 | 248 | 188 |
n = int(input())
d = dict()
for i in range(n):
s = input()
if(s not in d.keys()):
d[s] = 1
else:
d[s] +=1
max = max(d.values())
ans = []
for i in d.keys():
if(d[i] == max):
ans.append(i)
for i in sorted(ans):
print(i)
|
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7
N = 10**5
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
N,K=map(int,input().split())
L=list(map(int,input().split()))
L=sorted(L)
s=0
for i in range(N-K+1):
s+=(cmb(N-i-1,K-1,mod)*(L[N-1-i]-L[i]))%mod
print(s%mod)
| 0 | null | 83,060,906,700,668 | 218 | 242 |
n = int(input())
M = int(n**(0.5))
ans = [0]*(n+1)
for x in range(1,M+1):
for y in range(1,10**2):
for z in range(1,10**2):
if x**2+y**2+z**2+x*y+y*z+z*x > n:
break
ans[x**2+y**2+z**2+x*y+y*z+z*x] += 1
if x**2+y**2 > n:
break
for i in range(n):
print(ans[i+1])
|
N=int(input())
f=[0]*10000
for i in range(100):
for j in range(100):
for k in range(100):
n=(i+1)**2+(j+1)**2+(k+1)**2+(i+1)*(j+1)+(j+1)*(k+1)+(k+1)*(i+1)
if n<=10000:
f[n-1]+=1
for i in range(N):
print(f[i])
| 1 | 7,932,179,156,836 | null | 106 | 106 |
import math
a,b = map(int,input().split())
gcd = math.gcd(a,b)
lcm = (a*b) // gcd
print(lcm)
|
mod = 10**9+7
n,k = map(int,input().split())
ans = 0
for i in range(k,n+2):
ans += (i*n-i*(i-1)+1)%mod
ans %=mod
print(ans)
| 0 | null | 73,012,162,420,120 | 256 | 170 |
N = int(input())
P = list(map(int,input().split()))
P_min = []
a = 200000
ans = 0
for i in range(N):
if a >= P[i]:
ans += 1
a = P[i]
print(ans)
|
#!/usr/bin/env python3
def main():
_ = int(input())
P = [int(x) for x in input().split()]
res = P[0]
ans = 0
for p in P:
if p <= res:
ans += 1
res = p
print(ans)
if __name__ == '__main__':
main()
| 1 | 85,203,622,538,020 | null | 233 | 233 |
# -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力を取得
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
# 求解処理
p = 0
q = 0
order = 1
for t in itertools.permutations(range(1, N + 1), N):
if t == P:
p = order
if t == Q:
q = order
order += 1
ans = abs(p - q)
# 結果出力
print(ans)
|
def cut(S,H,W,K):
cnt,h = 0,0
OP = [[0 for _ in range(W)] for _ in range(H)]
while "#" not in S[h]:
h += 1
burst = False
for i in range(h,H):
if "#" not in S[i]:
OP[i] = [OP[i-1][j] for j in range(W)]
burst = False
else:
cnt += 1
cnt_h = 1
for j in range(W):
OP[i][j] = cnt
if S[i][j] == "#" and cnt_h < S[i].count("#"):
cnt += 1
cnt_h += 1
for i in reversed(range(h)):
for j in range(W):
OP[i][j] = OP[i+1][j]
for i in range(H):
OP[i] = " ".join(map(str,OP[i]))
return OP
def main():
H,W,K = map(int,input().split())
S = [input() for _ in range(H)]
ans = cut(S,H,W,K)
for i in range(H):
print(ans[i])
if __name__ == "__main__":
main()
| 0 | null | 121,974,866,641,540 | 246 | 277 |
import sys
import math
import functools
def resolve(in_):
N = int(next(in_))
A = tuple(map(int, next(in_).split()))
max_a = max(A)
temp = [0] * (max_a + 1)
temp[1] = 1
for i in range(2, max_a + 1):
if temp[i]:
continue
j = i
while j < max_a + 1:
if not temp[j]:
temp[j] = i
j += i
B = set()
for a in A:
s = set()
while a > 1:
s.add(temp[a])
a = a // temp[a]
for v in s:
if v in B:
if functools.reduce(math.gcd, A) == 1:
return 'setwise coprime'
else:
return 'not coprime'
B.add(v)
return 'pairwise coprime'
def main():
answer = resolve(sys.stdin.buffer)
print(answer)
if __name__ == '__main__':
main()
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
A = LIST()
if reduce(gcd, A) != 1:
print("not coprime")
exit()
ma = max(A)
p = list(range(ma+1))
for x in range(2, int(ma ** 0.5) + 1):
if p[x]:
# xは素数，それがpの要素にあるうちは続ける
for i in range(2 * x, ma + 1, x):
p[i] = x
s = [set() for _ in range(N)]
t = set()
for i, x in enumerate(A):
while x != 1:
s[i].add(x)
t.add(x)
# 割り続けるとs[i]にその素数がたまっていく
x //= p[x]
l = sum(len(x) for x in s)
print("pairwise coprime" if l == len(t) else "setwise coprime")
| 1 | 4,124,499,455,788 | null | 85 | 85 |
while True:
a = map(int, raw_input().split(" "))
if len([x for x in a if x <> 0]) <= 0:
break
else:
a.sort()
print " ".join(map(str, a))
|
i=0
xArray=[]
yArray=[]
while True:
x,y=(int(num) for num in input().split())
if x==0 and y==0:
break
else:
xArray.append(x)
yArray.append(y)
i+=1
for count in range(i):
if xArray[count] < yArray[count]:
print(xArray[count],yArray[count])
else:
print(yArray[count],xArray[count])
| 1 | 534,307,898,872 | null | 43 | 43 |
A,V = map(int,input().split())
B,W= map(int,input().split())
T = int(input())
dist = abs(A-B)
vec = V-W
print('YES' if vec*T >= dist else 'NO')
|
import sys
rm = lambda: map(int, sys.stdin.buffer.readline().split())
ri = lambda: int(sys.stdin.readline())
a, v = rm()
b, w = rm()
t = ri()
if v - w == 0:
print('NO')
exit()
if 0 <= abs(a-b) / (v-w) <= t:
print('YES')
else:
print('NO')
| 1 | 15,112,154,123,142 | null | 131 | 131 |
N = int(input())
XL = [list(map(int, input().split())) for i in range(N)]
LR = [[x - l, x + l] for x, l in XL]
LR.sort(key=lambda x: x[1])
ans = 0
prev = -float("INF")
for l, r in LR:
if prev <= l:
ans += 1
prev = r
print(ans)
|
n = int(input())
def sieve1(n):
isPrime = [True] * (n+1)
isPrime[0] = False
isPrime[1] = False
for i in range(2*2, n+1, 2):
isPrime[i] = False
for i in range(3, n+1):
if isPrime[i]:
for j in range(i+i, n+1, i):
isPrime[j] = False
return isPrime
numOfDivisors = [2] * (n+1)
numOfDivisors[1] = 1
numOfDivisors[0] = 0
isPrime = sieve1(n)
for i in range(2, n+1):
if isPrime[i]:
for j in range(2*i, n+1, i):
x = j // i
numOfDivisors[j] += numOfDivisors[x] - 1
ans = 0
for k in range(1, n+1):
ans += numOfDivisors[k] * k
print (ans)
| 0 | null | 50,641,199,791,140 | 237 | 118 |
import sys
n, k = map(int, input().split())
a = list(map(int, input().split()))
f = list(map(int, input().split()))
a.sort()
f.sort(reverse=True)
l, r = -1, 10 ** 12 + 1
while r - l > 1:
m = (l + r) // 2
cnt = 0
for i in range(n):
cnt += max(0, a[i] - (m // f[i]))
if cnt <= k:
r = m
else:
l = m
print(r)
|
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list( map(int, input().split()))
A.sort()
F.sort(reverse=True)
la = 10**12+1
sm = -1
while sm+1<la:
mi = (sm+la)//2
y=0
for i in range(N):
y += max(0, A[i]-(mi//F[i]))
if y<=K:
la = mi
else:
sm = mi
print(la)
| 1 | 164,603,311,382,692 | null | 290 | 290 |
n=int(input())
s=input()
w=s.count('W')
r=s.count('R')
ans=10**9
if w==0 or r==0:
print(0)
exit(0)
left_white, right_red=0,r
for i in range(n):
if s[i]=='W':
left_white+=1
else:
right_red-=1
ans=min(ans,max(left_white,right_red))
print(ans)
|
import math
import numpy as np
import sys
import os
from operator import mul
from operator import itemgetter
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
N,M = LI()
H = LI()
AB = [LI() for _ in range(M)]
p = []
d = {}
for i in range(N):
# p.append((i,H[i]))
d[i]=H[i]
# p.sort(key=itemgetter(1),reverse=True)
# print(p)
# print(d)
# g = np.zeros(shape=(N,N),dtype='int')
g = [set()] * N
a = [True] * N
for i in range(M):
f = AB[i][0]-1
t = AB[i][1]-1
if d[t]>d[f]:
a[f]=False
elif d[f]>d[t]:
a[t]=False
else:
a[f]=False
a[t]=False
# print(a)
print(sum(a))
# print(g[f])
# g[f] = np.append(g[f],t)
# g[t] = np.append(g[t],f)
# g[f][t]=1
# g[t][f]=1
# print(g)
# list.sort(key=itemgetter(0))
# for i in range(N):
# a = np.where(g[0]==1)
# print(a)
| 0 | null | 15,693,435,587,434 | 98 | 155 |
x1,y1,x2,y2=list(map(float,input().split()))
d=((x1-x2)**2+(y1-y2)**2)**0.5
print(d)
|
N,X,T=map(int,input().split())
print((int(N/X)+(N%X!=0))*T)
| 0 | null | 2,235,025,782,678 | 29 | 86 |
def i():
return int(input())
def i2():
return map(int,input().split())
def s():
return str(input())
def l():
return list(input())
def intl():
return list(int(k) for k in input().split())
n = i()
a = [int(i) for i in input().split()]
cnt = 1
ans = 0
for i in range(n):
if a[i] == cnt:
cnt += 1
else:
ans += 1
if cnt == 1:
print(-1)
else:
print(ans)
|
n = int(input())
a = list(map(int, input().split()))
d = {}
for i in a:
if i in d: d[i] += 1
else: d[i] = 1
ans = 0
for i in d.values(): ans += i*(i-1)//2
for i in a:
print(ans - (d[i]-1))
| 0 | null | 81,225,501,292,808 | 257 | 192 |
import bisect
n,m = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
S = [0]*(n+1)
for i in range(n):
S[i+1] = S[i] + A[i]
def cnt(x,A,S):
res = 0
for i,a in enumerate(A):
res += bisect.bisect_left(A,x - a)
return res
def ans(x,A,S):
res = 0
for i,a in enumerate(A):
res += a*bisect.bisect_left(A,x-a) + S[bisect.bisect_left(A,x-a)]
return res
top = A[-1]*2+1
bottom = 0
# mid以上が何個あるか
while top - bottom > 1:
mid = (top + bottom)//2
if n*n - cnt(mid,A,S) > m:
bottom = mid
else:
top = mid
print(S[-1]*2*n - ans(top,A,S) + bottom*(m - (n*n - cnt(top,A,S))))
|
ina = input()
inb = input()
l = int(ina)
cw1 = inb.count("W")
cw2 = inb[-cw1:].count("W")
print(cw1-cw2)
| 0 | null | 57,515,443,848,320 | 252 | 98 |
from sys import stdin
import math
import re
import queue
input = stdin.readline
MOD = 1000000007
INF = 122337203685477580
def solve():
A,B,M = map(int, input().split())
v1 =list(map(int, input().split()))
v2 =list(map(int, input().split()))
res = INF
for i in range(M):
X,Y,C = map(int, input().split())
res = min(res,v1[X-1] + v2[Y-1] - C)
res = min(res,min(v1) + min(v2))
res = max(0,res)
print(res)
if __name__ == '__main__':
solve()
|
# For taking integer inputs.
def inp():
return(int(input()))
# For taking List inputs.
def inlist():
return(list(map(int, input().split())))
# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.
def instr():
s = input()
return(list(s[:len(s)]))
# For taking space seperated integer variable inputs.
def invr():
return(map(int, input().split()))
A, B, M = invr()
a = inlist() # all fridger cost list
b = inlist() # all oven cost list
C = []
for i in range(M):
C.append(inlist())
costs_of_using_tickets = [0] * M
for i in range(M):
ci = C[i]
costs_of_using_tickets[i] = a[ci[0]-1] + b[ci[1]-1] - ci[2]
cost_of_not_using_tickets = min(a) + min(b)
print(min(cost_of_not_using_tickets, min(costs_of_using_tickets)))
| 1 | 54,286,712,469,308 | null | 200 | 200 |
from sys import stdin
def main():
#入力
readline=stdin.readline
n,m=map(int,readline().split())
s=readline().strip()
ans=[]
flag=False
i=n
while True:
max_i=i
for sa in range(1,m+1):
if i-sa==0:
ans.append(sa)
flag=True
break
else:
if s[i-sa]=="0":
max_i=i-sa
if flag: break
else:
if max_i!=i:
ans.append(i-max_i)
i=max_i
else:
break
if flag:
ans.reverse()
print(*ans)
else:
print(-1)
if __name__=="__main__":
main()
|
n, m = map(int,input().split())
s = list(input())
s.reverse()
ng = False
c = 0
ans = []
while ng == False and c < n:
for i in range(m, 0, -1):
if c+i < n+1 and s[c+i] == '0':
c += i
ans.append(str(i))
break
elif i == 1:
ng = True
if ng:
print(-1)
else:
ans.reverse()
print(' '.join(ans))
| 1 | 139,011,341,860,310 | null | 274 | 274 |
a, b, c, d = map(int, input().split(" "))
while True:
c -= b
if c <= 0:
print("Yes")
break
a -= d
if a <= 0:
print("No")
break
|
A, B, C, D = map(int, input().split())
while A >= 0 and C >= 0:
if C <= B:
print('Yes')
break
else:
C = C - B
if A <= D:
print('No')
break
else:
A = A - D
| 1 | 29,861,101,464,192 | null | 164 | 164 |
def main():
k, n = map(int, input().split(" "))
a = list(map(int, input().split(" ")))
d =[min(a)+k-max(a)]
for i in range(n-1):
d.append(a[i+1]-a[i])
print(k-max(d))
if __name__ == "__main__":
main()
|
K,N=map(int,input().split())
array=input().split()
A=[]
for i in array:
A.append(int(i))
dist=[]
for i in range(N):
if i!=N-1:
dist.append(A[i+1]-A[i])
else:
dist.append((K-A[i])+A[0])
dist=sorted(dist)
ans=0
for i in range(N-1):
ans+=dist[i]
print(ans)
| 1 | 43,358,496,298,464 | null | 186 | 186 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
t1, t2 = map(int, readline().split())
a1, a2 = map(int, readline().split())
b1, b2 = map(int, readline().split())
if a1 < b1:
a1, b1 = b1, a1
a2, b2 = b2, a2
if a2 > b2:
return print(0)
else:
d1 = t1 * a1 + t2 * a2
d2 = t1 * b1 + t2 * b2
if d1 == d2:
return print("infinity")
elif d2 > d1:
ans = 1
diff = d2 - d1
x = t1 * (a1 - b1)
cnt = x // diff
ans += cnt * 2
if x % diff == 0:
ans -= 1
return print(ans)
else:
return print(0)
if __name__ == '__main__':
main()
|
t = list(input())
a = 0
b = 0
for i in range(len(t)):
if i == 0 and t[i] == '?':
t[i] = 'D'
if 0 < i < len(t) - 1 and t[i] == '?':
if t[i-1] == 'P':
t[i] = 'D'
elif t[i+1] == 'P':
t[i] = 'D'
else:
t[i] = 'P'
if i == len(t) -1 and t[i] == '?':
t[i] = 'D'
print(''.join(t))
| 0 | null | 74,981,554,611,758 | 269 | 140 |
import sys
input = sys.stdin.readline
import numpy as np
N, M = map(int, input().split())
L = list(map(int, input().split()))
A = np.zeros(1<<18)
for i in L:
A[i] += 1
C = (np.fft.irfft(np.fft.rfft(A) * np.fft.rfft(A)) + .5).astype(np.int64)
G = C.cumsum()
count = np.searchsorted(G, N*N-M)
rest = N*N-M - G[count-1]
temp = (C[:count]*np.arange(count, dtype=np.int64)).sum() + count*rest
ans = sum(L)*2*N - temp
print(ans)
|
import numpy as np
def convolve(A, B):
# 畳み込み # 要素は整数
# 3 つ以上の場合は一度にやった方がいい
dtype = np.int64
fft, ifft = np.fft.rfft, np.fft.irfft
a, b = len(A), len(B)
if a == b == 1:
return np.array([A[0]*B[0]])
n = a+b-1 # 返り値のリストの長さ
k = 1 << (n-1).bit_length()
AB = np.zeros((2, k), dtype=dtype)
AB[0, :a] = A
AB[1, :b] = B
return np.rint(ifft(fft(AB[0]) * fft(AB[1]))).astype(np.int64)[:n]
import sys
input = sys.stdin.readline
n,m = map(int, input().split())
a = list(map(int, input().split()))
cnt = np.zeros(100001)
for i in a:
cnt[i] += 1
c = convolve(cnt,cnt)
ans = 0
for i in range(len(c))[::-1]:
if c[i] > 0:
p = min(m,c[i])
m -= p
ans += i*p
if m == 0:
break
print(ans)
| 1 | 108,038,295,030,272 | null | 252 | 252 |
from collections import defaultdict
def dfs(here, connect, visited, answer):
global time
answer[here][1] = time
time += 1
visited[here] = 1
for c in connect[here]:
if not visited[c]:
dfs(c, connect, visited, answer)
answer[here][2] = time
time += 1
v_num = int(input())
connect = defaultdict(list)
for _ in range(v_num):
inp = [int(n) - 1 for n in input().split(" ")]
connect[inp[0]].extend(sorted(inp[2:]))
answer = [[n + 1 for m in range(3)] for n in range(v_num)]
time = 1
visited = [0 for n in range(v_num)]
for i in range(v_num):
if not visited[i]:
dfs(i, connect, visited, answer)
for v in range(v_num):
print(*answer[v])
|
list1 = input().split(" ")
if int(list1[0]) <= int(list1[1]) * int(list1[2]):
print("Yes")
else:
print("No")
| 0 | null | 1,780,358,558,500 | 8 | 81 |
N = int(input())
ac = 0
wa = 0
tle = 0
re = 0
for i in range(N):
s = input()
if s == "AC":
ac += 1
elif s == "WA":
wa += 1
elif s == "TLE":
tle += 1
else:
re += 1
print("AC x", ac)
print("WA x", wa)
print("TLE x", tle)
print("RE x", re)
|
N = int(input())
ans_ac = 0
ans_wa = 0
ans_tle =0
ans_re =0
for i in range(N):
S = input()
if S == 'AC':
ans_ac += 1
elif S == 'WA':
ans_wa += 1
elif S == 'TLE':
ans_tle += 1
else:
ans_re += 1
print('AC','x',ans_ac)
print('WA','x',ans_wa)
print('TLE','x',ans_tle)
print('RE','x',ans_re)
| 1 | 8,711,806,767,700 | null | 109 | 109 |
N = int(input())
A = list(map(int, input().split()))
# N日目の最大の所持金
dp = [1000] + [0] * (N-1)
for i in range(1, N):
dp[i] = dp[i-1]
for j in range(i):
# j日に買える最大の株数
max_unit = dp[j] // A[j]
# その場合の所持金の変化
money = dp[j] + (A[i]-A[j])*max_unit
dp[i] = max(money, dp[i])
print(dp[-1])
|
n = int(input())
a = [0 for _ in range(n)]
a = [int(s) for s in input().split()]
st_num = 0
mny = 1000
for i in range(n-1):
now_mn = a[i]
next_mn = a[i+1]
#print(st_num,mny)
if(next_mn > now_mn):
st_num += mny//now_mn
mny = mny%now_mn
else:
mny += st_num*now_mn
st_num = 0
if(a[n-1] > a[n-2] and st_num > 0):
mny += st_num*a[n-1]
st_num = 0
print(mny)
| 1 | 7,406,768,046,590 | null | 103 | 103 |
print(input()*0 + str(input().count("ABC")))
|
N = int(input())
S = input()
cnt = 0
for i in range(len(S)-2):
if S[i:i+3] == "ABC":
cnt += 1
print(cnt)
| 1 | 99,448,782,790,920 | null | 245 | 245 |
from collections import Counter
n = int(input())
s = input()
cnt = Counter(s)
ans = cnt["R"]*cnt["G"]*cnt["B"]
for i in range(n):
for j in range(i+1,n):
k = 2*j-i
if k >= n: continue
if s[i] != s[j] and s[i] != s[k] and s[j] != s[k]: ans -= 1
print(ans)
|
from collections import Counter as coun
from itertools import combinations as comb
import sys
input = sys.stdin.readline
N = int(input())
S = input()
C = coun(S)
ans = C["R"] * C["G"] * C["B"]
for i, j in comb(range(N), 2):
k = 2 * j - i
if k < N:
A, B, C = S[i], S[j], S[k]
if A != B and B != C and C != A: ans -= 1
print(ans)
| 1 | 36,225,424,207,008 | null | 175 | 175 |
cnt = 0
INF = pow(10, 18)
def merge(A, left, mid, right):
L = A[left:mid] + [INF]
R = A[mid:right] + [INF]
i = 0
j = 0
for k in range(left, right):
global cnt
cnt += 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)
n = int(input())
s = list(map(int, input().split()))
mergeSort(s, 0, n)
print(*s)
print(cnt)
|
import math
import sys
# 比較回数をここに記録
# 理論上 n * lg n を越えることはない。
_exchange = 0
def merge_sort(A, left, right):
"""数列 A を in place に昇順にソートする。
left は A の先頭のインデックス、right は末尾のインデックスのひとつ後ろ。
"""
if left + 1 < right:
mid = (left + right) // 2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
def merge(A, left, mid, right):
"""ソート済みの部分列をマージする。
数列 A の left から mid - 1 の要素、mid から right - 1 までの
２つの部分列はソート済みである。これをマージして、left から right - 1 まで
ソートする。
"""
first = A[left:mid]
first.append(math.inf) # 番兵
second = A[mid:right]
second.append(math.inf) # 番兵
global _exchange
i = j = 0
for k in range(left, right):
_exchange += 1
if first[i] <= second[j]:
A[k] = first[i]
i += 1
else:
A[k] = second[j]
j += 1
if __name__ == '__main__':
n = int(input())
A = list(map(int, sys.stdin.readline().split()))
merge_sort(A, 0, n)
print(*A)
print(_exchange)
| 1 | 114,952,424,542 | null | 26 | 26 |
n=int(input())
t = [[0 for _ in range(10)] for _ in range(10)]
for i in range(1,n+1):t[int(str(i)[0])][int(str(i)[-1])]+=1
g=0
for i in range(1,10):
for j in range(1,10):
g+=t[i][j]*t[j][i]
print(g)
|
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
n = inp()
ans = 0
n_ketasuu = len(str(n))
sta_max = int(str(n)[0])
end_max = int(str(n)[n_ketasuu-1])
for i in range(1,n+1):
sta = int(str(i)[len(str(i))-1])
end = int(str(i)[0])
if sta == 0:
continue
#1桁
if sta == end:
ans +=1
#2桁
if n_ketasuu >= 2 and sta*10 + end <= n:
ans += 1
#3桁
if n_ketasuu > 3 or (n_ketasuu == 3 and sta < sta_max):
ans += 10
elif n_ketasuu == 3 and sta == sta_max:
ans += int(str(n)[1:n_ketasuu-1])
if end <= end_max:
ans += 1
#4桁
if n_ketasuu > 4 or (n_ketasuu == 4 and sta < sta_max):
ans += 100
elif n_ketasuu == 4 and sta == sta_max:
ans += int(str(n)[1:n_ketasuu-1])
if end <= end_max:
ans += 1
#5桁
if n_ketasuu > 5 or (n_ketasuu == 5 and sta < sta_max):
ans += 1000
elif n_ketasuu == 5 and sta == sta_max:
ans += int(str(n)[1:n_ketasuu-1])
if end <= end_max:
ans += 1
#6桁
if n_ketasuu > 6 or (n_ketasuu == 6 and sta < sta_max):
ans += 10000
elif n_ketasuu == 6 and sta == sta_max:
ans += int(str(n)[1:n_ketasuu-1])
if end <= end_max:
ans += 1
print(ans)
| 1 | 86,553,984,716,676 | null | 234 | 234 |
def main():
import sys
input=sys.stdin.readline
n=int(input())
lst=[]
for i in range(n):
a,b=map(int,input().split())
lst.append([a-b,a+b])
lst=sorted(lst,key=lambda x:x[1])
ans=0
end=-float("inf")
for i in lst:
if i[0]>=end:
ans+=1
end=i[1]
print(ans)
if __name__=="__main__":
main()
|
N=int(input())
xl=[]
for _ in range(N):
x,l=map(int,input().split())
xl.append([x+l,2*l])
xl.sort()
r=-10**9
ans=0
for i in range(N):
if xl[i][0]-xl[i][1]>=r:
ans+=1
r=xl[i][0]
print(ans)
| 1 | 90,353,947,929,502 | null | 237 | 237 |
def solve(n):
import math
m = 26
nn = n - 1
for i in range(1, m + 1):
p = m ** i
if p > nn:
break
nn -= p
s = ''
for j in range(1, i + 1):
p = m ** (i - j)
x, nn = divmod(nn, p)
s += chr(x + ord('a'))
return s
def main(istr, ostr):
n, = list(map(int, istr.readline().strip().split()))
result = solve(n)
print(result, file=ostr)
if __name__ == "__main__":
import sys
main(sys.stdin, sys.stdout)
|
import bisect,collections,copy,heapq,itertools,math,string
import sys
from decimal import Decimal
def S(): return sys.stdin.readline().rstrip()
def M(): return map(Decimal,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b = M()
ab = a*b
print(math.floor(ab))
| 0 | null | 14,247,278,254,456 | 121 | 135 |
import math
a,b = [int(x) for x in input().split()]
ma = int(a//0.08)
mb = int(b//0.1)
fmindi = False
mindi = 9999999999999
for x in range(min(ma,mb),max(ma,mb)+2):
j = math.floor(x*0.08)
e = math.floor(x*0.1)
if j == a and e == b:
fmindi = True
mindi = min(mindi,x)
print(mindi if fmindi else -1)
|
n,r=map(int,input().split())
ans = r
if n<10:
ans = r+100*(10-n)
print(ans)
| 0 | null | 60,042,847,785,088 | 203 | 211 |
n,a,b=map(int,input().split())
if (b-a)%2 == 0:
print((b-a)//2)
else:
if n-b >= a-1:
ans = a-1
ans += (b-a-1)//2
print(ans+1)
else:
ans = n-b
ans += (b-a-1)//2
print(ans+1)
|
n = int(input())
S = input()
ans = 0
nums = list(map(str, range(10)))
for i in nums:
s1 = S.find(i)
if s1 < 0:
continue
for j in nums:
s2 = S.find(j, s1+1)
if s2 < 0:
continue
for k in nums:
s3 = S.find(k, s2+1)
if s3 > 0:
ans += 1
print(ans)
| 0 | null | 119,342,490,410,376 | 253 | 267 |
n,k,c = map(int,raw_input().split())
s = raw_input()
most = [0]*(n+1)
i = n
days = 0
while i > 0:
if s[i-1] == 'o':
days += 1
for j in xrange(min(max(1,c),i-1)):
#print days
#print i,j,1,days
most[i-j-1] = days
i -= (c+1)
else:
i -= 1
if i<n:
most[i] = most[i+1]
remain = k
i = 1
while i<=n:
if s[i-1] == 'o':
if most[i] < remain:
print i
remain -= 1
i += c+1
else:
i += 1
|
N, K, C = map(int, input().split())
S = input()
left = []
right = []
i, j = 0, N-1
while len(left) <= K-1:
if S[i] == "o":
left.append(i)
i += C+1
else:
i += 1
while len(right) <= K-1:
if S[j] == "o":
right.append(j)
j -= C+1
else:
j -= 1
right.sort()
for n in range(K):
if left[n] == right[n]:
print(left[n] + 1)
| 1 | 40,843,005,294,530 | null | 182 | 182 |
n=raw_input()
a=''
for i in n:
if i.islower():a+=i.upper()
else:a+=i.lower()
print a
|
import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
#H,N = LI()
_XY = [LI() for _ in range(N)]
# X,Y = zip(*XY)
XY = np.array(_XY)
#C = np.zeros(N + 1)
# print(XY)
# print(np.linalg.norm(XY[1]-XY[0]))
def calcdis(p1,p2):
return np.linalg.norm(p2-p1)
ans = []
for i in range(N):
tmp = 0
for j in range(N):
if not i==j:
# print(i,j)
tmp += calcdis(XY[i],XY[j])
ans.append(tmp)
print(np.average(ans))
# if ans:
# print('Yes')
# else:
# print('No')
| 0 | null | 74,759,371,055,292 | 61 | 280 |
n,m=map(int,input().split())
l=list(map(int,input().split()))
sum=0
for i in range(m):
sum+=l[i]
if sum>n:
print(-1)
else:
print(n-sum)
|
N, M = [int(_) for _ in input().split()]
A = [int(_) for _ in input().split()]
print(max(N - sum(A), -1))
| 1 | 32,029,057,762,860 | null | 168 | 168 |
import sys
from collections import deque
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())
n = I()
A = LI()
q = I()
m = LI()
ans = 0
partial_sum = set()
for i in range(2 ** n):
bit = [i>>j&1 for j in range(n)]
partial_sum.add(sum(A[k]*bit[k] for k in range(n)))
for x in m:
print('yes' if x in partial_sum else 'no')
|
n = int(input())
a = list(map(int,input().split()))
q = int(input())
m = list(map(int,input().split()))
"""def dfs(i,m):
global a
if i == 0:
if m == 0:
return True
else:
return False
if dfs(i-1, m):
return True
if dfs(i-1,m - a[i-1]):
return True
return False
for i in range(q):
if dfs(n,m[i]):
print("yes")
else:
print("no")"""
b = []
def dfs(i,m):
global b
if i == 0:
b.append(m)
else:
dfs(i-1,m)
dfs(i-1,m+a[i-1])
return b
b = dfs(n,0)
for i in range(q):
if m[i] in b:
print("yes")
else:
print("no")
| 1 | 95,548,158,408 | null | 25 | 25 |
a, b, c, k = map(int, input().split())
ans = 0
if a >= k:
print(k)
exit()
ans += a
k -= a
if b >= k:
print(ans)
exit()
k -= b
ans -= k
print(ans)
|
import sys
def input(): return sys.stdin.readline().rstrip()
A,B,C,K = map(int,input().split())
point = 0
if A <= K:
point += A
K -= A
else:
point += K
K = 0
if B <= K:
K -= B
else:
K = 0
point -= K
print(point)
| 1 | 21,871,750,732,882 | null | 148 | 148 |
n = int(input())
x = []
y = []
for _ in range(n):
a,b = map(int,input().split())
x.append(a)
y.append(b)
ans = 0
for i in range(n):
for j in range(n):
ans += ((x[i]-x[j])**2 + (y[i]-y[j])**2)**0.5
print(ans/n)
|
import numpy as np
import math
n=int(input())
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
a=np.array(a, dtype=object)
ans=0
for i in range(n):
for j in range(n):
if i==j:
continue
else:
x= (a[i]-a[j])**2
hei=math.sqrt(sum(x))
ans+= hei/n
print(ans)
| 1 | 148,494,038,458,140 | null | 280 | 280 |
# D - Road to Millionaire
def million(n, a):
wallet = 1000
i = 0
while i < n - 1:
highest_price = a[i]
cheapest_price = a[i]
# 直近の最高値と最安値を取得する
for j in range(i + 1, n):
if highest_price > a[j]:
break
if highest_price < a[j]:
highest_price = a[j]
if cheapest_price > a[j]:
cheapest_price = a[j]
if highest_price > cheapest_price:
# 取引する
stock = wallet // cheapest_price
wallet = wallet - stock * cheapest_price
wallet = wallet + stock * highest_price
i = j
else:
i += 1
return wallet
if __name__ == "__main__":
n = int(input())
a = list(map(int, input().split()))
print(million(n, a))
|
import sys
N = int(input())
A = list(map(int, sys.stdin.readline().rsplit()))
dp = [0] * N
dp[0] = 1000
for i in range(N - 1):
dp[i + 1] = max(dp[i], (dp[i] // A[i]) * A[i + 1] + dp[i] % A[i])
print(dp[N - 1])
| 1 | 7,354,493,897,310 | null | 103 | 103 |
n=input()
for i in range(n):
l=map(int,raw_input().split())
l.sort()
if l[0]**2+l[1]**2==l[2]**2:print"YES"
else:print"NO"
|
N = int(input())
for i in range(N):
num = sorted(map(int, input().split()))
if num[0] ** 2 + num[1] ** 2 == num[2] ** 2:
print("YES")
else:
print("NO")
| 1 | 351,442,092 | null | 4 | 4 |
array = list(map(int, input().split()))
array.sort()
print("{} {} {}".format(array[0], array[1], array[2]))
|
inp = input()
a = inp.split()
a[0] = int(a[0])
a[1] = int(a[1])
a[2] = int(a[2])
a.sort()
print(a[0],a[1],a[2])
| 1 | 421,404,555,972 | null | 40 | 40 |
def solve():
x = int(input())
if x == 1:
print(0)
else:
print(1)
if __name__ == "__main__":
solve()
|
print('10'[int(input())])
| 1 | 2,930,567,648,940 | null | 76 | 76 |
import sys
import heapq
input = sys.stdin.readline
n, k, s = map(int, input().split())
for i in range(n):
if i < k:
print(s)
else:
if s >= 10**9:
print(1)
else:
print(s+1)
|
N=int(input())
f=[0]*(N+1)
for x in range(1,100):
for y in range(1,100):
for z in range(1,100):
temp=x**2+y**2+z**2+x*y+y*z+z*x
if temp<=N:
f[temp]+=1
for i in range(1,N+1):
print(f[i])
| 0 | null | 49,614,946,134,390 | 238 | 106 |
def f(s):
a=[-c]
for i,s in enumerate(s,1):
if s<'x'and a[-1]+c<i:a+=i,
return a[1:k+1]
n,s=open(0)
n,k,c=map(int,n.split())
for a,b in zip(f(s[:n]),f(s[-2::-1])[::-1]):
if a==n+1-b:print(a)
|
N = int(input())
a = N // 100
if 0 <= N - 100 * a <= 5 * a:
print(1)
else:
print(0)
| 0 | null | 83,715,089,382,432 | 182 | 266 |
k = int(input())
s = str(input())
if len(s) > k:
print(s[:k], end='')
print("...")
else:
print(s)
|
while True:
H,W = map(int, raw_input().split(" "))
if H == 0 and W == 0:
break
else:
for h in xrange(H):
sw = True if (h % 2) == 0 else False
s = ""
for w in xrange(W):
s += "#" if sw else "."
sw = not sw
print s
print ""
| 0 | null | 10,218,022,446,632 | 143 | 51 |
a = ""
while True:
try:
a += input().lower()
except:
break
for i in range(ord("a"), ord("z")+1):
print("{} : {}".format(chr(i), a.count(chr(i))))
|
A, B = map(int, input().split())
if A == B:
print('Yes')
else:
print('No')
| 0 | null | 42,478,730,464,508 | 63 | 231 |
while True:
a, op, b = map(str, input().split())
if op == "?":
break
if op == "/":
op = "//"
formula = a + op + b
print(eval(formula))
|
if __name__ == "__main__":
while True:
a,op,b = map(str,input().split())
if op is "+":
print("%d"%(int(a)+int(b)))
elif op is "-":
print("%d"%(int(a)-int(b)))
elif op is "*":
print("%d"%(int(a)*int(b)))
elif op is "/":
print("%d"%(int(a)/int(b)))
else:
break
| 1 | 688,360,757,952 | null | 47 | 47 |
num_l = set(map(int, input().split()))
print('Yes' if len(num_l) == 2 else 'No')
|
# coding: utf-8
# Your code here!
N=input().split()
a=int(N[0])
b=int(N[1])
c=int(N[2])
if a < b < c:
print("Yes")
else:
print("No")
| 0 | null | 34,365,590,092,900 | 216 | 39 |
a,b,c = map(int, input().split())
if (a+b+c) <=21:
print('win')
else:
print('bust')
|
# https://kmjp.hatenablog.jp/entry/2020/05/10/0900
# 数学的な問題
mod = 998244353
class COM:
def __init__(self, n, MOD):
self.n = n
self.MOD = MOD
self.fac = [0] * (n+1)
self.finv = [0] * (n+1)
self.inv = [0] * (n+1)
self.fac[0] = self.fac[1] = 1
self.finv[0] = self.finv[1] = 1
self.inv[1] = 1
for i in range(2, n+1):
self.fac[i] = self.fac[i-1] * i % MOD
self.inv[i] = MOD - self.inv[MOD % i] * (MOD // i) % MOD
self.finv[i] = self.finv[i-1] * self.inv[i] % MOD
def calc(self, k):
if k < 0:
return 0
return self.fac[self.n] * (self.finv[k] * self.finv[self.n-k] % self.MOD) % self.MOD
def main():
N, M, K = map(int,input().split())
# 隣り合う組がK以下のパターンを総当たりして解く
if N > 1:
cmbclass = COM(N-1, mod)
cmb = cmbclass.calc
else:
cmb = lambda x:1
res = 0
for i in range(K+1):
res += M * cmb(i) % mod * pow(M-1, N-i-1, mod)
print(res % mod)
if __name__ == "__main__":
main()
| 0 | null | 71,098,398,689,634 | 260 | 151 |
N, K, S = map(int, input().split())
rem = 1 if S >= 10**9 else S+1
ret = [S]*K + [rem]*(N-K)
print(' '.join(map(str, ret)))
|
N,K,S=map(int,input().split())
a=[10**9 if S==1 else S-1]*N
for i in range(K):a[i]=S
print(' '.join(map(str,a)))
| 1 | 90,910,975,708,004 | null | 238 | 238 |
N = int(input())
res = [[0 for _ in range(9)] for _ in range(9)]
for i in range(1, N + 1):
if i % 10: res[int(str(i)[0]) - 1][i % 10 - 1] += 1
ans = 0
for i in range(1, N + 1):
if i % 10: ans += res[i % 10 - 1][int(str(i)[0]) - 1]
print(ans)
|
n, m, q = map(int, input().split())
a = [0] * q
b = [0] * q
c = [0] * q
d = [0] * q
for i in range(q):
a[i], b[i], c[i], d[i] = map(int, input().split())
score = []
# 数列Aの全探索
import copy
def dfs(A):
if len(A) == n+1:
# score計算
tmp = 0
#print(A)
for i in range(q):
if A[b[i]] - A[a[i]] == c[i]:
tmp += d[i]
score.append(tmp)
return
else:
tmp = A[-1]
arr = copy.copy(A)
arr.append(tmp)
while(arr[-1] <= m):
dfs(arr)
arr[-1] += 1
dfs([1])
print(max(score))
| 0 | null | 56,890,286,966,048 | 234 | 160 |
from math import sqrt
N = int(input())
X = []
Y = []
for i in range(N):
x, y = map(int, input().split())
X.append(x)
Y.append(y)
ans = 0
for i in range(0, N-1):
for j in range(i+1, N):
ans += sqrt((X[i] - X[j]) ** 2 + (Y[i] - Y[j]) ** 2)
print(ans * 2.0 / N)
|
s = input()
k = int(input())
if len(set(s)) == 1:
print((len(s)*k)//2)
exit()
ss = s + s
shoko = 0
prev = ''
cnt = 0
for i in range(len(s)):
if s[i] == prev:
cnt += 1
else:
shoko += cnt // 2
cnt = 1
prev = s[i]
shoko += cnt // 2
kosa = 0
prev = ''
cnt = 0
for i in range(len(ss)):
if ss[i] == prev:
cnt += 1
else:
kosa += cnt // 2
cnt = 1
prev = ss[i]
kosa += cnt // 2
kosa -= shoko
print(shoko + (k-1)*kosa)
| 0 | null | 161,379,767,009,340 | 280 | 296 |
score = list(map(int,input().split()))
kaisu = 1
hp = score[0]
while hp > score[1]:
kaisu += 1
hp -= score[1]
print(kaisu)
|
n = int(input())
x = list(map(int,input().split()))
k = []
def kyori(p):
m = 0
for i in range(n):
m += (p-x[i])**2
return m
for i in range(1,101):
k.append(kyori(i))
print(min(k))
| 0 | null | 71,072,099,454,132 | 225 | 213 |
def main():
N = int(input())
st = [list(input().split()) for i in range(N)]
X = input()
ans = 0
for i in range(N):
if st[i][0] == X:
i += 1
break
for j in range(i,N,1):
ans += int(st[j][1])
return ans
print(main())
|
n=int(input())
a=list()
for i in range(n):
s,t=input().split()
a.append([s,int(t)])
x=input()
flag=False
ans=0
for i in a:
if flag:
ans+=i[1]
if i[0]==x:
flag=True
print(ans)
| 1 | 96,823,643,693,888 | null | 243 | 243 |
from collections import defaultdict
N = int(input())
if N == 1:
print(0)
exit()
p = defaultdict(int)
while N % 2 == 0:
p[2] += 1
N //= 2
f = 3
while f * f <= N:
if N % f == 0:
p[f] += 1
N //= f
else:
f += 2
if N != 1:
p[N] += 1
ans = 0
for v in p.values():
n = 1
i = 1
while n <= v:
ans += 1
i += 1
n += i
print(ans)
|
#coding:utf-8
m = 0
f = 0
r = 0
while m + f + r >-3:
m , f, r =[int(i) for i in input().rstrip().split(" ")]
if m+f+r == -3:
break
if m == -1:
print("F")
elif f == -1:
print("F")
elif m+f <30:
print("F")
elif m+f <50:
if r>=50:
print("C")
else:
print("D")
elif m+f <65:
print("C")
elif m+f <80:
print("B")
else:
print("A")
| 0 | null | 9,000,850,534,958 | 136 | 57 |
num=int(input())
command=[input().split() for i in range(num)]
dic={}
for i in command:
if i[0]=="insert":
dic[i[1]]=1
if i[0]=="find":
if i[1] in dic:
print("yes")
else:
print("no")
|
n = int(input())
d = {}
for i in range(n):
order = input().split()
if order[0] == 'insert':
d[order[1]] = i
else:
if order[1] in d:
print("yes")
else:
print("no")
| 1 | 77,719,605,828 | null | 23 | 23 |
n, k = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A = sorted(A)
Minus_A = [-x for x in A]
F = sorted(F, reverse=True)
high = 10**12
low = 0
while high - low > 1:
mid = low + (high-low)//2
count = 0
for i in range(n):
now = mid // F[i]
count += max(A[i] - now, 0)
# print('-'*30)
# print(mid)
# print(count)
if count > k:
low = mid
else:
high = mid
ans = high
if sum(A) <= k:
ans = 0
print(ans)
|
import re
n = int(input())
s = input()
a = []
ans = 0
for i in range(n):
if s[i] == 'A':
a.append(i)
for i in a:
if s[i:i+3] == 'ABC':
ans += 1
print(ans)
| 0 | null | 132,222,232,614,580 | 290 | 245 |
import bisect
n, m, k = map(int, input().split())
alist = list(map(int, input().split()))
blist = list(map(int, input().split()))
for i in range(len(alist)-1):
alist[i+1] += alist[i]
for i in range(len(blist)-1):
blist[i+1] += blist[i]
x = bisect.bisect_right(alist, k)
ans = bisect.bisect_right(blist, k)
for i in range(x):
d = k - alist[i]
y = bisect.bisect_right(blist, d) + i + 1
if ans < y:
ans = y
print(ans)
|
n = int(input())
stone = list(input())
l = 0
r = n-1
ans = 0
while l < r:
if stone[l]=='W':
if stone[r]=='R':
ans += 1
l += 1
r -= 1
else:
r -= 1
else:
l += 1
if stone[r]=='W':
r -= 1
print(ans)
| 0 | null | 8,504,721,654,352 | 117 | 98 |
N=input()
I=list(map(int,input().split()))
E=list(filter(lambda x:x%2==0,I))
if len(E)==0:
print('APPROVED')
else:
O=list(filter(lambda r:r%3!=0 and r%5!=0,E))
if len(O)==0:
print('APPROVED')
else:
print('DENIED')
|
import sys
input()
numbers = map(int, input().split())
evens = [number for number in numbers if number % 2 == 0]
if len(evens) == 0:
print('APPROVED')
sys.exit()
for even in evens:
if even % 3 != 0 and even % 5 != 0:
print('DENIED')
sys.exit()
print('APPROVED')
| 1 | 69,145,480,831,962 | null | 217 | 217 |
n,k,*l=map(int,open(0).read().split())
for _ in range(k):
s=[0]*(n+1)
for i in range(n):
s[max(i-l[i],0)]+=1
s[min(i+l[i]+1,n)]-=1
s[0]=min(s[0],n)
for i in range(1,n):
s[i]=min(s[i-1]+s[i],n)
s.pop()
if s==l: break
l=s
print(*l)
|
n,k,*a=map(int,open(0).read().split())
def f(b):
rt=[0]*-~n
for i in range(n):
d=b[i]
rt[max(0,i-d)]+=1
rt[min(n,i+d+1)]+=-1
for i in range(n-1):
rt[i+1]+=rt[i]
return rt[:-1]
for i in range(k):
a=f(a)
if sum(a)==n**2:
break
print(*a)
| 1 | 15,340,892,735,812 | null | 132 | 132 |
print(len(set(input()))%2*'Yes'or'No')
|
A,B,C = map(int,input().split())
if(A==B and B==C):
print('No')
exit()
if(A==B or A==C or B==C):
print('Yes')
exit()
else:
print('No')
| 1 | 68,185,269,547,512 | null | 216 | 216 |
A,B,C,K=map(int, input().split())
if A >= K:
ans = K
elif A+B >= K:
ans = A
else:
ans = A - (K-A-B)
print(ans)
|
A,B,C,K = map(int,input().split())
SCO = 0
if A>K:
SCO+=K
else:
SCO+=A
if B<=(K-A):
if C<=(K-A-B):
SCO-=C
else:
SCO-=K-A-B
print(SCO)
| 1 | 21,901,384,022,390 | null | 148 | 148 |
n = input()
xi = map(int, raw_input().split())
print ("%d %d %d") %(min(xi), max(xi), sum(xi))
|
n = int(input())
v = list(map(int,input().split()))
print(min(v), max(v), sum(v))
| 1 | 737,294,670,660 | null | 48 | 48 |
x=int(input())
if x%100>(x//100)*5:
print(0)
else:
print(1)
|
# row = [int(x) for x in input().rstrip().split(" ")]
# n = int(input().rstrip())
# s = input().rstrip()
def resolve():
import sys
input = sys.stdin.readline
x = int(input().rstrip())
if x // 100 * 5 >= x % 100:
print(1)
else:
print(0)
if __name__ == "__main__":
resolve()
| 1 | 127,401,500,749,500 | null | 266 | 266 |
a,k,d = map(int, input().split())
if a < 0:
x = -a
else:
x = a
y = x % d
l = x // d
m = k - l
if m < 0:
ans = x - (k * d)
elif m % 2 ==0:
ans = y
else :
ans = y - d
print(abs(ans))
|
#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline
import itertools
def main():
n = int(input())
P=tuple(map(int,input().split()))
Q=tuple(map(int,input().split()))
permutations = list(itertools.permutations(range(1,n+1)))
a = permutations.index(P)
b = permutations.index(Q)
print(abs(a-b))
if __name__=="__main__":
main()
| 0 | null | 52,608,074,597,922 | 92 | 246 |
x, y, z = map(int, input().split())
createNum = 0
createTime = 0
loopCnt = x//y
createNum = y*loopCnt
createTime = z*loopCnt
remain = x%y
if remain != 0:
createTime += z
print(createTime)
|
def main():
N, X, T = map(int, input().split())
if N % X == 0: return N // X * T
else: return (N//X + 1) * T
if __name__ == '__main__':
print(main())
| 1 | 4,261,511,439,112 | null | 86 | 86 |
n = int(input())
S = input()
s = []
for i in range(n):
s.append(S[i])
q = int(input())
BIT = []
for i in range(26):
B = [0]*(n+1) #1-indexed
BIT.append(B)
def sum_of_1_to_i(i, LIST):
z = 0
while i > 0:
z += LIST[i]
i -= i & (-i)
return z
def update(i, j, LIST):
while i <= n:
LIST[i] += j
i += i & (-i)
for i in range(n):
k = ord(s[i])-97
update(i+1, 1, BIT[k])
ans = []
for i in range(q):
a,b,c = input().split()
a = int(a)
b = int(b)
if a == 1:
temp = s[b-1]
if temp == c:
None
else:
update(b, -1, BIT[ord(temp)-97])
update(b, 1, BIT[ord(c)-97])
s[b-1] = c
else:
c = int(c)
cur = 0
for j in range(26):
if sum_of_1_to_i(c, BIT[j])-sum_of_1_to_i(b-1, BIT[j]) != 0:
cur += 1
ans.append(cur)
for i in range(len(ans)):
print(ans[i])
|
class BIT:
def __init__(self,n):
self.s = [0]*(n+1)
self.n = n
def add(self,val,idx):
while idx < self.n+1:
self.s[idx] = self.s[idx] + val
idx += idx&(-idx)
return
def get(self,idx):
res = 0
while idx > 0:
res = res + self.s[idx]
idx -= idx&(-idx)
return res
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
n = int(input())
S = [ord(s) - ord('a') for s in input()[:-1]]
bits = [BIT(n) for i in range(26)]
for i,s in enumerate(S):
bits[s].add(1,i+1)
Q = int(input())
ans = []
for _ in range(Q):
flag,x,y = input().split()
if flag == "1":
i = int(x)
c = ord(y) - ord('a')
bits[S[i-1]].add(-1,i)
bits[c].add(1,i)
S[i-1] = c
else:
l = int(x)
r = int(y)
res = 0
for i in range(26):
res += (bits[i].get(r) > bits[i].get(l-1))
ans.append(str(res))
print("\n".join(ans))
| 1 | 62,541,681,262,490 | null | 210 | 210 |
list =input().split()
list = [int(i) for i in list]
D=list[0]
S=list[1]
T=list[2]
if(D/S<=T):
print("Yes")
else:
print("No")
|
N = int(input())
ans = (N + N%2)/(2*N)
print(ans)
| 0 | null | 90,551,974,191,140 | 81 | 297 |
n = int(input())
s = input()
def rot(c, r):
base = 65
return chr((ord(c)-base+r)%26+base)
print(''.join([rot(i, n) for i in s]))
|
a=int(input())
b=list(map(int,input().split()))
c=0
for i in range(a):
if b[i]%2==0:
if b[i]%3==0 or b[i]%5==0:
c=c+1
else:
c=c+1
if c==a:
print("APPROVED")
else:
print("DENIED")
| 0 | null | 102,047,318,281,170 | 271 | 217 |
import itertools
n=[x for x in range(1,int(input())+1)]
P=list(map(int, input().split()))
Q=list(map(int, input().split()))
for i, a in enumerate(itertools.permutations(n), start=1):
if list(a)==P:
p=i
if list(a)==Q:
q=i
print(abs(p-q))
|
val = input()
print(val*val)
| 0 | null | 123,218,720,155,080 | 246 | 278 |
n,p = map(int,input().split())
s = list(map(int, list(input())))
def solve():
total = 0
if 10%p == 0:
for i in range(n):
if s[i] % p == 0: total += i + 1
return total
cnt = [0]*p
r = 0
ten = 1
for i in range(n-1, 0-1, -1):
cnt[r] += 1
r = (r + s[i]*ten) % p
total += cnt[r]
ten = ten * 10 % p
return total
print(solve())
|
import math
N, D = [int(x) for x in input().split()]
Z = []
for i in range(N):
Z.append([int(x) for x in input().split()])
ans = 0
for i in range(N):
if math.sqrt(Z[i][0]**2 + Z[i][1]**2) <= D:
ans += 1
print(ans)
| 0 | null | 32,188,614,219,428 | 205 | 96 |
radius = int(input())
print(44/7*radius)
|
pi = 3.14159265358
r = input()
r = int(r)
l = 2*r* pi
print(l)
| 1 | 31,383,325,029,938 | null | 167 | 167 |
#!usr/bin/env python3
import sys
def main():
while True:
m, f, r = [int(score) for score in sys.stdin.readline().split()]
if m == f == r == -1:
break
if m == -1 or f == -1:
print('F')
elif m+f >= 80:
print('A')
elif 80 > m+f >= 65:
print('B')
elif 65 > m+f >= 50:
print('C')
elif 50 > m+f >= 30:
if r >= 50:
print('C')
else:
print('D')
elif m+f < 30:
print('F')
if __name__ == '__main__':
main()
|
n=int(input())
mod=1000000007
l=list(map(int,input().split()))
me=[3]+[0]*2*n
ans=1
for x in l:
ans=ans*me[x]%mod
me[x]-=1
me[x+1]+=1
print(ans)
| 0 | null | 65,692,830,625,240 | 57 | 268 |
#!/usr/bin/env python3
import sys
# import math
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product # product(iter, repeat=n)
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4
def main():
mod = 1000000007 # 10^9+7
inf = float('inf')
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
h, w, k = mi()
L = []
for _ in range(h):
L.append(list(map(int, li())))
L_trans = [[None] * h for _ in range(w)]
for i in range(h):
for j in range(w):
L_trans[j][i] = L[i][j]
d = 2 ** (h-1)
cost = [float('inf')] * d
for state in range(d):
bit_count = bin(state)[2:].count('1')
separated = [[0] * (bit_count + 1) for _ in range(w)]
for i in range(w):
current = 0
for j in range(h):
if j >= 1 and 1 << (j-1) & state:
current += 1
if L_trans[i][j]:
separated[i][current] += 1
previous = [0] * (bit_count + 1)
cnt = 0
# print(separated)
for i in range(w):
if any(map(lambda x: x > k, separated[i])):
break
if all(map(lambda x: x <= k, [elm + previous[ind] for ind, elm in enumerate(separated[i])])):
# print(f"just add: {previous} {separated[i]}")
for ind, elm in enumerate(separated[i]):
previous[ind] += elm # 追加
else:
cnt += 1
# print(f"count up: {previous} {separated[i]}")
for ind, elm in enumerate(separated[i]):
previous[ind] = elm # 上書き
else:
cost[state] = bit_count + cnt
# print(cost)
print(min(cost))
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def solve(C: str):
return chr(ord(C)+1)
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
C = next(tokens) # type: str
print(f'{solve(C)}')
if __name__ == '__main__':
main()
| 0 | null | 70,768,977,988,128 | 193 | 239 |
#(40)フィボナッチ数列
n=int(input())
def fib(n):
a=1
b=1
for _ in range(n):
a,b=b,a+b
return a
print(fib(n))
|
print('ABC' if 'R' in input() else 'ARC')
| 0 | null | 12,123,414,695,930 | 7 | 153 |
def main():
N = int(input())
if N <= 1:
print(1)
return
fib = [0]*(N+1)
fib[0], fib[1] = 1, 1
for i in range(2, N+1):
fib[i] = fib[i-1] + fib[i-2]
print(fib[N])
if __name__ == "__main__":
main()
|
n = int(input())
arr = list(map(int, input().split()))
cnt = 1
for x in arr:
if cnt == x:
cnt = cnt + 1
if cnt == 1:
print(-1)
else:
print(n-cnt+1)
| 0 | null | 57,303,739,312,622 | 7 | 257 |
import sys
from itertools import product
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
H, W, K = map(int, input().split())
grid = [list(input()) for _ in range(H)]
R = [[0] * (W + 1) for _ in range(H + 1)]
for h in range(H):
for w in range(W):
R[h + 1][w + 1] = R[h][w + 1] + R[h + 1][w] - R[h][w] + int(grid[h][w])
res = f_inf
for pattern in product([0, 1], repeat=H-1):
cut_H = [idx + 1 for idx, p in enumerate(pattern) if p == 1] + [H]
cnt_cut = sum(pattern)
left = 0
right = 1
flg = 1
while right <= W:
if not flg:
break
up = 0
for bottom in cut_H:
cnt_w = R[bottom][right] - R[bottom][left] - R[up][right] + R[up][left]
if cnt_w > K:
if right - left == 1:
flg = False
cnt_cut += 1
left = right - 1
break
else:
up = bottom
else:
right += 1
else:
res = min(res, cnt_cut)
print(res)
if __name__ == '__main__':
resolve()
|
# -*- coding: utf-8 -*-
def linearSearch(l, key):
m = len(l)
l.append(key)
i = 0
while l[i] != key:
i += 1
l.pop()
if i == m:
return "NOT_FOUND"
return i
if __name__ == '__main__':
n = int(input())
S = [int(s) for s in input().split(" ")]
q = int(input())
T = [int(t) for t in input().split(" ")]
count = 0
for t in T:
if linearSearch(S, t) != "NOT_FOUND":
count += 1
print(count)
| 0 | null | 24,205,279,487,928 | 193 | 22 |
#!/usr/bin/env python3
def main():
N = int(input())
A = [int(x) for x in input().split()]
lst = [0] * (N + 1)
for a in A:
lst[a] += 1
for i in lst[1:]:
print(i)
if __name__ == '__main__':
main()
|
for i in sorted([input() for _ in xrange(10)])[:-4:-1]: print i
| 0 | null | 16,367,724,965,192 | 169 | 2 |
k,n = map(int,input().split())
a = list(map(int,input().split()))
b = []
for i in range(1,n):
b.append(a[i] - a[i-1])
b.append(k - a[n-1] + a[0])
b = sorted(b)
print(sum(b[:-1]))
|
[N, M] = [int(i) for i in input().split()]
print(int(N*max(N-1, 0)/2) + int(M*max(M-1, 0)/2))
| 0 | null | 44,559,181,357,700 | 186 | 189 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.