code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#l = list(map(int, input().split()))
n, a, b = map(int, input().split())
if (a == 0):
print (0)
exit()
ans = n // (a+b) * a
amari = n % (a+b)
if (amari <= a):
ans += amari
else:
ans +=a
print (ans)
| N = int(input())
S = input()
Q = int(input())
qs = [input().split() for i in range(Q)]
def ctoi(c):
return ord(c) - ord('a')
class BinaryIndexedTree:
def __init__(self,size):
self.N = size
self.bit = [0]*(size+1)
def add(self,x,w): # 0-indexed
x += 1
while x <= self.N:
self.bit[x] += w
x += (x & -x)
def _sum(self,x): # 1-indexed
ret = 0
while x > 0:
ret += self.bit[x]
x -= (x & -x)
return ret
def sum(self,l,r): # [l,r)
return self._sum(r) - self._sum(l)
def __str__(self): # for debug
arr = [self.sum(i,i+1) for i in range(self.N)]
return str(arr)
bits = [BinaryIndexedTree(N) for i in range(26)]
s = []
for i,c in enumerate(S):
bits[ctoi(c)].add(i,1)
s.append(c)
ans = []
for a,b,c in qs:
if a=='1':
i = int(b)-1
bits[ctoi(s[i])].add(i,-1)
bits[ctoi(c)].add(i,1)
s[i] = c
else:
l,r = int(b)-1,int(c)
a = 0
for i in range(26):
if bits[i].sum(l,r):
a += 1
ans.append(a)
print(*ans,sep='\n') | 0 | null | 58,975,427,273,672 | 202 | 210 |
def resolve():
N,K,C = map(int,input().split())
S=input()
dpt1=[0]*K
dpt2=[0]*K
pnt = 0
for i in range(K):
while S[pnt]=="x":
pnt+=1
dpt1[i]=pnt
pnt += C+1
pnt = N-1
for i in range(K-1,-1,-1):
while S[pnt] == "x":
pnt -=1
dpt2[i]=pnt
pnt-=C+1
for a,b in zip(dpt1,dpt2):
if a == b:
print(a+1)
if __name__ == "__main__":
resolve() | n,k,c=map(int,input().split())
s=input()
if k==1:
if s.count("o")==1:
print(s.index("o")+1)
exit()
l=[-c]*k
r=[n+c]*k
ll=0
for i in range(n):
if ll==0:
if s[i]=="o":
l[ll]=i
ll+=1
continue
if s[i]=="x" or l[ll-1]+c>=i:continue
l[ll]=i
ll+=1
if ll==k:break
rr=k-1
for i in range(n):
if rr==k-1:
if s[(n-1)-i]=="o":
r[rr]=(n-1)-i
rr-=1
continue
if s[(n-1)-i]=="x" or r[rr+1]-c<=(n-1)-i:continue
r[rr]=(n-1)-i
rr-=1
if rr==-1:break
for i in range(k):
if l[i]==r[i]:print(l[i]+1) | 1 | 40,719,757,061,088 | null | 182 | 182 |
X, Y = [int(v) for v in input().rstrip().split()]
r = 'No'
if Y % 2 == 0:
for n in range(X + 1):
cn = n
tn = X - cn
if cn * 2 + tn * 4 == Y:
r = 'Yes'
break
print(r)
| f = lambda: int(input())
d = -float('inf')
n = f()
l = f()
for _ in range(n-1):
r = f()
d = max(d, r-l)
l = min(l, r)
print(d)
| 0 | null | 6,944,633,382,518 | 127 | 13 |
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
q = int(input())
C = Counter(a)
ans = sum(a)
for i in range(q):
b, c = map(int, input().split())
ans += (c-b)*C[b]
C[c] += C[b]
C[b] = 0
print(ans) | n = int(input())
arr = list(map(int, input().split()))
s = sum(arr)
d = dict()
for i in arr:
if (i not in d):
d[i] = 1
else:
d[i] += 1
q = int(input())
for i in range(q):
b, c = map(int, input().split())
if (b in d):
s -= b * d[b]
s += c * d[b]
if (c not in d):
d[c] = d[b]
else:
d[c] += d[b]
d.pop(b)
print(s) | 1 | 12,191,791,024,940 | null | 122 | 122 |
# Bubble sort: ALDS1_2_A
def bsort(A, N):
flag = 1
swap = 0
while flag:
flag = 0
for j in reversed(range(1, N)):
if A[j] < A[j-1]:
A[j], A[j-1] = A[j-1], A[j]
flag = 1
swap += 1
return swap
N = int(raw_input())
A = [int(i) for i in raw_input().split()]
swap = bsort(A, N)
print " ".join([repr(i) for i in A])
print swap
| a, b, c, d = map(int,input().split())
t = c//b
if not c % b == 0:
t += 1
o = a//d
if not a % d == 0:
o += 1
if t <= o:
print('Yes')
else:
print('No') | 0 | null | 14,987,574,455,362 | 14 | 164 |
n, k, *a = map(int, open(0).read().split())
a.sort()
mod = 10 ** 9 + 7
fact = [1] * (n + 1)
for i in range(1, n + 1):
fact[i] = fact[i - 1] * i % mod
def inv(x):
return pow(x, mod - 2, mod)
def c(n, k):
return fact[n] * inv(fact[n - k] * fact[k] % mod) % mod
ans = 0
for i in range(k - 1, n):
# a[i]がmax
ans += a[i] * c(i, k - 1) % mod
a = list(reversed(a))
for i in range(k - 1, n):
ans -= a[i] * c(i, k - 1) % mod
print((ans + mod) % mod)
| class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
if n < r:
return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
A.sort()
ans = 0
comb = Combination(1000000)
cnt = []
for i in range(N-K+1):
cnt.append(comb(N-i-1,K-1))
ans -= comb(N-i-1,K-1) * A[i]
for i in range(N,N-len(cnt),-1):
ans += A[i-1] * (cnt[N-i])
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | 1 | 95,676,330,688,020 | null | 242 | 242 |
import math
def is_prime(x):
if x == 2:
return True
if (x % 2 == 0):
return False
m = math.ceil(math.sqrt(x))
for i in range(3, m + 1):
if x % i == 0:
return False
return True
n = int(input())
prime = 0
for i in range(n):
x = int(input())
if is_prime(x):
prime += 1
print(prime) | a, b, c = [int(temp) for temp in input().split()]
count = 0
for check in range(a, b + 1) :
if c % check == 0 :
count += 1
print(count) | 0 | null | 290,002,916,142 | 12 | 44 |
def breathSerch(P,N):
n=len(P)-1
m=1
QQ=[N[1]]
while(QQ != []):
R=[]
for Q in QQ:
for i in range(1,n+1):
if Q[i]==1 and P[i]==-1:
P[i]=m
R.append(N[i])
QQ = R
m=m+1
n = int(input())
A = [[0 for j in range(n+1)] for i in range(n+1)]
for i in range(n):
vec = input().split()
u = int(vec[0])
k = int(vec[1])
nodes = vec[2:]
for i in range(int(k)):
v = int(nodes[i])
A[u][v] = 1
P=[-1 for i in range(n+1)]
P[1]=0
breathSerch(P,A)
for i in range(1,n+1):
print(i,P[i]) | from collections import deque
def breadth_first_search(adj_matrix, n):
distance = [0] + [-1] * (n - 1)
searching = deque([0])
while len(searching) > 0:
start = searching.popleft()
for end in range(n):
if adj_matrix[start][end] and distance[end] == -1:
searching.append(end)
distance[end] = distance[start] + 1
return distance
def main():
n = int(input())
adj = [[False for _ in range(n)] for _ in range(n)]
for _ in range(n):
ukv = input().split()
id = int(ukv[0])
dim = int(ukv[1])
if dim > 0:
nodes = map(int, ukv[2:])
for node in nodes:
adj[id - 1][node - 1] = True
distance = breadth_first_search(adj, n)
for i in range(n):
print("{} {}".format(i + 1, distance[i]))
if __name__ == "__main__":
main()
| 1 | 3,627,456,408 | null | 9 | 9 |
n=int(input())
s,t=map(str, input().split())
a=[]
for i in range(n):
a.append(s[i]+t[i])
a = "".join(a)
print(a) | n, m = map(int, input().split())
vector_a = []
vector_b = []
for i in range(n):
vector_a.append(list(map(int,input().split())))
for i in range(m):
vector_b.append(list())
vector_b[i]=int(input())
for i in range(n):
tmp=0
for j in range(m):
tmp+=vector_a[i][j]*vector_b[j]
print(tmp) | 0 | null | 56,637,392,608,290 | 255 | 56 |
r=int(input())
import math
c=2*r*math.pi
print("{0:.6}".format(c)) | print(int(input())*6.28) | 1 | 31,362,779,427,040 | null | 167 | 167 |
X = int(input())
prime_under_X = []
for i in range(2, int(X ** 0.5) + 1):
flg = True
for j in range(len(prime_under_X)):
if i % prime_under_X[j] == 0:
flg = False
break
if flg:
prime_under_X.append(i)
while True:
flg = True
for j in range(len(prime_under_X)):
if X % prime_under_X[j] == 0:
flg = False
break
if flg:
print(X)
break
X = X + 1
| A,B,M = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
oldp = min(a)+min(b)
for _ in range(M):
x, y, cp = map(int,input().split())
p = a[x-1]+b[y-1]-cp
if oldp > p:
oldp = p
print(oldp) | 0 | null | 79,566,162,307,794 | 250 | 200 |
s, w = list(map(int, input().split()))
output = "safe"
if s <= w:
output = "un" + output
print(output) | from collections import defaultdict as dd
from collections import deque
import bisect
import heapq
def ri():
return int(input())
def rl():
return list(map(int, input().split()))
def solve():
s, w = rl()
if s > w:
print ("safe")
else:
print ("unsafe")
mode = 's'
if mode == 'T':
t = ri()
for i in range(t):
solve()
else:
solve()
| 1 | 29,369,060,412,992 | null | 163 | 163 |
K,N = map(int,input().split())
A = list(map(int,input().split()))
B = []
for i in range(N-1):
temp = A[i+1]-A[i]
B.append(temp)
B.append(K-A[-1]+A[0])
B.sort()
#print(B)
ans = K-B[-1]
print(ans)
| k,n = map(int,input().split())
a = list(map(int,input().split()))
dd = k-a[-1]+a[0]
d = 0
for i in range(n-1):
d = max(d,a[i+1]-a[i])
d = max(d,dd)
print(k-d) | 1 | 43,417,069,053,248 | null | 186 | 186 |
c = input()
alphabet = 'abcdefghijklmnopqrstuvwxyz'
list_a = list(alphabet)
num_c = list_a.index(c)
print(list_a[num_c + 1]) | c = input()
alpha_list = 'abcdefghijkfmnopqrstuvrxyz'
for i in range(len(alpha_list)):
if c == alpha_list[i]:
print(alpha_list[i+1])
break | 1 | 92,220,234,435,150 | null | 239 | 239 |
a,b = map(int,input().split())
c="入力が間違っています。"
d="鶴が"
e="匹で、亀が"
f="匹です。"
k=b//2-a
t=2*a-b//2
if k<0 or t<0 or b%2!=0:
print('No')
else:
print('Yes') | X, Y = list(map(int, input().split()))
crane = 0
turtle = X
while turtle >= 0:
allLegs = crane * 2 + turtle * 4
if allLegs == Y:
print("Yes")
exit()
crane += 1
turtle -= 1
print("No")
| 1 | 13,753,770,112,042 | null | 127 | 127 |
s=str(input())
t=str(input())
n=len(s)
count=0
for i in range(n):
if s[i]==t[i]:
count+=1
else:
continue
print(n-count)
| a,b=map(str,input().split())
import math
a=int(a)
B=int(b[0]+b[2]+b[3])
print(int(a*B//100)) | 0 | null | 13,479,969,782,148 | 116 | 135 |
n, k = map(int,input().split())
w_in = list()
for i in range(n):
w_in.append(int(input()))
def alloc(p):
load = 0
track = 1
for w in w_in:
if w > p:
return False
if load + w <= p:
load += w
else:
load = w
track += 1
if track > k:
return False
return True
def binsearch():
upper = sum(w_in)
lower = max(w_in)
while(upper != lower):
mid = int((upper + lower) / 2)
if alloc(mid):
upper = mid
else:
lower = mid + 1
return upper
print(binsearch()) | def check(P):
i=0
for _ in[0]*k:
s=0
while s+w[i]<=P:
s+=w[i];i+=1
if i==n: return n
return i
n,k=map(int,input().split())
w=[int(input())for _ in[0]*n]
l=0;r=n*100000
while r-l>1:
m=(l+r)//2
if check(m)>=n:r=m
else:l=m
print(r)
| 1 | 88,808,315,410 | null | 24 | 24 |
import math
p_max = 1000000 * 1000000
n, k = map(int, input().split())
w = [int(input()) for i in range(n)]
def check(p):
i = 0
for j in range(k):
s = 0
while (s + w[i] <= p):
s += w[i]
i += 1
if i == n:
return n
return i
if __name__ == "__main__":
right = p_max
left = 0
mid = 0
while (right - left > 1):
mid = math.floor((right + left) / 2)
v = check(mid)
if v >= n:
right = mid
else:
left = mid
print (right)
| # Rem of sum is Num
# Reviewing problem
from collections import defaultdict
def cnt_func(X):
res = 0
right = 0
L = len(X)
for i in range(L):
while right+1 < L and X[right+1] < K+X[i]:
right += 1
res += right-i
return res
N, K = map(int, input().split())
A = list(map(int, input().split()))
A.insert(0, 0)
for i in range(1, N+1):
A[i] += A[i-1]
B = [0 for i in range(N+1)]
for i in range(N+1):
B[i] = (A[i]-i) % K
ans = 0
Mod = defaultdict(list)
for i in range(N+1):
Mod[B[i]].append(i)
for X in Mod.values():
ans += cnt_func(X)
print(ans) | 0 | null | 68,750,646,671,040 | 24 | 273 |
from collections import deque
def main():
d = deque()
for _ in range(int(input())):
command = input()
if command[0] == 'i':
d.appendleft(command[7:])
elif command[6] == ' ':
try:
d.remove(command[7:])
except ValueError:
pass
elif len(command) == 11:
d.popleft()
else:
d.pop()
print(*d)
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10**8)
N = int(input())
X = input()
if X == '0':
for _ in range(N):
print(1)
exit()
mem = [None] * (200005)
mem[0] = 0
def f(n):
if mem[n] is not None: return mem[n]
c = bin(n).count('1')
r = 1 + f(n%c)
mem[n] = r
return r
for i in range(200005):
f(i)
cnt = X.count('1')
a,b = cnt+1, cnt-1
ans = [None] * N
x = int(X,2)
n = x % a
for i,c in reversed(list(enumerate(X))):
if c=='1': continue
ans[i] = mem[(n+pow(2,N-i-1,a))%a] + 1
if b:
n = x % b
for i,c in reversed(list(enumerate(X))):
if c=='0': continue
ans[i] = mem[(n-pow(2,N-i-1,b))%b] + 1
else:
for i in range(N):
if ans[i] is None:
ans[i] = 0
print(*ans, sep='\n') | 0 | null | 4,145,422,263,304 | 20 | 107 |
x,y = map(int,input().split())
n = int((y-2*x)/2)
m = int((4*x-y)/2)
if x == m+n and m >= 0 and n >= 0:
print('Yes')
else:
print('No')
| N = int(input())
X = input()
memo = {}
X_int = int(X, 2)
def popcount(n: int):
x = bin(n)[2:]
return x.count("1")
pcf = popcount(int(X, 2))
pcm = pcf - 1
pcp = pcf + 1
xm = X_int % pcm if pcm != 0 else 0
xp = X_int % pcp
def f(n: int, ops: int):
while n != 0:
n %= popcount(n)
ops += 1
return ops
def rev(x: str, i: int):
if x == "1":
if pcm == 0:
return -1
n = (xm - (pow(2, N-i-1, pcm))) % pcm
else:
n = (xp + (pow(2, N-i-1, pcp))) % pcp
return n
if __name__ == "__main__":
for i, x in enumerate(X):
n = rev(x, i)
if n == -1:
print(0)
else:
print(f(n, 1))
| 0 | null | 11,081,092,603,968 | 127 | 107 |
n = int(input())
T_p, H_p = 0, 0
for i in range(n):
T, H = input().split()
if T > H:
T_p += 3
elif T < H:
H_p += 3
else:
T_p += 1; H_p += 1
print(T_p, H_p)
| n, k = map( int, input().split() )
p = list( map( int, input().split() ) )
sum_k = sum( p[ : k ] )
max_sum_k = sum_k
for i in range( k, n ):
sum_k += p[ i ] - p[ i - k ]
if sum_k > max_sum_k:
max_sum_k = sum_k
print( ( max_sum_k + k ) / 2 ) | 0 | null | 38,533,454,617,678 | 67 | 223 |
n = int(input())
S = list(map(int, input(). split()))
q = int(input())
T = list(map(int, input(). split()))
Sum = 0
for i in T:
if i in S:
Sum += 1
print(Sum) | import sys
input = sys.stdin.readline
from collections import *
def bfs(s):
q = deque([s])
dist = [-1]*N
dist[s] = 0
leaf = set()
while q:
v = q.popleft()
flag = True
for nv in G[v]:
if dist[nv]==-1:
dist[nv] = dist[v]+1
q.append(nv)
flag = False
if flag:
leaf.add(v)
return dist, leaf
N, u, v = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(N-1):
A, B = map(int, input().split())
G[A-1].append(B-1)
G[B-1].append(A-1)
d1, _ = bfs(u-1)
d2, leaf = bfs(v-1)
ans = 0
for i in range(N):
if i not in leaf and d1[i]<=d2[i]:
ans = max(ans, d2[i])
print(ans) | 0 | null | 58,530,810,557,570 | 22 | 259 |
t = input() * 2
if input() in t:
print('Yes')
else:
print('No')
| s,p=input()*2,input()
print(['No','Yes'][p in s]) | 1 | 1,743,098,318,080 | null | 64 | 64 |
import sys
X,K,D= map(int,input().split())
temp = X
if abs(X) > K*D:
print(abs(X)-K*D)
sys.exit()
for t in range(K):
# 絶対値の小さい方に移動
if abs(temp - D) < abs(temp + D):
temp = temp-D
else:
temp = temp+D
# 移動幅より小さくなったとき
if abs(temp) < D:
if (K-t-1) % 2 == 0:
print(abs(temp))
sys.exit()
else:
if abs(temp - D) < abs(temp + D):
temp = temp-D
print(abs(temp))
sys.exit()
else:
temp = temp+D
print(abs(temp))
sys.exit()
print(abs(temp))
| import sys
# x = abs(int(input()))
# k = int(input())
# d = int(input())
array = list(map(int, input().strip().split()))
x = abs(array[0])
k = array[1]
d = array[2]
if (d == 0):
amari = abs(x)
else:
move_cnt = int(x / d)
if (move_cnt <= k):
k -= move_cnt
amari = x - move_cnt * d
else:
amari = x - k * d
k = 0
if (k > 0):
if (k % 2 == 1):
if (amari > 0):
amari -= d
else:
amari += d
print(abs(amari)) | 1 | 5,264,173,406,308 | null | 92 | 92 |
import math
N=int(input())
lim=int(math.sqrt(N))
ans=10**13
for i in range(1,lim+1):
if N%i==0:
if ans>(i+(N//i)-2):
ans=(i+(N//i)-2)
print(ans) | s, t = map(str, input().split())
a, b = map(int, input().split())
u = input()
st = {}
st[s] = a
st[t] = b
st[u] -= 1
print('{} {}'.format(st[s], st[t])) | 0 | null | 116,509,184,692,428 | 288 | 220 |
N, K = map(int, input().split())
if N%K == 0:
print(0)
if N%K != 0 and N > K :
a = N%K
b = K%a
if a >= b :
print(b)
if a < b:
print(a)
if N%K != 0 and N < K :
c = K-N
if c > N:
print(N)
if c < N:
print(c) | # import math
# import statistics
# import itertools
# a=int(input())
# b=input()
# c=[]
# for i in a:
# c.append(int(i))
N,K= map(int,input().split())
# f = list(map(int,input().split()))
# g = [int(input()) for _ in range(N)]
# h = []
# for i in range(a):
# h.append(list(map(int,input().split())))
# a = [[0] for _ in range(H)]#nizigen
if N%K==0:
print(0)
else:
et=N//K
a1=et*K
a2=(et+1)*K
mi = min(abs(a1-N),abs(a2-N))
print(mi) | 1 | 39,335,555,836,292 | null | 180 | 180 |
from math import ceil
def point(x,y,r,s,p):
if y == 'r':
y = p
if y == 's':
y = r
if y == 'p':
y = s
return ceil(x/2) * y
n,k = map(int,input().split())
r,s,p = map(int,input().split())
t = list(input())
ans = 0
for _ in range(k):
l = t[_::k]
x = 1
y = l[0]
for i in l[1:]:
if i != y:
ans += point(x,y,r,s,p)
x = 1
y = i
else:
x += 1
ans += point(x,y,r,s,p)
print(ans) | import sys
from collections import deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: map(int, read().split())
def bfs(N, v0, edge):
search = [-1] * N
search[v0] = 0
q = deque()
q.append(v0)
while q:
v = q.popleft()
for nv in edge[v]:
if search[nv] == -1:
q.append(nv)
search[nv] = search[v] + 1
return search
def bfs2(N, v0, edge, dis):
q = deque()
q.append(v0)
max_dis = dis[v0]
while q:
v = q.popleft()
for nv in edge[v]:
if dis[v] < dis[nv]:
q.append(nv)
max_dis = max(max_dis, dis[nv])
return max_dis
def main():
N, taka, aoki = in_nn()
taka, aoki = taka - 1, aoki - 1
edge = [[] for _ in range(N)]
for i in range(N - 1):
x, y = in_nn()
x, y = x - 1, y - 1
edge[x].append(y)
edge[y].append(x)
dis = bfs(N, aoki, edge)
if dis[taka] > 2:
x = (dis[taka] + 1) // 2 - 1
for _ in range(x):
for v in edge[taka]:
if dis[v] < dis[taka]:
taka = v
break
ans = bfs2(N, taka, edge, dis) - 1
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 112,233,405,795,368 | 251 | 259 |
L, R, d = map(int, input().split())
a = 0
for i in range(L,R+1):
if i%d==0:
a += 1
else:
a += 0
print(a) | L, R, d = list(map(int, input().split()))
cnt = 0
for i in range(L, R+1):
if i % d == 0:
cnt += 1
print(cnt)
| 1 | 7,544,929,435,932 | null | 104 | 104 |
X,Y=map(int,input().split());m=4-min(X,Y)
if X==Y==1:print(10**6)
elif X<=3and Y<=3:print(((4-X)+(4-Y))*10**5)
else:print(m*10**5if m>=0else 0) | MOD = 10 ** 9 + 7
INF = 10 ** 11
import sys
sys.setrecursionlimit(100000000)
N = int(input())
ans = []
def dfs(i,standard):
if i == N:
ans.append(standard)
return
before_M = max(ord(s) for s in standard)
for j in range(97,before_M + 2):
dfs(i + 1,standard + chr(j))
dfs(1,'a')
print('\n'.join(ans))
| 0 | null | 96,553,036,971,810 | 275 | 198 |
x,y=map(int ,input().split())
if x*2<=y<=x*4 and y%2==0:
print("Yes")
else:
print("No") | import sys
import decimal # 10進法に変換，正確な計算
def input():
return sys.stdin.readline().strip()
def main():
s, t = input().split()
print(t, end="")
print(s)
main()
| 0 | null | 58,488,772,506,912 | 127 | 248 |
n = int(input())
mod = 10**9+7
ls = list(map(int,input().split()))
di = [i**2 for i in ls]
print((((sum(ls)**2)-(sum(di)))//2)%mod) | import sys
def main():
s,w = list(map(int,(input().split())))
if s<=w:
print('unsafe')
sys.exit()
else:
print('safe')
sys.exit()
if __name__ == '__main__':
main()
| 0 | null | 16,427,823,229,090 | 83 | 163 |
# N = 10
# X = '1'*N
N = int(input())
X = input()
popcount_X = X.count('1')
X_ = int(X, 2)
X_mod_minus = X_%(popcount_X-1) if popcount_X > 1 else -1
X_mod_plus = X_%(popcount_X+1)
for i in range(N):
if X[i] == '0':
popcount = popcount_X+1
X_i = (X_mod_plus + pow(2, N-i-1, popcount))%(popcount)
else:
if X_mod_minus == -1:
print(0)
continue
popcount = popcount_X-1
X_i = (X_mod_minus - pow(2, N-i-1, popcount))%(popcount)
ans = 1
while X_i > 0:
X_i %= bin(X_i).count('1')
ans += 1
print(ans) | N=int(input())
X=input()
c=X.count('1')
r1=int(X,2)%(c-1) if c>1 else 0
r2=int(X,2)%(c+1)
d=[0]*(N+1)
for i in range(N):
d[i+1]=d[(i+1)%bin(i+1).count('1')]+1
for i in range(N):
if X[i]=='0':
n=(r2+pow(2,N-i-1,c+1))%(c+1)
else:
if c==1:
print(0)
continue
n=(r1-pow(2,N-i-1,c-1))%(c-1)
print(d[n]+1) | 1 | 8,231,267,051,392 | null | 107 | 107 |
import math
H = int(input())
ans = 0
num = 0
while True:
ans += 2**num
if H == 1:
print(ans)
break
else:
H = math.floor(H/2)
num += 1 | import math
H = int(input())
l = math.log(H,2)
ll = math.floor(l)+1
ans = 2 ** ll -1
print(ans) | 1 | 80,024,490,743,262 | null | 228 | 228 |
N = int(input()) - 1
rst = ''
for i in range(1, 10 ** 15):
if N >= 26 ** i:
N -= 26 ** i
continue
for j in range(i):
rst += chr(ord('a') + N % 26)
N //= 26
print(rst[::-1])
break | def numtoalpha(n):
if n <= 26:
return chr(96+n)
elif n % 26 == 0:
return numtoalpha(n//26-1) + chr(96+26)
else :
return numtoalpha(n//26) + chr(96+(n%26))
if __name__ == '__main__':
n = int(input())
print(numtoalpha(n))
| 1 | 11,861,495,700,050 | null | 121 | 121 |
s = input()
if s == "ABC" :
print("ARC")
elif s == "ARC" :
print("ABC") | last=input()
if last=="ABC":
print("ARC")
elif last=="ARC":
print("ABC") | 1 | 23,948,825,837,760 | null | 153 | 153 |
x = input()
alpha2num = lambda c: ord(c) - ord('a') + 1
num2alpha = lambda c: chr(c+96+1)
a = alpha2num(x)
b = num2alpha(a)
print(b) | C = str(input())
print(chr(ord(C)+1)) | 1 | 92,304,860,989,760 | null | 239 | 239 |
s = str(input())
t = str(input())
t_before = ''
for i in range(len(s)):
t_before += t[i]
if s == t_before:
print('Yes')
else:
print('No') | n, m = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
for ai in a:
n -= ai
n = -1 if n < 0 else n
print(n) | 0 | null | 26,449,014,165,010 | 147 | 168 |
n = int(raw_input())
a = map(int, raw_input().split())
def print_list(list):
for i in range(len(list)-1):
print(list[i]),
print(list[len(list)-1])
#print("")
print_list(a)
for i in range(1,n):
v = a[i]
j = i - 1
while j >= 0 and a[j] > v:
a[j+1] = a[j]
j -= 1
a[j+1] = v
print_list(a) | import sys
sys.setrecursionlimit(10**8)
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 li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
S = input()
N = len(S)
cnt = 0
for i in range(N//2):
if S[i] != S[-1-i]:
cnt += 1
print(cnt) | 0 | null | 60,220,830,009,690 | 10 | 261 |
MOD = 10**9+7
def mod(x):
return x % MOD
def solve(n):
"""
0: {}
1: {0}
2: {9}
3: {0,9}
"""
x = [1,0,0,0]
for i in range(n):
x = list(map(mod, (
8*x[0],
(9*x[1] + x[0]),
(9*x[2] + x[0]),
(10*x[3] + x[2] + x[1])
)))
return x[3]
n = int(input())
print(solve(n)) |
N, K = map(int, input().split())
mod = 998244353
move = []
for _ in range(K):
L, R = map(int, input().split())
move.append((L, R))
dp = [0]*(2*N+1)
dp[0] = 1
for i in range(N):
for l, r in move:
dp[i+l] += dp[i]
dp[i+l] %= mod
dp[i+r+1] -= dp[i]
dp[i+r+1] %= mod
if i:
dp[i+1] += dp[i]
dp[i] %= mod
print(dp[N-1]) | 0 | null | 2,941,118,556,650 | 78 | 74 |
n, k = map(int, input().split())
r, s, p = map(int, input().split())
t = input()
ans = 0
prevs = [''] * k
for i in range(n//k+1):
#print(i)
#print(prevs)
for j in range(i*k, (i+1)*k):
if j >= n:
break
prevs_i = j%k
prev = prevs[prevs_i]
#print(prev)
if t[j] == 'r':
if prev == 'p':
prevs[prevs_i] = ''
else:
prevs[prevs_i] = 'p'
ans += p
elif t[j] == 's':
if prev == 'r':
prevs[prevs_i] = ''
else:
prevs[prevs_i] = 'r'
ans += r
elif t[j] == 'p':
if prev == 's':
prevs[prevs_i] = ''
else:
prevs[prevs_i] = 's'
ans += s
print(ans) | N, K = [int(i) for i in input().split()]
R, S, P = [int(i) for i in input().split()]
d = {'r': P, 's': R, 'p': S}
T = input()
checked = [False for i in range(N)]
# 勝てるだけ勝てばいい
for i in range(N-K):
if T[i] == T[i+K]:
if checked[i] == False:
checked[i+K] = True
result = 0
for i in range(N):
if checked[i] == False:
result += d[T[i]]
print(result) | 1 | 107,169,571,227,448 | null | 251 | 251 |
#! /usr/bin/env python3
import sys
import numpy as np
from itertools import groupby
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
S = readline().decode().rstrip()
cnt = [0] * (len(S) + 1)
for i in range(len(S)):
if S[i] == '<':
cnt[i + 1] = max(cnt[i + 1], cnt[i] + 1)
for i in range(len(S) - 1, -1, -1):
if S[i] == '>':
cnt[i] = max(cnt[i], cnt[i + 1] + 1)
print(sum(cnt)) | # region header
import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**6)
INF = float('inf')
MOD = 10 ** 9 + 7
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rf(): return float(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]
def rf_(): return [float(_) for _ in rs().split()]
def divisors(n, sortedresult=True):
div = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
div.append(i)
if i != n // i:
div.append(n//i)
if sortedresult:
div.sort()
return div
# endregion
S = list(rs())
ans = 0
tmp = 0
cnt = 0
f = 1
for i in range(len(S)):
if S[i] == '<':
if f:
cnt += 1
else:
ans += cnt * (cnt - 1) // 2
ans += max(tmp, cnt)
cnt = 1
f = 1
else:
if f:
ans += cnt * (cnt - 1) // 2
tmp = cnt
cnt = 1
f = 0
else:
cnt += 1
ans += cnt * (cnt - 1) // 2
if f:
ans += cnt
else:
ans += max(tmp, cnt)
print(ans) | 1 | 156,920,985,133,418 | null | 285 | 285 |
a, b, c, d = map(int, input().split())
T = 0
A = 0
while a > 0:
a -= d
A += 1
while c > 0:
c -= b
T += 1
if A >= T:
print("Yes")
else:
print("No") | list = [int(x) for x in input().split()]
list.sort()
print(list[0], list[1], list[2]) | 0 | null | 15,017,317,707,812 | 164 | 40 |
def main():
N = int(input())
X = input()
XINT = int(X,2)
ANS = [0]*N
TEMP = [0]*N
CHAIND = [0]*N
cnt = count_ones_by_bitmask(XINT)
if cnt == 0:
for i in range(N):
print(1)
return
if cnt ==1:
for i in range(N):
if X[i] == '1':
print(0) #全てが0になる
else:
if i==N-1:
print((int(X[N-1])+1)%2+1) # 2の剰余の反転
else:
print((int(X[N-1]))%2+1) # 2の剰余
return
p = XINT % (cnt+1)
m = XINT % (cnt-1)
pmod = 1
mmod = 1
for i in range(N):
ANS[i] = 1
if (X[N-i-1] == '0'):
TEMP[i] = (p + pmod) % (cnt+1)
else:
TEMP[i] = (m - mmod) % (cnt-1)
pmod = (pmod*2) % (cnt+1)
mmod = (mmod*2) % (cnt-1)
CHA = list(set(TEMP))
for i in range(len(CHA)):
an = 0
cha = CHA[i]
cnt = count_ones_by_bitmask(CHA[i])
while cnt>0:
an += 1
cha = cha%cnt
cnt = count_ones_by_bitmask(cha)
CHAIND[CHA[i]] = an
for i in reversed(range(N)):
print(ANS[i]+CHAIND[TEMP[i]])
def count_ones_by_bitmask(num):
count = 0
while num:
count += num & 1
num >>= 1
return count
if __name__ == '__main__':
main()
| n=int(input())
if n%2!=0:
print(0)
else:
ans=0
t=10
while True:
ans=ans+n//t
t=t*5
if n//t==0:
break
print(ans) | 0 | null | 61,934,215,709,782 | 107 | 258 |
def solve(n, k, a):
for i in range(k, n):
print("Yes" if a[i-k] < a[i] else "No")
n, k = map(int, input().split())
a = list(map(int, input().split()))
solve(n, k, a) | X, Y, A, B, C = map(int, input().split())
L = []
P = list(map(int, input().split()))
P.sort(reverse=True)
L += P[:X]
Q = list(map(int, input().split()))
Q.sort(reverse=True)
L += Q[:Y]
L += list(map(int, input().split()))
L.sort(reverse=True)
print(sum(L[:X + Y]))
| 0 | null | 25,916,821,707,908 | 102 | 188 |
from collections import Counter
N = int(input())
S = input()
c = Counter(S)
ans = c['R'] * c['G'] * c['B']
for s in range(N-2):
for d in range(1, (N-1-s)//2+1):
t = s + d
u = t + d
if S[s] != S[t] and S[t] != S[u] and S[u] != S[s]:
ans -= 1
print(ans)
| # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# . ' Udit Gupta @luctivud ,
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
## ## ####### # # ######
## ## ## ## ### ##
## ## ## # # # ##
######### ####### # # ##
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
import sys
import math
# sys.setrecursionlimit(10**6)
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def printwsp(*args): return print(*args, end="")
def printsp(*args): return print(*args, end=" ")
def printchk(*args): return print(*args, end="tst, ")
MODPRIME = int(1e9+7); BABYMOD = 998244353;
# ################################ HELPER PROGRAMS USED ###################################
# ################################## MAIN STARTS HERE #####################################
# for _testcases_ in range(int(input())):
x, y, a, b, c = get_ints()
la = get_array()
lb = get_array()
lc = get_array()
la.sort(reverse = True)
lb.sort(reverse = True)
for i in range(x):
lc.append(la[i])
for i in range(y):
lc.append(lb[i])
lc.sort(reverse = True)
sum = 0
for i in range(x+y):
sum += lc[i]
print(sum)
# #########################################################################################
'''
THE LOGIC AND APPROACH IS BY ME @luctivud.
SOME PARTS OF THE CODE HAS BEEN TAKEN FROM WEBSITES LIKE::
(I Own the code if no link is provided here or I may have missed mentioning it)
: DO NOT PLAGIARISE.
''' | 0 | null | 40,505,727,268,960 | 175 | 188 |
nums = input().split()
if len(set(nums)) == 2:
print('Yes')
else:
print('No') | A,B,C = map(int,input().split())
if (A==B) and A !=C:
print("Yes")
elif (B==C ) and B !=A:
print("Yes")
elif (C==A ) and C !=B:
print("Yes")
else:
print("No") | 1 | 67,845,384,855,780 | null | 216 | 216 |
import sys
x, k, d = map(int,input().split())
x = abs(x)
ans = 0
if k <= x // d:
ans = x - k*d
print(ans)
sys.exit()
if (k - (x // d)) % 2 == 0:
print(x % d)
else:
print(abs(x % d - d)) | X,K,D = map(int,input().split())
X = abs(X)
if X >= K*D:
ans = X - K*D
else:
k = X // D
if (K - k) % 2 == 0:
ans = X - k*D
else:
ans = abs(X-(k+1)*D)
print(ans)
| 1 | 5,256,808,293,968 | null | 92 | 92 |
X = int(input())
while True:
flag = True
for i in range(2,X):
if X%i == 0:
flag = False
break
if flag:
break
X += 1
print(X) | x=int(input())
while 1:
for i in range(2,x):
if x%i==0:
x+=1
break
else:
break
print(x) | 1 | 105,523,919,792,906 | null | 250 | 250 |
a,b = input().split()
c = [a*int(b), b*int(a)]
print(sorted(c)[0]) | def main():
n = input()
A = []
for i in xrange(n):
A.append(map(int,raw_input().split()))
c,d = bfs(n,A)
for i in xrange(n):
if c[i] == -1:
print i+1, -1
else:
print i+1, d[i]
def bfs(n,A):
color = [-1]*n
d = [-1]*n
Q = []
d[0] = 0
Q.append(0)
while(True):
if len(Q)==0:
break
u = Q.pop(0)
for i in A[u][2:]:
if color[i-1] == -1:
color[i-1] = 0
d[i-1] = d[u]+1
Q.append(i-1)
color[u] = 1
return color, d
if __name__ == '__main__':
main() | 0 | null | 41,928,542,975,000 | 232 | 9 |
X, Y = map(int, input().split())
MD = pow(10, 9) + 7
def choose(n, a):
x, y = 1, 1
for i in range(a):
x = x * (n - i) % MD
y = y * (i + 1) % MD
return x * pow(y, MD - 2, MD) % MD
a = (2*Y-X)//3
b = (Y-2*X)//-3
if a < 0 or b < 0 or (X+Y) % 3 != 0:
print(0)
exit()
print(choose(a+b, min(a,b))) | N = int(input())
S, T = input().split()
ans = ""
for p in range(N):
ans += S[p]
ans += T[p]
print(ans) | 0 | null | 130,831,787,499,090 | 281 | 255 |
H, W, M = map(int, input().split())
bomb = []
h_sum = [0]*W
w_sum = [0]*H
for _ in range(M):
h, w = map(int, input().split())
bomb.append((h,w))
h_sum[w-1] += 1
w_sum[h-1] += 1
max_h = max(h_sum)
max_w = max(w_sum)
target_cnt = h_sum.count(max_h)*w_sum.count(max_w)
for h, w in bomb:
if h_sum[w-1] == max_h and w_sum[h-1] == max_w:
target_cnt -= 1
if target_cnt == 0:
print(max_h+max_w-1)
else:
print(max_h+max_w) | import sys
H, W, M = map(int, input().split())
bomb = [tuple(map(lambda x: int(x) - 1, s.split())) for s in sys.stdin.readlines()]
X = [0] * H # X:各行の爆破対象の個数
Y = [0] * W # Y:各列の爆破対象の個数
for h, w in bomb:
X[h] += 1
Y[w] += 1
maxX = max(X)
maxY = max(Y)
R = [h for h, x in enumerate(X) if x == maxX] # R:爆破対象の数が最大となる行の番号
C = [w for w, y in enumerate(Y) if y == maxY] # C:爆破対象の数が最大となる列の番号
bomb = set(bomb)
for r in R:
for c in C:
if (r, c) not in bomb:
# (r, c)に爆破対象が存在しないとき, maxX + maxY が答えとなることが確定するため,
# 即座に探索を終了する. これによりループの回数は最大でもM+1回となる.
print(maxX + maxY)
exit()
print(maxX + maxY - 1) | 1 | 4,724,475,930,700 | null | 89 | 89 |
import sys
for m,n in [map(int,x.split()) for x in list(sys.stdin)]:
g,r = m,n
while r!=0:
g,r = r,g%r
print(g,m//g*n) | from sys import stdin
mod = 10**9+7
N,K = [int(x) for x in stdin.readline().rstrip().split()]
A = [int(x) for x in stdin.readline().rstrip().split()]
maxn = 2*10**6
fac = [0 for _ in range(maxn)]
finv = [0 for _ in range(maxn)]
inv = [0 for _ in range(maxn)]
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,maxn):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
def combinations(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
ans = 0
A.sort()
for ind,a in enumerate(A):
ans -= a*combinations(N-ind-1,K-1) % mod
ans %= mod
A.reverse()
for ind,a in enumerate(A):
ans += a*combinations(N-ind-1,K-1) % mod
ans %= mod
print(ans%mod) | 0 | null | 47,852,325,282,080 | 5 | 242 |
from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
dAl = defaultdict(int)
dAr = defaultdict(int)
for i in range(N):
L = (i + 1) + A[i]
R = (i + 1) - A[i]
dAl[L] += 1
dAr[R] += 1
# dictの中を見る
ans = 0
for k, v in dAl.items():
ans += v * dAr[k]
print(ans) | N = int(input())
A = list(map(int, input().split()))
L = {}
R = {}
ans = 0
for i in range(N):
t = i + 1 + A[i]
if t in L:
L[t] += 1
else:
L[t] = 1
t = i + 1 - A[i]
if t > 0:
if t in R:
R[t] += 1
else:
R[t] = 1
for i in R:
if i in L:
ans += R[i] * L[i]
print(ans) | 1 | 26,088,764,922,440 | null | 157 | 157 |
from collections import defaultdict
def main():
n = int(input())
s =defaultdict(lambda:0)
for i in range(n):
s[input()] += 1
max_s = max(s.values())
for key, value in sorted(s.items()):
if value == max_s:
print(key)
if __name__ == "__main__":
main() | print(0 if input() == '1' else 1) | 0 | null | 36,382,583,260,800 | 218 | 76 |
S = input()
count = 0
for a, b in zip(S, reversed(S)):
if a != b:
count += 1
print(count // 2)
| S = input()
result = 0
# 入力例1なら3文字目まで
for i in range(len(S) // 2):
# sの1(2番目)がsの最後尾と一緒ならカウント
if S[i] != S[-(i + 1)]:
result += 1
print(result) | 1 | 120,334,807,489,370 | null | 261 | 261 |
from collections import deque
def main():
H,W=map(int,input().split())
S=[]
for i in range(H):
s=input()
S.append(s)
G=[]
for i in range(H):
for j in range(W):
tmp=[]
if S[i][j]=="#":
G.append(tmp)
continue
if i-1>=0:
if S[i-1][j]==".":
tmp.append((i-1)*W+j)
if i+1<=H-1:
if S[i+1][j]==".":
tmp.append((i+1)*W+j)
if j-1>=0:
if S[i][j-1]==".":
tmp.append(i*W+j-1)
if j+1<=W-1:
if S[i][j+1]==".":
tmp.append(i*W+j+1)
G.append(tmp)
res=0
for start in range(H*W):
dist = 0
v = [-1 for _ in range(H * W)]
que=deque([])
que.append(start)
v[start]=dist
while len(que)>0:
next_index=que.popleft()
next=G[next_index]
for i in next:
if v[i]==-1:
que.append(i)
v[i]=v[next_index]+1
if max(v)>=res:
res=max(v)
print(res)
if __name__=="__main__":
main()
| # !/use/bin/python3
"""
https://atcoder.jp/contests/abc151/tasks/abc151_a
Next Alphabate
"""
def solve(c):
ans = ord(c)
return chr(ans+1)
if __name__ == "__main__":
c = input()
print(solve(c))
| 0 | null | 93,219,921,496,900 | 241 | 239 |
def main():
element_num = int(input())
elements = [int(s) for s in input().split()]
swap_count = 0
for i in range(1, element_num):
for j in reversed(range(i, element_num)):
if elements[j-1] > elements[j]:
elements[j-1], elements[j] = elements[j], elements[j-1]
swap_count += 1
print(' '.join(list(map(str, elements))))
print(swap_count)
return 0
if __name__ == '__main__':
main() | n = int(input())
A = [int(i) for i in input().split(' ')]
# A = '0 33 43 62 29 0 8 52 56 56 19 11 51 43 5 8 93 30 66 69'.split(' ')
# A = [int(i) for i in A]
def trace(A):
for index, v in enumerate(A):
print(v, end='')
if index != len(A) - 1:
print(' ', end='')
print()
def bubble_sort(A, n):
i = 0
counter = 0
while i <= n - 1:
j = n - 1
while j >= i + 1:
if A[j] < A[j-1]:
A[j], A[j-1] = A[j-1], A[j]
counter += 1
j -= 1
i += 1
trace(A)
print(counter)
bubble_sort(A, n) | 1 | 18,065,079,410 | null | 14 | 14 |
def main():
K = int(input())
v = 7 % K
for i in range(K+5):
if v == 0:
print(i+1)
return
v = v * 10 + 7
v %= K
print(-1)
if __name__ == '__main__':
main()
| def main():
H, W, M = [int(s) for s in input().split()]
cols = [0] * W
rows = [0] * H
bombs = set()
for _ in range(M):
x, y = [int(s)-1 for s in input().split()]
bombs.add((x, y))
cols[y] += 1
rows[x] += 1
sc = sorted([(c, i) for i, c in enumerate(cols)], reverse=True)
sr = sorted([(c, i) for i, c in enumerate(rows)], reverse=True)
best = 0
for v1, c in sc:
for v2, r in sr:
if v1 + v2 <= best:
break
score = v1 + v2
if (r, c) in bombs:
score -= 1
best = max(best, score)
print(best)
main() | 0 | null | 5,445,325,497,360 | 97 | 89 |
N=int(input())
A=list(map(int,input().split()))
for i in range(N):
A[i] = [i+1, A[i]]
A.sort(key=lambda x:x[1])
ans=[]
for i in range(N):
ans.append(A[i][0])
ans = map(str, ans)
print(' '.join(ans))
| N = int(input())
A = list(map(int,input().split()))
Adict = {}
for i in range(N):
Adict[A[i]] = (i+1)
ans = []
for i in range(1,N+1):
ans.append(str(Adict[i]))
print(" ".join(ans)) | 1 | 181,116,568,341,802 | null | 299 | 299 |
# 解説を見た。
# https://at274.hatenablog.com/entry/2020/01/24/060000
def main():
num = int(input())
counter = [[0] * 10 for _ in range(10)]
for x in range(1, num + 1):
x = str(x)
head = int(x[0])
tail = int(x[-1])
counter[head][tail] += 1
gen = (counter[head][tail] * counter[tail][head]
for head in range(1, 10)
for tail in range(1, 10))
print(sum(gen))
if __name__ == '__main__':
main()
| for x in range(9):
x = x + 1
for y in range(9):
y = y + 1
print(x.__str__() + 'x' + y.__str__() + '=' + (x * y).__str__() ) | 0 | null | 43,250,946,565,080 | 234 | 1 |
# coding: utf-8
def main():
X = int(input())
C = X // 100
print([0, 1][X >= C * 100 and X <= C * 105])
if __name__ == "__main__":
main()
| x=int(input())
if x>=2100:
print(1)
exit()
ans=[0]*2100
for a in range(22):
for b in range(22):
for c in range(22):
for d in range(22):
for e in range(22):
for f in range(21):
y=a*100+b*101+c*102+d*103+e*104+f*105
if y<=2099:
ans[y]=1
print(ans[x]) | 1 | 127,425,327,590,920 | null | 266 | 266 |
N = int(input())
S = [input() for _ in range(N)]
C0 = 0
C1 = 0
C2 = 0
C3 = 0
for i in range(N):
if S[i] == "AC": C0 += 1
elif S[i] == "WA": C1 += 1
elif S[i] == "TLE": C2 += 1
else: C3 += 1
print("AC x "+ str(C0))
print("WA x "+ str(C1))
print("TLE x "+ str(C2))
print("RE x "+ str(C3))
| import math
x=int(input());money=100;year=0
while True:
if money >= x:
print(year)
break
money+=money//100
year+=1 | 0 | null | 17,859,917,013,512 | 109 | 159 |
x, y = map(int, input().split())
def gcd(x, y):
if x % y == 0:
return y
elif x % y == 1:
return 1
else:
return gcd(y, x % y)
if x >= y:
n = gcd(x, y)
print(n)
else:
n = gcd(y, x)
print(n) | twoNumbers=list(map(int,input().split()))
x=twoNumbers[0]
y=twoNumbers[1]
devidedBy=[]
syou=[]
if x>=y:
for number in range(1, y+1):
if y%number==0:
if number>y//number:
break
else:
if not number in devidedBy:
devidedBy.append(number)
if not y//number in syou:
syou.append(y//number)
else:
for number in range(1, x+1):
if x%number==0:
if number>x//number:
break
else:
if not number in devidedBy:
devidedBy.append(number)
if not x//number in syou:
syou.append(x//number)
if devidedBy[len(devidedBy)-1]==syou[len(syou)-1]:
del devidedBy[len(devidedBy)-1]
devidedBy.extend(syou)
devidedBy.sort()
index=len(devidedBy)-1
while index>=0:
if x>=y:
if x%devidedBy[index]==0:
print(devidedBy[index])
break
else:
index-=1
else:
if y%devidedBy[index]==0:
print(devidedBy[index])
break
else:
index-=1
| 1 | 7,679,535,202 | null | 11 | 11 |
input()
xs = list(map(int, input().split()))
def insertion_sort(xs):
for i in range(1, len(xs)):
v = xs[i]
j = i - 1
while j >= 0 and xs[j] > v:
xs[j + 1] = xs[j]
j -= 1
xs[j + 1] = v
print(*xs)
print(*xs)
insertion_sort(xs) | import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
H, W, M = MI()
h = [0] * H
w = [0] * W
item_list = [[0, 0] for _ in range(M)]
for i in range(M):
item_h, item_w = MI()
item_h -= 1
item_w -= 1
h[item_h] += 1
w[item_w] += 1
item_list[i][0] = item_h
item_list[i][1] = item_w
h_max = max(h)
w_max = max(w)
h_cnt = h.count(h_max)
w_cnt = w.count(w_max)
ans = h_max + w_max
cnt = 0
for item in item_list:
if h[item[0]] == h_max and w[item[1]] == w_max:
cnt += 1
x = h_cnt * w_cnt
if cnt == x:
ans -= 1
print(ans)
| 0 | null | 2,330,321,276,438 | 10 | 89 |
while 1:
x,y = map(int, raw_input().split())
if x == 0 and y == 0:
break
if y >= x:
print '%s %s' % (x, y)
else:
print '%s %s' % (y, x) | x,y,a,b,c=[int(i) for i in input().split()]
red_list=[int(i) for i in input().split()]
green_list=[int(i) for i in input().split()]
non_col_list=[int(i) for i in input().split()]
red_list.sort()
green_list.sort()
non_col_list.sort()
eat_red=[]
eat_green=[]
for i in range(x):
eat_red.append(red_list.pop())
for i in range(y):
eat_green.append(green_list.pop())
ans_list=eat_green+eat_red+non_col_list
ans_list.sort()
ans=0
for i in range(x+y):
ans+=ans_list.pop()
print(ans) | 0 | null | 22,784,659,948,050 | 43 | 188 |
import math
from collections import deque
N, D, A = list(map(int, input().split()))
data = []
for _ in range(N):
x, h = list(map(int, input().split()))
data.append((x, math.ceil(h/A)))
data = sorted(data, key=lambda x: x[0])
c = 0
damage_que = deque()
attack = 0 # 有効なダメージ合計
for i in range(N):
x, h = data[i]
# 爆破範囲が届いていなければ削除していく
while damage_que and x > damage_que[0][0]:
_, a = damage_que.popleft()
attack -= a
# 有効な過去の爆破攻撃を受ける
remain = max(h - attack, 0)
# 0になるまで爆破
attack += remain
c += remain
# 爆破回数追加
damage_que.append([x+2*D, remain])
print(c) | import sys
sys.setrecursionlimit(2147483647)
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
class LazySegmentTree(object):
def __init__(self, A, dot, unit, compose, identity, act):
# A : array of monoid (M, dot, unit)
# (S, compose, identity) : sub monoid of End(M)
# compose : (f, g) -> fg (f, g in S)
# act : (f, x) -> f(x) (f in S, x in M)
logn = (len(A) - 1).bit_length()
n = 1 << logn
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n, self._logn, self._tree, self._lazy = n, logn, tree, [identity] * (2 * n)
self._dot, self._unit, self._compose, self._identity, self._act = dot, unit, compose, identity, act
def _ascend(self, i):
tree, lazy, dot, act = self._tree, self._lazy, self._dot, self._act
while i > 1:
i >>= 1
tree[i] = act(lazy[i], dot(tree[i << 1], tree[i << 1 | 1]))
def _descend(self, i):
tree, lazy, identity, compose, act = self._tree, self._lazy, self._identity, self._compose, self._act
for k in range(self._logn, 0, -1):
p = i >> k
f = lazy[p]
tree[p << 1], lazy[p << 1] = act(f, tree[p << 1]), compose(f, lazy[p << 1])
tree[p << 1 | 1], lazy[p << 1 | 1] = act(f, tree[p << 1 | 1]), compose(f, lazy[p << 1 | 1])
lazy[p] = identity
# A[i] <- f(A[i]) for all i in [l, r)
def range_act(self, l, r, f):
l += self._n
r += self._n
# propagation isn't necessary if S is commutative
# self._descend(l)
# self._descend(r - 1)
l0, r0 = l, r
tree, lazy, act, compose = self._tree, self._lazy, self._act, self._compose
while l < r:
if l & 1:
tree[l], lazy[l] = act(f, tree[l]), compose(f, lazy[l])
l += 1
if r & 1:
r -= 1
tree[r], lazy[r] = act(f, tree[r]), compose(f, lazy[r])
l >>= 1
r >>= 1
self._ascend(l0)
self._ascend(r0 - 1)
# calculate product of A[l:r]
def sum(self, l, r):
l += self._n
r += self._n
self._descend(l)
self._descend(r - 1)
l_val = r_val = self._unit
tree, dot = self._tree, self._dot
while l < r:
if l & 1:
l_val = dot(l_val, tree[l])
l += 1
if r & 1:
r -= 1
r_val = dot(tree[r], r_val)
l >>= 1
r >>= 1
return dot(l_val, r_val)
from operator import add
def resolve():
n, d, a = map(int, input().split())
XH = [None] * n
coordinates = set() # for coordinates compression
for i in range(n):
x, h = map(int, input().split())
XH[i] = [x, (h - 1) // a + 1] # 初めから何回減らすかだけ持てばよい
coordinates.add(x)
coordinates.add(x + 2 * d + 1) # [x, x + 2d + 1) に減らす
XH.sort()
compress = {v : i for i, v in enumerate(sorted(coordinates))}
n = len(compress)
A = [0] * n
for i in range(len(XH)):
A[compress[XH[i][0]]] = XH[i][1]
res = 0
tree = LazySegmentTree(A, max, 0, add, 0, add) # 区間 add, 1点取得ができればよいので、区間拡張しなくてよい max にしておく
for x, h in XH:
# もし x が生き残っていたら、[x, x + 2d + 1) から hp を引く
hp = tree.sum(compress[x], compress[x] + 1)
if hp <= 0:
continue
res += hp
tree.range_act(compress[x], compress[x + 2 * d + 1], -hp)
print(res)
resolve() | 1 | 82,653,275,654,118 | null | 230 | 230 |
N = int(input())
S = input()
total = S.count('R') * S.count('G') * S.count('B')
cnt = 0
for i in range(N):
for j in range(i+1,N):
k = 2 * j - i
if k >= N:
break
if S[i] != S[j] and S[i] != S[k] and S[j] != S[k]:
cnt += 1
print(total-cnt) | # coding: utf-8
# Here your code !
import collections
s=int(input())
deq =collections.deque()
for i in range(s):
n=input().split()
if n[0]=="insert":
deq.appendleft(n[1])
elif n[0]=="delete":
try:
deq.remove(n[1])
except ValueError:
pass
elif n[0]=="deleteFirst":
deq.popleft()
elif n[0]=="deleteLast":
deq.pop()
print(" ".join(list(deq))) | 0 | null | 18,066,890,128,290 | 175 | 20 |
def main():
day = [list(map(int, input().split())) for _ in range(2)]
print(1 if day[0][0] + 1 == day[1][0] else 0)
if __name__ == '__main__':
main()
| n = int(input())
s = list(input())
ans = 1
for i in range(1, n):
if s[i-1] != s[i]:
ans += 1
print(ans)
| 0 | null | 147,376,496,189,872 | 264 | 293 |
n = int(input())
l = [list(map(int, input().split())) for i in range(n)]
#print(l[0][0])
#print(l[0][1])
ans = n-2
ans1 = 0
for m in range(ans):
if l[m][0] == l[m][1] and l[m+1][0] == l[m+1][1] and l[m+2][0] == l[m+2][1]:
ans1 += 1
if ans1 >= 1:
print("Yes")
else:
print("No") | # coding:UTF-8
import sys
from math import factorial
MOD = 10 ** 9 + 7
INF = 10000000000
def main():
# ------ 入力 ------#
n = int(input()) # 数字
# 定数行入力
x = n
dList = [list(map(int, input().split())) for _ in range(x)] # スペース区切り連続数字(行列)
# ------ 処理 ------#
flg = 1
for i in range(n-2):
if dList[i][0] == dList[i][1]:
if dList[i+1][0] == dList[i+1][1]:
if dList[i+2][0] == dList[i+2][1]:
flg = 0
# ------ 出力 ------#
if flg == 0:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 1 | 2,473,910,655,440 | null | 72 | 72 |
# n, m, l = map(int, input().split())
# list_n = list(map(int, input().split()))
# n = input()
# list = [input() for i in range(N)
# list = [[i for i in range(N)] for _ in range(M)]
import sys
input = sys.stdin.readline
A, B, M = map(int, input().split())
List_A = list(map(int, input().split()))
List_B = list(map(int, input().split()))
List_discount = [list(map(int, input().split())) for i in range(M)]
# print(List_discount)
ans = 2 * 10**5
for d in List_discount:
# print(d)
p = List_A[d[0]-1] + List_B[d[1]-1] - d[2]
ans = min(ans, p)
no_discount = min(List_A) + min(List_B)
ans = min(ans, no_discount)
print(ans)
| import sys, math
input = sys.stdin.readline
MAX = 2e9
def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = A[left:mid]
L.append(MAX)
R = A[mid:right]
R.append(MAX)
merged = []
index_L = 0
index_R = 0
comp_cnt = 0
for _ in range(n1+n2):
cand_L = L[index_L]
cand_R = R[index_R]
comp_cnt += 1
if (cand_L < cand_R):
merged.append(cand_L)
index_L += 1
else:
merged.append(cand_R)
index_R += 1
A[left:right] = merged
return comp_cnt
def merge_sort(A, left, right):
comp_cnt = 0
if (left + 1 < right):
# Devide
mid = (left + right) // 2
# Solve
_, cnt = merge_sort(A, left, mid)
comp_cnt += cnt
_, cnt = merge_sort(A, mid, right)
comp_cnt += cnt
# Conquer
comp_cnt += merge(A, left, mid, right)
return A, comp_cnt
def main():
N = int(input())
S = list(map(int, input().split()))
left = 0
right = len(S)
merged, cnt = merge_sort(S, left, right)
print(" ".join([str(x) for x in merged]))
print(cnt)
if __name__ == "__main__":
main()
| 0 | null | 27,191,627,366,760 | 200 | 26 |
N,K = map(int,input().split())
S = []
d = {}
A = list(map(int,input().split()))
ans = 0
sum =0
for i in range(1,N+1):
sum += A[i-1] % K
s = (sum - i) % K
if i > K:
x = S.pop(0)
d[x] -= 1
elif i < K:
if s == 0:
ans += 1
if s not in d:
d[s] = 0
ans += d[s]
d[s] += 1
S.append(s)
print(ans)
| n,k = map(int,input().split())
A = list(map(int,input().split()))
c = 0
from collections import Counter
d = Counter()
d[0] = 1
ans = 0
r = [0]*(n+1)
for i,x in enumerate(A):
if i>=k-1:
d[r[i-(k-1)]]-=1#ここで範囲kからはみ出たものの数を減らす
c = (c+x-1)%k
ans += d[c]
d[c] += 1
r[i+1] = c
print(ans) | 1 | 136,931,233,407,732 | null | 273 | 273 |
def main():
a=int(input())
print(a*(1+a+a*a))
main() | def resolve():
a = int(input())
print(a+a*a+a*a*a)
if '__main__' == __name__:
resolve() | 1 | 10,290,997,338,752 | null | 115 | 115 |
n, k = map(int,input().split())
p = list(map(lambda x:int(x)+1,input().split()))
s = [0]*(n+1)
for i in range(n):
s[i+1] = s[i] + p[i]
res = 0
for i in range(n-k+1):
res = max(res,s[i+k]-s[i])
print(res/2) | X = int(input())
ans = 8 - (X - 400)//200
print(ans) | 0 | null | 40,686,220,439,488 | 223 | 100 |
n = int(input())
ss = {}
tt = []
for i in range(n):
s, t = map(str, input().split())
ss[s] = i + 1
tt.append(t)
x = input()
print(sum([int(x) for x in tt[ss[x]:]])) | N = int(input())
M = []
for _ in range(N):
s, t = input().split()
M.append((s, int(t)))
X = input()
res = sum(map(lambda m: m[1], M))
for m in M:
res -= m[1]
if X == m[0]:
break
print(res)
| 1 | 96,958,812,160,420 | null | 243 | 243 |
n=int(input())
s=input()
c=n
for i in range(0,n-1):
if s[i]==s[i+1]:
c-=1
print(c) | n,m,k = map(int,input().split())
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 = 998244353 #出力の制限
N = n #Nの最大値
g1 = [0]*(N+1) #元テーブル(p(n,r))
g1[0] = g1[1] = 1
g2 = [0]*(N+1) #逆元テーブル
g2[0] = g2[1] = 1
inverse = [0]*(N+1) #逆元テーブル計算用テーブル
inverse[0],inverse[1] = 0,1
for i in range(2,N+1):
g1[i] = (g1[i-1] * i) % mod
inverse[i] = (-inverse[mod % i] * (mod//i)) % mod
g2[i] = (g2[i-1] * inverse[i]) % mod
# i組 -> m * (n-1)Ci * (m-1)^(n-1-i)
ans = 0
for i in range(k+1):
ans += m * cmb(n-1,i,mod) * pow(m-1,n-1-i,mod)
ans %= mod
print(ans) | 0 | null | 96,507,536,453,758 | 293 | 151 |
n = int(input())
s = input()
if n % 2 == 1:
print('No')
else:
sa = s[:n//2]
sb = s[n//2:]
if sa == sb:
print('Yes')
else:
print('No') | import math
n=int(input())
debt=100000
for i in range(n):
debt=math.ceil((debt*1.05)/1000)*1000
print(int(debt)) | 0 | null | 73,287,035,634,840 | 279 | 6 |
x = list(map(int , input().split()))
s = set()
for i in x:
if i not in s:
s.add(i)
if len(s) == 2:
print('Yes')
else:
print('No') | a,b,c=map(int,input().split())
if a==b==c or (a!=b!=c and a!=c!=b):
print("No")
else:
print("Yes")
| 1 | 68,103,513,873,350 | null | 216 | 216 |
import sys
from collections import deque
n,q = map(int,input().split())
f = lambda n,t: (n,int(t))
queue = deque(f(*l.split()) for l in sys.stdin)
t = 0
while queue:
name,time = queue.popleft()
t += min(q, time)
if time > q:
queue.append((name, time-q))
else:
print(name,t)
| s = input()
if "B" in s:
print("ARC")
else:
print("ABC") | 0 | null | 11,977,624,798,030 | 19 | 153 |
k, n =map(int,input().split())
a = list(map(int,input().split()))
longest = k - a[-1] + a [0]
for i in range(len(a)-1):
longest = max(longest,a[i+1]-a[i])
print(k-longest) | k,n=map(int,input().split())
l=list(map(int,input().split()))
diff=[]
l.append(l[0]+k)
for i in range(n):
diff.append(l[i+1]-l[i])
print(sum(diff)-max(diff))
| 1 | 43,596,653,886,852 | null | 186 | 186 |
mod=10**9+7
n,k=map(int,input().split())
l=[0]*(k+1)
for i in range(k):
num=(k-i)
if k//num==1:
l[num]=1
else:
ret=pow(k//num,n,mod)
for j in range(2,k//num+1):
ret-=l[num*j]
ret%=mod
l[num]=(ret)%mod
ans=0
for i in range(k+1):
ans+=(l[i]*i)%mod
print(ans%mod)
| H,A=map(int,input().split())
count=0
while H >= 1:
H -= A
count += 1
print(count) | 0 | null | 57,039,635,681,280 | 176 | 225 |
N,M=map(int,input().split())
H=list(map(int,input().split()))
cnt=[1 for _ in range(N)]
for _ in range(M):
A,B=map(int,input().split())
A-=1
B-=1
if H[A]>H[B]:
cnt[B]=0
elif H[A]<H[B]:
cnt[A]=0
else:
cnt[A]=0
cnt[B]=0
print(cnt.count(1))
| while True:
n = int(input())
if n == 0: break
nsum = 0
while n != 0:
nsum += n%10
n = n//10
print(nsum) | 0 | null | 13,352,846,744,710 | 155 | 62 |
# -*- coding: utf-8 -*-
import math
x1, y1, x2, y2 = map(float, raw_input().split())
dx = x2-x1
dy = y2-y1
print math.sqrt(dx*dx+dy*dy) | import math
x1,y1,x2,y2=map(float,input().split())
a = ((x1-x2)**2)+((y1-y2)**2)
a = math.sqrt(a)
print('{:.8f}'.format(a))
| 1 | 157,490,612,960 | null | 29 | 29 |
def factorial(n, mod):
fac = [0] * (n + 1)
inv = [0] * (n + 1)
fac[0], inv[0] = 1, 1
for i in range(1, n + 1):
fac[i] = fac[i-1] * i % mod
inv[i] = inverse(fac[i], mod)
return fac, inv
def inverse(a, mod):
a %= mod # 除数が正なら正になる
p = mod
x, y = 0, 1
while a > 0:
n = p // a
p, a = a, p % a,
x, y = y, x - n * y
return x % mod # 除数が正なら正になる
mod = 10 ** 9 + 7
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
fac, inv = factorial(n, mod)
ans = 0
for i in range(0, n-k+1):
m = n - i - 1
ans = (ans + (a[-i-1] - a[i]) % mod * fac[m] % mod * inv[m-k+1] % mod * inv[k-1]) % mod
print(ans)
| N,K = map(int, input().split())
tmp=N
count=0
while tmp!=0:
tmp = tmp//K
count += 1
print(count) | 0 | null | 79,854,690,589,920 | 242 | 212 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(read())
lim = int(n ** 0.5)
fact = [1]
for i in range(2, lim + 1):
if (n % i == 0):
fact.append(i)
else:
pass
if (len(fact) == 1):
ans = n - 1
else:
tar = fact[-1]
ans = tar + int(n // tar) - 2
print(ans)
| N=int(input())
import math
n=int(math.sqrt(N))
m=0
T=True
while T==True:
if N%n==0:
m=N//n
T=False
break
else:
n-=1
print(n+m-2) | 1 | 161,557,116,915,808 | null | 288 | 288 |
S = input()
T = input()
S_chars = list(S)
T_chars = list(T)
i = 0
count = 0
for roop in S_chars:
if not S_chars[i] == T_chars[i]:
count += 1
i += 1
print(count) | # https://atcoder.jp/contests/abc155/submissions/10157837
# 写経
def main():
a = [0]
a += map(int, input())
a.reverse()
n = len(a)
b = a.copy()
for i in range(n):
if b[i] > 5 or (b[i] == 5 and b[i + 1] >= 5):
b[i] = 0
b[i + 1] += 1
cnt = sum(b)
for i in range(n):
if a[i] > b[i]:
b[i] += 10
b[i + 1] -= 1
cnt += b[i] - a[i]
print(cnt)
if __name__ == '__main__':
main()
| 0 | null | 40,890,787,808,320 | 116 | 219 |
from collections import deque
x,y,a,b,c = map(int,input().split())
ls = []
la = list(map(int,input().split()))
lb = list(map(int,input().split()))
lc = list(map(int,input().split()))
la.sort(reverse=True)
lb.sort(reverse=True)
lc.sort(reverse=True)
for i in range(a):
ls.append([la[i],1])
for j in range(b):
ls.append([lb[j],2])
for l in range(c):
ls.append([lc[l],3])
ls.sort(key=lambda x:x[0],reverse=True)
ls = deque(ls)
s,t,k = 0,0,0
cnt = 0
while True:
now = ls.popleft()
if now[1] == 1:
if s < x:
cnt += now[0]
s += 1
elif now[1] == 2:
if t < y:
cnt += now[0]
t += 1
else:
cnt += now[0]
k += 1
if s + t + k == x + y:
print(cnt)
break | import math
import sys
import collections
import bisect
readline = sys.stdin.readline
def main():
x, y, a, b, c = map(int, input().split())
p = sorted(list(map(int, input().split())), reverse=True)[0:x]
q = sorted(list(map(int, input().split())), reverse=True)[0:y]
r = sorted(list(map(int, input().split())), reverse=True)
pq = sorted((p + q))
for i in range(min(c, (x + y))):
if pq[i] > r[i]:
break
pq[i] = r[i]
print(sum(pq))
if __name__ == '__main__':
main()
| 1 | 45,126,468,955,670 | null | 188 | 188 |
from collections import deque
n, x, y = map(int, input().split())
g = [[] for _ in range(n)]
for i in range(n - 1):
g[i].append(i + 1)
g[i + 1].append(i)
g[x - 1].append(y - 1)
g[y - 1].append(x - 1)
def bfs(g, n_node, start_node):
dist = [-1] * n_node
dist[start_node] = 0
que = deque([start_node])
while que:
node = que.popleft()
for j in g[node]:
if dist[j] != -1:
continue
dist[j] = dist[node] + 1
que.append(j)
return dist
ans = [0] * n
for i in range(n):
dist = bfs(g, n, i)
for d in dist:
ans[d] += 1
for a in ans[1:]:
print(a//2) | import sys
from collections import Counter
def main():
input = sys.stdin.buffer.readline
n, x, y = map(int, input().split())
k_cnt = Counter()
for i in range(1, n):
for j in range(i + 1, n + 1):
if i <= x:
if j < y:
dist = min(j - i, (x - i) + 1 + (y - j))
elif y <= j:
dist = (x - i) + 1 + (j - y)
elif x < i < y:
dist = min(j - i, (i - x) + 1 + abs(j - y))
else:
dist = j - i
k_cnt[dist] += 1
for i in range(1, n):
print(k_cnt[i])
if __name__ == "__main__":
main()
| 1 | 44,262,556,834,808 | null | 187 | 187 |
import math
N=int(input())
A=[0]*N
B=[0]*N
for i in range(N):
A[i],B[i]=map(int,input().split())
total=0
for i in range(N):
for j in range(i+1,N):
total+=((A[i]-A[j])**2+(B[i]-B[j])**2)**0.5
print(total/N*2) | INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
import itertools, math
def distance(x1,y1,x2,y2):
return(((x2-x1)**2+(y2-y1)**2)**0.5)
def do():
xs=[]
ys=[]
per=[]
n=INT()
ans=0
for i in range(n):
x,y=INTM()
xs.append(x)
ys.append(y)
per.append(i)
for i in itertools.permutations(per, n):
for k in range(n-1):
ans+=distance(xs[i[k]],ys[i[k]],xs[i[k+1]],ys[i[k+1]])
#print(ans)
print(ans/math.factorial(n))
if __name__=='__main__':
do() | 1 | 149,056,234,505,540 | null | 280 | 280 |
n, m = map(int, input().split())
a, b = n, 1
V = [False for d in range(1, n + 1)]
for i in range(m):
d = min(a - b, n - (a - b))
if 2 * d == n or V[d]:
a -= 1
print(a, b)
d = min(a - b, n - (a - b))
V[d] = True
a -= 1
b += 1
| import sys,collections
input = sys.stdin.readline
N = int(input())
A = list(map(int,input().split()))
Ac = collections.Counter(A)
def num_combi2(n):
combi = n*(n-1)//2
return combi
def sub_combi2(n):
c_before = n*(n-1)//2
c_after =(n-1)*(n-2)//2
return c_after - c_before
all_combi = 0
for val in Ac.values():
all_combi += num_combi2(val)
for i in range(N):
print(all_combi + sub_combi2(Ac[A[i]]))
| 0 | null | 37,978,367,839,398 | 162 | 192 |
from collections import Counter
from math import gcd
N=int(input())
def factorize(x):
i=2
ret=[]
while i*i<=x:
while x%i==0:
ret.append(i)
x//=i
i+=1
if x>1:
ret.append(x)
return Counter(ret)
ans=1
for v in factorize(N-1).values():
ans*=v+1
ans-=1
cnt=1
for v in factorize(gcd(N,N-1)).values():
cnt*=v+1
cnt-=1
ans-=cnt
k=2
while k*k<=N:
if N%k==0:
n=N//k
while n%k==0:
n//=k
if n%k==1:
ans+=1
k+=1
ans+=1
print(ans) | S = sorted(list(input().rstrip()))
r = 'Yes' if S[0] != S[2] else 'No'
print(r)
| 0 | null | 47,984,612,063,502 | 183 | 201 |
# import math
N = int(input())
# Nが奇数の場合は-2していくと全て奇数になるので答えは0
# Nが偶数の場合を検討するべし
# Nが偶数の場合、明らかに2の倍数より5の倍数の方が少ないので5の倍数がいくつかで考える
if (N % 2 == 1):
print(0)
exit()
bunbo = 0
sum_5 = 0
while (10 * 5 ** bunbo) <= N:
sum_5 += N // (10 * 5**bunbo)
bunbo += 1
print(sum_5)
| import sys
input = sys.stdin.readline
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N=I()
if N%2==1:
print(0)
exit()
ans=0
for i in range(1,100):
a=2*pow(5,i)
ans+=N//a
print(ans)
main()
| 1 | 116,312,693,870,328 | null | 258 | 258 |
N = int(input())
A = list(map(int, input().split()))
counter = [0 for _ in range(max(A)+1)]
appeard = []
for k in range(N):
counter[A[k]] += 1
if counter[A[k]] == 2:
appeard.append(A[k])
allsum = 0
for item in appeard:
allsum += counter[item]*(counter[item]-1)//2
for k in range(N):
if counter[A[k]] > 1:
print(allsum - (counter[A[k]]-1))
else:
print(allsum) | s = input()
p = input()
s = s * 2
for i in range(len(s) - len(p) + 1):
#print(s[i:i + len(p)])
if p == s[i:i + len(p)]:
print("Yes")
exit()
print("No")
| 0 | null | 24,701,796,230,580 | 192 | 64 |
import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
n,u,v = map(int,ipt().split())
way = [[] for _ in range(n+1)]
for _ in range(n-1):
a,b = map(int,ipt().split())
way[a].append(b)
way[b].append(a)
ta = [-1]*(n+1)
tt = [-1]*(n+1)
ta[v] = 0 #AOKI
tt[u] = 0
qa = queue.Queue()
qt = queue.Queue()
qt.put((0,u,-1))
qa.put((0,v,-1))
while not qa.empty():
ti,pi,pp = qa.get()
for i in way[pi]:
if i == pp:
continue
if ta[i] == -1:
ta[i] = ti+1
qa.put((ti+1,i,pi))
while not qt.empty():
ti,pi,pp = qt.get()
if ta[pi] <= ti:
continue
for i in way[pi]:
if i == pp:
continue
if ta[i] > ti:
tt[i] = ti+1
qt.put((ti+1,i,pi))
ma = 0
for i in range(1,n+1):
if tt[i] == -1:
continue
if ma < tt[i]+max(0,ta[i]-tt[i]-1):
ma = tt[i]+max(0,ta[i]-tt[i]-1)
print(ma)
return
if __name__ == '__main__':
main()
| import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, p, q, *AB = map(int, read().split())
p -= 1
q -= 1
G = [[] for _ in range(N)]
for a, b in zip(*[iter(AB)] * 2):
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
if len(G[p]) == 1 and G[p][0] == q:
print(0)
return
dist1 = [-1] * N
dist1[p] = 0
queue = deque([p])
while queue:
v = queue.popleft()
for nv in G[v]:
if dist1[nv] == -1:
dist1[nv] = dist1[v] + 1
queue.append(nv)
dist2 = [-1] * N
dist2[q] = 0
queue = deque([q])
while queue:
v = queue.popleft()
for nv in G[v]:
if dist2[nv] == -1:
dist2[nv] = dist2[v] + 1
queue.append(nv)
max_d = 0
for d1, d2 in zip(dist1, dist2):
if d1 < d2 and max_d < d2:
max_d = d2
print(max_d - 1)
return
if __name__ == '__main__':
main()
| 1 | 116,998,558,281,502 | null | 259 | 259 |
import sys
s = sys.stdin.readline().rstrip("\n")
print(s[:3]) | #!/usr/bin/env python
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**6)
def main():
S = input().decode().rstrip()
print(S[0:3])
if __name__ == "__main__":
main() | 1 | 14,638,928,521,920 | null | 130 | 130 |
import sys
input = sys.stdin.readline
def main():
s = input().rstrip('\n')
n = len(s)
ansl = [0]*(n+1)
for i in range(n):
if s[i] == '<':
ansl[i+1] = ansl[i]+1
for i in reversed(range(n)):
if s[i] == '>':
ansl[i] = max(ansl[i+1]+1,ansl[i])
print(sum(ansl))
if __name__ == '__main__':
main() | s=input()
#><となるところを見つける<<となるところを見つける>>となるところを見つける<>となるところについて考える
n=len(s)
ans=[0]*(n+1)
#左から>>となる部分を探す
for i in range(n):
if s[i]=='<':
ans[i+1]=max(ans[i+1],ans[i]+1)
for i in reversed(range(n)):
if s[i]=='>':
ans[i]=max(ans[i],ans[i+1]+1)
print(sum(ans))
#rangeの挙動に注意しよう | 1 | 156,499,249,934,752 | null | 285 | 285 |
N, M = map(int, input().split())
ans = []
n = M // 2
m = 2 * n + 1
l = 2 * M + 1
for i in range(n):
ans.append([i + 1, m - i])
for i in range(M - n):
ans.append([m + i + 1, l - i])
for v in ans:
print(*v)
| s = list(input())
t = list(input())
length = len(s)-len(t) + 1
max = 0
for i in range(length):
count = 0
for j in range(len(t)):
if t[j] == s[i+j]:
count += 1
if j == len(t)-1 and max < count:
max = count
print(len(t) - max) | 0 | null | 16,234,373,549,760 | 162 | 82 |
# +1/-1の折れ線で表したとき
# 「0で終わる」かつ「途中で0未満にならない」を満たせば良い
# あとは貪欲を上手い事使う
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
n = int(input())
a = []
b = []
for _ in range(n):
s = input().rstrip()
# 最終的に上がる量/最下点
up, down = 0, 0
for i in s:
if i == ')':
up -= 1
if down > up:
down = up
else:
up += 1
if up >= 0:
a.append((down, up))
else:
b.append((up-down, down, up))
a.sort(reverse=True)
b.sort(key=lambda a: a[0],reverse=True)
c = 0
for d, u in a:
if c+d < 0:
print('No')
break
else:
c += u
else:
for _, d, u in b:
if c+d < 0:
print('No')
break
else:
c += u
else:
if c == 0:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| x = int(input())
b = x
a = 1
while b%360!=0:
a += 1
b += x
print(a) | 0 | null | 18,434,904,775,870 | 152 | 125 |
import math
N = int(input())
X = N / 1.08
floor = math.ceil(N/1.08)
ceil = math.ceil((N+1)/1.08)
for i in range(floor,ceil):
print(i)
break
else:
print(":(") | n = int(input())
s, t = input().split()
combination_of_letters = ''
for i in range(n):
combination_of_letters += s[i] + t[i]
print(combination_of_letters) | 0 | null | 118,781,744,844,942 | 265 | 255 |
# 二通りのやり方で解いてみよう。
# Aそれぞれに対してBを二分探索→M(累積和構成) + NlogM
# Aを昇順、Bを降順に動かす→O(N+M) このコードはこっち★
n, m, k = list(map(int, input().split()))
aa = list(map(int, input().split()))
bb = list(map(int, input().split()))
time_sum = sum(bb)
a_idx = 0
b_idx = m-1
ans = 0
# 最初はA無し、B全部からスタート
book_num = m
while True:
if time_sum > k:
if b_idx < 0:
break
time_sum -= bb[b_idx]
b_idx -= 1
book_num -= 1
else:
# 実行可能な読み方
ans = max(ans, book_num)
if a_idx > n-1:
break
time_sum += aa[a_idx]
a_idx += 1
book_num += 1
print(ans)
| n, k = map(int, input().split())
a = list(map(int, input().split()))
def check(x):
c = 0
for i in range(n):
c += a[i]//x
if a[i]%x == 0:
c -= 1
if c <= k:
return True
else:
return False
mx = max(a)
mn = 0
ans = [mx]
while mn <= mx:
m = (mx+mn)//2
if m == 0:
if check(1):
ans.append(1)
break
if check(m):
mx = m - 1
ans.append(m)
else:
mn = m + 1
print (min(ans))
| 0 | null | 8,577,855,237,960 | 117 | 99 |
# A, Can'tWait for Holiday
# 今日の曜日を表す文字列Sが与えられます。
# Sは'SUN','MON','TUE','WED','THU','FRI','SAT'のいずれかであり、それぞれ日曜日、月曜日、火曜日。水曜日、木曜日、金曜日、土曜日を表します。
# 月の日曜日（あす以降）が何日後か求めてください。
# Sは'SUN','MON','TUE','WED','THU','FRI','SAT'のいずれか。
S = input()
if S == 'MON':
print(6)
elif S == 'TUE':
print(5)
elif S == 'WED':
print(4)
elif S == 'THU':
print(3)
elif S == 'FRI':
print(2)
elif S == 'SAT':
print(1)
else:print(7) | S=input()
ans='Yes'
i=0
while i<len(S):
if S[i:i+2]!='hi':
ans='No'
i+=2
print(ans) | 0 | null | 93,369,312,252,568 | 270 | 199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.