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
|
|---|---|---|---|---|---|---|
import collections
k = int(input())
Q = collections.deque([int(i) for i in range(1, 10)])
for _ in range(k):
x = Q.popleft()
if x%10:
Q.append(10*x + x%10 - 1)
Q.append(10*x + x%10)
if x%10 != 9:
Q.append(10*x + x%10 + 1)
print(x)
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
import bisect
import heapq
import itertools
import math
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
bunshi=1
bunbo=1
for i in range(r):
bunbo = bunbo*(i+1)%mod
bunshi = bunshi*(n-i)%mod
return (bunshi*pow(bunbo,mod-2,mod))%mod
mod = 10**9+7
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return [list(map(int, input().split())) for _ in range(n)]
#bisect.bisect_left(list,key)はlistのなかでkey未満の数字がいくつあるかを返す
#つまりlist[i] < x となる i の個数
#bisect.bisect_right(list, key)はlistのなかでkey以下の数字がいくつあるかを返す
#つまりlist[i] <= x となる i の個数
#これを応用することで
#len(list) - bisect.bisect_left(list,key)はlistのなかでkey以上の数字がいくつあるかを返す
#len(list) - bisect.bisect_right(list,key)はlistのなかでkeyより大きい数字がいくつあるかを返す
#これらを使うときはあらかじめlistをソートしておくこと！
k = I()
d = deque([1,2,3,4,5,6,7,8,9])
for i in range(k):
num = d.popleft()
if num%10 != 0:
d.append(10*num + (num%10) -1)
d.append(10*num + (num%10))
if num%10 != 9:
d.append(10*num + (num%10) + 1)
print(num) | 1 | 39,776,436,717,794 | null | 181 | 181 |
input()
a = list(input().split())
a.reverse()
print(' '.join(a)) | x = list(map(int, input().split()))
if len(set(x))==2:
kotae='Yes'
else:
kotae='No'
print(kotae) | 0 | null | 34,636,273,843,142 | 53 | 216 |
import sys
N = int(input())
if N>=4:
C=[0]*N
C[0]=0
C[1]=0
C[2]=1
n=2
#フィボナッチ数列のイメージ
while True:
n=n+1
C[n]=C[n-1]+C[n-3]
#print(n,C[n])
if n==(N-1):
break
print(C[N-1]%(10**9+7))
if N==3:
print(1)
if N<=2:
print(0) | s = int(input())
a = [-1]*(s+10)
mod = 10**9 + 7
a[0] = 1
a[1] = 0
a[2] = 0
a[3] = 1
if s > 3:
for i in range (4,s+1):
a[i] = (a[i-1]+a[i-3])%mod
print(a[s])
| 1 | 3,283,220,282,540 | null | 79 | 79 |
a, b, k = map(int, input().split())
n = min(a,k)
k -= n
print(a-n, max(0,b-k)) | N, A, B = [int(_) for _ in input().split()]
MOD = 10 ** 9 + 7
var1 = pow(2, N, MOD) - 1
def f(x):
f1 = 1
for i in range(N - x + 1, N + 1):
f1 = (f1 * i) % MOD
# 逆元
f2 = 1
for i in range(2, x + 1):
f2 = (f2*i)%MOD
f2 = pow(f2, MOD - 2, MOD)
return (f1 * f2) % MOD
ans = var1 - f(A) - f(B)
print(ans % MOD)
| 0 | null | 85,135,579,789,920 | 249 | 214 |
a, b, c = map(int, input().split())
k = int(input())
cnt = 0
while not (a < b < c):
cnt += 1
if a >= b:
b *= 2
elif b >= c:
c *= 2
if cnt > k:
print("No")
exit(0)
print("Yes") | s = input()
t = input()
counter = 0
for index, character in enumerate(s):
if t[index] != character:
counter += 1
print(counter) | 0 | null | 8,793,423,479,070 | 101 | 116 |
def gcd(a,b):
if b == 1:
return 1
else:
return (gcd(b,a%b) if b != 0 else a)
A = list(map(int,input().split()))
print(gcd(A[0],A[1])) | h,n=map(int,input().split())
inf=100000000000
dp=[inf]*(h+1)
dp[h]=0
for i in range(n):
a,b=map(int,input().split())
for j in range(h,-1,-1):
dp[max(j-a,0)]=min(dp[max(j-a,0)],dp[j]+b)
print(dp[0]) | 0 | null | 40,790,050,580,650 | 11 | 229 |
N = int(input())
S,T = map(str,input().split())
slist = list(S)
tlist = list(T)
new = ''
for i in range(N):
new += slist[i]
new += tlist[i]
print(new) | from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
N = int(input())
S, T = map(str, input().split())
ans = ""
for i in range(N):
ans += S[i] + T[i]
print(ans) | 1 | 111,994,597,389,092 | null | 255 | 255 |
L = ['ABC', 'ARC']
S = input()
a = [i for i in L if i != S][0]
print(a) | str = input()
if str=="ABC":
print("ARC")
else:
print("ABC") | 1 | 24,164,586,039,910 | null | 153 | 153 |
from operator import itemgetter
n = int(input())
lis = []
for _ in range(n):
x,l = map(int,input().split())
lis.append([x-l,x+l])
lis.sort(key = itemgetter(1))
ans = 0
last = -float("inf")
for i in range(n):
if lis[i][0] >= last:
ans += 1
last = lis[i][1]
print(ans) | def main():
N = int(input())
robot = []
for _ in range(N):
X, L = map(int, input().split())
robot.append([X-L,X+L])
robot.sort(key=lambda x: x[1])
cnt = 1
l = robot[0][1]
for i in range(1,N):
if l <= robot[i][0]:
cnt += 1
l = robot[i][1]
print(cnt)
if __name__ == "__main__":
main() | 1 | 90,357,754,175,808 | null | 237 | 237 |
A, B, M = map(int, input().split())
price_A = list(map(int, input().split()))
price_B = list(map(int, input().split()))
ans = min(price_A)+min(price_B)
for m in range(M):
x, y, c = map(int, input().split())
p1 = price_A[x-1] + price_B[y-1] - c
if p1 <= ans: ans=p1
print(ans) | import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
## dp ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str: return format(x, 'b') # rev => int(res, 2)
def to_oct(x: int) -> str: return format(x, 'o') # rev => int(res, 8)
def to_hex(x: int) -> str: return format(x, 'x') # rev => int(res, 16)
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
while y: x,y = y,x%y
return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
"""Return a tuple list of divisor of n"""
return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers n or less"""
is_prime = [True]*(MAX_NUM+1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX_NUM**0.5)+1):
if not is_prime[i]: continue
for j in range(i*2, MAX_NUM+1, i):
is_prime[j] = False
return [i for i in range(MAX_NUM+1) if is_prime[i]]
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
#======================================================#
def main():
a, b, m = MII()
aa = MII()
bb = MII()
q = [MII() for _ in range(m)]
minv = min(aa) + min(bb)
for x,y,c in q:
minv = min(minv, aa[x-1]+bb[y-1]-c)
print(minv)
if __name__ == '__main__':
main() | 1 | 53,833,006,019,300 | null | 200 | 200 |
l=input().split()
n=int(l[0])
m=int(l[1])
#receive vecter a(n*m)
i=0
A=[]
while i<n:
a=input().split()
for p in a:
A.append(int(p))
i+=1
#receive vecter b(m*1)
I=0
B=[]
while I<m:
b=int(input())
B.append(b)
I+=1
#Ci=ai1b1+ai2b2+...+aimbm
#C[i]=a[m*(i)+1]*b[1]+a[m*(i)+2]*b[2]+...a[m*(i)+m]*b[m]
q=0
C=[]
while q<n:
Q=0
cq=0
while Q<m:
cq+=A[m*q+Q]*B[Q]
Q+=1
C.append(cq)
q+=1
for x in C:
print(x)
| n,m = [int(x) for x in input().split( )]
a = [[0 for x in range(m)] for y in range(n)]
b = []
for i in range(n):
retsu = [int(x) for x in input().split( )]
a[i] = retsu
for j in range(m):
b.append(int(input()))
answer = []
for i in range(n):
value = 0
for j in range(m):
value += a[i][j]*b[j]
answer.append(value)
for ans in answer:
print(ans)
| 1 | 1,160,504,309,468 | null | 56 | 56 |
N = int(input())
count = 0
for i in range(1,N+1):
if i % 2 == 1:
count += 1
else:
pass
print(count/N)
| n=int(input())
if(n%2==0):
print((n//2)/n)
else:
print((n//2+1)/n) | 1 | 177,147,173,365,568 | null | 297 | 297 |
n = input()
ans = 0
for i,j in enumerate(map(int,input().split())):
ans += (~i&1 and j&1)
print(ans) | def az11():
n, xs = int(input()), map(int,raw_input().split())
print min(xs), max(xs), sum(xs)
az11() | 0 | null | 4,192,461,511,952 | 105 | 48 |
n=int(input())
c=input()
r_cnt=c.count('R')
w_cnt=c.count('W')
last_c='R'*r_cnt+'W'*w_cnt
num=0
for i in range(n):
if c[i]!=last_c[i]:
num+=1
print((num+2-1)//2) | isprime = [True] * 100201
def seive(n):
isprime[0] = isprime[1] = False
p = 2
while (p*p <= n):
if isprime[p]:
for i in range(p*p, n+1, p):
isprime[i] = False
p += 1
prime = [j for j in range(n) if isprime[j]]
return prime
def program():
x = int(input())
N = 100200
prime = seive(N)
for i in range(len(prime)):
if prime[i] >= x:
return prime[i]
break
print(program())
| 0 | null | 55,936,677,878,240 | 98 | 250 |
import math
import sys
def lcm(a, b):
return a * b // math.gcd(a, b)
input = sys.stdin.readline
n = int(input())
A = list(map(int, input().split()))
LCM = 1
ans = 0
MOD = 1000000007
for x in A:
LCM = lcm(LCM, x)
for x in A:
ans += LCM // x
print(ans%MOD) | N = int(input())
S, T = input().split()
i = ''
for j in zip(S, T):
for k in j:
i += k
print(i) | 0 | null | 99,834,850,756,798 | 235 | 255 |
n = int(input())
R = (int(input()) for _ in range(n))
ret = -(10 ** 9)
mn = next(R)
for r in R:
ret = max(ret, r - mn)
mn = min(mn, r)
print(ret) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
XY = []
for _ in range(N):
A = int(input())
xy = [list(mapint()) for _ in range(A)]
XY.append(xy)
ans = 0
for i in range(1<<N):
honest = [-1]*N
cnt = 0
ok = True
for j in range(N):
if (i>>j)&1:
honest[j]=1
else:
honest[j]=0
for j in range(N):
if (i>>j)&1:
cnt += 1
for x, y in XY[j]:
if honest[x-1]!=y:
ok = False
break
if ok:
ans = max(ans, cnt)
print(ans)
| 0 | null | 60,445,500,882,228 | 13 | 262 |
r, c = map(int, input().split())
a = [list(map(int, input().split())) for i in range(r)]
newr = []
for i in range(r):
a[i].append(sum(a[i]))
for j in range(c + 1):
sumc = 0
for i in range(r):
sumc += a[i][j]
newr.append(sumc)
a.append(newr)
for i in range(r+1):
print(" ".join(str(t) for t in a[i])) | (r, c) = [int(i) for i in input().split()]
table = [[0 for j in range(c + 1)]for i in range(r + 1)]
for i in range(r):
tmp = [int(x) for x in input().split()]
for j in range(c + 1):
if not j == c:
table[i][j] = tmp[j]
table[i][c] += table[i][j]
table[r][j] += table[i][j]
for i in range(r + 1):
for j in range(c + 1):
if j == c:
print(table[i][j], end='')
else:
print(table[i][j], '', end='')
print() | 1 | 1,338,030,249,280 | null | 59 | 59 |
n = int(input())
def dfs(s, i):
if i == n:
print(s)
else:
for j in range(ord("a"), max(map(ord, list(s))) + 2):
dfs(s + chr(j), i + 1)
dfs("a", 1) | N = int(input())
# 最後の数字+1以下じゃないとだめ
# abc -> 次はa,b,c,d
dic = ["a","b","c","d","e","f","g","h","i","j"]
strs = ["a"]
cnt = 1
while cnt < N:
tmps = []
for s in strs:
for i,d in enumerate(dic[::-1]):
if d in s:
ind = len(dic)-i-1
break
# print(s,ind,dic[i])
for i in range(ind+2):
tmps.append(s+dic[i])
cnt += 1
strs = tmps[:]
for s in strs:
print(s) | 1 | 52,549,865,967,452 | null | 198 | 198 |
import bisect
N=int(input())
rllist=[]
for _ in range(N):
X,L=map(int,input().split())
rllist.append((X+L,X-L))
rllist.sort()
#print(rllist)
dp=[0]*N
dp[0]=1
for i in range(1,N):
r,l=rllist[i]
pos=bisect.bisect(rllist,(l,float("inf")))
#print(i,pos)
if pos==0:
dp[i]=dp[i-1]
else:
dp[i]=max(dp[i-1],dp[pos-1]+1)
#print(dp)
print(dp[-1]) | INF = 1 << 60
n = int(input())
x = [0 for i in range(n)]
l = [0 for i in range(n)]
for i in range(n):
x[i], l[i] = map(int, input().split())
itv = [[x[i] - l[i], x[i] + l[i]] for i in range(n)]
itv.sort(key=lambda x:x[1])
# print("itv =", itv)
ans = 0
t = -INF
for i in range(n):
if t <= itv[i][0]:
ans += 1
t = itv[i][1]
print(ans)
| 1 | 89,557,171,916,608 | null | 237 | 237 |
n,k = map(int,input().split())
a = list(map(int,input().split()))
b = [0] * n
c = ['Y'] * n
c[0] = 'N'
x = 0
y = 1
while x != k:
c[y-1] = 'N'
x += 1
y = a[y-1]
b[x-1] = y
if c[y-1] == 'N':
break
if x != k:
y = b.index(a[y-1])
k -= x
k %= (x-y)
c = b[y:x]
print(c[k-1])
else:
print(y) | def resolve():
N, K = list(map(int, input().split()))
A = list(map(lambda x: int(x)-1, input().split()))
routes = [0]
current = 0
visited = [False for _ in range(N)]
visited[0] = True
while visited[A[current]] is False:
current = A[current]
routes.append(current)
visited[current] = True
leftlen = routes.index(A[current])
repeat = routes[leftlen:]
# print(leftlen)
# print(routes)
# print(repeat)
print(repeat[(K-leftlen)%len(repeat)]+1 if K > leftlen else routes[K]+1)
if '__main__' == __name__:
resolve()
| 1 | 22,685,923,809,918 | null | 150 | 150 |
from collections import defaultdict as d
n=int(input())
a=list(map(int,input().split()))
p=d(int)
l=0
for i in a:
p[i]+=1
l+=i
for i in range(int(input())):
b,c=map(int,input().split())
l+=p[b]*(c-b)
p[c]+=p[b]
p[b]=0
print(l) | s=''
try:
while True:
sentence=input()
s+=sentence.lower()
except:
for i in[chr(i) for i in range(97,97+26)]:
print(i,':',s.count(i)) | 0 | null | 6,968,463,708,878 | 122 | 63 |
import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def nck(n, k, kaijyo):
return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD
def npk(n, k, kaijyo):
if k == 0 or k == n:
return n % MOD
return (kaijyo[n] * divide(kaijyo[n-k])) % MOD
def kaijyo(n):
ret = [1]
for i in range(1, n + 1):
ret.append((ret[-1] * i)% MOD)
return ret
def solve():
n, m = getList()
nums = getList()
peaks = [[] for i in range(n)]
for i in range(m):
a,b = getZList()
peaks[a].append(b)
peaks[b].append(a)
ans = 0
for i, num in enumerate(nums):
flg = True
for p in peaks[i]:
if nums[p] >= num:
flg = False
if flg:
ans += 1
print(ans)
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve() | import sys
def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))
def RN(N): return [input().strip() for i in range(N)]
def main():
a, b = MI()
L = sorted([a, b])
if L[0] == a:
ans = int(str(a)*b)
else:
ans = int(str(b)*a)
print(ans)
if __name__ == "__main__":
main() | 0 | null | 55,084,005,832,520 | 155 | 232 |
N, M = map(int, input().split())
H = list(map(int, input().split()))
max_h = [0]*N
ans = 0
for i in range(M):
a, b = map(int, input().split())
max_h[a-1] = max(max_h[a-1], H[b-1])
max_h[b-1] = max(max_h[b-1], H[a-1])
for j in range(N):
if max_h[j] < H[j]:
ans += 1
print(ans)
|
def main():
n, m = map(int, input().split(" "))
ls=[{} for _ in range(n)]
h = list(map(int, input().split(" ")))
for i in range(n):
ls[i] = [h[i]]
ab = []
for i in range(m):
ab.append(list(map(lambda i:int(i)-1, input().split(" "))))
for i in range(m):
if ls[ab[i][0]][0] >= ls[ab[i][1]][0]:
ls[ab[i][1]].append(ls[ab[i][0]][0]+1)
if ls[ab[i][1]][0] >= ls[ab[i][0]][0]:
ls[ab[i][0]].append(ls[ab[i][1]][0] + 1)
cnt = 0
for i in range(n):
if ls[i][0] == max(ls[i]):
cnt += 1
print(cnt)
if __name__ == "__main__":
main() | 1 | 25,031,050,222,190 | null | 155 | 155 |
s = input()
t = input()
print("Yes" if s == t[:len(t) - 1] else "No") | class Dice():
def __init__(self, nums):
self.nums = nums
self.top, self.front, self.right = 0, 1, 2
def move(self, op):
for c in op:
if c == 'N':
self.top, self.front = self.front, 5 - self.top
elif c == 'S':
self.top, self.front = 5 - self.front, self.top
elif c == 'E':
self.top, self.right = 5 - self.right, self.top
else:
self.top, self.right = self.right, 5 - self.top
dice = Dice([int(n) for n in input().split()])
dice.move(input())
print(dice.nums[dice.top]) | 0 | null | 10,896,580,756,010 | 147 | 33 |
N, P = map(int, input().split())
S = input()
now = 0
hyou = [0] * P
hyou[0] = 1
cnt = 1
ans = 0
if P == 2 or P == 5:
for i, t in enumerate(S[::-1]):
temp = int(t)
if temp % P == 0:
ans += N - i
print(ans)
exit()
for i, t in enumerate(S[::-1]):
now = (now + int(t) * pow(10, i, P)) % P
ans += hyou[now]
hyou[now] += 1
print(ans)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def main():
n, p = map(int, input().split())
s = list(input())
if 10 % p == 0:
ans = 0
for i in range(n):
if (ord(s[i])-ord('0')) % p == 0:
ans += i+1
print(ans)
return
d = [0] * (n+1)
ten = 1
for i in reversed(range(n)):
a = (ord(s[i])-ord('0')) * ten % p
d[i] = (d[i+1]+a) % p
ten *= 10
ten %= p
cnt = [0] * p
ans = 0
for i in reversed(range(n+1)):
ans += cnt[d[i]]
cnt[d[i]] += 1
print(ans)
main()
| 1 | 58,464,754,605,490 | null | 205 | 205 |
h1, m1, h2, m2, k = map(int, input().split())
s = h1 * 60 + m1
e = h2 * 60 + m2
print(e - k - s) | n = int(input())
for i in range(n):
a = list(map(int, input().split()))
m = max(a)
b = sum([i**2 for i in a if i != m])
if (m**2 == b):
print("YES")
else:
print("NO") | 0 | null | 9,056,241,937,518 | 139 | 4 |
import bisect
h,w,k=map(int,input().split())
s=["."*(w+2)]+["."+input()+"." for i in range(h)]+["."*(w+2)]
l=[[0]*(w+2) for i in range(h+2)]
ans=1
for i in range(1,h+1):
for j in range(1,w+1):
if s[i][j]=='#':
l[i][j]=ans
ans+=1
A=1
ss=[]
for i in range(1,h+1):
if list(set(s[i]))!=['.']:
ss.append(i)
for j in range(1,w+1):
if l[i][j]!=0:
A=l[i][j]
elif l[i][j]==0:
l[i][j]=A
A+=1
for i in range(1,h+1):
if i not in ss:
z=bisect.bisect_left(ss,i)
if z==len(ss):
l[i]=l[ss[z-1]]
else:
l[i]=l[ss[z]]
for i in range(1,h+1):
print(" ".join(map(str,l[i][1:-1])))
| n = int(input())
taro = 0
hanako = 0
for i in range(n):
t,h =input().split()
if t > h:
taro+=3
elif t<h:
hanako += 3
else:
taro += 1
hanako += 1
print("%d %d" % (taro,hanako)) | 0 | null | 72,522,444,629,740 | 277 | 67 |
n = int(input())
numList = map(int,input().split())
numList = list(numList)
multiplyList = []
start = 0
for i in range(n+1):
start += 1
for j in range(start, n):
multiplyList.append(numList[i] * numList[j])
print(sum(multiplyList)) | n=int(input())
l=list(map(int,input().split()))
prod=0
for i in range(n):
for j in range(i+1,n):
prod=prod+(l[i]*l[j])
print(prod)
| 1 | 168,447,094,936,372 | null | 292 | 292 |
# AOJ ITP1_9_A
# ※大文字と小文字を区別しないので注意！！！！
# 全部大文字にしちゃえ。
def main():
W = input().upper() # 大文字にする
line = ""
count = 0
while True:
line = input().split(" ")
if line[0] == "END_OF_TEXT": break
for i in range(len(line)):
word = line[i].upper()
if W == word: count += 1
print(count)
if __name__ == "__main__":
main()
# Accepted.
| import fileinput
W = input()
cnt = 0
for T in fileinput.input():
if T.rstrip() =='END_OF_TEXT':
break
T = T.lower().split()
cnt += T.count(W)
# print(T, cnt)
print(cnt)
| 1 | 1,827,892,883,128 | null | 65 | 65 |
import sys
read=sys.stdin.readline
class SEGTree:
def __init__(self,n):
self.Unit=0
i=1
while(i<n):
i*=2
self.SEG=[self.Unit]*(2*i-1)
self.d=i
def update(self,i,x):
i+=self.d-1
self.SEG[i]=1<<x
while i>0:
i=(i-1)//2
self.SEG[i]=self.SEG[i*2+1]|self.SEG[i*2+2]
def find(self,a,b,k,l,r):
if r<=a or b<=l:
return self.Unit
if a<=l and r<=b:
return self.SEG[k]
else:
c1=self.find(a,b,2*k+1,l,(l+r)//2)
c2=self.find(a,b,2*k+2,(l+r)//2,r)
return c1|c2
def get(self,a,b):
return self.find(a,b,0,0,self.d)
def bitcnt(x):
res=0
while x>0:
if x&1:
res+=1
x//=2
return res
n=int(input())
s=input()
q=int(input())
seg=SEGTree(n)
for i in range(n):
seg.update(i,ord(s[i])-97)
for i in range(q):
q,x,y=read().rstrip().split()
if q=='1':
seg.update(int(x)-1,ord(y)-97)
else:
x,y=int(x)-1,int(y)
bit=seg.get(x,y)
print(bitcnt(bit)) | import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
# import heapq
import decimal
# import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
s = list(input())
q = ni()
alphabet_idx = {}
for i in range(26):
alphabet_idx[i] = []
for i, si in enumerate(s):
alphabet_idx[ord(si) - ord("a")].append(i)
for _ in range(q):
qi, a, b = input().split()
qi, a = int(qi), int(a)
if qi == 1:
a -= 1
if s[a] == b:
continue
del_char = ord(s[a]) - ord("a")
del_idx = bisect.bisect_left(alphabet_idx[del_char], a)
del alphabet_idx[del_char][del_idx]
insert_char = ord(b) - ord("a")
insert_idx = bisect.bisect_left(alphabet_idx[insert_char], a)
alphabet_idx[insert_char].insert(insert_idx, a)
s[a] = b
if qi == 2:
b = int(b)
a -= 1
b -= 1
ans = 0
for i in range(26):
a_idx = bisect.bisect_left(alphabet_idx[i], a)
if a_idx < len(alphabet_idx[i]):
if alphabet_idx[i][a_idx] <= b:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 1 | 62,458,776,405,180 | null | 210 | 210 |
H, W, K = map(int, input().split())
S = [input() for _ in range(H)]
def count(n):
A = [0]
c = 0
i = 1
while(n):
if n & 1:
A.append(i)
c += 1
n >>= 1
i += 1
A.append(H)
return c, A
ans = 2000
for n in range(1 << (H-1)):
c, A = count(n)
X = [0]*(len(A)-1)
j = 0
flag=True
while j < W:
for k in range(len(A)-1):
for i in range(A[k], A[k+1]):
if S[i][j] == "1":
X[k] += 1
for x in X:
if x > K:
if flag:
c += 10000
break
flag = True
c += 1
X = [0]*(len(A)-1)
break
else:
flag = False
j += 1
if c > 10000:
break
ans = min(ans, c)
print(ans)
| A,B,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
l=[]
for i in range(m):
x,y,c=map(int,input().split())
l.append(a[x-1]+b[y-1]-c)
l.append(min(a)+min(b))
print(min(l)) | 0 | null | 51,008,499,144,018 | 193 | 200 |
import sys
def input(): return sys.stdin.readline().rstrip()
def dfs(s,mxs):
if len(s)==n:
print(s)
else:
for i in range(ord('a'),ord(mxs)+1):
dfs(s+chr(i),chr(i+1) if i ==ord(mxs) else mxs)
def main():
global n
n=int(input())
dfs('','a')
if __name__=='__main__':
main() | import sys
import itertools
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: map(int, read().split())
in_s = lambda: readline().rstrip().decode('utf-8')
def main():
N = in_n()
ans = []
def dfs(s):
if len(s) == N:
ans.append(s)
return
maxs = max(map(ord, s))
for i in range(ord('a'), maxs + 2):
dfs(s + chr(i))
dfs('a')
print('\n'.join(sorted(ans)))
if __name__ == '__main__':
main()
| 1 | 52,568,384,761,270 | null | 198 | 198 |
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') | n = int(input())
list01 = input().split()
x = 0
for i in list01:
if int(i) % 2 != 0:
pass
elif int(i) % 3 == 0:
pass
elif int(i) % 5 == 0:
pass
else:
x += 1
break
if x == 1:
print('DENIED')
else:
print('APPROVED') | 1 | 69,126,357,019,452 | null | 217 | 217 |
from collections import Counter
s = input()
MOD = 2019
ts = [0]
cur = 0
for i, j in enumerate(s[::-1], 1):
cur = (cur + pow(10, i, MOD) * int(j)) % MOD
ts.append(cur)
ct = Counter(ts)
res = 0
for k, v in ct.items():
if v > 1:
res += v * (v-1) // 2
print(res) | def main():
N = int(input())
x, y = map(int, input().split())
a1 = x + y
a2 = x + y
b1 = y - x
b2 = y - x
N -= 1
while N != 0:
x, y = map(int, input().split())
a1 = max(a1, x + y)
a2 = min(a2, x + y)
b1 = max(b1, y - x)
b2 = min(b2, y - x)
N = N - 1
print(max(a1 - a2, b1 - b2))
main()
| 0 | null | 17,070,598,244,724 | 166 | 80 |
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
#from fractions import gcd
def debug(*args):
if debugmode:
print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 998244353
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True
n2 = [1 for _ in range(3010)]
for i in range(1, 3010):
n2[i] = n2[i - 1] * 2 % mod
n, s = MAP()
a = LIST()
dp = [[0 for _ in range(s + 1)] for _ in range(n)]
if s >= a[0]:
dp[0][a[0]] = 1
for i in range(1, n):
for j in range(1, min(s + 1, a[i])):
dp[i][j] = dp[i - 1][j] * 2
dp[i][j] %= mod
if a[i] <= s:
dp[i][a[i]] = dp[i - 1][a[i]] * 2 + n2[i]
dp[i][a[i]] %= mod
for j in range(a[i] + 1, s + 1):
dp[i][j] = dp[i - 1][j] * 2 + dp[i - 1][j - a[i]]
dp[i][j] %= mod
print(dp[n - 1][s])
| n = int(input())
def dfs(n, s, idx):
l = len(s)
if n == l:
print(s)
return
alpha = "abcdefghijklmnopqrstuvwxyz"
i = 0
while i < idx + 1:
if i == idx:
dfs(n, s + alpha[i], idx + 1)
else:
dfs(n, s + alpha[i], idx)
i += 1
dfs(n, "", 0)
| 0 | null | 34,891,997,369,140 | 138 | 198 |
import itertools
N, X, Y = map(int, input().split())
# 距離が0,1,2,...,n-1のパスの本数
l = [0] * N
# 1,2,...,Nから2つを選ぶ組み合わせ
# 生成される組み合わせ(i,j)は既にi<jになっている
comb = itertools.combinations(range(1, N + 1), 2)
# (直接iとjを繋ぐ)or(特殊なパスを通る)の２種類が考えられる
# 両方計算してminを取れば欲しい距離が得られる
for v in comb:
min_dist = min(v[1] - v[0], abs(X - v[0]) + 1 + abs(Y - v[1]))
l[min_dist] += 1
# 距離が1,2,3,...,N-1について総数を出力
for item in l[1:]:
print(item)
| import sys
from scipy.sparse.csgraph import floyd_warshall
N, M, L = map(int, input().split())
INF = 10 **9 +1
G = [[float('inf')] * N for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
a, b, = a - 1, b -1
G[a][b] = c
G[b][a] = c
#全点間最短距離を計算
G = floyd_warshall(G)
#コストL以下で移動可能な頂点間のコスト1の辺を張る
E = [[float('inf')] * N for i in range(N)]
for i in range(N):
for j in range(N):
if G[i][j] <= L:
E[i][j] = 1
#全点間最短距離を計算
E = floyd_warshall(E)
#クエリに答えていく
Q = int(input())
for i in range(Q):
s, t = map(int, input().split())
s, t = s - 1, t-1
print(int(E[s][t] - 1) if E[s][t] != float('inf') else -1) | 0 | null | 108,979,616,582,550 | 187 | 295 |
n, k = map(int, (input().split()))
n %= k
print(min(n, abs(n-k))) | k = int(input())
s = input()
print(s[:k] + ('...' if len(s) > k else ''))
| 0 | null | 29,418,662,493,558 | 180 | 143 |
N = int(input())
A = list(map(int,input().split()))
ans = [ 0 for _ in range(N)]
for i in A:
ans[i-1] += 1
print(*ans,sep='\n') | temp = input()
temp = int(temp)
if temp<-40 or temp>40:
print('Out')
elif temp >=30:
print('Yes')
else:
print('No') | 0 | null | 19,096,109,814,052 | 169 | 95 |
class Comb():
def __init__(self, n, p):
# O(n)
fct, inv = [1, 1], [1, 1]
a, b = 1, 1
for i in range(2, n + 1):
a = (a * i) % p
b = (b * pow(i, p - 2, p)) % p
fct.append(a)
inv.append(b)
self.fct = fct
self.inv = inv
self.n = n
self.p = p
def calc(self, n, r):
fct, inv = self.fct, self.inv
if (r < 0 or n < r):
return 0
else:
return fct[n] * inv[r] * inv[n - r] % p
N, K = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
B = A[::-1]
p = 10 ** 9 + 7
cmb = Comb(N, p)
ans = 0
for n in range(N - K + 1):
c = cmb.calc(N - n - 1, K-1)
ans -= A[n] * c % p
ans += B[n] * c % p
print(ans % p)
| from sys import stdin
n = int(stdin.readline())
M = [None]
M += [list(map(int, stdin.readline().split()[2:])) for i in range(n)]
sndf = [None]
sndf += [[False, i] for i in range(1, n + 1)]
tt = 0
def dfs(u):
global tt
sndf[u][0] = True
tt += 1
sndf[u].append(tt)
for v in M[u]:
if not sndf[v][0]:
dfs(v)
tt += 1
sndf[u].append(tt)
for i in range(1, n + 1):
if not sndf[i][0]:
dfs(i)
for x in sndf[1:]:
print(*x[1:]) | 0 | null | 47,873,298,468,930 | 242 | 8 |
n, m = map(int,input().split())
a = [[0]*m for i in range(n)]
b = [0]*m
for i in range(n):
a[i] = list(map(int,input().split()))
for j in range(m):
b[j] = int(input())
c = [0]*n
for i in range(n):
for j in range(m):
c[i] += a[i][j] * b[j]
for i in c:
print(i)
| n,m = map(int,input().split())
kakeru = [list(map(int,input().split())) for _ in range(n)]
kakerareru = [int(input()) for _ in range(m)]
for a in range(n):
kotae = 0
for b in range(m):
kotae += kakeru[a][b]*kakerareru[b]
print(kotae) | 1 | 1,139,465,490,580 | null | 56 | 56 |
n, u, v = map(int, input().split())
u -= 1
v -= 1
ab = [list(map(int, input().split())) for _ in range(n - 1)]
adj = [[] for _ in range(n)]
for a, b in ab:
a -= 1
b -= 1
adj[a].append(b)
adj[b].append(a)
def dfs(s):
d = [-1] * n
d[s] = 0
stack = [s]
while stack:
frm = stack.pop()
for to in adj[frm]:
if d[to] == -1:
d[to] = d[frm] + 1
stack.append(to)
return d
du = dfs(u)
dv = dfs(v)
ans = 0
for eu, ev in zip(du, dv):
if eu < ev:
ans = max(ans, ev - 1)
print(ans)
| import sys
n = int(sys.stdin.readline().rstrip("\n"))
if n % 2 == 0:
print(n // 2)
else:
print(n // 2 + 1) | 0 | null | 88,086,139,330,500 | 259 | 206 |
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)) | #!/usr/bin/python3
import sys
from collections import Counter
input = lambda: sys.stdin.readline().strip()
n = int(input())
a = [int(x) for x in input().split()]
c = Counter(a)
def c2(n):
return n * (n - 1) // 2
ans = sum(c2(v) for v in c.values())
def add(x):
global ans
ans -= c2(c[x])
c[x] += 1
ans += c2(c[x])
def remove(x):
global ans
ans -= c2(c[x])
c[x] -= 1
ans += c2(c[x])
for x in a:
remove(x)
print(ans)
add(x) | 1 | 47,557,131,113,128 | null | 192 | 192 |
n=int(input())
l=list(map(int,input().split()))
c=1
s=0
for i in l:
if(i==c):
c+=1
else:
s+=1
if(s==n):
print(-1)
else:
print(s) | n = int(input())
a = list(map(int,input().split()))
k = 1
c = 0
for i in range(n):
if a[i] != k:
c+=1
elif a[i] == k:
k += 1
if c==n:
print(-1)
else:
print(c) | 1 | 114,797,215,931,930 | null | 257 | 257 |
import math
K = int(input())
result = 0
for a in range(1, K+1):
for b in range(1, K+1):
r = math.gcd(a, b)
for c in range(1, K+1):
result += math.gcd(r, c)
print(result)
| a = input()
b = input()
c = 0
d = 0
for x in a:
if x != b[c]:
d += 1
c += 1
print(d) | 0 | null | 23,200,995,371,708 | 174 | 116 |
def az8():
xs = map(int,raw_input().split())
a,b = xs[0],xs[1]
print (a/b),(a%b), "%5f"%(float(a)/b)
az8() | import string
c = input()
abc_list = list(string.ascii_lowercase)
for num,string in enumerate(abc_list):
if string == c:
print(abc_list[num+1]) | 0 | null | 46,214,191,544,740 | 45 | 239 |
bingoSheet = [0 for x in range(9)]
for i in range(3):
bingoRow = input().split()
for j in range(3):
bingoSheet[i*3 + j] = int(bingoRow[j])
bingoCount = int(input())
responses = []
for i in range(bingoCount):
responses.append(int(input()))
hasBingo = False
step = 1
initialIndex = 0
for i in range(3):
firstIndex = i*3
subList = [bingoSheet[index] for index in [firstIndex, firstIndex+1, firstIndex+2]]
if (all(elem in responses for elem in subList)):
hasBingo = True
break
for i in range(3):
firstIndex = i
subList = [bingoSheet[index] for index in [firstIndex, firstIndex+3, firstIndex+6]]
if (all(elem in responses for elem in subList)):
hasBingo = True
break
subList = [bingoSheet[index] for index in [0, 4, 8]]
if (all(elem in responses for elem in subList)):
hasBingo = True
subList = [bingoSheet[index] for index in [2, 4, 6]]
if (all(elem in responses for elem in subList)):
hasBingo = True
if hasBingo:
print('Yes')
quit()
print('No')
quit()
| a = [list(map(int,input().split())) for _ in range(3)]
n = int(input())
b = [int(input()) for _ in range(n)]
for i in b:
for j in range(3):
for k in range(3):
if a[j][k] == i:
a[j][k] = 0
a_2 = list(zip(*a))
flag_1 = sum(a[0]) == 0 or sum(a[1]) == 0 or sum(a[2]) == 0
flag_2 = sum(a_2[0]) == 0 or sum(a_2[1]) == 0 or sum(a_2[2]) == 0
flag_3 = a[0][0] + a[1][1] + a[2][2] == 0 or a[0][2] + a[1][1] + a[2][0] == 0
print(['No','Yes'][flag_1 or flag_2 or flag_3]) | 1 | 59,732,187,779,508 | null | 207 | 207 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import defaultdict
def main():
N = int(input())
ans = defaultdict(int)
for i in range(1, 110):
for j in range(1, 110):
for k in range(1, 110):
v = i*i+j*j+k*k+i*j+j*k+k*i
ans[v] += 1
for i in range(1, N+1):
print(ans[i])
if __name__ == '__main__':
main()
| import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
ans = [0]*N
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
val = x**2+y**2+z**2+x*y+y*z+z*x
if val<=N:
ans[val-1] += 1
for v in ans:
print(v) | 1 | 8,019,664,502,180 | null | 106 | 106 |
import sys
sys.setrecursionlimit(10**7)
def input(): return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def readInt():return int(input())
def readIntList():return list(map(int,input().split()))
def readStringList():return list(input())
def readStringListWithSpace():return list(input().split())
def readString():return input()
n = readInt()
text = readStringList()
import collections
c = collections.Counter(text)
if c['W'] == 0:
print("0")
exit()
i,j,count = 0,len(text)-1,0
while i <= j and i < len(text):
if text[i] == 'W':
while text[j] != 'R' and j > 0:
j -= 1
if i <= j and j > 0:
text[i],text[j] = text[j],text[i]
count += 1
i += 1
print(count)
| r=int(input())
import math
c=2*r*math.pi
print("{0:.6}".format(c)) | 0 | null | 18,778,948,600,298 | 98 | 167 |
W = input()
lis = []
cot = 0
while True:
x = input().split()
if x == ["END_OF_TEXT"]:
break
lis += x
for y in lis:
if y.lower() == W:
cot += 1
print(str(cot))
| n = int(input())
if n % 2 == 0:
ans = n / 2 - 1
else:
ans = n / 2
print(int(ans)) | 0 | null | 77,781,298,310,100 | 65 | 283 |
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 6 12:21:24 2020
@author: liang
"""
import math
pi = 3.141592653589793238
h, m, H, M = map(int,input().split())
print(math.sqrt(h**2+m**2-2*h*m*math.cos(2*pi*(30*H-5.5*M)/360))) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def main():
n, p = map(int, input().split())
s = list(input())
if 10 % p == 0:
ans = 0
for i in range(n):
if (ord(s[i])-ord('0')) % p == 0:
ans += i+1
print(ans)
return
d = [0] * (n+1)
ten = 1
for i in reversed(range(n)):
a = (ord(s[i])-ord('0')) * ten % p
d[i] = (d[i+1]+a) % p
ten *= 10
ten %= p
cnt = [0] * p
ans = 0
for i in reversed(range(n+1)):
ans += cnt[d[i]]
cnt[d[i]] += 1
print(ans)
main()
| 0 | null | 39,326,419,228,138 | 144 | 205 |
import sys
input = sys.stdin.readline
n, s = map(int,input().split())
A = list(map(int,input().split()))
mod = 998244353
l = 3050
M = [1] # i!のmod
m = 1
for i in range(1, l):
m = (m * i) % mod
M.append(m)
def pow(x, y, mod): # x**y の mod を返す関数
ans = 1
while y > 0:
if y % 2 == 1:
ans = (ans * x) % mod
x = (x**2) % mod
y //= 2
return ans
def inv(x, mod): # x の mod での逆元を返す関数
return pow(x, mod-2, mod)
D = [0] * 3050
M2 = [1]
M2I = [0] * l
for i in range(l-1):
M2.append((M2[-1] * 2) % mod)
for i in range(l):
M2I[i] = inv(M2[i], mod)
i2 = inv(2,mod)
D[0] = M2[n]
for i in range(n):
for j in range(l-1,-1,-1):
if j - A[i] >= 0:
D[j] = (D[j] + D[j-A[i]] * i2) % mod
# print(D[:10])
print(D[s])
| def main():
N = int(input())
ans = 0
for x in range(1, N + 1):
# x(1+2+3+...+e)
e = N // x
ans += x * e * (1 + e) // 2
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 14,365,570,099,920 | 138 | 118 |
class UnionFind:
def __init__(self, num):
self.parent = [-1] * num
def find(self, node):
if self.parent[node] < 0:
return node
self.parent[node] = self.find(self.parent[node])
return self.parent[node]
def union(self, node1, node2):
node1 = self.find(node1)
node2 = self.find(node2)
if node1 == node2:
return
if self.parent[node1] > self.parent[node2]:
node1, node2 = node2, node1
self.parent[node1] += self.parent[node2]
self.parent[node2] = node1
return
def same(self, node1, node2):
return self.find(node1) == self.find(node2)
def size(self, x):
return -self.parent[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.parent) if x < 0]
def group_count(self):
return len(self.roots())
n, m = map(int, input().split())
uf = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
uf.union(a, b)
print(uf.group_count() - 1)
| n = int(input())
d = list(map(int, input().split()))
dist = [0]*n
for i in range(n):
dist[d[i]] += 1
ans = 1
if d[0]!=0:
ans = 0
elif dist[0] != 1:
ans = 0
else:
for i in range(2,n):
if dist[i-1]==0 and dist[i]!=0:
ans = 0
break
elif dist[i] == 0:
continue
else:
for j in range(dist[i]):
ans *= dist[i-1]
if ans > 998244353:
ans %= 998244353
print(ans)
| 0 | null | 78,588,208,355,900 | 70 | 284 |
import sys
while True:
cards = sys.stdin.readline().strip()
if cards == "-":
break
n = int(sys.stdin.readline())
for i in range(n):
h = int(sys.stdin.readline())
cards = cards[h:] + cards[:h]
print(cards) | A,B,C = list(map(int,input().split(" ")))
print(C,A,B) | 0 | null | 19,828,304,709,342 | 66 | 178 |
H1, M1, H2, M2, K = map(int, input().split())
x = H1*60+M1
y = H2*60+M2
print(y-x-K) | def main():
import sys
input = lambda: sys.stdin.readline().rstrip()
h1, m1, h2, m2, k = map(int, input().split())
m = 60 - m1
h1 += 1
m += (h2 - h1)*60 + m2
print(max(0, m - k))
main() | 1 | 18,134,455,197,220 | null | 139 | 139 |
n,k = map(int, input().split())
ans = 0
for i in range(k,n+2):
a = (i-1)*i//2
ans += n*i-2*a+1
print(ans%(10**9+7)) | from itertools import accumulate
N,K = map(int,input().split())
acc = list(accumulate(range(N+1), lambda x,y:x+y))
ans = 0
mod = 10**9+7
for i in range(K, N+1):
r = acc[N] - acc[N-i]
l = acc[i-1]
ans = (ans+r-l+1) % mod
ans += 1
print(ans % mod) | 1 | 32,907,857,685,248 | null | 170 | 170 |
R, C, K = map(int, input().split())
items = [[0] * C for _ in range(R)]
for i in range(K):
r, c, v = map(int, input().split())
items[r-1][c-1] = v
dp = [[0] * 4 for _ in range(C)]
for i in range(R):
dp2 = [[0] * 4 for _ in range(C)]
for j in range(C):
if j != 0:
dp2[j] = dp2[j-1][:]
dp2[j][0] = max(dp2[j][0], max(dp[j]))
for k in range(3, 0, -1):
dp2[j][k] = max(dp2[j][k], dp2[j][k-1] + items[i][j])
dp = dp2
print(max(dp[-1]))
| import sys
input=sys.stdin.readline
def main():
r,c,k=map(int,input().split())
item=[[0]*c for i in range(r)]
for i in range(k):
R,C,v=map(int,input().split())
item[R-1][C-1]=v
dp0=[[-10**10]*c for i in range(r)]
dp1 = [[-10 ** 10] * c for i in range(r)]
dp2 = [[-10 ** 10] * c for i in range(r)]
dp3 = [[-10 ** 10] * c for i in range(r)]
if item[0][0]==0:
dp0[0][0]=0
else:
dp0[0][0]=0
dp1[0][0]=item[0][0]
for i in range(r):
for j in range(c):
if j!=c-1:
v=item[i][j+1]
if v==0:
dp0[i][j+1]=max(dp0[i][j],dp0[i][j+1])
dp1[i][j + 1] = max(dp1[i][j], dp1[i][j + 1])
dp2[i][j + 1] = max(dp2[i][j], dp2[i][j + 1])
dp3[i][j + 1] = max(dp3[i][j], dp3[i][j + 1])
else:
dp0[i][j+1]=max(dp0[i][j],dp0[i][j+1])
dp1[i][j+1]=max(dp0[i][j]+v,dp1[i][j],dp1[i][j+1])
dp2[i][j + 1] = max(dp1[i][j] + v, dp2[i][j], dp2[i][j + 1])
dp3[i][j + 1] = max(dp2[i][j] + v, dp3[i][j], dp3[i][j + 1])
if i!=r-1:
v=item[i+1][j]
if v==0:
dp0[i+1][j]=max(dp0[i][j],dp1[i][j],dp2[i][j],dp3[i][j],dp0[i+1][j])
else:
dp0[i+1][j]=max(dp0[i][j],dp1[i][j],dp2[i][j],dp3[i][j],dp0[i+1][j])
dp1[i + 1][j] = max(dp0[i][j]+v, dp1[i][j]+v, dp2[i][j]+v, dp3[i][j]+v, dp1[i + 1][j])
ans=max(dp0[r-1][c-1],dp1[r-1][c-1],dp2[r-1][c-1],dp3[r-1][c-1])
print(ans)
if __name__=='__main__':
main() | 1 | 5,527,602,549,040 | null | 94 | 94 |
n = int(input())
A = list(map(int,input().split()))
ANS=[0]*(n)
for i in range(n-1):
a=A[i]
ANS[a-1]+=1
for i in range(n):
print(ANS[i]) | n = int(input())
a = list(map(int, input().split()))
sub_list = [0] * n
for i in (a):
sub_list[i - 1] += 1
for i in range(n):
print(sub_list[i], sep = ',')
| 1 | 32,592,632,206,428 | null | 169 | 169 |
from itertools import permutations
n = int(input())
p = tuple(map(int,input().split()))
q = tuple(map(int,input().split()))
for i,j in enumerate(permutations(range(1, n+1))):
if j == p:
a = i
if j == q:
b = i
print(abs(a-b)) | import itertools
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
num = [i for i in range(1,n+1)]
lst = list(itertools.permutations(num))
pos_p = 0
pos_q = 0
for i in range(len(lst)):
temp = list(lst[i])
if temp == p:
pos_p = i
if temp == q:
pos_q = i
print(abs(pos_p - pos_q))
| 1 | 100,658,510,489,508 | null | 246 | 246 |
import sys
N = int(input())
mod = pow(10, 9)+7
if N < 3:
print(0)
sys.exit()
ans = 1
for j in range(2, N//3+1):
r = j-1
n = N-j*3+r
bunshi = 1
bunbo = 1
for i in range(r):
bunshi = (bunshi*(n-i)) % mod
bunbo = (bunbo*(i+1)) % mod
ans = (ans+(bunshi*pow(bunbo, -1, mod))) % mod
print(ans)
| 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) | 0 | null | 44,738,148,532,188 | 79 | 234 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
N, M, K = map(int, input().split())
md = 998244353
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % md )
inverse.append( ( -inverse[md % i] * (md//i) ) % md )
g2.append( (g2[-1] * inverse[-1]) % md )
def cmb(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % md
def cnt(k):
ret = pow(M-1, N-1-k, md)
ret *= cmb(N-1,k)
ret %= md
ret *= M
ret %= md
return ret
def main():
rt = 0
for k in range(K+1):
rt += cnt(k)
rt %= md
print(rt)
if __name__ == '__main__':
main()
| n = int(input()); s = input().split()
q = int(input()); t = input().split()
cnt = 0
for i in t:
if i in s:
cnt += 1
print(cnt)
| 0 | null | 11,543,418,614,020 | 151 | 22 |
import math
n=int(input())
#def koch(p1,p2,n):
def koch(d,p1,p2):
if d==0:
return
#3等分する
s=[(2*p1[0]+1*p2[0])/3,(2*p1[1]+1*p2[1])/3]
t=[(1*p1[0]+2*p2[0])/3,(1*p1[1]+2*p2[1])/3]
#正三角形の頂点のひとつである座標を求める
u=[
(t[0]-s[0])*math.cos(math.radians(60))-(t[1]-s[1])*math.sin(math.radians(60))+s[0],
(t[0]-s[0])*math.sin(math.radians(60))+(t[1]-s[1])*math.cos(math.radians(60))+s[1]
]
koch(d-1,p1,s)
print(*s)
koch(d-1,s,u)
print(*u)
koch(d-1,u,t)
print(*t)
koch(d-1,t,p2)
print('0 0')
koch(n,[0,0],[100,0])
print('100 0')
| import math
def triangle(co1, co2):
ans = []
x1 = co1[0]
y1 = co1[1]
x2 = co2[0]
y2 = co2[1]
part1 = [(2 * x1 + x2) /3, (2 * y1 + y2) / 3]
part2 = [(x1 + 2 * x2) /3, (y1 + 2 * y2) / 3]
#part2をpart1中心に60度回転
edge = [(part2[0] - part1[0])/2 - (part2[1] - part1[1])/ 2 * math.sqrt(3) + part1[0], (part2[0] - part1[0])/2 * math.sqrt(3) + (part2[1] - part1[1])/ 2 + part1[1]]
ans.extend([part1, edge, part2, co2])
return ans
def rec(A, n):
if n == 0:
return
rec(A, n-1)
for i in range(4 ** (n-1)):
A[n].extend(triangle(A[n-1][i], A[n-1][i+1]))
n = int(input())
koch = [[[0.0, 0.0]] for i in range(n + 1)]
koch[0].append([100.0, 0.0])
rec(koch, n)
for i in range(4 ** n + 1):
print(*koch[n][i])
| 1 | 128,390,499,474 | null | 27 | 27 |
def inpl(): return list(map(int, input().split()))
print((int(input())-1)//2) | import sys
def ISI(): return map(int, sys.stdin.readline().rstrip().split())
n, r = ISI()
if n<10:
r+=100*(10-n)
print(r)
| 0 | null | 107,864,082,668,228 | 283 | 211 |
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 11:05:00 2020
@author: liang
"""
"""
片側を固定して、それぞれのケースに対して最適解を求める
それぞれのケースについて
index(b_i) =< index(b_i-1)
であるから、bの最大値bestを保存して探索することで重複探索を回避できる
"""
N, M, K = map(int, input().split())
A = [0] + [int(x) for x in input().split()]
B = [0] + [int(x) for x in input().split()]
s_b = 0
for i in range(M+1):
s_b += B[i]
if s_b > K:
s_b -= B[i]
best = i - 1
break
else:
best = M
res = best
#print(res)
s_a = 0
for i in range(N+1):
# print("i", i)
s_a += A[i]
if s_a > K:
break
for j in reversed(range(best+1)):
#print("j",j)
if s_b <= K - s_a:
if i + j > res:
res = i + j
best = j
#print(i, j, s_a, s_b)
break
else:
s_b -= B[j]
print(res) | from itertools import accumulate
import bisect
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
SA = [0] + list(accumulate(A))
SB = [0] + list(accumulate(B))
max_count = 0
for i in range(N + 1):
a_count = i
b_count = bisect.bisect_right(SB, K - SA[a_count]) - 1
if b_count >= 0:
count = a_count + b_count
if count > max_count:
max_count = count
print(max_count) | 1 | 10,785,258,845,440 | null | 117 | 117 |
def main():
n = int(input())
s = input()
ans = s.count('R') * s.count('G') * s.count('B')
for i in range(n-2):
for j in range(i+1, n-1):
if j - i > n - j - 1:
break
if s[i] != s[j] and s[j] != s[2*j-i] and s[2*j-i] != s[i]:
ans -= 1
print(ans)
if __name__ == '__main__':
main() | import sys
def I(): 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 = I()
s = list(input())
r = s.count('R')
g = s.count('G')
b = s.count('B')
cnt = r*g*b
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(cnt)
if __name__ == '__main__':
main() | 1 | 36,170,014,178,934 | null | 175 | 175 |
#!/usr/bin/env python3
import sys
from collections import deque
def input(): return sys.stdin.readline().rstrip()
def main():
N, D, A = map(int, input().split())
mlist = []
for _ in range(N):
x, h = map(int, input().split())
mlist.append([x, (h+A-1)//A])
mlist.sort(key=lambda x: x[0])
db = deque()
dnotb = deque()
left = mlist[0][0]
ans = 0
for monster in mlist:
if monster[0] <= left+2*D:
db.append(monster)
else:
dnotb.append(monster)
ans = 0
while db or dnotb:
if not db:
monster = dnotb.popleft()
monster[1] += ans
db.append(monster)
bmonster = db.popleft()
while dnotb:
if dnotb[0][0] <= bmonster[0]+2*D:
monster = dnotb.popleft()
monster[1] += ans
db.append(monster)
else:
break
ans = max(ans, bmonster[1])
print(ans)
if __name__ == '__main__':
main()
| from bisect import *
from math import *
N,D,A=map(int,input().split())
monsters=[list(map(int,input().split())) for _ in range(N)]
monsters.sort(key=lambda x:x[0])
killingrange=[0]*N
monsterspoint=[]
monstershp=[]
imos=[0]*N
for i in range(N):
monsterspoint.append(monsters[i][0])
monstershp.append(monsters[i][1])
for i in range(N):
ind=bisect(monsterspoint,monsterspoint[i]+2*D)
killingrange[i]=ind
#print(killingrange)
cnt=0
for i in range(N):
monstershp[i]=monstershp[i]+imos[i]
if (monstershp[i]>0):
cnt=cnt+ceil(monstershp[i]/A)
imos[i]=imos[i]-A*ceil(monstershp[i]/A)
if killingrange[i]<N:
imos[killingrange[i]]=imos[killingrange[i]]+A*ceil(monstershp[i]/A)
monstershp[i]=monstershp[i]-A*ceil(monstershp[i]/A)
if i<N-1:
imos[i+1]=imos[i]+imos[i+1]
#print(monstershp,imos)
print(cnt) | 1 | 82,392,170,235,172 | null | 230 | 230 |
import string
n = int(input())
s = input()
alpha = [chr(i) for i in range(65, 65+26)]
res = ""
for c in s:
po = alpha.index(c)
po = po + n
if po > 25:
po = po - 26
res = res + alpha[po]
print(res) | def readinput():
n=int(input())
l=list(map(int,input().split()))
return n,l
def main(n,a):
MOD=10**9+7
hist=[0]*61
bs=[]
for i in range(n):
# s=list(reversed(bin(a[i])[2:]))
# for j in range(len(s)):
# if s[j]=='1':
# hist[j]+=1
# bs.append(s)
s=bin(a[i])[2:]
for j in range(len(s)):
if s[j]=='1':
hist[len(s)-j-1]+=1
# j=0
# ai=a[i]
# while ai>0:
# if ai&1==1:
# hist[j]+=1
# ai = ai >> 1
# j+=1
#print(bs)
#print(hist)
#print(hist)
sum=0
# for i in range(n-1):
# s=bs[i]
# b=1
# for j in range(len(s)):
# if s[j]=='0':
# sum=(sum+hist[j]*b)%MOD
# else:
# sum=(sum+( n-i-hist[j] )*b)%MOD
# hist[j]-=1
# b*=2
# for j in range(len(s),61):
# sum=(sum+hist[j]*b)%MOD
# b*=2
b=1
for j in range(61):
sum=(sum+( hist[j]*(n-hist[j])*b )%MOD )%MOD
b*=2
return sum
if __name__=='__main__':
n,l=readinput()
ans=main(n,l)
print(ans)
| 0 | null | 128,682,361,062,540 | 271 | 263 |
def stringconcant(S,T):
a=S
b=T
c=a+b
return c
S,T = input().split()
a = stringconcant(T,S)
print(a) | import sys
def main():
N = int(sys.stdin.readline().rstrip())
S = sys.stdin.readline().rstrip()
cnt = 0
for i in range(10):
pos_1 = S.find(str(i))
if pos_1 == -1 or pos_1 > N - 3:
continue
for j in range(10):
pos_2 = S[pos_1 + 1:].find(str(j))
if pos_2 == -1 or pos_2 > N - 2:
continue
for k in range(10):
pos_3 = S[pos_1 + 1 + pos_2 + 1:].find(str(k))
if pos_3 != -1:
cnt += 1
print(cnt)
main()
| 0 | null | 115,676,346,582,690 | 248 | 267 |
import numpy as np
from numba import njit
@njit('i8(i8)', cache=True)
def solve(x):
count = np.zeros(x + 1, dtype=np.int64)
for i in range(1, x + 1):
for j in range(i, x + 1, i):
count[j] += j
return count.sum()
if __name__ == "__main__":
x = int(input())
print(solve(x))
| n = int(input())
ans = 0
for i in range(1, n+1):
g = n // i
ans += i * (g*(g+1))//2
print(ans)
| 1 | 11,099,990,192,540 | null | 118 | 118 |
n = int(input())
mod = 10**9 + 7
per = [1] * (n+1)
for i in range(1, n+1):
per[i] = per[i-1] * i
per[i] %= mod
inv = [1] * (n+1)
inv[-1] = pow(per[-1], mod-2, mod)
for j in range(2, n+2):
inv[-j] = inv[-j+1] * (n-j+2)
inv[-j] %= mod
def C(n, k):
cmb = per[n] * inv[k] * inv[n-k]
cmb %= mod
return cmb
total = 0
for k in range(1, n+1):
if n < 3*k:
break
total += C(n-2*k-1, k-1)
total %= mod
print(total)
| import sys
S = int(sys.stdin.readline())
mod = 10**9 + 7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, 2*S+1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
def nCr(n, r, mod=10**9+7):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % mod
ans = 0
n = 1
n_max = S // 3
while n <= n_max:
res = S - 3 * n
tmp = nCr(res + n - 1, n - 1)
# print(n, res, tmp)
ans += tmp
ans %= mod
n += 1
print(ans) | 1 | 3,278,788,786,468 | null | 79 | 79 |
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF = float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353
N = int(input())
if N % 2 == 0:
print(0.5)
else:
print(1.0-((N-1)//2.0)/N)
| s=input()
p=input()
print('Yes' if p in s+s else 'No') | 0 | null | 89,174,759,888,550 | 297 | 64 |
while 1:
m, f, r = map(int, raw_input().split())
if m == -1 and f == -1 and r == -1:
break
else:
if m == -1 or f == -1:
print 'F'
elif m+f >= 80:
print 'A'
elif m+f >= 65 and m+f < 80:
print 'B'
elif m+f >= 50 and m+f < 65:
print 'C'
elif m+f >= 30 and m+f < 50:
if r >= 50:
print 'C'
else:
print 'D'
else:
print 'F' | A=[]
while True:
#midterm exam score(50) : m
#final exam score(50) : f
#retest score(100) : r
m,f,r = [int(i) for i in input().split()]
if m == f == r == -1:
break
elif m==-1 or f==-1:
A.append('F')
elif m+f >= 80:
A.append('A')
elif 65<=m+f<80:
A.append('B')
elif (50<=m+f<65) or ((30<=m+f<50) and (50<=r)):
A.append('C')
elif (30<=m+f<50):
A.append('D')
else:
A.append('F')
for i in range(len(A)):
print(A[i]) | 1 | 1,211,636,369,460 | null | 57 | 57 |
a,b,c=map(int,raw_input().split())
if a+b >= c:
print "No"
else:
ans1 = 4 * a * b;
ans2 = (c - a - b) * (c - a - b)
if ans1 < ans2:
print "Yes"
else:
print "No" | MOD = 10**9+7
k = int(input())
s = input()
n = len(s)
U = n+k
fact = [0]*(U+1)
fact[0] = 1
for i in range(1, U+1):
fact[i] = fact[i-1]*i % MOD
invfact = [0]*(U+1)
invfact[U] = pow(fact[U], MOD-2, MOD)
for i in reversed(range(U)):
invfact[i] = invfact[i+1]*(i+1) % MOD
def nCr(n, r):
if r < 0 or n < r:
return 0
return fact[n]*invfact[r]*invfact[n-r]
ans = 0
for x in range(k+1):
ans += pow(26, x, MOD)*nCr(n+k-x-1, n-1)*pow(25, k-x, MOD)
ans %= MOD
print(ans) | 0 | null | 32,242,454,297,958 | 197 | 124 |
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
xyc = [map(int, input().split()) for _ in range(M)]
x, y, c = [list(x) for x in zip(*xyc)]
m = min(a)+min(b)
for i in range(M):
tmp = a[x[i]-1]+b[y[i]-1]-c[i]
m = min(m, tmp)
print(m) | A, B, M = map(int, input().split())
la = list(map(int, input().split()))
lb = list(map(int, input().split()))
prm_min = min(la) + min(lb)
lcost = list()
for i in range(M):
x, y, c = map(int, input().split())
lcost.append(la[x-1] + lb[y-1] - c)
print(min(min(lcost), prm_min)) | 1 | 54,340,915,701,732 | null | 200 | 200 |
turn=int(input())
ten=[0,0]
for _ in range(turn):
hikaku = input().split()
if hikaku[0] < hikaku[1]:
ten[1] +=3
elif hikaku[0] > hikaku[1]:
ten[0] +=3
else:
ten[0]+=1
ten[1]+=1
print(" ".join(map(str,ten))) | #! python3
# stable_sort.py
import copy
def num_from_card(card):
return int(card[1:])
def bubble_sort(A, N):
A_ = copy.copy(A)
flag = True
while flag:
flag = False
for i in range(N-1, 0, -1):
if num_from_card(A_[i]) < num_from_card(A_[i-1]):
A_[i-1], A_[i] = A_[i], A_[i-1]
flag = True
return A_
def selection_sort(A, N):
A_ = copy.copy(A)
for i in range(N-1):
minj = i
for j in range(i, N):
if num_from_card(A_[j]) < num_from_card(A_[minj]):
minj = j
if i != minj:
A_[i], A_[minj] = A_[minj], A_[i]
return A_
def is_stable(A, sorted_A, N):
A_nums = [int(x[1:]) for x in A]
same_num = [x for x in set(A_nums) if A_nums.count(x) > 1]
A_symbols, sorted_A_symbols = [], []
flag = 'Stable'
for num in same_num:
if [card[0] for card in A if int(card[1:]) == num] != [card[0] for card in sorted_A if int(card[1:]) == num]:
flag = 'Not stable'
break
return flag
N = int(input())
cards = [x for x in input().split(' ')]
bubble_sorted = bubble_sort(cards, N)
selection_sorted = selection_sort(cards, N)
print(' '.join(bubble_sorted))
print(is_stable(cards, bubble_sorted, N))
print(' '.join(selection_sorted))
print(is_stable(cards, selection_sorted, N))
| 0 | null | 999,769,724,854 | 67 | 16 |
import itertools
def actual(n, D):
"""
combinations でゴリ押し
"""
comb = itertools.combinations(D, 2)
# return sum([x * y for x, y in comb])
"""
「順番を考慮しない2要素の選び方」を全探索する際のポイント
内側のループ変数の始点を外側のループ変数 +1 から始めるとよい。
これにより、内側のループで選ぶインデックスが必ず外側のループで選ぶインデックスより大きくなり、
同じ選び方を 2 回見てしまうことを回避できます。
"""
# s = 0
# for i in range(len(D)):
# for j in range(i + 1, len(D)):
# s += D[i] * D[j]
#
# return s
"""
O(N)で解くパターン
ex: a, b, c, d
a*b + a*c + a*d = a * (b + c +d)
b*c + b*d = b * ( c +d)
c*d = c * ( d)
"""
s = 0
for i in range(len(D) - 1):
s += D[i] * sum(D[i + 1:])
return s
n = int(input())
D = list(map(int, input().split()))
print(actual(n, D))
| N = list(map(int,input().split()))
value = list(map(int,input().split()))
sum = 0
newValue = sorted(value)
for i in range(N[1]):
sum = sum + newValue[i]
print(sum) | 0 | null | 89,956,138,738,752 | 292 | 120 |
import sys
import collections
S=collections.deque(input())
Q=int(input())
rev=0
for _ in range(Q):
fields=next(sys.stdin).split()
T,F,C=(fields+['',''])[:3]
if T=='1':
rev^=1
elif (rev and F=='1') or (not rev and F=='2'):
S.append(C)
else:
S.appendleft(C)
if rev:
print(''.join(reversed(S)))
else:
print(''.join(S))
| n = int(input())
a = list(map(int,input().split()))
cnt = 0
for v in a:
if v == cnt+1:
cnt += 1
print(-1 if cnt==0 else n-cnt) | 0 | null | 85,939,109,808,650 | 204 | 257 |
n = int(input())
A = list(map(int, input().rstrip().split(" ")))
q = int(input())
M = list(map(int, input().rstrip().split(" ")))
existBits = 1
for a in A:
existBits |= existBits << a
if(__name__ == '__main__'):
for m in M:
judge = (existBits << m)
if(((existBits >> m) & 1) == 1):
print("yes")
else:
print("no")
| import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
sys.setrecursionlimit(10 ** 7)
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
def floyd_warshall(n, dist):
for i in range(n):
for j in range(n):
for k in range(n):
dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k])
n, m, l = na()
abc = nan(m)
q = ni()
st = nan(q)
g = [[] for _ in range(n)]
dist = [[inf] * n for _ in range(n)]
for i in range(m):
a, b, c = abc[i]
a -= 1
b -= 1
dist[a][b] = c
dist[b][a] = c
floyd_warshall(n, dist)
ans = [[inf] * n for _ in range(n)]
for i in range(n):
for j in range(n):
if dist[i][j] <= l:
ans[i][j] = 1
ans[j][i] = 1
floyd_warshall(n, ans)
for i in range(q):
s, t = st[i]
s -= 1
t -= 1
if ans[s][t] >= inf:
print(-1)
else:
print(ans[s][t] - 1) | 0 | null | 86,535,433,065,242 | 25 | 295 |
A,B = map(int,input().split())
if A - 2*B > 0 :
print(A-2*B)
else :
print("0") | a, b = list(map(int, input().split()))
print(a - 2 * b) if a > 2 * b else print(0)
| 1 | 166,140,403,876,612 | null | 291 | 291 |
n=int(input())
arr=list(map(int,input().strip().split()))
ans=[0]*n
for i in range(n):
ans[arr[i]-1]=i+1
print(*ans,sep=" ") | def main():
N = int(input())
for i in range(1, 10):
if N // i < 10 and N % i == 0:
print('Yes')
return
print('No')
main() | 0 | null | 169,830,933,441,510 | 299 | 287 |
n = int(input())
a = 0
b = 0
for i in range(n):
A,B = map(str,input().split())
if A>B:
a += 3
elif B>A:
b += 3
else:
a += 1
b += 1
print('%d %d' % (a,b))
| n = input()
p = [0] * 2
for i in range(n):
t, h = raw_input().split()
if(t > h):
p[0] += 3
elif(t < h):
p[1] += 3
else:
p[0] += 1
p[1] += 1
print("%d %d" %(p[0], p[1])) | 1 | 1,996,196,108,588 | null | 67 | 67 |
H = int(input())
import math
def caracal(H):
if H == 1:
return 1
return 2*caracal(math.floor(H/2)) + 1
print(caracal(H))
| from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
@functools.lru_cache(None)
def aa(k):
if k > 1: return 2*aa(k//2) + 1
return 1
h = int(stdin.readline().rstrip())
print(aa(h)) | 1 | 79,807,186,849,568 | null | 228 | 228 |
N = int(input())
def sum(n):
return (n + 1) * n // 2
print(sum(N) - sum(N // 3) * 3 - sum(N // 5) * 5 + sum(N // 15) * 15)
| N = int(input())
SUM = 0
for i in range(1, N + 1):
if i % 3 != 0:
if i % 5 != 0:
SUM += i
print(SUM) | 1 | 34,818,595,003,640 | null | 173 | 173 |
import math
N=int(input())
sum=0
for i in range(1,N+1):
for j in range(1,N+1):
x=math.gcd(i,j)
for k in range(1,N+1):
y=math.gcd(x,k)
sum = sum+y
print(sum) | from math import gcd
k=int(input())
ans=0
for i in range(1,k+1):
for j in range(1,k+1):
ans_=gcd(i,j)
for l in range(1,k+1):
ans+=gcd(ans_,l)
print(ans) | 1 | 35,484,100,877,860 | null | 174 | 174 |
X, K, D = map(int, input().split())
X = abs(X)
point = X % D
q = X // D
ans = 0
if q >= K:
ans = abs(X-D*K)
elif (K - q) % 2 == 0:
ans = point
else:
ans = D-point
print(ans) | import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
mod = 998244353
n, k = LI()
l = [0 for _ in range(k)]
r = [0 for _ in range(k)]
for i in range(k):
l[i], r[i] = LI()
dp = [0 for _ in range(n+1)]
dpsum = [0 for _ in range(n+1)]
dp[1], dpsum[1] = 1, 1
for i in range(2,n+1):
for el, er in zip(l, r):
dp[i] += dpsum[max(i-el, 0)] - dpsum[max(i-er-1, 0)]
dp[i] %= mod
dpsum[i] = (dpsum[i-1] + dp[i])%mod
print(dp[n])
main()
| 0 | null | 3,949,139,711,932 | 92 | 74 |
import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
INF = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
ans = 0
for x in range(1, N + 1):
n = N // x # Nのうちにxがいくつ含まれるか（等差数列の項数）
ans += (n * (2 * x + (n - 1) * x)) // 2 # 初項と公差がxでn項の等差数列の和
print(ans)
if __name__ == '__main__':
main()
| n = int(input())
c = list(input())
r = 0
w = 0
for i in range(len(c)):
if(c[i]=="R"):
r += 1
ans = max(r,w)
for i in range(len(c)):
if(c[i]=="R"):
r -= 1
else:
w += 1
now = max(r,w)
ans = min(ans,now)
print(ans) | 0 | null | 8,656,305,496,410 | 118 | 98 |
rooms = [0] * (4*3*10)
n = input();
for i in xrange(n):
b,f,r,v = map(int, raw_input().split())
rooms[(b-1)*30+(f-1)*10+(r-1)] += v
sep = "#" * 20
for b in xrange(4):
for f in xrange(3):
t = 30*b + 10*f
print ""," ".join(map(str, rooms[t:t+10]))
if b < 3: print sep | S,T=map(str,input().split())
ans = T+S
print(ans)
| 0 | null | 52,187,847,974,370 | 55 | 248 |
c = {
'S' : [0 for _ in range(13)], 'H' : [0 for _ in range(13)],
'C' : [0 for _ in range(13)], 'D' : [0 for _ in range(13)]
}
x = int(input())
for _ in range(x):
(a, b) = input().split()
b = int(b)
c[a][b - 1] = b
for a in ('S', 'H', 'C', 'D'):
for b in range(13):
if c[a][b] == 0:
print('{0:s} {1:d}'.format(a, b+1)) | from collections import OrderedDict
d = OrderedDict()
d['S'] = set()
d['H'] = set()
d['C'] = set()
d['D'] = set()
a = frozenset(range(1,14))
n = int(input())
for i in range(n):
s, r = input().split()
d[s].add(int(r))
for k, v in d.items():
racks = a.difference(v)
for rack in racks:
print(k, rack) | 1 | 1,053,709,004,366 | null | 54 | 54 |
N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H = sorted(H, reverse=True)
for i in range(min(K,len(H))):
H[i] = 0
print(sum(H)) | 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, groupby, combinations_with_replacement
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()
D = [len(set(LIST()))==1 for _ in range(N)]
for i in range(N):
if sum(D[i:i+3]) == 3:
print("Yes")
break
else:
print("No")
| 0 | null | 40,833,774,324,290 | 227 | 72 |
import sys
sys.setrecursionlimit(10**9)
INF = 110110110
H, W, K = list(map(int, input().split()))
S = [''] * H
for i in range(H):
S[i] = input()
ans = H * W
for bit in range(2**(H-1)):
cnt = bin(bit).count('1')
id = [0] * H
for i in range(H-1):
if bit>>i & 1:
id[i+1] = id[i] + 1
else:
id[i+1] = id[i]
num = [[0] * W for i in range(id[H-1]+1)]
for i in range(H):
for j in range(W):
if S[i][j] == '1':
num[id[i]][j] += 1
for i in range(id[H-1]+1):
for j in range(W):
if num[i][j] > K:
cnt = INF
sum = [0] * (id[H-1]+1)
for j in range(W):
need = False
for i in range(id[H-1]+1):
if sum[i] + num[i][j] > K:
need = True
if need:
cnt += 1
for i in range(id[H-1]+1):
sum[i] = num[i][j]
else:
for i in range(id[H-1]+1):
sum[i] += num[i][j]
ans = min(ans, cnt)
print(ans)
| #E
H,W,K = map(int,input().split())
S = [list(str(input())) for _ in range(H)]
inf = float("inf")
ans = inf
T = 2**(H-1)
for i in range(T):
b = bin(i)
b = b.lstrip("0b")
blist = list(b)
lb = len(b)
clist = blist[::-1]
while lb < H-1:
clist.append("0")
lb+=1
r = clist.count("1")
count = r
nw = [0]*(r+1)
for w in range(W):
nind = 0
for h in range(H):
if h > 0:
if clist[h-1] == "1":
nind+=1
if S[h][w] == "1":
nw[nind]+=1
if w == 0:
pass
else:
for k in nw:
if k > K:
count+=1
nw = [0]*(r+1)
nind = 0
for h in range(H):
if h > 0:
if clist[h-1] == "1":
nind+=1
if S[h][w] == "1":
nw[nind]+=1
if max(nw) > K:
count = inf
break
ans = min(ans,count)
print(ans)
| 1 | 48,498,726,898,700 | null | 193 | 193 |
S = input()
L = S.split()
a = L[0]
a = int(a)
b = L[1]
b = int(b)
if a < b:
print('a < b')
elif a > b:
print('a > b')
elif a == b:
print('a == b') | import sys
read = sys.stdin.read
def main():
h, n = map(int, input().split())
m = map(int, read().split())
mm = zip(m, m)
large_num = 10**9
dp = [large_num] * (h + 10**4 + 1)
dp[0] = 0
for a, b in mm:
for i1 in range(h + 1):
if dp[i1 + a] > dp[i1] + b:
dp[i1 + a] = dp[i1] + b
r = min(dp[h:])
print(r)
if __name__ == '__main__':
main() | 0 | null | 40,495,732,659,930 | 38 | 229 |
s = input()
n = len(s)
dp = [0 for _ in range(n)]
dp[-1] = int(s[-1])
memo = 0
cnt_dic = {}
tmp = 1
ans = 0
cnt_dic[0] = 1
for i in range(n-1, -1, -1):
memo = (memo + int(s[i]) * pow(10, n-i-1, 2019)) % 2019
if not memo in cnt_dic:
cnt_dic[memo] = 0
ans += cnt_dic[memo]
cnt_dic[memo] += 1
print(ans) | from collections import Counter
s = input()
n = len(s)
dp = [0]
mod = 2019
a = 0
for i in range(n):
a = a + int(s[n-i-1]) * pow(10, i, mod)
a %= mod
dp.append(a%mod)
ans = 0
c = Counter(dp)
for value in c.values():
ans += value * (value-1) / 2
print(int(ans)) | 1 | 30,765,068,856,060 | null | 166 | 166 |
A,B = input().split()
print((int(A)*round(100*float(B)))//100) | K=int(input())
A=0
for i in range(K):
A=(A*10+7)%K
if A%K==0:
print(i+1)
break
if i==K-1:print(-1) | 0 | null | 11,402,629,295,680 | 135 | 97 |
import sys
input = sys.stdin.readline
a, b = [int(x) for x in input().split()]
if 2*b >= a:
print(0)
else:
print(a - 2*b) | X = int(input())
for i in range(-201, 201):
done = False
for j in range(-201, 201):
if i ** 5 - j ** 5 == X:
print(i, j)
done = True
break
if done:
break | 0 | null | 95,832,753,003,328 | 291 | 156 |
n,m = map(int, input().split())
l = n - m
if l== 0:
print('Yes')
else:
print('No') | n,m=input().split()
if(n==m):
print("Yes\n")
else:
print("No\n")
| 1 | 83,239,223,283,830 | null | 231 | 231 |
#!/usr/bin/env python3
import collections as cl
import sys
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, M = MI()
S, C = [], []
for i in range(M):
s, c = MI()
S.append(s - 1)
C.append(c)
ans = [-1] * N
for i in range(M):
if ans[S[i]] != -1 and ans[S[i]] != C[i]:
print(-1)
exit()
ans[S[i]] = C[i]
if ans[0] == 0:
if N != 1:
print(-1)
exit()
else:
print(0)
exit()
if N == 1 and ans[0] == -1:
print(0)
exit()
for i in range(N):
if ans[i] == -1:
ans[i] = 0 if i != 0 else 1
ans[i] = str(ans[i])
print("".join(ans))
main()
| n=int(input())
c= sorted(list(map(int, input().split())), reverse=True)
l = len(c)
m = l//2
ans = c[0]
if l%2 == 0:
for i in range(1,m):
ans += 2*c[i]
else:
for i in range(1,m):
ans += 2*c[i]
ans += c[m]
print(ans) | 0 | null | 34,917,456,635,332 | 208 | 111 |
al =["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
C = input()
kk = al.index(C)
print(al[kk+1])
| N = input()
ans = 'Yes' if '7' in N else 'No'
print(ans) | 0 | null | 63,126,080,342,710 | 239 | 172 |
import sys
def m():
d={};input()
for e in sys.stdin:
if'f'==e[0]:print('yes'if e[5:]in d else'no')
else:d[e[7:]]=0
if'__main__'==__name__:m()
| class Dic:
def __init__(self):
self.end = False
self.a = self.c = self.g = self.t = 0
def insert(self, s):
node = self
index = 0
while index < len(s):
c = s[index]
child = 0
if c == 'A':
if not node.a:
node.a = Dic()
child = node.a
elif c == 'C':
if not node.c:
node.c = Dic()
child = node.c
elif c == 'G':
if not node.g:
node.g = Dic()
child = node.g
elif c == 'T':
if not node.t:
node.t = Dic()
child = node.t
else:
return
node = child
index += 1
node.end = True
def find(self, s):
node = self
index = 0
while index < len(s):
c = s[index]
child = 0
if c == 'A':
child = node.a
elif c == 'C':
child = node.c
elif c == 'G':
child = node.g
elif c == 'T':
child = node.t
if child == 0:
return False
node = child
index += 1
return node.end
dic = Dic()
n = int(input())
for _ in range(n):
cmd = list(input().split())
if cmd[0] == 'insert':
dic.insert(cmd[1])
elif cmd[0] == 'find':
print('yes' if dic.find(cmd[1]) else 'no')
| 1 | 77,221,696,662 | null | 23 | 23 |
import numpy as np
N=int(input())
A=np.array(list(map(int,input().split())))
'''
以下、方針
・Aから、各要素の出現回数を取得する。
・出現回数から、組み合わせを計算する。
'''
uni,cou=np.unique(A,return_counts=True)
# print(uni)
# print(cou)
dic0={}
dic1={}
dic={} #回答用
com=[]
for i in range(len(cou)):
c=cou[i]*(cou[i]-1)//2
dic0[uni[i]]=cou[i]
dic1[uni[i]]=c
com.append(c)
dic.setdefault(uni[i])
# print(com)
totalcombination=sum(com)
# print(com)
# print(dic1)
'''
以下方針
・Aから数字を取得
・その数字に対応する組み合わせを減らす。
・その数字の出現回数を1減らした状態の組み合わせの数を足す。
'''
for j in range (N):
n=A[j] #nはAの数列の数字
if dic[n]==None:
e=(dic0[n]-1)*(dic0[n]-2)//2
t=totalcombination-dic1[n]+e
dic[n]=t
print(t)
else:
print(dic[n]) | n,p=map(int,input().split())
s=list(map(int,list(input()[::-1])))
if p in [2,5]:
ans=0
for i in range(n):
if s[-i-1]%p==0:ans+=i+1
print(ans)
exit()
from collections import defaultdict
d=defaultdict(int)
t=0
d[t]+=1
m=1
for i in range(n):
t+=m*s[i]
t%=p
d[t]+=1
m*=10
m%=p
print(sum(d[i]*(d[i]-1)//2 for i in range(p))) | 0 | null | 53,189,633,585,380 | 192 | 205 |
N = int(input())
a = list(map(int, input().split()))
Xsum = 0
for i in a:
Xsum = Xsum ^ i
ans = list()
for i in a:
s = Xsum ^ i
# print(s)
ans.append(str(s))
print(' '.join(ans)) | from functools import reduce
from operator import xor
# via https://drken1215.hatenablog.com/entry/2020/06/22/122500
N, *A = map(int, open(0).read().split())
B = reduce(xor, A)
print(*map(lambda a: B^a, A)) | 1 | 12,583,341,221,330 | null | 123 | 123 |
line = list(map(int,input().split()))
if line[0]==line[1]: op = '=='
if line[0]>line[1]: op = '>'
if line[0]<line[1]: op = '<'
print('a {op} b'.format(op=op)) | text = input()
ab = text.split()
a = int(ab[0])
b = int(ab[1])
if(a<b):
print("a < b")
elif(a>b):
print("a > b")
else:
print("a == b")
| 1 | 353,981,558,688 | null | 38 | 38 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.