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
|
|---|---|---|---|---|---|---|
while True:
try:
a, b = map(int, input().split())
i = a + b
c = 1
while i:
if int(i/10) == 0:
print(c)
break
c+=1
i /= 10
except Exception:
break | s = '0' + input()
m = len(s)
up = 0
cnt = 0
y = []
for i in range(-1, -m-1, -1):
cs = int(s[i]) + up
if cs < 5 or (cs == 5 and int(s[i-1]) < 5):
cnt += cs
y.append([cs, s[i]])
up = 0
else:
cnt += 10 - cs
y.append([10 - cs, s[i]])
up = 1
print(cnt) | 0 | null | 35,458,942,019,710 | 3 | 219 |
# Python3 implementation of the approach
# Function to find the number of divisors
# of all numbers in the range [1,n]
def findDivisors(n):
# List to store the count
# of divisors
div = [0 for i in range(n + 1)]
# For every number from 1 to n
for i in range(1, n + 1):
# Increase divisors count for
# every number divisible by i
for j in range(1, n + 1):
if j * i <= n:
div[i * j] += 1
else:
break
# Print the divisors
return div
# Driver Code
if __name__ == "__main__":
n = int(input())
print(sum(findDivisors(n-1)))
# This code is contributed by
# Vivek Kumar Singh
| n=int(input())
ans=0
for a in range(1,n):
x=(n-1)//a
ans+=x
print(ans)
| 1 | 2,616,947,462,500 | null | 73 | 73 |
from math import sqrt, ceil
def divisors(n):
out = []
nn = ceil(sqrt(n))
for i in range(1, nn):
if n % i == 0:
out.append(i)
out.append(n//i)
if nn ** 2 == n:
out.append(nn)
out.sort()
return out
n = int(input())
a = len(divisors(n-1)[1:])
d = divisors(n)
for dd in d[1:]:
nn = n
while nn % dd == 0:
nn = nn // dd
if nn % dd == 1:
a += 1
print(a)
| X,N = map(int, input().split())
P = list(map(int, input().split()))
table = [0] * 102
ans = X
dist = 102
for p in P:
table[p] = 1
for i in range(102):
if table[i] != 0:
continue
if abs(i - X) < dist:
ans = i
dist = abs(i - X)
elif abs(i - X) == dist:
ans = min(i, ans)
print(str(ans)) | 0 | null | 27,636,776,574,048 | 183 | 128 |
def main():
from collections import deque
N, M = (int(i) for i in input().split())
if N % 2 == 0:
A = deque([i+1 for i in range(N)])
for i in range(1, M+1):
if (N-i)-i > N//2:
print(A[i], A[N-i])
else:
print(A[i], A[N-i-1])
else:
A = deque([i for i in range(N)])
for i in range(1, M+1):
print(A[i], A[N-i])
if __name__ == '__main__':
main()
| import bisect
import copy
import heapq
import math
import sys
from collections import *
from itertools import accumulate, combinations, permutations, product
from math import gcd
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
n,m=map(int,input().split())
half=n//2
lst=[]
if n%2==1:
for i in range(m):
lst.append([half-i,half+i+1])
else:
for i in range(m):
if i%2==0:
lst.append([half-i//2,half+i//2+1])
else:
lst.append([1+i//2,n-1-i//2])
for i in range(m):
print(*lst[i])
# dic=defaultdict(int)
# for i in range(m):
# tmp=lst[i]
# dic[tmp[1]-tmp[0]]+=1
# dic[n-tmp[1]+tmp[0]]+=1
# print(dic)
| 1 | 28,577,744,006,240 | null | 162 | 162 |
N = int(input())
#U:0~9の整数でN桁の数列 = 10**N
#A:0を含まないN桁の数列 = 9**N
#B:9を含まないN桁の数列 = 9**N
#ans = |U-(A∪B)| = |U|-|A|-|B|+|A∩B|
MOD = 10**9 + 7
ans = pow(10, N, MOD) - pow(9, N, MOD) - pow(9, N, MOD) + pow(8, N, MOD)
ans %= MOD
print(ans) | # -*- coding: utf-8 -*-
import sys
from collections import deque
N,D,A=map(int, sys.stdin.readline().split())
XH=[ map(int, sys.stdin.readline().split()) for _ in range(N) ]
XH.sort()
q=deque() #（攻撃が無効となる座標、攻撃によるポイント）
ans=0
cnt=0
attack_point=0
for x,h in XH:
while q:
if x<q[0][0]:break #無効となる攻撃がない場合はwhileを終了
end_x,end_point=q.popleft()
attack_point-=end_point #攻撃が無効となる座標<=現在の座標があれば、その攻撃のポイントを引く
if h<=attack_point: #モンスターの体力よりも攻撃で減らせるポイントの方が大きければ新規攻撃は不要
pass
else: #新規攻撃が必要な場合
if h%A==0:
cnt=(h-attack_point)/A #モンスターの大量をゼロ以下にするために何回攻撃が必要か
else:
cnt=(h-attack_point)/A+1
attack_point+=cnt*A
q.append((x+2*D+1,cnt*A)) #（攻撃が無効となる座標、攻撃によるポイント）をキューに入れる
ans+=cnt
print ans | 0 | null | 42,596,837,371,004 | 78 | 230 |
def resolve():
L = list(map(int, input().split()))
print("Yes" if len(L)-1 == len(set(L)) else "No")
if '__main__' == __name__:
resolve() | A = [0] * 10
B = list(map(int, input().split()))
for i in range(len(B)):
A[B[i]] += 1
for i in range(len(A)):
if A[i] == 2:
print('Yes')
break
else:
print('No')
| 1 | 68,292,569,957,180 | null | 216 | 216 |
K=int(input())
S=input()
M=10**9+7
#----------------------------------------------------------------
f=1
Fact=[f]
for i in range(1,len(S)+K+1):
f=(f*i)%M
Fact.append(f)
Inv=[0]*(len(S)+K+1)
g=pow(f,M-2,M)
Inv=[0]*(len(S)+K+1)
Inv[-1]=g
for j in range(len(S)+K-1,-1,-1):
Inv[j]=(Inv[j+1]*(j+1))%M
def nCr(n,r):
if 0<=r<=n:
return (Fact[n]*Inv[r]*Inv[n-r])%M
else:
return 0
A=len(S)
T=0
for i in range(K+1):
T=(T+nCr(A+K-1-i,K-i)*pow(25,K-i,M)*pow(26,i,M))%M
print(T)
| MOD = 10 ** 9 + 7
def solveBrute(K, S):
# On the i-th iteration, dp[j] counts all strings of length i which contains S[:j] as a subsequence
N = len(S)
dp = [0] * (N + 1)
dp[0] = 1
for i in range(N + K):
nextDp = [0] * (N + 1)
for j in range(N):
nextDp[j] += dp[j] * 25
nextDp[j + 1] += dp[j]
nextDp[N] += dp[N] * 26
dp = nextDp
for j in range(N + 1):
dp[j] %= MOD
# print(dp)
return dp[N]
def solveBrute2(K, S):
import numpy as np
def matrixPower(mat, k):
assert k >= 0
if k == 0:
return np.eye(mat.shape[0], dtype=np.int64)
if k == 1:
return mat
temp = matrixPower(mat, k // 2)
ret = (temp @ temp) % MOD
if k % 2:
return (ret @ mat) % MOD
return ret
# For intution, can interpret the bruteforce as a matrix multiplication:
# {{0, 0, 0, 1}} . MatrixPower[{{25, 0, 0, 0}, {1, 25, 0, 0}, {0, 1, 25, 0}, {0, 0, 1, 26}}, 8] . {{1}, {0}, {0}, {0}}
# https://www.wolframalpha.com/input/?i=%7B%7B0%2C+0%2C+0%2C+1%7D%7D+.+MatrixPower%5B%7B%7B25%2C+0%2C+0%2C+0%7D%2C+%7B1%2C+25%2C+0%2C+0%7D%2C+%7B0%2C+1%2C+25%2C+0%7D%2C+%7B0%2C+0%2C+1%2C+26%7D%7D%2C+8%5D+.+%7B%7B1%7D%2C+%7B0%7D%2C+%7B0%7D%2C+%7B0%7D%7D
N = len(S)
mat = 25 * np.eye(N + 1, dtype=np.int64,)
mat[N][N] += 1
for i in range(N):
mat[i + 1][i] = 1
vec = np.zeros((N + 1, 1), dtype=np.int64)
vec[0] = 1
res = matrixPower(mat, N + K) @ vec
return int(res[N]) % MOD
def solve(K, S):
def modInverse(a, p):
# Fermat's little theorem, a**(p-1) = 1 mod p
return pow(a, p - 2, p)
# Precompute all factorials
fact = [1]
for i in range(1, 2 * (10 ** 6) + 1):
fact.append((fact[-1] * i) % MOD)
def nCr(n, r, p=MOD):
# Modulo binomial coefficients
return (fact[n] * modInverse(fact[r], p) * modInverse(fact[n - r], p)) % p
total = 0
N = len(S)
for i in range(N, N + K + 1):
total += nCr(N + K, i) * pow(25, N + K - i, MOD)
total %= MOD
return total
(K,) = [int(x) for x in input().split()]
S = input()
ans = solve(K, S)
# assert ans == solveBrute(K, S) == solveBrute2(K, S)
print(ans)
| 1 | 12,830,313,316,988 | null | 124 | 124 |
a=input()
cnt=0
for i in a:
if i=='R':
cnt+=1
if cnt==2 and len(a)==3:
if a[0]=='R' and a[2]=='R':
cnt=1
print(cnt)
| a, b = map(str, input().split())
ans = [a] * int(b) if int(a)<=int(b) else [b] * int(a)
print(''.join(ans)) | 0 | null | 44,586,745,893,096 | 90 | 232 |
import sys
N,K = map(int,input().split())
array_hight = list(map(int,input().split()))
if not ( 1 <= N <= 10**5 and 1 <= K <= 500 ): sys.exit()
count = 0
for I in array_hight:
if not ( 1 <= I <= 500): sys.exit()
if I >= K:
count += 1
print(count) | h = int(input())
counter = 0
while h > 0 :
h //= 2
counter += 1
print(pow(2, counter) - 1) | 0 | null | 129,529,789,881,440 | 298 | 228 |
N = int(input())
for i in range(1, 50000):
pay = int(i*1.08)
if pay == N:
print(i)
break
elif pay > N:
print(':(')
break | #!/usr/bin/env python3
import sys
import math
np = ":("
def solve(N: int):
ans = math.ceil(N/ 108 * 100)
if math.floor(ans * 1.08) != N:
print(np)
else:
print(ans)
return
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
solve(N)
if __name__ == '__main__':
main()
| 1 | 125,188,834,972,890 | null | 265 | 265 |
s=raw_input()
target=raw_input()
ring=s*2
ans="No"
for i in range(len(s)):
if ring[i:i+len(target)]==target:
ans="Yes"
break
print ans | a=[s for s in input()]*2
b=input()
w=False
for j in range(len(a)):
if a[j]==b[0]:
total=1
if len(b)==1:
print("Yes")
w=True
break
for i in range(1,len(b)):
if j+i==len(a):
print("No")
w=True
break
else:
if a[j+i]==b[i]:
total+=1
if total==len(b):
print("Yes")
w=True
break
else:
break
if w==True:
break
if w==False:
print("No")
| 1 | 1,770,586,465,748 | null | 64 | 64 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
N = int(readline())
first = []
second = []
for _ in range(N):
s = input()
l, r = 0, 0
cnt = 0
for char in s:
if char == "(":
cnt += 1
else:
if cnt > 0:
cnt -= 1
else:
l += 1
r = cnt
if r >= l:
first.append((l, r))
elif l > r:
second.append((l, r))
from operator import itemgetter
first.sort(key=itemgetter(0))
second.sort(key=itemgetter(1), reverse=True)
r_cur = 0
for x, y in first:
r_cur -= x
if r_cur < 0:
return print("No")
r_cur += y
for x, y in second:
r_cur -= x
if r_cur < 0:
return print("No")
r_cur += y
if r_cur == 0:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| # ABC155E
s = input()
d0 = [0,1,2,3,4,5,6,7,8,9]
d1 = [0,1,2,3,4,5,5,4,3,2] # 通常時
a0 = d1[int(s[0])]
a1 = d1[int(s[0]) + 1] if int(s[0])<=8 else 1
for c in s[1:]:
c = int(c)
b0 = min(a0 + c, a1 + (10 - c))
b1 = min(a0 + c + 1, a1 + (9 - c)) if c <=8 else a1
a0, a1 = b0, b1
print(a0) | 0 | null | 47,078,832,672,800 | 152 | 219 |
S, W = map(int, input().split(' '))
if S <= W:
print('unsafe')
else:
print('safe') | while 1:
(a,b,c) = map(int,raw_input().split())
if a == -1 and b == -1 and c == -1:
break
if a == -1 or b == -1:
print 'F'
elif a+b >= 80:
print 'A'
elif a+b >= 65:
print 'B'
elif a+b >= 50:
print 'C'
elif a+b >= 30:
if c >= 50:
print 'C'
else:
print 'D'
else:
print 'F' | 0 | null | 15,194,051,155,532 | 163 | 57 |
def nCk(n, k):
if k > n or min(n, k) < 0:
return 0
res = 1
for i in range(1, k + 1):
res = res * (n - i + 1) // i
return res
def solveSmaller():
return 9 ** k * nCk(n - 1, k)
def solveDp():
global k
dp = [[[0 for _ in range(2)] for _ in range(k + 1)] for _ in range(n)] # i, used k, smaller
dp[0][1][0] = 1
dp[0][1][1] = int(s[0]) - 1
cnt = 1
for i in range(1, n):
cnt += s[i] != '0'
for k in range(1, k + 1):
dp[i][k][0] = cnt == k
dp[i][k][1] = dp[i - 1][k][1] + \
(dp[i - 1][k][0] if s[i] != '0' else 0) + \
dp[i - 1][k - 1][1] * 9 + \
dp[i - 1][k - 1][0] * max(0, int(s[i]) - 1)
return dp[n - 1][k][0] + dp[n - 1][k][1]
s = input()
k = int(input())
n = len(s)
print(solveSmaller() + solveDp()) | S = input()
L = len(S)
K = int(input())
dp = [[[0,0] for _ in range(K+1)] for _ in range(L+1)]
dp[0][0][0] = 1
for i,c in enumerate(S):
c = int(c)
for k in reversed(range(K+1)):
for d in range(10):
nk = k + (d>0)
if nk > K: continue
dp[i+1][nk][1] += dp[i][k][1]
if d > c: continue
less = int(d < c)
dp[i+1][nk][less] += dp[i][k][0]
print(sum(dp[-1][-1])) | 1 | 75,978,351,569,172 | null | 224 | 224 |
A, B, m = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
minp = min(a) + min(b)
for i in range(m):
x, y, c = map(int,input().split())
minp = min(minp, a[x-1] + b[y-1] -c)
print(minp) | import sys
from math import gcd
from collections import defaultdict
sys.setrecursionlimit(10**7)
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 LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
mod = 10**9+7
plus = defaultdict(int)
minus = defaultdict(int)
flag = defaultdict(int)
A_zero,B_zero = 0,0
zero_zero = 0
for i in range(N):
a,b = MI()
if a == b == 0:
zero_zero += 1
elif a == 0:
A_zero += 1
elif b == 0:
B_zero += 1
else:
if a < 0:
a,b = -a,-b
a,b = a//gcd(a,b),b//gcd(a,b)
if b > 0:
plus[(a,b)] += 1
else:
minus[(a,b)] += 1
flag[(a,b)] = 1
ans = 1
for a,b in plus.keys():
ans *= pow(2,plus[(a,b)],mod)+pow(2,minus[(b,-a)],mod)-1
ans %= mod
flag[(b,-a)] = 0
for key in minus.keys():
if flag[key] == 1:
ans *= pow(2,minus[key],mod)
ans %= mod
ans *= pow(2,A_zero,mod)+pow(2,B_zero,mod)-1
ans %= mod
ans += zero_zero-1
ans %= mod
print(ans)
| 0 | null | 37,689,840,838,132 | 200 | 146 |
S = input()
hi = []
for i in range(5):
hi.append("hi"*(i+1))
print("Yes" if S in hi else "No") | a,b,c,k=map(int,input().split())
if(k<=a):
print(k)
else:
print(a-(k-a-b)) | 0 | null | 37,547,442,332,330 | 199 | 148 |
x=input().split()
W,H,x,y,r=int(x[0]),int(x[1]),int(x[2]),int(x[3]),int(x[4])
if x<r or x>W-r or y<r or y>H-r:
print("No")
else:
print("Yes")
| import math
a, b, C = map(int, input().split())
rad = C/180*math.pi
print('%.8f' % (a*b*math.sin(rad)/2))
print('%.8f' % ((a**2-2*a*b*math.cos(rad)+b**2)**0.5 + a + b))
print('%.8f' % (b * math.sin(C/180*math.pi)))
| 0 | null | 304,419,643,348 | 41 | 30 |
# ALDS1_3_B
# coding: utf-8
from collections import deque
n, q = [int(i) for i in raw_input().split()]
d = deque()
for i in range(n):
name, time = raw_input().split()
time = int(time)
d.append([name, time])
total = 0
while len(d) > 0:
p = d.popleft()
if p[1] <= q: # 終わり
total += p[1]
print "{} {}".format(p[0], total)
else:
total += q
p[1] -= q
d.append(p)
| n,k=map(int,input().split())
a=list(map(int,input().split()))
f=list(map(int,input().split()))
a.sort()
f.sort(reverse=True)
ok=10**15
ng=-1
while ok-ng>1:
check=(ok+ng)//2
cnt=0
for i in range(n):
cnt+=(max(0,a[i]-check//f[i]))
if cnt > k:ng = (ok+ng)//2
else: ok = (ok+ng)//2
print(ok) | 0 | null | 82,305,863,793,020 | 19 | 290 |
H,W=map(int,input().split())
if H==1 or W==1:
print(1)
else:
print(0--H*W//2) | import math
A = list(map(int, input().split()))
H = A[0]
W = A[1]
first = math.ceil(H/2)
second = math.floor(H/2)
if H>= 2 and W>=2:
ans = math.ceil(W/2)*first + math.floor(W/2)*second
elif W==1:
ans = 1
elif H==1:
ans = 1
print(ans) | 1 | 51,068,516,111,558 | null | 196 | 196 |
N,K=map(int,input().split())
a=0
while N>0:
a+=1
N=N//K
print(a) | import math
n, k = map(int, input().split())
print(int(math.floor(math.log(n, k) + 1))) | 1 | 64,278,498,531,072 | null | 212 | 212 |
from sys import stdin
input = stdin.readline
def solve():
X = int(input())
check = (X - 400)//200
print(8 - check)
if __name__ == '__main__':
solve()
| #!/usr/bin/env python3
import sys
input = iter(sys.stdin.read().splitlines()).__next__
sys.setrecursionlimit(10000)
R = int(input())
res = -1
if R <= 599:
res = 8
elif R <= 799:
res = 7
elif R <= 999:
res = 6
elif R <= 1199:
res = 5
elif R <= 1399:
res = 4
elif R <= 1599:
res = 3
elif R <= 1799:
res = 2
elif R <= 1999:
res = 1
print(res)
| 1 | 6,667,991,726,270 | null | 100 | 100 |
# 解説を参考に作成
def solve():
N, M = map(int, input().split())
m = 0
# 奇数の飛び
oddN = M
oddN += (oddN + 1) % 2
for i in range(oddN // 2):
print(i + 1, oddN - i)
m += 1
if m == M:
return
# 偶数の飛び
for i in range(M):
print(oddN + i + 1, M * 2 + 1 - i)
m += 1
if m == M:
return
if __name__ == '__main__':
solve()
| from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
n = INT()
x = [[0]*2 for i in range(n)]
for i in range(n):
x[i][0], x[i][1] = MAP()
x.sort()
tmp = -inf
ans = n
for i in range(n):
if tmp > x[i][0] - x[i][1]:
ans -= 1
tmp = min(tmp, x[i][0] + x[i][1])
else:
tmp = x[i][0] + x[i][1]
print(ans) | 0 | null | 59,270,251,253,180 | 162 | 237 |
while True:
n = input()
if n == '0':
break
print(sum([int(x) for x in list(n)])) | N=int(input())
kouholist=[]
worddict=dict()
maxvalue=0
for i in range(N):
S=input()
if S in worddict.keys():
worddict[S]+=1
else:
worddict[S]=1
maxvalue=max(maxvalue,worddict[S])
#print("ここから")
#print(worddict)
for k in worddict.keys():
if worddict[k]==maxvalue:
kouholist.append(k)
kouholist=sorted(kouholist)
for h in range(len(kouholist)):
print(kouholist[h]) | 0 | null | 35,830,555,820,030 | 62 | 218 |
dic = set()
n = int(input())
for i in range(n):
cmd, val = input().split()
if cmd == "insert":
dic.add(val)
elif cmd == "find":
print("yes" if val in dic else "no")
else:
print("wrong command")
| def insert(cnt, data):
T[str(data)] = cnt
cnt = 0
T = {}
n = int(input())
for i in range(n):
Order, data_S = input().split()
if Order[0] =="i":
insert(cnt, data_S)
cnt +=1
else:
if str(data_S) in T:
print("yes")
else:
print("no")
| 1 | 80,390,031,358 | null | 23 | 23 |
def solve(x):
if x >= 30:
return "Yes"
else:
return "No"
def main():
x = int(input())
res = solve(x)
print(res)
def test():
assert solve(25) == "No"
assert solve(30) == "Yes"
if __name__ == "__main__":
test()
main()
| N = int(input())
N += 1
print(N // 2) | 0 | null | 32,509,788,221,088 | 95 | 206 |
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
d1 = T1 * (A1 - B1)
d2 = T2 * (A2 - B2)
if d1 > 0 and d1 + d2 > 0:
print(0)
elif d1 < 0 and d1 + d2 < 0:
print(0)
elif d1 + d2 == 0:
print("infinity")
else:
if d1 < 0:
d1 = -d1
d2 = -d2
ok = 0
ng = (d1 + d1) // (-d1 - d2) + 1
x = 0
while ok + 1 < ng:
mid = (ok + ng) // 2
s = mid * (d1 + d2)
if s + d1 > 0:
ok = mid
elif s + d1 == 0:
ok = mid
ng = ok + 1
x = -1
else:
ng = mid
print(ng * 2 - 1 + x) | #!/usr/bin python3
# -*- coding: utf-8 -*-
t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
s1 = a1 - b1
s2 = a2 - b2
# a1 が先行にする
if s1<0:
s1*=-1
s2*=-1
d = s1*t1 + s2*t2
mxd = s1*t1
if d>0:
print(0)
elif d==0:
print('infinity')
else:
if mxd%abs(d)==0:
print(mxd//abs(d)*2)
else:
print(mxd//abs(d)*2+1)
| 1 | 131,380,013,902,946 | null | 269 | 269 |
nii=lambda:map(int,input().split())
from collections import deque
n,u,v=nii()
u-=1
v-=1
tree=[[] for i in range(n)]
for i in range(n-1):
a,b=nii()
a-=1
b-=1
tree[a].append(b)
tree[b].append(a)
def BFS(s):
dist=[-1 for i in range(n)]
dist[s]=0
que=deque()
que.append(s)
while que:
x=que.popleft()
for i in tree[x]:
if dist[i]==-1:
que.append(i)
dist[i]=dist[x]+1
return dist
dist_t=BFS(u)
dist_a=BFS(v)
ans=0
for i in range(n):
if dist_a[i]>dist_t[i]:
ans=max(ans,dist_a[i]-1)
print(ans) | import sys
def input(): return sys.stdin.readline().rstrip()
def main():
x,y,a,b,c=map(int, input().split())
p=list(map(int, input().split()))
q=list(map(int, input().split()))
r=list(map(int, input().split()))
p.sort(reverse=True)
q.sort(reverse=True)
r.sort(reverse=True)
p=[10**10]+p[:x]
q=[10**10]+q[:y]
r+=[0]*(a+b)
ans=sum(p)+sum(q)-2*10**10
pcnt,qcnt=0,0
for i in range(x+y):
if p[-1-pcnt] >= r[i] and q[-1-qcnt] >= r[i]:
break
elif p[-1-pcnt] > q[-1-qcnt]:
ans += -q[-1-qcnt] + r[i]
qcnt +=1
else:
ans += -p[-1-pcnt] + r[i]
pcnt +=1
print(ans)
if __name__ == '__main__':
main() | 0 | null | 81,343,860,983,342 | 259 | 188 |
from collections import Counter
N,MOD=map(int,input().split())
S=input()
res=0
if MOD==2 or MOD==5:
for i in range(N):
if(int(S[N-i-1])%MOD==0):
res+=N-i
else:
Cum=[0]*(N+1)
for i in range(N):
Cum[i+1]=(Cum[i]+int(S[N-i-1])*pow(10,i,MOD))%MOD
c=Counter(Cum).most_common()
for a,b in c:
res+=b*(b-1)//2
print(res) | N, P = map(int, input().split())
S = input()
if 10 % P == 0:
ans = 0
for r in range(N):
if int(S[r]) % P == 0:
ans += r + 1
print(ans)
exit()
d = [0] * (N + 1)
ten = 1
for i in range(N - 1, -1, -1):
a = int(S[i]) * ten % P
d[i] = (d[i + 1] + a) % P
ten *= 10
ten %= P
cnt = [0] * P
ans = 0
for i in range(N, -1, -1):
ans += cnt[d[i]]
cnt[d[i]] += 1
print(ans) | 1 | 58,138,004,922,620 | null | 205 | 205 |
def myAnswer(N:int,A:int,B:int) -> int:
ans = 0
BN = N - B
A1 = A - 1
while True:
if((B - A) % 2== 0):
ans += (B - A)//2
break
elif(A == 1):
ans += 1
B -= 1
elif(B == N):
ans += 1
A += 1
else:
if(BN > A1):
ans +=A1
B -= A1
A = 1
else:
ans += BN
A += BN
B = N
return ans
def modelAnswer():
tmp=1
def main():
N,A,B = map(int,input().split())
print(myAnswer(N,A,B))
if __name__ == '__main__':
main() | x = 0
while x == 0:
m = map(int,raw_input().split())
if m[0] == 0 and m[1] == 0:
break
print "#" * m[1]
for i in xrange(m[0]-2):
print "#" + "." * (m[1]-2) + "#"
print "#" * m[1]
print "" | 0 | null | 55,030,406,916,548 | 253 | 50 |
n,k=map(int,input().split())
h=[int(x) for x in input().split() if int(x)>=k]
print(len(h)) | N,K = map(int,input().split())
import numpy as np
arr = np.array(input().split(),np.int64)
print(np.count_nonzero(arr>=K)) | 1 | 178,359,704,095,440 | null | 298 | 298 |
import sys
inp = sys.stdin
# inp = open("testdata.txt", "r")
def input():
return inp.readline().strip()
n, m, l = map(int, input().split())
def warshall_floyd(d):
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
adjl = [[float('inf') for j in range(n)] for i in range(n)]
for i in range(n):
adjl[i][i] = 0
for _ in range(m):
a, b, c = map(int, input().split())
adjl[a-1][b-1] = c
adjl[b-1][a-1] = c
adjl = warshall_floyd(adjl)
for i in range(n):
for j in range(n):
if i==j: adjl[i][j] = 0
else: adjl[i][j] = 1 if adjl[i][j] <= l else float("inf")
adjl = warshall_floyd(adjl)
q = int(input())
for _ in range(q):
a, b = map(int, input().split())
ans = adjl[a-1][b-1]
print(-1 if ans==float("inf") else ans-1) | import sys
input = sys.stdin.readline
N, K = map(int, input().strip().split(" "))
A = list(map(int, input().strip().split(" ")))
A = [0] + A
for i in range(1, N + 1):
A[i] += A[i - 1]
A[i - 1] -= i - 1
A[N] -= N
rem_count = {}
rem_count[0] = 1
ans = 0
for i in range(1, N + 1):
if i - K >= 0:
rem_count[A[i - K] % K] -= 1
if A[i] % K in rem_count:
ans += rem_count[A[i] % K]
rem_count[A[i] % K] += 1
else:
rem_count[A[i] % K] = 1
print(ans) | 0 | null | 155,408,212,328,468 | 295 | 273 |
A,B,C,D = map(int,input().split())
while A>=0 or C>=0:
C=C-B
if C <= 0:
print('Yes')
exit()
A=A-D
if A <=0:
print('No')
exit() | i = 1
while True:
n = input()
if n == 0:
break
else:
print "Case %d: %d" % (i, n)
i = i + 1 | 0 | null | 15,142,257,477,940 | 164 | 42 |
N = input()
print(N[:3])
|
x,y=map(int,input().split())
a=1
while a!=0:
if x>y:
a=x%y
else:
a=y%x
x=y
y=a
print(x)
| 0 | null | 7,356,657,275,170 | 130 | 11 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
plus = []
minus = []
for i in a:
if i >= 0: plus.append(i)
if i < 0: minus.append(-i)
plus.sort(reverse=True)
minus.sort(reverse=True)
ans = 1
if k == n:
for x in a:
ans = (ans * x) % mod
elif n == len(plus):
for x in plus[:k]:
ans = (ans * x) % mod
elif n == len(minus):
if k % 2 == 1:
ans = -1
minus.sort()
for x in minus[:k]:
ans = (ans * x) % mod
else:
i, j = 0, 0
if k % 2 == 1:
ans = plus[0]
i += 1
while i + j != k:
x_p = plus[i] * plus[i + 1] if i < len(plus) - 1 else 0
x_m = minus[j] * minus[j + 1] if j < len(minus) - 1 else 0
if x_p > x_m:
ans = (ans * x_p) % mod
i += 2
else:
ans = (ans * x_m) % mod
j += 2
print(ans) | n,k=map(int, input().split())
a = list(map(int, input().split()))
mod=10**9+7
if n==k:
ans=1
for i in range(k):
ans*=a[i]
ans%=mod
print(ans)
exit()
minus=[i for i in a if i<0]
plus=[i for i in a if i>=0]
from collections import deque
minus=deque(sorted(minus))
plus=deque(sorted(plus,reverse=True))
n_minus=len(minus)
n_plus=len(plus)
if n_minus==n:
ans=1
if k%2==0:
for i in range(k):
ans*=minus.popleft()
ans+=mod
ans%=mod
print(ans)
exit()
else:
for i in range(k):
ans*=minus.pop()
ans+=mod
ans%=mod
print(ans)
exit()
cnt_minus=0
cand=deque([])
for i in range(k):
if not plus or ((plus and minus) and abs(minus[0])>abs(plus[0])):
cand.append(minus.popleft())
cnt_minus+=1
elif not minus or ((plus and minus) and abs(minus[0])<abs(plus[0])):
cand.append(plus.popleft())
else:
if cnt_minus%2==1:
cand.append(minus.popleft())
cnt_minus+=1
else:
cand.append(plus.popleft())
if cnt_minus%2==0:
ans=1
for i in range(k):
ans*=cand[i]
ans+=mod
ans%=mod
print(ans)
exit()
if 0 in cand:
print(0)
exit()
tmpm,tmpp=None,None
for i in range(k-1,-1,-1):
if cand[i]<0 and tmpm==None:
tmpm=cand[i]
elif cand[i]>=0 and tmpp==None:
tmpp=cand[i]
#print(tmpm,tmpp)
cand1,cand2=None,None
if tmpm!=None and plus:
cand1=plus[0]/abs(tmpm)
if tmpp!=None and minus:
if tmpp!=0:
cand2=abs(minus[0])/abs(tmpp)
else:
cand2=0
if tmpp==0:
if minus:
ans=1
flg=True
for i in range(k):
if flg and cand[i]==tmpp:
flg=False
continue
ans*=cand[i]
ans+=mod
ans%=mod
print((ans*minus[0])%mod)
exit()
elif (cand1!=None and cand2==None) or ((cand1!=None and cand2!=None) and plus[0]*abs(tmpp)>=abs(minus[0]*tmpm)):
ans=1
flg=True
for i in range(k):
if flg and cand[i]==tmpm:
flg=False
continue
ans*=cand[i]
ans+=mod
ans%=mod
print((ans*plus[0])%mod)
exit()
elif (cand1==None and cand2!=None) or ((cand1!=None and cand2!=None) and plus[0]*abs(tmpp)<abs(minus[0]*tmpm)):
ans=1
flg=True
for i in range(k):
if flg and cand[i]==tmpp:
flg=False
continue
ans*=cand[i]
ans+=mod
ans%=mod
print((ans*minus[0])%mod)
exit() | 1 | 9,377,005,910,538 | null | 112 | 112 |
import math
h = int(input())
cnt = 0
while h > 1:
h = h // 2
cnt += 1
ans = 0
for i in range(cnt+1):
ans += 2 ** i
print(ans) | if input() == '0':
print(1)
else:
print(0) | 0 | null | 41,389,770,748,000 | 228 | 76 |
a1=list(map(int,input().split()))
a2=list(map(int,input().split()))
a3=list(map(int,input().split()))
n=int(input())
for i in range (n):
num=int(input())
if num in a1:
a1[a1.index(num)]='O'
if num in a2:
a2[a2.index(num)]='O'
if num in a3:
a3[a3.index(num)]='O'
if a1[0] == 'O' and a1[1] == 'O' and a1[2] == 'O':
print('Yes')
elif a2[0] == 'O' and a2[1] == 'O' and a2[2] == 'O':
print('Yes')
elif a3[0] == 'O' and a3[1] == 'O' and a3[2] == 'O':
print('Yes')
elif a1[0] == 'O' and a2[0] == 'O' and a3[0] == 'O':
print('Yes')
elif a1[1] == 'O' and a2[1] == 'O' and a3[1] == 'O':
print('Yes')
elif a1[2] == 'O' and a2[2] == 'O' and a3[2] == 'O':
print('Yes')
elif a1[0] == 'O' and a2[1] == 'O' and a3[2] == 'O':
print('Yes')
elif a1[2] == 'O' and a2[1] == 'O' and a3[0] == 'O':
print('Yes')
else:
print('No') | a = []
for i in range(3):
t = [int(x) for x in input().split()]
a.append(t)
n = int(input())
b = [int(input()) for i in range(n)]
m = [[0 for j in range(3)] for i in range(3)]
for i in range(3):
for j in range(3):
for k in b:
if (a[i][j] == k):
m[i][j] = 1
for i in range(3):
if (m[i][0] and m[i][1] and m[i][2]):
print("Yes")
exit()
for i in range(3):
if (m[0][i] and m[1][i] and m[2][i]):
print("Yes")
exit()
if ((m[0][0] and m[1][1] and m[2][2]) or (m[0][2] and m[1][1] and m[2][0])):
print("Yes")
exit()
print("No") | 1 | 59,703,228,411,388 | null | 207 | 207 |
n, k = map(int, input().split())
a = [0] + list(map(int, input().split()))
journey = [1]
for i in range(n):
journey.append(a[journey[i]])
if k <= n:
print(journey[k])
exit()
cycle_end = n
cycle_start = n - 1
while journey[cycle_start] != journey[cycle_end]:
cycle_start -= 1
cycle_range = cycle_end - cycle_start
cycle_cnt = (k - n) // cycle_range
extra = (k - n) - (cycle_range * cycle_cnt)
for i in range(extra):
journey.append(a[journey[i + n]])
print(journey[-1]) | N,K=map(int,input().split())
A=list(map(int,input().split()))
B=[0]*N
B[0]=1
if B[0] in A:c=B[0]
for i in range(1,N):
B[i]=A[B[i-1]-1]
d=B.index(B[-1])+1
if K<=N:print(B[K]);exit()
print(B[d-1+(K+1-d)%(N-d)])
| 1 | 22,732,685,136,392 | null | 150 | 150 |
#=============================================================================
# Breadth First Search
#=============================================================================
import queue
N=int(input())
Graph=[[] for _ in range(N+1)]
dist=[-1 for _ in range(N+1)]
for i in range(1,N+1):
Graph[i]=list(map(int,input().split()))[2:]
que=queue.Queue()
que.put(1)
dist[1]=0
while not que.empty():
v=que.get()
for nv in Graph[v]:
if dist[nv] != -1:
continue
dist[nv]=dist[v]+1
que.put(nv)
for i in range(1,N+1):
print(i,dist[i],sep=" ")
| #木ではない
#非連結成分
#処理済みの判定、辺の距離はすべて1なので一度到達すればよい
from collections import deque
n = int(input())
V = [[] for _ in range(n+1)]
for _ in range(n):
inpt = list(map(int,input().split( )))
if len(inpt)>2:
V[inpt[0]] = inpt[2:]
lrg = 10000
D = [lrg]*(n+1)
End = [0]*(n+1)
D[1] = 0
Deq = deque()
time = 1
Q = [1]
Deq.append(1)
while len(Deq) > 0:
v = Deq.popleft()
for i in V[v]:
D[i] = min(D[i],D[v]+1)
if End[i] == 0:
Deq.append(i)
End[i] = 1
for i in range(1,n+1):
if D[i]<lrg-1:
print(i,D[i])
else:
print(i,-1)
| 1 | 3,943,310,440 | null | 9 | 9 |
A, B, C, K = list(map(lambda x : int(x), input().split(" ")))
if A >= K:
print(K)
elif A + B >= K:
print(A)
else:
print(2 * A + B - K)
| inf = 10**10
n,m,l = map(int,input().split())
def warshall_floyd(d):
for i in range(n):
for j in range(n):
for k in range(n):
d[j][k] = min(d[j][k],d[j][i]+d[i][k])
return d
G = [[inf] * n for _ in range(n)] #重み付きグラフ
for i in range(n):
G[i][i] = 0
for _ in range(m):
a,b,c = map(int,input().split())
G[a-1][b-1] = c
G[b-1][a-1] = c
G = warshall_floyd(G)
P = [[0] * n for _ in range(n)]
for i in range(n):
for j in range(n):
if i == j:
P[i][j] = 0
elif G[i][j] <= l:
P[i][j] = 1
else:
P[i][j] = inf
p = warshall_floyd(P)
q = int(input())
for _ in range(q):
s,t = map(int,input().split())
ans = p[s-1][t-1]-1
print(ans if ans <= 10**9 else -1) | 0 | null | 97,970,920,577,888 | 148 | 295 |
import math
from functools import reduce
n,m = map(int, input().split())
A = list(map(int, input().split()))
def lcm_base(x,y):
return x*y//math.gcd(x,y)
def lcm(target_list):
return reduce(lcm_base, target_list)
A_gcd = reduce(math.gcd, A)
flg = True
for a in A:
if a//A_gcd%2==0:
flg = False
break
if flg:
min_x = int(lcm(A))//2
ans = m//min_x - m//(2*min_x)
print(ans)
else:
print(0) | N, M = map(int, input().split())
a = list(map(int, input().split()))
from math import floor
from fractions import gcd
from functools import reduce
def lcm(x, y):
return x * y // gcd(x, y)
b = [n // 2 for n in a]
lcm_b = reduce(lcm, b)
for n in b:
if (lcm_b // n) % 2 == 0:
print(0)
exit()
n = floor((M / lcm_b - 1) / 2) + 1
print(n)
| 1 | 101,663,729,373,778 | null | 247 | 247 |
n, m = map(int , input().split())
a = [int(num) for num in input().split()]
st = sum(a)
if (n >= st):
print(n-st)
else :
print(-1)
| n = int(input())
ans = 0
for i in range(1, n):
if i >= n - i:
break
ans += 1
print(ans) | 0 | null | 92,767,233,036,952 | 168 | 283 |
import math
n = int(input())
m = n//2
if n % 2 == 0:
print(m)
else:
print(m+1)
| n, m = map(int, input().split(' '))
def nCr(n, r):
if n < r:
return 0
ans = 1
for i in range (r):
ans *= (n-r+i+1)
ans = ans // (i+1)
return ans
print(nCr(n, 2) + nCr(m, 2)) | 0 | null | 52,544,025,850,030 | 206 | 189 |
N=int(input())
mod=10**9+7
a = (10**N)%mod
b = (9**N)%mod
c = (8**N)%mod
ans = (a+c-2*b)%mod
print(ans) | x, n = list(map(int, input().split()))
if n == 0:
print(x)
exit(0)
else:
arr = list(map(int, input().split()))
arr.sort()
if x in arr:
i = arr.index(x)
else:
print(x)
exit(0)
if not i and i != 0:
print(x)
exit(0)
j = 1
for _ in range(n):
row = i - j
high = i + j
if x - j not in arr:
print(x - j)
exit(0)
elif x + j not in arr:
print(x + j)
exit(0)
j += 1
print(x-1)
| 0 | null | 8,613,550,056,958 | 78 | 128 |
S = input()
if S[0] == 'R' and S[1] == 'R' and S[2] == 'R':
ans = 3
elif (S[0] == 'R' and S[1] == 'R' and S[2] == 'S') or (S[0] == 'S' and S[1] == 'R' and S[2] == 'R'):
ans = 2
elif S[0] == 'S' and S[1] == 'S' and S[2] == 'S':
ans = 0
else:
ans = 1
print(ans)
| # ABC 147 D
N=int(input())
A=list(map(int,input().split()))
res=0
p=10**9+7
bits=[0]*71
for a in A:
j=0
while a>>j:
if (a>>j)&1:
bits[j]+=1
j+=1
t=0
n=70
while n>=0:
if bits[n]!=0:
break
n-=1
for a in A:
j=0
while j<=n:
if (a>>j)&1:
res+=((2**j)*(N-bits[j]))%p
else:
res+=((2**j)*bits[j])%p
j+=1
t=res
print((res*500000004)%p) | 0 | null | 63,861,414,231,942 | 90 | 263 |
import sys
import math
from collections import defaultdict, deque
from copy import deepcopy
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return map(int, input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
def fib(num):
d = defaultdict(int)
d[0] = 1
d[1] = 1
if num <= 1:
return d[num]
else:
for i in range(1,num):
d[i+1] = d[i]+d[i-1]
return d[num]
def main():
num = I()
print(fib(num))
if __name__ == "__main__":
main()
| N=int(input())
A=list(map(int,input().split()))
cur=1
for i in range(N):
if A[i]==cur:
cur+=1
if cur==1:
print(-1)
elif cur>1:
print(N-(cur-1))
| 0 | null | 57,245,750,502,730 | 7 | 257 |
N, K = map(int, input().split())
N += 1
res = 0
s = [i for i in range(N)]
if K == 1:
res += N
K = 2
if N == 0:
print(res)
exit(0)
res += 1
minimum = sum(s[:K - 1])
maximum = sum(s[-K + 1:])
for i in range(K, N):
minimum += s[i]
maximum += s[-i + 1]
res = (res + (maximum - minimum + 1)) % (10 ** 9 + 7)
print(res)
| line1 = input()
line2 = input()
aryLine1 = line1.split()
arystrLine2 = line2.split()
K = int(aryLine1[0]);
N = int(aryLine1[1]);
aryLine2 = [int(s) for s in arystrLine2]
#print(aryLine2)
aryLine2.sort()
#print(aryLine2)
ans = K
for i in range(0, N):
temp1 = int(aryLine2[i])
if i == N - 1:
temp2 = int(aryLine2[0]) + K
else:
temp2 = int(aryLine2[i + 1])
temp = temp1 - temp2 + K
if temp < ans:
ans = temp
print(ans) | 0 | null | 38,391,904,952,830 | 170 | 186 |
x,y,a,b,c = map(int,input().split())
R=list(map(int,input().split()) )
G=list(map(int,input().split()) )
W=list(map(int,input().split()) )
R.sort(reverse=True)
G.sort(reverse=True)
Z = W+R[0:x] + G[0:y]
Z.sort(reverse=True)
print(sum(Z[0:x+y]))
| import heapq
def main():
X, Y, A, B, C = (int(_) for _ in input().split())
p = sorted([int(_) for _ in input().split()])[::-1]
q = sorted([int(_) for _ in input().split()])[::-1]
r = sorted([int(_) for _ in input().split()])[::-1]
output = 0
apple = list()
heapq.heapify(apple)
for i in range(X):
heapq.heappush(apple, p[i])
output += p[i]
for i in range(Y):
heapq.heappush(apple, q[i])
output += q[i]
i = 0
while i < C:
x = heapq.heappop(apple)
if x < r[i]:
heapq.heappush(apple, r[i])
output = output - x + r[i]
i += 1
else: break
print(output)
return
if __name__ == '__main__':
main()
| 1 | 45,057,045,388,252 | null | 188 | 188 |
n = int(input())
num_AC = 0
num_WA = 0
num_TLE = 0
num_RE = 0
for i in range(n):
i = input()
if i == "AC":
num_AC += 1
elif i == "WA":
num_WA += 1
elif i == "TLE":
num_TLE += 1
elif i == "RE":
num_RE += 1
print("AC x " + str(num_AC))
print("WA x " + str(num_WA))
print("TLE x " + str(num_TLE))
print("RE x " + str(num_RE)) | #k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
#a = [input() for _ in range(n)]
import itertools
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
if (p == q):
print(0)
exit()
seq = []
for i in range(1,n+1):
seq.append(i)
t = list(itertools.permutations(seq))
ans = []
for i in range(len(t)):
if list(t[i]) == p or list(t[i]) == q:
ans.append(i)
print(ans[1]-ans[0])
| 0 | null | 54,877,618,868,868 | 109 | 246 |
N = input()
K = int(input())
dp = [[[0 for _ in range(5)] for _ in range(2)] for _ in range(len(N)+1)]
dp[0][0][0] = 1
for i in range(len(N)):
dgt = int(N[i])
for k in range(K+1):
dp[i+1][1][k+1] += dp[i][1][k] * 9
dp[i+1][1][k] += dp[i][1][k]
if dgt > 0:
dp[i+1][1][k+1] += dp[i][0][k] * (dgt-1)
dp[i+1][1][k] += dp[i][0][k]
dp[i+1][0][k+1] = dp[i][0][k]
else:
dp[i+1][0][k] = dp[i][0][k]
print(dp[len(N)][0][K] + dp[len(N)][1][K])
| #WA
#桁DP
N=str(input())
K=int(input())
L=len(N)
#DP[i][smaller][j]=上からi桁(1<=i<=L)で0でない数字がj個(0<=j<=3)
DP=[[[0]*5 for index1 in range(2)] for index2 in range(L+1)]
#適当に初期設定
DP[0][0][0]=1
for i in range(1,L+1):
#smaller=1->smaller=1
DP[i][1][4]+=DP[i-1][1][4]*10+DP[i-1][1][3]*9
DP[i][1][3]+=DP[i-1][1][3]+DP[i-1][1][2]*9
DP[i][1][2]+=DP[i-1][1][2]+DP[i-1][1][1]*9
DP[i][1][1]+=DP[i-1][1][1]+DP[i-1][1][0]*9
DP[i][1][0]+=DP[i-1][1][0]
n=int(N[i-1])
#smaller=0->smaller=1
#n=0だとsmaller=0->smaller=1がない
#n=1だとsmaller=0->smaller=1のとき必ずjは変化しない
if n==1:
DP[i][1][4]+=DP[i-1][0][4]
DP[i][1][3]+=DP[i-1][0][3]
DP[i][1][2]+=DP[i-1][0][2]
DP[i][1][1]+=DP[i-1][0][1]
DP[i][1][0]+=DP[i-1][0][0]
elif n>=2:
DP[i][1][4]+=DP[i-1][0][4]*n+DP[i-1][0][3]*(n-1)
DP[i][1][3]+=DP[i-1][0][3]+DP[i-1][0][2]*(n-1)
DP[i][1][2]+=DP[i-1][0][2]+DP[i-1][0][1]*(n-1)
DP[i][1][1]+=DP[i-1][0][1]+DP[i-1][0][0]*(n-1)
DP[i][1][0]+=DP[i-1][0][0]
#smaller=0->smaller=0
#n=0だと必ずjは変化しない
if n==0:
DP[i][0][4]+=DP[i-1][0][4]
DP[i][0][3]+=DP[i-1][0][3]
DP[i][0][2]+=DP[i-1][0][2]
DP[i][0][1]+=DP[i-1][0][1]
DP[i][0][0]+=DP[i-1][0][0]
else:
DP[i][0][4]+=DP[i-1][0][4]+DP[i-1][0][3]
DP[i][0][3]+=DP[i-1][0][2]
DP[i][0][2]+=DP[i-1][0][1]
DP[i][0][1]+=DP[i-1][0][0]
print(DP[L][0][K]+DP[L][1][K])
| 1 | 75,565,090,114,250 | null | 224 | 224 |
A = int(input())
if A >= 30:
print('Yes')
else:
print('No') | h,w,k = map(int, input().split())
s = [list(map(str,list(input()))) for i in range(h)]
ans =0
for ii in range(1<<h):
for jj in range(1<<w):
cnt = 0
for i in range(h):
for j in range(w):
if (ii >> i & 1):
continue
if (jj >> j & 1):
continue
if (s[i][j] == '#'):
cnt += 1
if cnt == k:
ans += 1
print(ans)
| 0 | null | 7,347,089,252,220 | 95 | 110 |
from collections import deque
n, m = map(int, input().split())
name = ['']*n
time = ['']*n
for i in range(n):
name[i], time[i] = input().split()
time = list(map(int, time))
Q = deque([i for i in range(n)])
t = 0
while Q!=deque([]):
q = Q.popleft()
if time[q]<=m:
t += time[q]
print(name[q] + ' ' + str(t))
else:
t += m
time[q] -= m
Q.append(q)
| num = input()
num = int(num)
print(num**3) | 0 | null | 164,719,051,912 | 19 | 35 |
N, K = map(int, input().split())
X = list(map(int, input().split()))
ub = 10 ** 9 + 7
lb = 0
while ub - lb > 1:
mid = (ub + lb) // 2
cnt = 0
for v in X:
cnt += -(-v // mid) - 1
if cnt <= K:
ub = mid
else:
lb = mid
print(ub)
| # -*- coding:utf-8 -*-
def solve():
import math
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
left, right = 1, 10**9
while left != right:
mid = (left+right)//2
cut = 0
for a in As:
if a/mid > 1: cut += math.ceil(a/mid) - 1
if cut <= K:
# 切って良い回数を満たしている
if left+1 == right:
print(left)
return
right = mid
else:
# 切って良い回数を満たしていない
if left+1 == right:
print(right)
return
left = mid
if __name__ == "__main__":
solve()
| 1 | 6,480,381,576,810 | null | 99 | 99 |
N, X, M = map(int, input().split())
NN = N
li = []
isused = [False] * M
while isused[X] == False and N != 0:
li.append(X)
isused[X] = True
X = (X ** 2) % M
N -= 1
if N == 0:
print(sum(li))
elif N != 0 and X in li:
l = len(li)
s = li.index(X)
T = l - s
q = (NN - s) // T
r = (NN - s) % T
print(sum(li) + sum(li[i] for i in range(s, len(li))) * (q-1) + sum(li[i] for i in range(s, s + r))) | import math
N,X,M = map(int, input().split())
MAP = [-1]*(M+1)
TMAP = [0]*(M+1)
ans = 0
for i in range(N):
if (X%M!=0):
X = X%M
ans += X
if MAP[X]==-1:
MAP[X] = i
TMAP[X] = ans
else:
loopcnt = i-MAP[X]
loopsum = ans-TMAP[X]
ans += (((N-MAP[X])//loopcnt)-1)*loopsum
jmax = N-(MAP[X]+((N-MAP[X])//loopcnt)*loopcnt)
ans -= X
for j in range(jmax):
X = X%M
ans += X
X = X**2
X=M
X = X**2
else:
break
print(ans)
| 1 | 2,826,447,254,528 | null | 75 | 75 |
N = int(input())
s = "ACL"
ans = ""
for i in range(N):
ans += s
print(ans) | a = int(input())
if a == 1:
print("ACL")
elif a == 2:
print("ACLACL")
elif a == 3:
print("ACLACLACL")
elif a == 4:
print("ACLACLACLACL")
else:
print("ACLACLACLACLACL") | 1 | 2,210,060,731,460 | null | 69 | 69 |
s = input()
s = s[::-1]
n = len(s)
# stmp = s[::-1]
# for i in range(len(s)):
# for j in range(i,len(s)):
# sint = int(stmp[i:j+1])
# if sint % 2019 == 0:
# print(n-j,n-i)
# print(sint)
# print()
rem2019_cnts = [0]*2019
rem2019_cnts[0] = 1
curr_rem = int(s[0])
rem2019_cnts[curr_rem] = 1
curr_10_rem = 1
ans = 0
for i,si in enumerate(s[1:]):
sint = int(si)
next_10_rem = (curr_10_rem*10)%2019
next_rem = (next_10_rem*sint + curr_rem)%2019
ans += rem2019_cnts[next_rem]
rem2019_cnts[next_rem] += 1
curr_10_rem = next_10_rem
curr_rem = next_rem
# print(i+2, curr_rem)
print(ans) | from decimal import *
n,k = map(int,input().split())
a = list(map(int,input().split()))
MOD = 10**9 + 7
ze = []
pl,mi = [],[]
for i in range(n):
if a[i] < 0:
ze.append((-a[i],1))
mi.append(a[i])
else:
ze.append((a[i],0))
pl.append(a[i])
ze.sort(reverse = True)
pl.sort(reverse = True)
mi.sort()
one = 0
for i in range(k):
one += ze[i][1]
ans = 1
zero = k-one
if one % 2 == 0:
for i in range(k):
ans = ans * ze[i][0] % MOD
print(ans)
elif len(pl) == 0:
for i in range(k):
ans = ans * mi[n-1-i] % MOD
print(ans)
else:
if (zero == len(pl) and one == len(mi)) or len(pl) == 0 or len(mi) == 0:
ak = [zero,one]
elif (zero != len(pl) and one == len(mi)) or zero == 0:
ak = [zero+1,one-1]
elif zero == len(pl) and one != len(mi) or one == 0:
ak = [zero-1,one+1]
else:
if Decimal(abs(mi[one]))/Decimal(pl[zero-1]) >= Decimal(pl[zero])/Decimal(abs(mi[one-1])):
ak = [zero-1,one+1]
else:
ak = [zero+1,one-1]
ans = 1
for i in range(ak[0]):
ans = ans * pl[i] % MOD
for i in range(ak[1]):
ans = ans * mi[i] % MOD
print(ans) | 0 | null | 20,303,443,474,350 | 166 | 112 |
n=int(input())
s = input()
ans = 0
if n%2 != 0:
print('No')
if n%2 == 0:
for i in range(n//2):
if s[i] == s[i+n//2]:
ans += 1
if ans == n//2:
print('Yes')
if ans != n//2:
print('No') | N = int(input())
S = input()
print("Yes" if S[:N//2] == S[N//2:] else "No") | 1 | 146,505,111,964,586 | null | 279 | 279 |
n = int(input())
left = []
mid = []
midminus = []
right = []
L = []
R = []
for i in range(n):
s = input()
l = 0
r = 0
for x in s:
if x == '(':
l += 1
else:
if l > 0:
l -= 1
else:
r += 1
if l > 0 and r == 0:
left.append((l, r))
elif l > 0 and r > 0:
if l > r:
mid.append((r, l)) # a,b-a
else:
midminus.append((r,l))
elif l == 0 and r > 0:
right.append((l, r))
L.append(l)
R.append(r)
if sum(L) != sum(R):
print('No')
exit()
A = 0
B = 0
for x in left:
A += x[0]
for x in right:
B += x[1]
mid = sorted(mid, key=lambda x: (x[0],-x[1]))
midminus = sorted(midminus,key= lambda x:x[0]-x[1])
mid += midminus
l = A
r = 0
for a, b in mid:
if l < a:
print('No')
exit()
l -= a
l += b
print('Yes') | import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7
def meg(f, ok, ng):
while abs(ok-ng)>1:
mid = (ok+ng)//2
if f(mid):
ok=mid
else:
ng=mid
return ok
def get_inv(n, modp):
return pow(n, modp-2, modp)
def factorials_list(n, modp): # 10**6
fs = [1]
for i in range(1, n+1):
fs.append(fs[-1] * i % modp)
return fs
def invs_list(n, fs, modp): # 10**6
invs = [get_inv(fs[-1], modp)]
for i in range(n, 1-1, -1):
invs.append(invs[-1] * i % modp)
invs.reverse()
return invs
def comb(n, k, modp):
num = 1
for i in range(n, n-k, -1):
num = num * i % modp
den = 1
for i in range(2, k+1):
den = den * i % modp
return num * get_inv(den, modp) % modp
def comb_from_list(n, k, modp, fs, invs):
return fs[n] * invs[n-k] * invs[k] % modp
#
class UnionFindEx:
def __init__(self, size):
#正なら根の番号、負ならグループサイズ
self.roots = [-1] * size
def getRootID(self, i):
r = self.roots[i]
if r < 0: #負なら根
return i
else:
r = self.getRootID(r)
self.roots[i] = r
return r
def getGroupSize(self, i):
return -self.roots[self.getRootID(i)]
def connect(self, i, j):
r1, r2 = self.getRootID(i), self.getRootID(j)
if r1 == r2:
return False
if self.getGroupSize(r1) < self.getGroupSize(r2):
r1, r2 = r2, r1
self.roots[r1] += self.roots[r2] #サイズ更新
self.roots[r2] = r1
return True
Yes = 'Yes'
No = 'No'
def main():
N=ii()
up = []
down = []
for _ in range(N):
S = input()
h = 0
b = 0
for s in S:
if s=='(':
h += 1
else:
h -= 1
b = min(b, h)
#
if h>=0:
up.append((h, b))
else:
down.append((h, b))
#
up.sort(key=lambda t: t[1], reverse=True)
down.sort(key=lambda t: t[0]-t[1], reverse=True)
H = 0
for h, b in up:
if H+b>=0:
H += h
else:
print(No)
return
for h, b in down:
if H+b>=0:
H += h
else:
print(No)
return
#
if H == 0:
print(Yes)
else:
print(No)
main()
| 1 | 23,497,929,396,280 | null | 152 | 152 |
n = int(input()) - 1 # n=n-1
print(sum([(n//x - x)*2 + 1 for x in range(1, int(n**0.5) + 1)]))
| # Reference: https://qiita.com/dn6049949/items/afa12d5d079f518de368
# self.data: 1-indexed
# __1__
# _2_ _3_
# 4 5 6 7
# f(f(a, b), c) == f(a, f(b, c))
class SegmentTree:
# a = [default] * n
# O(n)
def __init__(self, n, f=max, default=-2**30):
self.num_leaf = 2 ** (n-1).bit_length()
self.data = [default] * (2*self.num_leaf)
self.f = f
# a[i] = x
# O(log(n))
def update(self, i, x):
i += self.num_leaf
self.data[i] = x
i >>= 1
while i > 0:
self.data[i] = self.f(self.data[2*i], self.data[2*i+1])
i >>= 1
# return f(a[l:r])
# O(log(n))
def query(self, l, r):
l += self.num_leaf
r += self.num_leaf - 1
lres, rres = self.data[0], self.data[0] # self.data[0] == default
while l < r:
if l & 1:
lres = self.f(lres, self.data[l])
l += 1
if not r & 1:
rres = self.f(self.data[r], rres)
r -= 1
l >>= 1
r >>= 1
if l == r:
res = self.f(self.f(lres, self.data[l]), rres)
else:
res = self.f(lres, rres)
return res
# You can use min_index only if f == max.
# return min({i | x <= i and v <= a[i]}, self.num_leaf)
# O(log(n))
def min_index(self, x, v):
x += self.num_leaf
while self.data[x] < v:
if x & 1:
if x.bit_length() == (x+1).bit_length():
x += 1
else:
return self.num_leaf
else:
x >>= 1
while x < self.num_leaf:
if self.data[2*x] >= v:
x = 2*x
else:
x = 2*x + 1
return x - self.num_leaf
from sys import stdin
def input():
return stdin.readline().strip()
def main():
n = int(input())
s = list(input())
forest = [SegmentTree(n, f=max, default=0) for _ in range(26)]
for ind, si in enumerate(s):
forest[ord(si) - 97].update(ind, 1)
q = int(input())
ans = []
for _ in range(q):
typ, l, r = input().split()
l = int(l) - 1
if typ == '1':
forest[ord(s[l]) - 97].update(l, 0)
s[l] = r
forest[ord(r) - 97].update(l, 1)
else:
cnt = 0
for tree in forest:
if tree.min_index(l, 1) < int(r):
cnt += 1
ans.append(cnt)
for i in ans:
print(i)
main() | 0 | null | 32,607,488,036,918 | 73 | 210 |
MOD = 10**9 + 7
def modpow(a: int, p: int, mod: int) -> int:
# return a**p (mod MOD) O(log p)
res = 1
while p > 0:
if p & 1 > 0:
res = res * a % mod
a = a**2 % mod
p >>= 1
return res
def comb(N, x):
numerator = 1
for i in range(N-x+1, N+1):
numerator = numerator * i % MOD
denominator = 1
for j in range(1, x+1):
denominator = denominator * j % MOD
d = modpow(denominator, MOD-2, MOD)
return numerator * d
n,a,b=map(int,input().split())
ans = (modpow(2,n,MOD)-1 - comb(n,a) - comb(n,b)) % MOD
print(ans) | # フェルマーの小定理
def mcomb(n, k):
a = 1
b = 1
for i in range(k):
a *= n - i
a %= m
b *= i + 1
b %= m
return a * pow(b, m - 2, m) % m
n, a, b = map(int, input().split())
m = 1000000007
result = pow(2, n, m) - 1
result -= mcomb(n, a)
result %= m
result -= mcomb(n, b)
result %= m
print(result)
| 1 | 66,159,245,094,268 | null | 214 | 214 |
#dpでできないかな？
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,cos,radians,sqrt
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7
n,a,b=MI()
l=b-a
if l%2==0:
ans=l//2
print(ans)
else:
edge=min(n-b,a-1)
#print(edge)
ans=edge
ans+=1
l-=1
ans+=l//2
print(ans) | a, b, c = map(int, input().split())
d = 0
if a > b:
d = a
a = b
b = d
else: pass
d = 0
if b > c:
d = b
b = c
c = d
else: pass
d = 0
if a > b:
d = a
a = b
b = d
else: pass
print(a, b, c)
| 0 | null | 54,731,548,131,820 | 253 | 40 |
n = input()
res = 0
for i in range(len(n)):
res += int(n[i])
print("Yes" if res%9 == 0 else "No") | 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))
| 0 | null | 2,294,736,863,668 | 87 | 29 |
n = int(input())
ans = 0
for a in range(1,n):
b = n//a
if b*a == n:
b -= 1
ans += b
print(ans) | n=int(input())
c=0
for a in range(1,n+1):
c+=(n-1)//a
print(c) | 1 | 2,613,012,401,352 | null | 73 | 73 |
import sys
sys.setrecursionlimit(10**8)
def dfs(x, last=-1, ban_color=-1):
"""
x: 今いる頂点
last: 既に探索済の頂点(無限ループにならないように初期値-1)
ban_color: 既に探索済の頂点(last)と今いる頂点(x)との辺に塗られている色(→使っちゃいけない色)
"""
color = 1
for to in vertex[x]: #今いる頂点に隣接する頂点(つまり今いる頂点から出てる辺をすべて舐める),(rootから隣接する頂点に対してのroopとも捉えられる)
if to == last: continue # 既に探索済の辺はもう色が塗られているからスキップ
if color == ban_color: color += 1
color_dic[(x, to)] = color # 辺の色をぬる
dfs(to, x, color)
color += 1
n = int(input())
vertex = {i: [] for i in range(n)} # 隣接頂点を保持
a = [0] * (n - 1) #i番目の辺を保持
b = [0] * (n - 1) #i番目の辺を保持
color_dic = {} # 辺の色を保持
for i in range(n-1): # 隣接頂点の辞書を作成
a[i], b[i] = map(int, input().split())
a[i] -= 1
b[i] -= 1
vertex[a[i]].append(b[i])
vertex[b[i]].append(a[i])
max_v = 0
for _, v in vertex.items():
if len(v) > max_v:
max_v = len(v)
print(max_v)
dfs(0)
for i in range(n - 1):
if (a[i], b[i]) in color_dic:
print(color_dic[(a[i], b[i])])
else:
print(color_dic[(b[i], a[i])])
| while True:
m, f, r = list(map(int,input().split()))
if (m == -1) & (f == -1) & (r == -1):
break
if (m + f) < 30 or m == -1 or f == -1:
print("F")
elif (m + f) < 50 and r < 50:
print("D")
elif (m + f) < 65:
print("C")
elif (m + f) < 80:
print("B")
else:
print("A") | 0 | null | 68,318,443,227,200 | 272 | 57 |
N=int(input())
L=list(map(int,input().split()))
sort_L=sorted(L,reverse=True)
ans=0
for n in range(N-2):
for o in range(n+1,N-1):
lar=sort_L[n]
kouho=sort_L[o+1:]
mid=sort_L[o]
sa=lar-mid
left=0
right=N-o-2
if kouho[-1]>sa:
ans+=right+1
else:
while right > left + 1:
half = (right + left) // 2
if kouho[half] <= sa:
right = half
else:
left = half
if kouho[right]<=sa and kouho[left]<=sa:
continue
elif kouho[right]>sa:
ans+=right+1
else:
ans+=left+1
print(ans)
| n = int(input())
S = set(map(int, input().split()))
q = int(input())
T = tuple(map(int, input().split()))
cnt = 0
for n in T:
cnt += n in S
print(cnt) | 0 | null | 86,346,067,098,670 | 294 | 22 |
import math
sentinel = 1e9 + 1
counter = 0
def merge(a, left, mid, right):
global counter
L = a[left:mid] + [sentinel]
R = a[mid:right] + [sentinel]
i,j = 0,0
for k in range(left, right):
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
counter += right - left
def mergeSort(a, left, right):
if left+1 < right:
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
n = int(input())
a = list(map(int, input().split()))
mergeSort(a, 0, n)
print(*a)
print(counter)
| n = int(input())
t = [0] * 100
for i in range(11, 100):
msb = i // 10
lsb = i % 10
if lsb == 0:
continue
for j in range(1, n+1):
if j % 10 == lsb and int(str(j)[0]) == msb:
t[i] += 1
ans = 0
for i in range(11, 100):
msb = i // 10
lsb = i % 10
if lsb == 0:
continue
if msb == lsb:
ans += t[i] ** 2
else:
ans += t[i] * t[lsb * 10 + msb]
print(ans)
| 0 | null | 43,517,770,320,320 | 26 | 234 |
def main() :
n = int(input())
nums = [int(i) for i in input().split()]
exchange_count = 0
for i in range(n) :
minj = i
for j in range(i, n) :
if nums[j] < nums[minj] :
minj = j
if minj != i :
exchange_count += 1
nums[i], nums[minj] = nums[minj], nums[i]
print(" ".join(map(str, nums)))
print(exchange_count)
if __name__ == '__main__' :
main() | #!/usr/bin/env python3
N = int(input())
A = list(map(int, input().split()))
c = 0
for i in range(N):
minj = i
for j in range(i, N):
if A[j] < A[minj]:
minj = j
A[i], A[minj] = A[minj], A[i]
if i != minj:
c += 1
print(' '.join((str(x) for x in A)))
print(c) | 1 | 21,417,623,278 | null | 15 | 15 |
X, Y, A, B, C = [int(_) for _ in input().split()]
P = [int(_) * 3 for _ in input().split()]
Q = [int(_) * 3 + 1 for _ in input().split()]
R = [int(_) * 3 + 2 for _ in input().split()]
S = sorted(P + Q + R)
cnt = [0, 0, 0]
ans = [0, 0, 0]
limit = [X, Y, 10**10]
while S:
s = S.pop()
q, r = divmod(s, 3)
if cnt[r] >= limit[r]:
continue
cnt[r] += 1
ans[r] += q
if sum(cnt) == X + Y:
print(sum(ans))
exit()
| def main():
P = 2019
S = [int(s) for s in input()]
ans = 0
if P == 2:
for i, v in enumerate(S, start=1):
if v % 2 == 0:
ans += i
elif P == 5:
for i, v in enumerate(S, start=1):
if v == 0 or v == 5:
ans += i
else:
cnt = [0]*P
d = 1
pre = 0
cnt[pre] += 1
for v in S[::-1]:
v *= d
v += pre
v %= P
cnt[v] += 1
d *= 10
d %= P
pre = v
ans = sum(cnt[i]*(cnt[i]-1)//2 for i in range(P))
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 37,940,198,833,720 | 188 | 166 |
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())
from collections import defaultdict
from collections import Counter
import bisect
from functools import reduce
def main():
H, N = MI()
A = LI()
A_sum = sum(A)
if A_sum >= H:
print('Yes')
else:
print('No')
if __name__ == "__main__":
main()
| import math
arr = input().split( )
a = int(arr[0])
b1, b2 = arr[1].split('.')
b = int(b1)*100 + int(b2)
print(a*b//100) | 0 | null | 47,092,567,934,218 | 226 | 135 |
import math
a, b, n = map(int, input().split())
k = min(n, b-1)
print(math.floor(a/b*k)) | H, W, K = map(int, input().split())
c = []
b_h = [0] * H
b_w = [0] * W
b = 0
for h in range(H):
c.append(input().rstrip())
for w in range(W):
if c[h][w] == "#":
b_h[h] += 1
b_w[w] += 1
b += 1
ans = 0
for hi in range(2 ** H):
for wi in range(2 ** W):
bsum = b
for h in range(H):
if hi & (2 ** h) != 0:
bsum -= b_h[h]
for w in range(W):
if wi & 2 ** w != 0:
if c[h][w] == '#':
bsum += 1
for w in range(W):
if wi & (2 ** w) != 0:
bsum -= b_w[w]
if bsum == K:
ans += 1
print(ans)
| 0 | null | 18,433,850,461,272 | 161 | 110 |
i=0
while True:
i+=1
a=input()
if a==0:
break
else:
print("Case "+str(i)+": "+str(a)) | import sys
i = 1
for line in sys.stdin.readlines():
x = line.strip()
if x != "0":
print("Case {}: {}".format(i, x))
i += 1 | 1 | 487,044,537,952 | null | 42 | 42 |
import collections
N=int(input())
if N==1:
print(0)
exit()
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
c = collections.Counter(prime_factorize(N))
s=list(set(prime_factorize(N)))
ans=0
def a(n):
return (1/2)*n*(n+1)
def f(n):
ans=0
x=1
while n>=a(x):
x+=1
ans+=1
return ans
for i in s:
x=c[i]
ans+=f(x)
print(ans)
| n=int(input())
p=n
yakusu=[]
for i in range(1,int(n**0.5)+1):
if n%i==0:
yakusu.append(i)
if i!=n//i:
yakusu.append(n//i)
p-=1
yakusu_1=[]
for i in range(1,int(p**0.5)+1):
if p%i==0:
yakusu_1.append(i)
if i!=p//i:
yakusu_1.append(p//i)
ans=len(yakusu_1)-1
for x in yakusu:
r=n
if x!=1:
while r%x==0:
r//=x
if (r-1)%x==0:
ans+=1
print(ans) | 0 | null | 28,933,204,305,600 | 136 | 183 |
import sys
input = sys.stdin.readline
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
#import numpy as np
from math import gcd
from collections import defaultdict
def main():
n=II()
mod=10**9+7
ans=1
cnt=0
d=defaultdict(int)
for _ in range(n):
a,b=MI()
if a==b==0:
cnt+=1
elif a==0:
d[(1,0)]+=1
elif b==0:
d[(0,-1)]+=1
else:
g=gcd(abs(a),abs(b))
if a*b>0:
d[(abs(a//g),abs(b//g))]+=1
else:
d[(abs(a//g),-abs(b//g))]+=1
s=set()
for a,b in list(d):
#print(a,b,s)
if (a,b) in s:
continue
if b>=0:
x=d[(a,b)]
y=d[(b,-a)]
s.add((a,b))
s.add((b,-a))
else:
x=d[(a,b)]
y=d[(-b,a)]
s.add((a,b))
s.add((-b,a))
ans*=2**x+2**y-1
ans%=mod
ans+=cnt-1
print(ans%mod)
if __name__ == "__main__":
main()
| s = str(input())
if 1 <= s.count('AB') or 1 <= s.count('BA'):
print('Yes')
else:
print('No') | 0 | null | 37,837,979,290,540 | 146 | 201 |
import bisect
n = int(input())
l = list(map(int, input().split()))
l = sorted(l)
cnt = 0
for i in range(n):
for j in range(i+1, n):
x = bisect.bisect_left(l, l[i]+l[j])
cnt += x-j-1
print(cnt) | import bisect
N = int(input())
numbers = [int(i) for i in input().split()]
numbers = sorted(numbers)
counter = 0
for a in range(N):
for b in range(a+1, N):
c = bisect.bisect_left(numbers, numbers[a] + numbers[b])
if c > b:
counter += c - b -1
print(counter) | 1 | 172,373,980,226,328 | null | 294 | 294 |
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
a,b = readInts()
print(a*b if (1 <= a <= 9 and 1 <= b <= 9) else '-1')
| A, B = map(int, input().split())
print(A * B if A < 10 and B < 10 else '-1') | 1 | 158,449,398,708,946 | null | 286 | 286 |
import sys
official_house = {}
for b in range(1, 5):
for f in range(1, 4):
for r in range(1, 11):
official_house[(b, f, r)] = 0
n = int(sys.stdin.readline())
for line in sys.stdin:
(b, f, r, v) = [int(i) for i in line.split()]
official_house[(b, f, r)] += v
for b in range(1, 5):
if b != 1:
print("####################")
for f in range(1, 4):
for r in range(1, 11):
print(" %d" % official_house[(b, f, r)], end="")
print() | n = int(input())
d = {}
for i in range(n):
[b, f, r, v] = list(map(int,input().split()))
key = f'{b} {f} {r}'
if key in d:
d[key] += v
else:
d[key] = v
for b in range(1,5):
for f in range(1,4):
for r in range(1,11):
key = f'{b} {f} {r}'
if key in d:
print(" "+str(d[key]),end="")
else:
print(" "+str(0),end="")
if r == 10:
print()
if r == 10 and f == 3 and b != 4:
print('####################')
| 1 | 1,087,104,775,300 | null | 55 | 55 |
# https://qiita.com/takayg1/items/7008e4c9584e42ae13c7
from collections import deque
N, M = (int(i) for i in input().split())
graph = [deque([]) for _ in range(N + 1)]
for _ in range(M):
a, b = (int(i) for i in input().split())
graph[a].append(b)
graph[b].append(a)
seen = [-1] * (N + 1)
def dfs(v):
stack = [v]
while stack:
v = stack[-1]
if graph[v]:
w = graph[v].popleft()
if seen[w] < 0:
seen[w] = 0
stack.append(w)
else:
stack.pop()
ans = 0
for i in range(N):
if seen[i + 1] < 0:
dfs(i + 1)
ans += 1
print(ans - 1) | # Connect Cities
# Union Findデータ構造（素集合データ構造）
#入力:N,M(int:整数)
def input2():
return map(int,input().split())
#入力:[n1,n2,...nk](int:整数配列)
def input_array():
return list(map(int,input().split()))
class UnionFind():
"""docstring for UnionFind"""
def __init__(self, n):
self.parents = [-1]*n
def find(self,x):
if self.parents[x] < 0: #自分が親である時
return x
else: #自分が子供である時
self.parents[x]=self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
# 各要素の親要素を返す
x=self.find(x)
y=self.find(y)
if x==y:
return
if self.parents[x] > self.parents[y]:
x,y=y,x
self.parents[y]=x
n,m=input2()
AB=[input_array() for _ in range(m)]
uf = UnionFind(n)
for ab in AB:
a=ab[0]
b=ab[1]
uf.union(a-1,b-1)
ans=0
for i in uf.parents:
if i < 0:
ans+=1
print(ans-1) | 1 | 2,288,175,347,198 | null | 70 | 70 |
print(1-int(input()))
|
n1,n2,n3 = map(int,input().split(" "))
list1 = [list(map(int,input().split(" "))) for _ in range(n1)]
list2 = [list(map(int,input().split(" "))) for _ in range(n2)]
mat = [[0 for _ in range(n3)] for _ in range(n1)]
for i in range(n1):
for j in range(n2):
for k in range(n3):
mat[i][k] += list1[i][j] * list2[j][k]
for m in mat:
print(*m)
| 0 | null | 2,213,123,855,462 | 76 | 60 |
n=int(input())
a=[None] * (n+1)
a[0] = 1
a[1] = 1
for i in range(n-1):
a[i+2]=a[i]+a[i+1]
print(a[n])
| s,t,a,b,x,y=map(int,open(0).read().split())
i=(x-a)*s
j=(b-y)*t-i
print(max(0,i//j*2+(i%j!=0))if j else'infinity') | 0 | null | 65,437,121,172,548 | 7 | 269 |
n = int(input())
h = {}
for i in range(n):
op, st = input().split()
if op == 'insert':
h[st] = 'yes'
else:
print (h.get(st, 'no')) | import sys
sys.setrecursionlimit(100000000)
k=int(input())
logl=len(str(k))
def bfs(nowres, result=[]):
if len(result) >= k:
return sorted(result)
rescand=[]
for res in nowres:
eq=res*10+res%10
rescand.append(eq)
if eq % 10>0:
rescand.append(eq-1)
if eq % 10<9:
rescand.append(eq+1)
return bfs(rescand, result+nowres)
res=bfs(list(range(1,10)))
#print(res)
print(res[k-1]) | 0 | null | 20,139,596,789,888 | 23 | 181 |
X,Y = map(int, input().split())
if Y - 2*X >= 0 and 4*X - Y >= 0 and (Y - 2*X) % 2 == 0 and (4*X - Y) % 2 == 0:
print('Yes')
else:
print('No') | x,y = map(int,input().split())
A = y//2
B = (x-A)
while A>-1:
if y==2*A + 4*B:
print("Yes")
break
A = A-1
B = B+1
if A==-1:
print("No") | 1 | 13,789,865,368,132 | null | 127 | 127 |
a,b,c,d = map(int,input().split())
ans1 = a * c
ans2 = a * d
ans3 = b * c
ans4 = b * d
print(max(ans1,ans2,ans3,ans4)) | a, b, c, d = [int(i) for i in input().split()]
res = float("-inf")
for i in [a,b]:
for j in [c,d]:
res = max(i * j, res)
print(res) | 1 | 3,001,073,704,328 | null | 77 | 77 |
import sys
sys.setrecursionlimit(10**7)
readline = sys.stdin.buffer.readline
def readstr():return readline().rstrip().decode()
def readstrs():return list(readline().decode().split())
def readint():return int(readline())
def readints():return list(map(int,readline().split()))
def printrows(x):print('\n'.join(map(str,x)))
def printline(x):print(' '.join(map(str,x)))
from math import ceil
h,w = readints()
s = [readstr() for i in range(h)]
dp = [[0]*w for i in range(h)]
if s[0][0] == '.':
dp[0][0] = 0
else:
dp[0][0] = 1
for i in range(1,h):
if s[i][0] != s[i-1][0]:
dp[i][0] = dp[i-1][0] + 1
else:
dp[i][0] = dp[i-1][0]
for i in range(1,w):
if s[0][i] != s[0][i-1]:
dp[0][i] = dp[0][i-1] + 1
else:
dp[0][i] = dp[0][i-1]
for i in range(1,h):
for j in range(1,w):
if s[i][j] != s[i-1][j]:
dp[i][j] = dp[i-1][j] + 1
else:
dp[i][j] = dp[i-1][j]
if s[i][j] != s[i][j-1]:
dp[i][j] = min(dp[i][j-1] + 1,dp[i][j])
else:
dp[i][j] = min(dp[i][j-1],dp[i][j])
print(ceil(dp[-1][-1]/2))
| H, W = map(int,input().split())
grid = [input() for _ in range(H)]
dp = [[float('inf')]*(W) for _ in range(H)]
dp[0][0] = 0 if grid[0][0] == '.' else 1
for i in range(H):
for k in range(W):
if i+1 < H:
if grid[i][k] == '.' and grid[i+1][k] == '#':
dp[i+1][k] = min(dp[i][k]+1,dp[i+1][k])
else:
dp[i+1][k] = min(dp[i][k],dp[i+1][k])
if k+1 < W:
if grid[i][k] == '.' and grid[i][k+1] == '#':
dp[i][k+1] = min(dp[i][k]+1,dp[i][k+1])
else:
dp[i][k+1] = min(dp[i][k],dp[i][k+1])
print(dp[-1][-1]) | 1 | 49,218,383,383,622 | null | 194 | 194 |
X, N =map(int, input().split())
p_list=list(map(int, input().split()))
#i=N
#1st Xがp_listにあるか
#あれば+=!
#なければ答え
#|X-i|=1がp_listにあるか
#あれば+=!
#なければ答え
i=N
j=0
while True:
if X-j not in p_list:
print(X-j)
exit()
elif X+j not in p_list:
print(X+j)
exit()
else:
j+=1
| K = int(input())
S = input()
s = len(S)
mod = int(1e9+7)
n = pow(26, K, mod)
ans = n
for i in range(K):
n = n*25*(s+i)*pow(26*(i+1),-1,mod)%mod
ans = (ans +n) % mod
print(ans) | 0 | null | 13,474,825,192,010 | 128 | 124 |
import sys
#input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
class BinaryIndexedTree:
def __init__(self,n,default=0):
self.s=[default]*(n+1)
self.n=n
def add(self,val,idx):
while idx<self.n+1:
self.s[idx]=self.s[idx]+val
idx+=idx&(-idx)
return
def get(self,idx):
res=0
while idx>0:
res=res+self.s[idx]
idx-=idx&(-idx)
return res
from collections import defaultdict
def main():
n=II()
s=input()
S=[0]+list(s)
d=defaultdict(lambda:BinaryIndexedTree(n))
for i,si in enumerate(s):
#print(i,si)
d[si].add(1,i+1)
q=II()
for _ in range(q):
f,a,b=input().split()
if int(f)==1:
a=int(a)
d[S[a]].add(-1,a)
d[b].add(1,a)
S[a]=b
else:
#print(S,a,b)
a=int(a)
b=int(b)
cnt=0
for bit in d.values():
if bit.get(b)-bit.get(a-1)>0:
cnt+=1
print(cnt)
if __name__=="__main__":
main()
| class SegmentTree:
def __init__(self, lst, op, e):
self.n = len(lst)
self.N = 1 << ((self.n - 1).bit_length())
self.op = op # operation
self.e = e # identity element
self.v = self._build(lst) # self.v is set to be 1-indexed for simplicity
def _build(self, lst):
# construction of a tree
# total 2 * self.N elements (tree[0] is not used)
tree = [self.e] * (self.N) + lst + [self.e] * (self.N - self.n)
for i in range(self.N - 1, 0, -1): tree[i] = self.op(tree[i << 1], tree[(i << 1)|1])
return tree
def __getitem__(self, i):
return self.v[i + self.N]
# update a_i to be x
def update(self, i, x):
v, op = self.v, self.op
i += self.N
v[i] = x
while i > 0:
i >>= 1 # move to parent
v[i] = op(v[i << 1], v[(i << 1)|1])
# returns answer for the query interval [l, r)
def fold(self, l, r):
N, e, v, op = self.N, self.e, self.v, self.op
left = l + N; right = r + N
L = R = e
while left < right:
if left & 1: # self.v[left] is the right child
L = op(L, v[left])
left += 1
if right & 1: # self.v[right-1] is the left child
right -= 1
R = op(v[right], R)
left >>= 1; right >>= 1
return op(L, R)
def wa(set1, set2):
return set1 | set2
n = int(input())
s = input()
lst = []
for i in range(n):
lst.append(set([s[i]]))
st = SegmentTree(lst, wa, set([]))
ans = []
q = int(input())
for i in range(q):
que = input()
if que[0] == '1':
kind, i, c = que.split()
i = int(i) - 1
st.update(i, set([c]))
else:
kind, l, r = map(int, que.split())
l -= 1
ans.append(len(st.fold(l, r)))
for i in ans:
print(i) | 1 | 62,648,939,633,438 | null | 210 | 210 |
tmp = -1
cnt = 1
output = []
while tmp != 0:
tmp = int(input())
if tmp == 0:
break
output += ["Case " + str(cnt) + ": " + str(tmp)]
cnt += 1
for x in output:
print(x)
| s=raw_input()
target=raw_input()
ring=s+s[0:len(target)]
f=0
for i in range(len(s)):
if ring[i:i+len(target)]==target:
f=1
break
if f==1:
print "Yes"
else:
print "No" | 0 | null | 1,101,296,677,020 | 42 | 64 |
while True:
[H,W]=[int(x) for x in input().split()]
if [H,W]==[0,0]:
break
unit="#."
for i in range(0,H):
print(unit*(W//2)+unit[0]*(W%2))
unit=unit[1]+unit[0]
print("") | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
S, T = input().split()
A, B = map(int, readline().split())
U = input()
if S == U:
A -= 1
if T == U:
B -= 1
print(A, B)
if __name__ == '__main__':
main()
| 0 | null | 36,274,771,017,492 | 51 | 220 |
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
N,M,L = map(int,input().split())
gurahu = np.zeros((N,N))
for k in range(M):
a,b,c = map(int,input().split())
gurahu[a-1,b-1] = c
gurahu[b-1,a-1] = c
gurahu = floyd_warshall(gurahu, directed=False)
gurahu = np.where((gurahu <= L) & (gurahu > 0), 1, 0)
gurahu = floyd_warshall(gurahu) - np.ones((N, N))
Q = int(input())
for k in range(Q):
s,t = map(int,input().split())
ans = gurahu[s-1,t-1]
if ans == float('inf'):
print(-1)
else:
print(int(ans)) | text = ''
key= input().lower()
while True:
s = input()
if s.find("END_OF_TEXT") >= 0: break
try:
text += s + ' '
except:
break
print([x.lower() for x in text.split(" ")].count(key) ) | 0 | null | 87,864,416,154,240 | 295 | 65 |
N = int(input())
S = 0
for i in range(1, N + 1):
if i % 15 == 0:
S += 0
elif i % 3 == 0:
S += 0
elif i % 5 == 0:
S += 0
else:
S += i
print(S)
| N = int(input())
def isnot_fizzbuzz(number: int) -> bool:
if (number) % 3 != 0 and (number) % 5 != 0:
return True
return False
def main():
sum = 0
for number in range(1, N + 1):
if isnot_fizzbuzz(number) == True:
sum += number
print(sum)
if __name__ == "__main__":
main() | 1 | 34,838,649,327,730 | null | 173 | 173 |
def main():
n = int(input())
l_0 = []
r_0 = []
ls_plus = []
ls_minus = []
sum_l = 0
sum_r = 0
for i in range(n):
s = input()
left, right = 0, 0
for j in range(len(s)):
if s[j] == '(':
right += 1
else:
if right > 0:
right -= 1
else:
left += 1
if left == right == 0:
continue
if left == 0:
l_0.append((left, right))
elif right == 0:
r_0.append((left, right))
elif left < right:
ls_plus.append((left, right))
else:
ls_minus.append((left, right))
sum_l += left
sum_r += right
if len(ls_plus) == len(ls_minus) == len(l_0) == len(r_0) == 0:
print("Yes")
return
if len(l_0) == 0 or len(r_0) == 0:
print("No")
return
if sum_l != sum_r:
print("No")
return
# r-lの大きい順
ls_plus.sort(key=lambda x: x[1] - x[0], reverse=True)
# lの小さい順
ls_plus.sort(key=lambda x: x[0])
# l-rの小さい順
ls_minus.sort(key=lambda x: x[0] - x[1])
# lの大さい順
ls_minus.sort(key=lambda x: x[0], reverse=True)
now_r = 0
for ll in l_0:
now_r += ll[1]
for _ in ls_plus:
r = _[1]
x = now_r - _[0]
if x >= 0:
now_r = x + r
else:
print("No")
return
for _ in ls_minus:
r = _[1]
x = now_r - _[0]
if x >= 0:
now_r = x + r
else:
print("No")
return
print("Yes")
main()
| def main():
n = int(input())
Ss = [input() for _ in range(n)]
U = [[0, 0] for _ in range(n)]
for i in range(n):
for c in Ss[i]:
if c == "(":
U[i][1] += 1
else:
if U[i][1] == 0:
U[i][0] += 1
else:
U[i][1] -= 1
L, R = 0, 0
P = []
for i in range(n):
if U[i][0] == 0 and U[i][1] > 0:
L += U[i][1]
elif U[i][0] > 0 and U[i][1] == 0:
R += U[i][0]
elif U[i][0] > 0 and U[i][1] > 0:
P.append([U[i][0], U[i][1]])
P.sort(key=lambda x: (x[0]-x[1], x[0], -x[1]))
if L == 0 and R == 0 and len(P) == 0:
print("Yes")
elif (L == 0 or R == 0) and len(P) > 0:
print("No")
else:
f = True
for i in range(len(P)):
L -= P[i][0]
if L < 0:
f = False
break
L += P[i][1]
if L == R and f:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main() | 1 | 23,649,165,527,532 | null | 152 | 152 |
n,m=map(int,input().split())
c=list(map(int,input().split()))
dp=[10**5 for i in range(50001)]
dp[0]=0
dp[1]=1
for i in range(1,n+1):
for j in range(m):
if i>=c[j]:
dp[i]=min(dp[i-c[j]]+1,dp[i])
print(dp[n])
| n, m = map(int, input().split())
c = list(map(int, input().split()))
dp = [0] * (n+1)
for i in range(1, n+1):
dpi = 10 ** 9
for j in range(m):
if(i-c[j]>=0):
tmp = dp[i-c[j]] + 1
if(tmp < dpi):
dpi = tmp
dp[i] = dpi
print(dp[n])
| 1 | 139,772,104,444 | null | 28 | 28 |
A, B = map(int, input().split())
if A == 1 or B == 1:
print(1)
elif (A*B) % 2 == 0:
print(A*B//2)
else:
print(A*B//2+1) | h,w=map(int,input().split())
if h==1 or w==1:
print(1)
exit()
print(((h+1)//2)*((w+1)//2)+(h//2)*(w//2)) | 1 | 50,547,436,379,780 | null | 196 | 196 |
N=int(input())
max_x=int(N**0.5)
ans_list=[0]*N
for x in range(1,max_x):
for y in range(1,max_x):
for z in range(1,max_x):
s=x**2+y**2+z**2+x*y+y*z+z*x
if s<=N:
ans_list[s-1]+=1
for i in range(N):
print(ans_list[i]) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, X, mod = mapint()
doubling = [[i*i%mod for i in range(mod)]]
accu = [doubling[0][:]]
for i in range(40):
tmp1 = [None]*mod
tmp2 = [None]*mod
for j in range(mod):
tmp1[j] = doubling[-1][doubling[-1][j]]
tmp2[j] = accu[-1][doubling[-1][j]] + accu[-1][j]
doubling.append(tmp1)
accu.append(tmp2)
now = X
ans = X
for i in range(40):
if (N-1)>>i&1:
ans += accu[i][now]
now = doubling[i][now]
print(ans) | 0 | null | 5,474,292,420,030 | 106 | 75 |
N, K = map(int, input().split())
mod = 10 ** 9 + 7
ans = 0
for i in range(K, N+2):
ans += ((N + 1) * i - i ** 2 + 1) % mod
print(ans % mod) | # https://drken1215.hatenablog.com/entry/2020/04/20/003900
# k 個足してできる最小の整数を求める (a とする)
# k 個足してできる最大の整数を求める (b とする)
# 出来上がる整数は b−a+1 個である
N, K = map(int, input().split())
mod = 10 ** 9 + 7
ans = 0
for k in range(K, N+2):
mx = k * (2 * N - k + 1) / 2
mi = k * (k - 1) / 2
add = mx - mi + 1
ans += add
ans %= mod
print(int(ans)) | 1 | 33,128,111,604,174 | null | 170 | 170 |
n, x, m = list(map(int, input().split()))
count = 0
# table2jou = []
# for mi in range(m + 1):
# table2jou.append(pow(mi, 2))
# tablef = []
# for mi in range(m + 1):
# # tablef.append(table2jou[mi] % m)
# tablef.append(pow(mi, 2, m))
is_used = [0] * (m + 1)
count = x
pre_an = x
his = [x]
for ni in range(2, n + 1):
# an = tablef[pre_an]
an = pow(pre_an, 2, m)
if is_used[an] == 1:
leftnum = n - ni + 1
start = his.index(an)
end = leftnum % (len(his) - start) + start
loopnum = leftnum // (len(his) - start)
count = count + sum(his[start: end])
count = count + sum(his[start:]) * loopnum
break
his.append(an)
is_used[an] = 1
count = count + an
pre_an = an
print(count)
| from decimal import *
n,k = map(int,input().split())
a = list(map(int,input().split()))
MOD = 10**9 + 7
ze = []
pl,mi = [],[]
for i in range(n):
if a[i] < 0:
ze.append((-a[i],1))
mi.append(a[i])
else:
ze.append((a[i],0))
pl.append(a[i])
ze.sort(reverse = True)
pl.sort(reverse = True)
mi.sort()
one = 0
for i in range(k):
one += ze[i][1]
ans = 1
zero = k-one
if one % 2 == 0:
for i in range(k):
ans = ans * ze[i][0] % MOD
print(ans)
elif len(pl) == 0:
for i in range(k):
ans = ans * mi[n-1-i] % MOD
print(ans)
else:
if (zero == len(pl) and one == len(mi)) or len(pl) == 0 or len(mi) == 0:
ak = [zero,one]
elif (zero != len(pl) and one == len(mi)) or zero == 0:
ak = [zero+1,one-1]
elif zero == len(pl) and one != len(mi) or one == 0:
ak = [zero-1,one+1]
else:
if Decimal(abs(mi[one]))/Decimal(pl[zero-1]) >= Decimal(pl[zero])/Decimal(abs(mi[one-1])):
ak = [zero-1,one+1]
else:
ak = [zero+1,one-1]
ans = 1
for i in range(ak[0]):
ans = ans * pl[i] % MOD
for i in range(ak[1]):
ans = ans * mi[i] % MOD
print(ans) | 0 | null | 6,168,793,601,102 | 75 | 112 |
# -*- coding: utf-8 -*-
import io
import sys
import math
def solve():
# implement process
pass
def main():
# input
n, *a = open(0).read().split()
# process
s_list = list(a)
s_set = set()
for s in s_list:
s_set.add(s)
ans = str( len( s_set) )
# output
print(ans)
return ans
### DEBUG I/O ###
_DEB = 0 # 1:ON / 0:OFF
_INPUT = """\
5
grape
grape
grape
grape
grape
"""
_EXPECTED = """\
1
"""
def logd(str):
"""usage:
if _DEB: logd(f"{str}")
"""
if _DEB: print(f"[deb] {str}")
### MAIN ###
if __name__ == "__main__":
if _DEB:
sys.stdin = io.StringIO(_INPUT)
print("!! Debug Mode !!")
ans = main()
if _DEB:
print()
if _EXPECTED.strip() == ans.strip(): print("!! Success !!")
else: print(f"!! Failed... !!\nANSWER: {ans}\nExpected: {_EXPECTED}") | def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
# ABC154 E - Almost Everywhere Zero
"""
N = '9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999'
K = 3
L = len(N)
"""
N = input()
K = getN()
L = len(N)
def judge(a):
return a != 0
# N以下の数字で条件を満たす桁がk個のもの
def digit_dp(n, k):
l = len(n)
dp = [[[0] * (k + 1) for _ in range(2)] for i in range(l + 1)]
dp[0][0][0] = 1
for i in range(l):
d = int(n[i])
for j in range(2):
for d_j in range(10 if j else d + 1):
for k_j in range(k + 1):
if judge(d_j):
if k_j + 1 <= k:
dp[i + 1][j | (d_j < d)][k_j + 1] += dp[i][j][k_j]
else:
dp[i + 1][j | (d_j < d)][k_j] += dp[i][j][k_j]
return dp
dp = digit_dp(N, K)
print(dp[L][0][K] + dp[L][1][K])
# ABC029 D - 1
"""
N = '999999999'
L = len(N)
def judge_2(a):
return a == 1
# N以下の数字の中で「1が書いてある桁がk個ある数字」がいくつあるか
# 上のものと関数の中身自体は変えていない
def digit_dp_2(n, k):
l = len(n)
dp = [[[0] * (k + 1) for _ in range(2)] for i in range(l + 1)]
dp[0][0][0] = 1
for i in range(l):
d = int(n[i])
for j in range(2):
for d_j in range(10 if j else d + 1):
for k_j in range(k + 1):
if judge_2(d_j):
if k_j + 1 <= k:
dp[i + 1][j | (d_j < d)][k_j + 1] += dp[i][j][k_j]
else:
dp[i + 1][j | (d_j < d)][k_j] += dp[i][j][k_j]
return dp
dp = digit_dp_2(N, L)
ans = 0
for j in range(L + 1):
# dp[l]について各j(1のカウント)の通りの数 * j
ans += (dp[L][0][j] + dp[L][1][j]) * j
print(ans)
""" | 0 | null | 52,916,436,402,870 | 165 | 224 |
n = int(input())
a = int(n**0.5+1)
ans = [0]*n
for x in range(1, a):
for y in range(1, a):
for z in range(1, a):
if x**2 + y**2 + z**2 + x*y + y*z + z*x <= n:
ans[x**2 + y**2 + z**2 + x*y + y*z + z*x -1] += 1
[print(i) for i in ans] | text = input()
q = int(input())
for _ in range(q):
ops = input().split()
if len(ops) == 3:
op, a, b = ops
else:
op, a, b, p = ops
a = int(a)
b = int(b)
if op == 'print':
print(text[a:b+1])
elif op == 'reverse':
text = text[:a] + ''.join(reversed(text[a:b+1])) + text[b + 1:]
else:
text = text[:a] + p + text[b + 1:] | 0 | null | 5,038,698,954,432 | 106 | 68 |
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque, defaultdict
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve():
N, M = MI()
uf = UnionFind(N)
for i in range(M):
a, b = MI1()
uf.union(a, b)
print(uf.group_count()-1)
if __name__ == '__main__':
solve()
| N, M = map(int, input().split())
t = [-1] * N
import sys
sys.setrecursionlimit(10 ** 9)
root = [-1] * N
def parent(x):
if root[x] < 0:
return x
root[x] = parent(root[x])
return root[x]
def union(x, y):
x_parent = parent(x)
y_parent = parent(y)
if x_parent == y_parent:
return
root[x_parent] += root[y_parent]
root[y_parent] = x
for i in range(M):
a,b = map(int, input().split())
union(a-1,b-1)
ans = -1
for i in root:
if i < 0:
ans += 1
print(ans) | 1 | 2,297,214,590,680 | null | 70 | 70 |
n = int(input())
a = list(map(int, input().split()))
dict_diffs = dict()
for i in range(1, n+1):
dict_diffs[i+a[i-1]] = dict_diffs.get(i+a[i-1], 0) + 1
total = 0
for j in range(1, n+1):
total += dict_diffs.get(j-a[j-1], 0)
print(total) | while True:
try:
spam=map(int, input().split(' '))
spam = [i for i in spam]
spam.sort()
cola = spam[0] * spam[1]
while True:
if spam[0] == 0:
print('{} {}'.format(spam[1],int(cola/spam[1])))
break
pre = spam[0]
spam[0] = spam[1] % spam[0]
spam[1] = pre
except:
break | 0 | null | 12,951,630,382,390 | 157 | 5 |
modulo = 10**9+7
def modpow(base, n):
ans = 1
while n:
if n&1:
ans = (ans*base)%modulo
base = (base*base)%modulo
n >>= 1
return ans
factorials = [1]
N = 10**5
for i in range(1, N+1):
factorials.append((factorials[-1]*i)%modulo)
inv = [0]
for i in range(1, N+1):
inv.append(modpow(factorials[i], modulo-2))
def nCr(n, r):
if r == 0 or r == n:
return 1
return (factorials[n]*inv[n-r]*inv[r])%modulo
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
N, K = read_ints()
A = read_ints()
A.sort()
max_sum = 0
for i in range(K-1, N):
max_sum = (max_sum+A[i]*nCr(i, K-1))%modulo
min_sum = 0
for i in range(N-K+1):
min_sum = (min_sum+A[i]*nCr(N-i-1, K-1))%modulo
return (max_sum-min_sum)%modulo
if __name__ == '__main__':
print(solve())
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
import numpy as np
N, K = map(int, input().split())
A = np.array(list(map(int, input().split())), dtype = np.int64)
MOD = 10**9+7
def cumprod(x, MOD = MOD):
L = len(x)
Lsq = int(L**.5 + 1)
x = np.resize(x, Lsq ** 2).reshape(Lsq, Lsq)
for n in range(1, Lsq):
x[:,n] *= x[:,n-1]
x[:,n] %= MOD
for n in range(1,Lsq):
x[n] *= x[n-1, -1]
x[n] %= MOD
return x.flatten()[:L]
def make_fact(U, MOD = MOD):
x = np.arange(U, dtype = np.int64)
x[0] = 1
fact = cumprod(x, MOD)
x = np.arange(U, 0, -1, dtype = np.int64)
x[0] = pow(int(fact[-1]), MOD - 2, MOD)
fact_inv = cumprod(x, MOD)[::-1]
return fact, fact_inv
fact, inv = make_fact(N+100, MOD)
A.sort()
ans = 0
lim = N - K + 1
for ind, a in enumerate(A, 1):
if ind < K:
tmp_max = 0
else:
max_comb = (fact[ind-1] * inv[K-1]) % MOD * inv[ind-K] % MOD
tmp_max = max_comb * a % MOD
if ind > lim:
tmp_min = 0
else:
min_comb = (fact[N - ind] * inv[K-1]) % MOD * inv[N - ind - K + 1] % MOD
tmp_min = min_comb * a % MOD
ans += (tmp_max - tmp_min) % MOD
ans %= MOD
print(ans) | 1 | 95,257,729,227,748 | null | 242 | 242 |
import sys
from math import gcd
from collections import Counter
MOD = 10**9 + 7
def main():
input = sys.stdin.readline
N = int(input())
V = []
z = 0
for _ in range(N):
A, B = map(int, input().split())
g = gcd(A, B)
if g == 0:
z += 1
continue
A, B = A // g, B // g
if A == 0: V.append((0, 1))
elif A < 0: V.append((-A, -B))
else: V.append((A, B))
C = Counter(V)
ans = Mint(1)
used = set()
for k, V in C.items():
if k in used: continue
a, b = k
v = (0, 1) if b == 0 else (b, -a) if b > 0 else (-b, a)
t = Mint(1)
t += pow(2, V, MOD) - 1
t += pow(2, C[v], MOD) - 1
ans *= t
used.add(v)
print(ans - 1 + z)
class Mint:
def __init__(self, value=0):
self.value = value % MOD
if self.value < 0: self.value += MOD
@staticmethod
def get_value(x): return x.value if isinstance(x, Mint) else x
def inverse(self):
a, b = self.value, MOD
u, v = 1, 0
while b:
t = a // b
b, a = a - t * b, b
v, u = u - t * v, v
if u < 0: u += MOD
return u
def __repr__(self): return str(self.value)
def __eq__(self, other): return self.value == other.value
def __neg__(self): return Mint(-self.value)
def __hash__(self): return hash(self.value)
def __bool__(self): return self.value != 0
def __iadd__(self, other):
self.value = (self.value + Mint.get_value(other)) % MOD
return self
def __add__(self, other):
new_obj = Mint(self.value)
new_obj += other
return new_obj
__radd__ = __add__
def __isub__(self, other):
self.value = (self.value - Mint.get_value(other)) % MOD
if self.value < 0: self.value += MOD
return self
def __sub__(self, other):
new_obj = Mint(self.value)
new_obj -= other
return new_obj
def __rsub__(self, other):
new_obj = Mint(Mint.get_value(other))
new_obj -= self
return new_obj
def __imul__(self, other):
self.value = self.value * Mint.get_value(other) % MOD
return self
def __mul__(self, other):
new_obj = Mint(self.value)
new_obj *= other
return new_obj
__rmul__ = __mul__
def __ifloordiv__(self, other):
other = other if isinstance(other, Mint) else Mint(other)
self *= other.inverse()
return self
def __floordiv__(self, other):
new_obj = Mint(self.value)
new_obj //= other
return new_obj
def __rfloordiv__(self, other):
new_obj = Mint(Mint.get_value(other))
new_obj //= self
return new_obj
if __name__ == '__main__':
main()
| from math import gcd
n = int(input())
C = {}
z = 0
for i in range(n):
x, y = map(int, input().split())
if x == 0 and y == 0:
z += 1
continue
g = gcd(x, y)
x, y = x // g, y // g
if y < 0:
x, y = -x, -y
try:
C[(x, y)] += 1
except KeyError:
C[(x, y)] = 1
ans = 1
p = 10**9 + 7
for x, y in C:
if C[(x, y)] == 0:
continue
a = C[(x, y)]
if x > 0:
x0, y0 = -y, x
else:
x0, y0 = y, -x
try:
b = C[(x0, y0)]
C[(x0, y0)] = 0
except KeyError:
b = 0
ans *= pow(2, a, p) + pow(2, b, p) - 1
ans %= p
C[(x, y)] = 0
print((ans + z - 1) % p)
| 1 | 21,037,353,078,132 | null | 146 | 146 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.