input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N, A, B = list(map(int, input().split()))
c = 0
bc = 0
while True:
if c > N:
ans = bc
break
c += A
bc += A
if c > N:
ans = bc - (c - N)
break
c += B
print(ans) | N, A, B = list(map(int, input().split()))
sumAB = A + B
c = N // sumAB
k = N % sumAB
if k < A:
ans = A * c + k
else:
ans = A * c + A
print(ans) | p02754 |
n,b,r=list(map(int,input().split()))
blue=True
c=0
while n>0:
if blue:
x=b if n>b else n
c+=x
n-=x
else:
n-=r if n>r else n
blue=(not blue)
print(c) | n,b,r=list(map(int,input().split()))
x=n%(b+r)
c=b*(n//(b+r))
c+=b if x>b else x
print(c) | p02754 |
n, a, b = list(map(int, input().split()))
ans = (n // (a + b)) * a
if n % (a + b) <= a:
ans += n % (a + b)
else:
ans += a
print(ans) | n, a, b = list(map(int, input().split()))
ans = n // (a+b) * a
ans += n % (a + b) if n % (a + b) <= a else a
print(ans) | p02754 |
n,a,b=list(map(int,input().split()))
x=n//(a+b)
x*=a
if a!=0:
for i in range(n%(a+b)):
x+=1
a-=1
if a==0:
break
print(x) | n,a,b=list(map(int,input().split()))
x=n//(a+b)
x*=a
if a!=0:
if n%(a+b)<a:
x=x+(n%(a+b))
else:
x+=a
print(x) | p02754 |
N, A, B = [int(x) for x in input().split()]
ans = 0
flag = True
list = ''
if A + B == N:
ans = A
elif A == 0:
ans = 0
else:
while flag == True:
for a in range(A):
ans = ans + 1
list += 'b'
if len(list) == N:
flag = False
break
for b in range(B):
list += 'r'
if len(list) == N:
flag = False
break
print(ans) | N, A, B = [int(x) for x in input().split()]
mod = int(N % (A + B))
kake = int(N // (A + B))
if mod <= A:
print((kake*A + mod))
else:
print((kake*A + A)) | p02754 |
import collections
N, A, B = list(map(int, input().split()))
cnt = []
for n in range(10 ** 100):
if len(cnt) == N:
break
for i in range(A):
if len(cnt) == N:
break
cnt.append("b")
for j in range(B):
if len(cnt) == N:
break
cnt.append("r")
ans = collections.Counter(cnt)
print((ans["b"])) | N, A, B = list(map(int, input().split()))
cnt = A * int(N / (A+B))
if (N % (A+B)) <= A:
cnt += (N % (A+B))
else:
cnt += A
print(cnt) | p02754 |
n, a, b = [int(x) for x in input().split()]
if a == 0 and b == 0:
print("0")
elif a >= n:
print(n)
else:
x = n // (a + b)
if x == 0:
print(a)
else:
if (n - ((a + b) * x)) >= a:
print((a * x + a))
else:
print((a * x + (n - (a + b) * x)))
| n, a, b = [int(x) for x in input().split()]
if a == 0 and b == 0:
print("0")
elif a >= n:
print(n)
else:
x = n // (a + b)
if x == 0:
print(a)
else:
if (n - ((a + b) * x)) >= a:
print((a * x + a))
else:
print((n - b * x))
| p02754 |
n,a,b=list(map(int,input().split()))
c=0
ans=0
while c<n:
c=c+a+b
ans+=a
if c==n:
print(ans)
else:
if c-n<=b:
print(ans)
else:
print((ans-c+n+b)) | n,a,b=list(map(int,input().split()))
q=n//(a+b)
r=n-q*(a+b)
if r>=a:
print((a*(q+1)))
else:
print((a*q+r)) | p02754 |
import math
from collections import deque
def main():
n,a,b = tuple([int(t)for t in input().split()])
if b == 0:
print(n)
else:
t = a+b
res = (n // t)*a+min(n%t,a)
print(res)
if __name__ == "__main__":
main() | n,a,b = tuple(map(int,input().split()))
ans = n//(a+b)*a
ans += min(n%(a+b),a)
print(ans) | p02754 |
n, a, b = list(map(int, input().split()))
x = n // (a + b)
y = n % (a + b)
if y <= a:
print(((x * a) + y))
else:
print(((x * a) + a)) | n, a, b = list(map(int, input().split()))
x = n // (a + b)
y = n % (a + b)
print(((x * a) + min(y, a))) | p02754 |
N, A, B = list(map(int, input().split()))
a = 0
b = 0
C = 0
while N > 0:
C = N
N = N - A
if N > 0:
a = a + A
else:
a = a + C
N = N - B
print(a) | N, A, B = list(map(int, input().split()))
ans = N // (A + B) * A
rem = N % (A + B)
ans += min(rem, A)
print(ans) | p02754 |
n, a, b = list(map(int, input().split()))
blue = 0
total = 0
for i in range(10**100):
blue += a
total += a
if total == n:
print(blue)
exit(0)
elif total > n:
print((blue - (total - n)))
exit(0)
total += b
if total >= n:
print(blue)
exit(0) | n, a, b = list(map(int, input().split()))
num = n//(a+b)
if (a+b)*num == n:
print((a*num))
elif (a+b)*num + a <= n:
print((a*(num+1)))
else:
print((a*num + n - (a+b)*num)) | p02754 |
n,a,b=list(map(int,input().split()))
ans=0
if a==0:
ans=0
elif b==0:
ans=n
else:
while True:
if n-a>=0:
n-=a
ans+=a
else:
ans+=n
break
n-=b
if n<=0:
break
print(ans) | n,a,b=list(map(int,input().split()))
ans=0
if a==0:
ans=0
elif b==0:
ans=n
else:
ans=a*(int(n/(a+b)))
n=n%(a+b)
while True:
if n==0:
break
if n-a<0:
ans+=n
break
else:
ans+=a
break
print(ans) | p02754 |
n,a,b = list(map(int, input().split()))
ans = n//(a+b)*a + min(n%(a+b), a)
print(ans) | n,a,b = list(map(int, input().split()))
print((n//(a+b)*a + min(n%(a+b), a))) | p02754 |
n,a,b = list(map(int,input().split()))
sum = 0
while(n > a):
n = n-a-b
sum += a
if n < 0:
print(sum)
else:
print((sum+n))
| n,a,b = list(map(int,input().split()))
sum = n//(a+b)*a
res = n%(a+b)
sum += min(res,a)
print(sum) | p02754 |
n, a, b = list(map(int, input().split()))
extra = n % (a +b)
roop = n // (a +b)
result = a*roop
cycle = [1 for _ in range(a)] + [0 for _ in range(b)]
if extra != 0:
for i in range(extra):
result += cycle[i]
print(result) | n, a, b = list(map(int, input().split()))
result = 0
if a + b != 0:
roop = n // (a +b)
extra = n - roop*(a+b)
result = a*roop
if extra >= a:
result += a
else:
result += extra
print(result) | p02754 |
n, b, r = list(map(int, input().split()))
x = []
bool = True
while bool:
for i in range(b):
if len(x) == n:
bool = False
else:
x.append("b")
for j in range(r):
if len(x) == n:
bool = False
else:
x.append("r")
print((x.count("b")))
| n, b, r = list(map(int, input().split()))
b1 = n//(b+r)
b2 = n % (b+r)
if b == 0:
print((0))
elif r == 0:
print(n)
elif b2 != 0 and b2 <= b:
b1 = b1*b + b2
print(b1)
elif b2 != 0 and b2 > b:
b1 = b1*b + b
print(b1)
elif n % (b+r) == 0:
print((b1*b))
| p02754 |
N,A,B = list(map(int, input().split()))
adds = A + B
times = (N-1) // (adds + 1)
boalsLen = adds * times
count = A * times
while True:
if boalsLen > N:
break
tmpBoalsLen = boalsLen + A
if tmpBoalsLen > N:
addBoals = N - boalsLen
count += addBoals
break
boalsLen = tmpBoalsLen
boalsLen += B
count += A
print(count)
| N,A,B = list(map(int, input().split()))
adds = A + B
times = N // adds
boalsLen = adds * times
count = A * times
while True:
if boalsLen > N:
break
tmpBoalsLen = boalsLen + A
if tmpBoalsLen > N:
addBoals = N - boalsLen
count += addBoals
break
boalsLen = tmpBoalsLen
boalsLen += B
count += A
print(count)
| p02754 |
n,a,b = (int(x) for x in input().split())
c = 0
b_flg = True
while True:
if n <= 0:
break
if b_flg:
n -= a
c += a
if n <= 0:
c += n
b_flg = False
else:
n -= b
b_flg = True
print(c)
| n,a,b = (int(x) for x in input().split())
count = (int(n/(a+b)))*a
count += min(n%(a+b),a)
print(count)
| p02754 |
N,A,B=list(map(int, input().split()))
arr=[]
for i in range(N):
if A != 0:
for _ in range(A):
arr.append('b')
if B != 0:
for _ in range(B):
arr.append('r')
print((arr[0:N].count('b'))) | N,A,B=list(map(int, input().split()))
len=A+B
print(((N // len)* A + min(A, N % len)))
| p02754 |
N,A,B = list(map(int,input().split()))
a = N//(A+B)
ans = a*A + min((N-a*(A+B)),A)
print(ans)
| N,A,B = list(map(int,input().split()))
print((N//(A+B)*A + min((N-N//(A+B)*(A+B)),A)))
| p02754 |
N, A, B = list(map(int, input().split()))
div = int(N/(A+B))
amari = N%(A+B)
if amari > A:
print((A*div + A))
else:
print((A*div + amari)) | n,a,b=list(map(int,input().split()))
p=n//(a+b)
ans=a*p+min(a,(n % (a + b)))
print(ans) | p02754 |
n, a, b = list(map(int, input().split()))
ans = []
c = 0
if n == a + b:
print(a)
exit()
elif a == 0:
print((0))
exit()
while True:
for i in range(a):
if len(ans) == n:
print((ans.count("b")))
exit()
ans.append("b")
for j in range(b):
if len(ans) == n:
print((ans.count("b")))
exit()
ans.append("r")
| n, a, b = list(map(int, input().split()))
v = n
if n == a + b:
print(a)
exit()
elif a == 0:
print((0))
exit()
c = n % (a +b)
if n % (a +b) < a:
print(((a * (n//(a+b))) + (n %(a+b))))
exit()
else:
print(((a * (n//(a+b))) + a))
exit()
| p02754 |
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().rstrip('\n').split()))
d, m = divmod(n, (a + b))
print((d * a + min(m, a)))
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, readline().split()))
d, m = divmod(n, a + b)
print((a * d + min(a, m)))
if __name__ == '__main__':
solve()
| p02754 |
import sys
n, a, b = list(map(int, input().split()))
if a == 0:
print((0))
sys.exit()
ans = 0
while n > 0:
if n - a <= 0:
for i in range(a):
ans += 1
n -= 1
if n <= 0: break
else:
ans += a
n -= a
n -= b
print(ans) | import sys
n, a, b = list(map(int, input().split()))
if a == 0:
print((0))
sys.exit()
syou = n // (a+b)
amari = n % (a+b)
if amari <= a:
print((syou*a + amari))
else:
print((syou*a + a)) | p02754 |
N_A_B = list(map(int, input().split()))
N = N_A_B[0]
A = N_A_B[1]
B = N_A_B[2]
count = 0
retu = []
while count < 10 ** 100 and count < N:
count += 1
for index in range(A):
retu.append(1)
for index in range(B):
retu.append(0)
retu = retu[0:N]
print((sum(retu)))
| N_A_B = list(map(int, input().split()))
N = N_A_B[0]
A = N_A_B[1]
B = N_A_B[2]
"""
count = 0
retu = []
while count < 10 ** 100 and count < N:
count += 1
for index in range(A):
retu.append(1)
for index in range(B):
retu.append(0)
retu = retu[0:N]
print(sum(retu))
"""
if N % (A + B) == 0:
print((N // (A + B) * A))
elif N % (A + B) > A:
print((N // (A + B) * A + A))
else:
print((N // (A + B) * A + N % (A + B)))
| p02754 |
N,A,B=list(map(int,input().split()))
ans=0
count=0
Flag=False
waru=N//(A+B)
amari=N%(A+B)
for i in range (10**18):
if amari==0:
break
for j in range(A):
ans+=1
count+=1
if count==amari:
Flag=True
break
for k in range(B):
if Flag:
break
count+=1
if count==amari:
Flag=True
break
if Flag:
break
print((ans+waru*A)) | N,A,B=list(map(int,input().split()))
ans=0
count=0
Flag=False
waru=N//(A+B)
amari=N%(A+B)
if amari>A:
print((waru*A+A))
else:
print((waru*A+amari)) | p02754 |
N, A, B = list(map(int, input().split()))
str = ''
if A == 0:
print((0))
exit()
for _ in range(N):
for i in range(A):
if len(str) < N:
str += 'b'
for j in range(B):
if len(str) < N:
str += 'r'
print((str.count('b'))) | N, A, B = list(map(int, input().split()))
print(((N // (A + B) * A) + min(A, N % (A + B)))) | p02754 |
n, a ,b = list(map(int, input().split()))
ans = 0
length = 0
while length <= n:
length += a + b
ans += a
over = length - n
if (over == 0):
print(ans)
else:
if (over <= b):
print(ans)
else:
over -= b
ans -= over
print(ans) | n, a, b = list(map(int, input().split()))
q = n // (a+b)
mod = n % (a+b)
ans = q * a
if (mod > a):
ans += a
else:
ans += mod
print(ans) | p02754 |
n,a,b=list(map(int,input().split()))
K=n//(a+b)
J=n%(a+b)
if J<=a:
print((K*a+J))
else:
print((K*a+a)) | n,a,b=list(map(int,input().split()))
print((a*(n//(a+b))+min(a,n%(a+b))))
| p02754 |
[N, A, B] = [int(i) for i in input().split()]
Ac = 0
Bc = 0
times = 0
length = 0
while length < N:
if times % 2 == 0:
length += A
Ac += 1
else:
length += B
Bc += 1
times += 1
if times % 2 == 0:
print((A*Ac))
else:
print((A*Ac - (length - N))) | [N, A, B] = [int(i) for i in input().split()]
div = N // (A+B)
ans = A*div
diff = N - ((A+B)*div)
if A < diff:
ans += A
else:
ans += diff
print(ans) | p02754 |
N,A,B = list(map(int,input().split()))
cnt = 0
num = 0
flg = 'A'
for i in range(N):
if flg == 'A' and num < A:
cnt += 1
num += 1
if num == A:
num = 0
flg = 'B'
elif flg == 'B' and num < B:
num += 1
if num == B:
num = 0
flg = 'A'
print(cnt)
| N, A, B = list(map(int, input().split()))
ans = N // (A + B) * A
rem = N % (A + B)
ans += min(rem, A)
print(ans)
| p02754 |
n, a, b = list(map(int, input().split(' ')))
count = 0
ret = 0
while(count < n):
if count + a >= n:
ret += n - count
break
if count + a + b >= n:
ret += a
break
count += a + b
ret += a
print(ret) | n, a, b = list(map(int, input().split(' ')))
ret = n // (a + b) * a
ret += a if (n % (a + b) >= a) else n % (a + b)
print(ret) | p02754 |
N, A, B = [int(x) for x in input().split(" ")]
lst = []
b = 0
r = 0
while b + r <= N:
for i in range(0,A):
lst.append("b")
b += 1
for i in range(0,B):
lst.append("r")
r += 1
print((lst[:N].count("b"))) | N, A, B = [int(x) for x in input().split(" ")]
print((int(N/(A+B))*A+int(min(N%(A+B),A)))) | p02754 |
n, a, b = list(map(int,input().split()))
ball_n = [0, 0]
while sum(ball_n) != n:
for _ in range(a):
ball_n[0] += 1
if sum(ball_n) == n:
break
if sum(ball_n) == n:
break
for _ in range(b):
ball_n[1] += 1
if sum(ball_n) == n:
break
print((ball_n[0])) | n, a, b = list(map(int,input().split()))
ans = n // (a+b) * a
r = n % (a+b)
ans += min(a, r)
print(ans)
| p02754 |
N,A,B=list(map(int,input().split()))
l=[]
for i in range(N):
for j in range(A):
l.append('r')
if len(l) >= N:
print((l.count(('r'))))
exit()
for k in range(B):
l.append('b')
if len(l) >= N:
print((l.count(('r'))))
exit()
print((l.count(('r'))))
| N,A,B=list(map(int,input().split()))
a=N//(A+B)
b=N%(A+B)
if A == 0:
print((0))
exit()
if b > A:
print((a*A+A))
exit()
print((a*A+b))
| p02754 |
n, a, b = list(map(int, input().split()))
c = a + b
if n % c == 0:
ans = a * (n // c)
elif n % c <= a:
ans = a * (n // c) + n % c
else:
ans = a * (n // c +1)
print(ans)
| n,a,b=list(map(int,input().split()))
t=a+b
if n%t<=a:
diff=n%t
else:
diff=a
print((a*(n//t)+diff)) | p02754 |
N,A,B=list(map(int,input().split()))
k=0
while (A+B)*k<N:
k+=1
if (A+B)*k==N:
print((A*k))
else:
if N-(k-1)*(A+B)>A:
print(((k-1)*A+A))
else:
print(((k-1)*A+N-(k-1)*(A+B))) | N,A,B=list(map(int,input().split()))
k=N//(A+B)
if (A+B)*k==N:
print((A*k))
else:
if N-k*(A+B)>A:
print((k*A+A))
else:
print((k*A+N-k*(A+B))) | p02754 |
n,a,b=list(map(int,input().split()))
s=0
if n>=(a+b):
while True:
n=n-(a+b)
s+=1
if n-(a+b)<=0:
break
else:pass
if n>=a:
print((a*(s+1)))
else:
print((a*s+n))
else:
if n>=a:
print(a)
else:
print(n)
| n,a,b=list(map(int,input().split()))
if n>=(a+b):
k=int(n/(a+b))
l=int(n%(a+b))
if l>=a:
print((a*k+a))
else:
print((a*k+l))
else:
if n>=a:
print(a)
else:
print(n)
| p02754 |
n, a, b = list(map(int, input().split()))
c = 0
while n > 0:
n = n - a
if n > 0:
c += a
else:
c += a+n
n = n - b
print(c) | n, a, b = list(map(int, input().split()))
x = n // (a+b)
c = a * x
n -= (a+b)*x
while n > 0:
n = n - a
if n > 0:
c += a
else:
c += a+n
n = n - b
print(c) | p02754 |
import math
## test
n,a,b=list(map(int, input().split()))
cnt = 0
mode = 0
if a == 0:
cnt = 0
elif a+b == n:
cnt = a
else:
roop = math.floor(n / (a+b))
anc_a = a*roop
n_b = n-(roop*(a+b))
while True:
if n_b >= a and mode == 0:
n_b = n_b - a
cnt += a
mode = 1
elif mode == 1:
n_b = n_b-b
mode = 0
elif n_b < a and mode == 0:
cnt += n_b
n_b = n_b -a
if n_b <= 0:
break
cnt += anc_a
print(cnt)
| import math
n,a,b=list(map(int, input().split()))
roop = math.floor(n / (a+b))
anc_a = a*roop
n_b = n-(roop*(a+b))
cnt = anc_a + min([n_b,a])
print(cnt) | p02754 |
N,A,B = list(map(int,input().split()))
count = 0
flag = True
while flag:
if N >= A:
N = N - A
count += A
else:
count += N
N = 0
flag = False
if N >= B:
N = N - B
else:
N = 0
flag = False
print(count) | N,A,B = list(map(int,input().split()))
C = A + B
shou = N // C
amari = N % C
if amari >= A:
print((A * shou + A))
else:
print((A * shou + amari)) | p02754 |
# N, A, B
num, greenNum, redNum = [int(x) for x in input().split(' ')]
# output
totalGreen = 0
while (num > 0):
if (num <= greenNum):
totalGreen += num
num = 0
else:
totalGreen += greenNum
num -= (greenNum + redNum)
print(totalGreen)
| # N, A, B
num, greenNum, redNum = [int(x) for x in input().split(' ')]
numSet = num // (greenNum+redNum)
remain = num % (greenNum+redNum)
numRest = remain if (remain < greenNum) else greenNum
totalGreen = numSet * greenNum + numRest
print(totalGreen)
| p02754 |
n, a, b = list(map(int, input().split()))
l = []
i = 0
res = 0
while i < n:
save = i
i += a
if i < n:
res += a
i += b
elif i > n:
res += n - save
print(res) | n, a, b = list(map(int, input().split()))
k = a + b
i = 0
res = 0
y = n // k
res += y * a
x = k * y
if x + a <= n:
res += a
elif x + a > n:
res += n - x
print(res) | p02754 |
N, A, B = list(map(int, input().split()))
ans = N//(A+B) * A
ra = N % (A+B)
if ra <= A:
ans += ra
elif ra > A:
ans += A
print(ans)
| N, A, B = list(map(int, input().split()))
ans = N//(A+B) * A
ra = N % (A+B)
ans += min(ra, A)
print(ans)
| p02754 |
n,b,r=list(map(int,input().split()))
flag = True
count = 0
counts = 0
while flag == True:
for i in range(b):
count += 1
counts += 1
if counts == n:
flag = False
break
for i in range(r):
counts += 1
if counts == n:
flag = False
break
print(count) | n,b,r=list(map(int,input().split()))
count = n // (b+r)
counts = n % (b+r)
countss=b*count
if counts<= b:
coun=counts
else:
coun=b
print((countss+coun)) | p02754 |
N,A,B = list(map(int, input().split()))
moji = ''
while len(moji) < N:
for i in range(A):
moji += 'b'
for j in range(B):
moji += 'r'
moji = moji[:N]
print((moji.count('b'))) | N,A,B = list(map(int, input().split()))
nn = N // (A+B)
amari = N % (A+B)
if amari < A:
print((A*nn + amari))
else:
print((A*nn + A)) | p02754 |
N,A,B=list(map(int,input().split()))
cnt_blue = 0
# cnt_red = 0
total = 0
while(True):
cnt_blue += A
total += A
if N <= total:
cnt_blue = cnt_blue - (total - N)
break
# cnt_red += B
total += B
if N <= total:
# cnt_red = cnt_red - (total - N)
break
print(cnt_blue) | N,A,B=list(map(int,input().split()))
cnt_blue = 0
total_tmp = 0
try:
pre_cnt = N // (A+B)
total_tmp = pre_cnt * (A+B)
total_tmp += A
if N <= total_tmp:
cnt_blue = N - (pre_cnt * B)
else:
cnt_blue = (pre_cnt * A) + A
print(cnt_blue)
except Exception as e:
print((0)) | p02754 |
n, a, b = list(map(int, input().split()))
ans = 0
count = 0
while(count < n):
if count%(a+b) < a:
ans+=1
count+=1
print(ans) | n, a, b = list(map(int, input().split()))
if n%(a+b) == 0:
print((n//(a+b)*a))
else:
tmp = n%(a+b)
if tmp >= a:
print((n//(a+b)*a + a))
elif tmp < a:
print((n//(a+b)*a + tmp))
else:
print((n//(a+b)*a)) | p02754 |
n,a,b = list(map(int, input().split()))
b_counter = 0
total = 0
count = 0
color = "test"
while total < n:
count += 1
if (count % 2) == 1: #blue
color="B"
b_counter += a
total += a
else: #red
color = "R"
total += b
if color == "B":
b_counter = b_counter - (total - n)
print(b_counter)
else:
print(b_counter) | n,a,b = list(map(int, input().split()))
if (a+b) == 0:
print((0))
else:
trial_num = n // (a + b)
amari = n % (a + b)
if a == 0:
print((0))
else:
if a <= amari:
print((trial_num*a + a))
else:
print((trial_num*a + amari)) | p02754 |
N, A, B = list(map(int, input().split()))
count_all = 0
count_blue = 0
is_blue = True
while True:
if is_blue:
if count_all + A > N:
count_blue += A - ((count_all + A) - N)
break
count_all += A
count_blue += A
is_blue = not is_blue
else:
if count_all + B > N:
break
count_all += B
is_blue = not is_blue
print(count_blue) | N, A, B = list(map(int, input().split()))
AB = A+B
C = N // AB
n = N - AB * C
if n > A:
print((C * A + A))
else:
print((C * A + A - (A - n))) | p02754 |
n,a,b = list(map(int, input().split()))
l=[]
while len(l) < n:
for i in range(a):
if len(l) < n:
l.append('b')
else:
break
for j in range(b):
if len(l) < n:
l.append('r')
else:
break
print((l.count('b'))) | n,a,b = list(map(int, input().split()))
q=n//(a+b)
mod=n%(a+b)
ans=a*q
if a < mod:
ans+=a
else:
ans+=mod
print(ans) | p02754 |
li = list(map(int,input().split()))
out = int(li[0] / (li[1] + li[2])) * li[1]
remain = li[0] - int(li[0] / (li[1] + li[2])) * (li[1] + li[2])
if(remain > li[1]):
out += li[1]
else:
out += remain
print(out) | N, A, B = list(map(int, input().split()))
n = int(N / (A + B))
m = min(N - n * (A + B), A)
print((n * A + m)) | p02754 |
N,A,B=list(map(int,input().split()))
a=[]
while len(a) < N:
for i in range(A):
a.append("x")
for j in range(B):
a.append("y")
ans=a[:N]
print((ans.count("x")))
| N,A,B=list(map(int,input().split()))
K=N//(A+B)
print((K*A+min(A,N%(A+B)))) | p02754 |
N,A,B=list(map(int,input().split()))
count=0
for i in range(N):
k=i%(A+B)
if k<A:
count+=1
print(count) | N,A,B=list(map(int,input().split()))
count=0
k=N%(A+B)
add=0
if k<A:
add=k
else:
add=A
print((N//(A+B)*A+add)) | p02754 |
N, A, B = (int(x) for x in input().split())
s = ""
while True:
for i in range(A):
if len(s) != N:
s += "b"
else:
break
for j in range(B):
if len(s) != N:
s += "r"
else:
break
if len(s) == N:
break
print((s[:N].count("b"))) | N, A, B = (int(x) for x in input().split())
a, b = divmod(N, (A + B))
if A <= b:
print(((a+1) * A))
else:
print(((a * A) + b)) | p02754 |
N, A, B = list(map(int, input().split()))
list = []
count = 0
for _ in range(0, N):
for _ in range(0, A):
list.append('b')
for _ in range(0, B):
list.append('r')
for i in range(0, N):
if list[i] == 'b':
count = count + 1
print(count)
| N, A, B = list(map(int, input().split()))
x = N // (A + B)
y = N % (A + B)
if y <= A:
print((x * A + y))
else:
print((x*A+A))
| p02754 |
N, A, B = list(map(int, input().split()))
capacity = N
is_a = True
cnt = 0
while capacity > 0:
if is_a:
ball = A
cnt += min(capacity, ball)
else:
ball = B
is_a = not is_a
capacity -= min(capacity, ball)
print(cnt)
| N, A, B = list(map(int, input().split()))
combo = A + B
num_of_combo = N // combo
remaining = N - combo * num_of_combo
print((num_of_combo * A + min(remaining, A)))
| p02754 |
S = input().split(" ")
n = int(S[0])
blue = int(S[1])
countB = 0
red = int(S[2])
countR = 0
shuki = blue + red
sh = 0
for i in range(1,n+1):
amari = i % shuki
if amari >=1 and amari <= blue:
countB = countB +1
else:
countR = countR + 1
print(countB) | N, A, B = list(map(int, input().split()))
an = N // (A+B) * A
rem = N % (A+B)
an += min(rem,A)
print(an) | p02754 |
def main():
n, a, b = list(map(int, input().split()))
flag = True
res = n
count = 0
if a == 0:
print((0))
exit(0)
count = res // (a + b)
res = n - ( ( a + b ) * count )
a_count = 0
while True:
if a_count == a or res == 0:
break
res -= 1
a_count += 1
print(( a_count + a * count))
if __name__ == "__main__":
main() |
def main():
n, a, b = list(map(int, input().split()))
res = n
count = 0
if a == 0:
print((0))
exit(0)
count = res // (a + b)
res = n - ( ( a + b ) * count )
if a < res:
print((a * (count + 1)))
else:
print((a * count + res))
if __name__ == "__main__":
main() | p02754 |
n, a, b = list(map(int, input().split(' ')))
count = 0
while(True):
val = n - a
if val > 0:
n = val
count += a
else:
count = count + a + val
break
n -= b
if n <= 0:
break
print(count)
| n, a, b = list(map(int, input().split(' ')))
ans = n // (a + b) * a
alp = min([n % (a + b), a])
print((ans + alp))
| p02754 |
a,b,c=list(map(int,input().split()))
l=[]
k=0
for i in range(a):
for g in range(b):
l.append("1")
for g in range(c):
l.append("2")
for j in range(a):
if l==[]:
k=0
break
elif l[j]== "1":
k+=1
print(k) | n,a,b = list(map(int, input().split()))
g = n//(a+b)
k = n-(a+b)*g
if k >= a:
print((a+a*g))
else:
print((a*g + k)) | p02754 |
N,A,B=list(map(int, input().split()))
a=[]
c=1
y=0
C=int(N/(A+B)+1)
for i in range(A):
a.append(1)
for j in range(B):
a.append(0)
b=a.copy()
for k in range(C):
a.extend(b)
for p in a:
if N>=c:
if p==1:
y+=1
c+=1
print(y) | N,A,B=list(map(int, input().split()))
C=0
#for i in range(N):
while N>=0:
for j in range(A):
if N==0:
break
C+=1
N-=1
for k in range(B):
N=N-1
print(C) | p02754 |
if __name__ == '__main__':
n, a, b = tuple([int(s) for s in input().split()])
res = 0
while n > 0:
res += min([a, n])
n -= a
n -= b
print(res)
| if __name__ == '__main__':
n, a, b = tuple([int(s) for s in input().split()])
div = n // (a + b)
mod = n % (a + b)
print((a * div + min([a, mod]))) | p02754 |
i = list(map(int, input().split()))
N = int(i[0])
A = int(i[1])
B = int(i[2])
l = []
while len(l) < N:
for i in range(A):
if len(l) == N:
break
l.append(0)
for i in range(B):
if len(l) == N:
break
l.append(1)
print((l.count(0))) | i = list(map(int, input().split()))
N = int(i[0])
A = int(i[1])
B = int(i[2])
count_blue = 0
syou = N // (A + B)
amari = N % (A + B)
if amari > A:
count_blue = A * syou + A
else:
count_blue = A * syou + amari
print(count_blue) | p02754 |
# coding: utf-8
n,a,b=list(map(int,input().split()))
cnt=0
x=n//(a+b)*a # (a+b)個までで入っている青の数（入力例1の場合，3個）
y=n%(a+b) # nを(a+b)で割った余り（入力例1の場合，1個）
for i in range(y):
x += 1
cnt += 1
if cnt == a:
break
print(x) | # coding: utf-8
n,a,b=list(map(int,input().split()))
cnt=0
x=n//(a+b)*a # a+b個までで入っている青の数（入力例1の場合，3個）
y=n%(a+b) # nを(a+b)で割った余り（入力例1の場合，1）
if y>a:
x = x + a
else:
x = x + y
print(x) | p02754 |
N, A, B = list(map(int, input().split()))
q = int(N / (A+B))
r = N%(A+B)
print(((q+1)*A if r>A else q*A+r)) | N, A, B = list(map(int, input().split()))
q = int(N / (A+B))
r = N%(A+B)
#print((q+1)*A if r>A else q*A+r)
print((q*A + min(A, r))) | p02754 |
n, a, b = list(map(int, input().split(" ")))
blue_count = 0
while n != 0:
# 青
if n > a:
n -= a
blue_count += a
else:
blue_count += n
n = 0
if n > b:
n -= b
else:
n = 0
print(blue_count)
| n, a, b = list(map(int, input().split(" ")))
blue_count = a * (n // (a + b))
n -= (a + b) * (n // (a + b))
if n >= a:
blue_count += a
else:
blue_count += n
print(blue_count)
| p02754 |
n, a, b = list(map(int, input().split()))
total = 0
blue = 0
for i in range(int(10e100)):
if i % 2 == 0: # blue
total += a
blue += a
if total >= n:
mod = total - n
print((blue - mod))
break
else: # red
total += b
if total >= n:
print(blue)
break | n, a, b = list(map(int, input().split()))
x, mod = divmod(n, a + b)
if x == 0:
print((min(a, n)))
else:
print((a * x + min(mod, a))) | p02754 |
N, A, B = list(map(int, input().split()))
ans = 0
num = 0
while True:
ans += A
num += A
if num >= N:
ans -= num-N
break
num += B
if num >= N:
break
print(ans) | N, A, B = list(map(int, input().split()))
ans = N//(A+B)*A
rem = N % (A+B)
ans += min(rem, A)
print(ans) | p02754 |
# -*- coding: utf-8 -*-
import math
def main():
N,A,B = list(map(int,input().split()))
ans0 = N//(A+B)
ans1 = A*ans0
ans2 = (N-(A+B)*ans0)
if ans2 <= 0:
ans2 = 0
if ans2 < A:
ans1 += ans2
elif ans2 >= A:
ans1 += A
print(ans1)
if __name__ == '__main__':
main() | # -*- coding: utf-8 -*-
def main():
N,A,B = list(map(int,input().split()))
ans0 = N//(A+B)
ans1 = A*ans0
ans2 = (N-(A+B)*ans0)
if ans2 <= 0:
ans2 = 0
ans1 += min(ans2,A)
print(ans1)
if __name__ == '__main__':
main() | p02754 |
def main():
N, A, B = list(map(int, input().split()))
ans = 0
a = 0
b = 0
for _ in range(N + 1):
if (a < A) and (b == 0):
ans += 1
a += 1
elif (a == A) and (b == 0):
a = 0
b += 1
elif b < B:
b += 1
elif b == B:
b = 0
print(ans)
return 0
if __name__ == '__main__':
main() | N, A, B = list(map(int, input().split()))
ans = N // (A + B) * A
rem = N % (A + B)
ans += min(rem, A)
print(ans) | p02754 |
N, A, B = list(map(int, input().split()))
ans = 0
while True:
if N >= A:
ans += A
N -= A + B
else:
ans += max(N, 0)
break
print(ans)
| N, A, B = list(map(int, input().split()))
ans = (N // (A+B)) * A + min(A, N%(A+B))
print(ans) | p02754 |
nums = input().split(" ")
N = int(nums[0])
A = int(nums[1])
B = int(nums[2])
time = 0
while N > (A + B):
N -= (A + B)
time += 1
if N - A <= 0:
print((N + A*time))
else:
print((A + A*time)) | nums = input().split(" ")
N = int(nums[0])
A = int(nums[1])
B = int(nums[2])
time = int(N / (A + B))
if time == 0 or (time == 1 and N / (A + B) == 1):
if N - A <= 0:
print(N)
else:
print(A)
else:
N -= (A + B) * time
if N - A <= 0:
print((N + A*time))
else:
print((A + A*time)) | p02754 |
N, A, B = list(map(int, input().split()))
div, mod = divmod(N, A + B)
ans = A * div
ans += min(mod, A)
print(ans)
| N, A, B = list(map(int, input().split()))
d, m = divmod(N, A + B)
ans = A * d + min(m, A)
print(ans) | p02754 |
from math import ceil,log
N=int(eval(input()))
A=[int(i) for i in input().split()]
def f(A):
dp=[[0]*16 for i in range(N)]
for i in range(16):
dp[N-1][i]=i
for n in range(N-2,-1,-1):
nx=ceil(log(A[n]/A[n+1])/log(4)) #A
for x in range(16):
dx=nx+x
if dx <=15:
#print(max(0,dx))
dp[n][x]=dp[n+1][max(0,dx)]+x
else:
dp[n][x]=dp[n+1][15]+x+(N-1-n)*(dx-15)
L=[0]*N
for i in range(N):
L[i]=dp[i][0]
return L
K=f(A)+[0]
L=[0]+f(A[::-1])[::-1]
ans=10**9
for i in range(N):
ans=min(ans,i+2*L[i]+2*K[i])
print(ans) | from math import ceil,log
N=int(eval(input()))
A=[int(i) for i in input().split()]
def f(A):
dp=[0]*16
L=[0]*N
for i in range(16):
dp[i]=i
for n in range(N-2,-1,-1):
ndp=[0]*16
nx=ceil(log(A[n]/A[n+1])/log(4)) #A
for x in range(16):
dx=nx+x
if dx <=15:
#print(max(0,dx))
ndp[x]=dp[max(0,dx)]+x
else:
ndp[x]=dp[15]+x+(N-1-n)*(dx-15)
dp=ndp
L[n]=dp[0]
return L
K=f(A)+[0]
L=[0]+f(A[::-1])[::-1]
ans=10**22
for i in range(N+1):
ans=min(ans,i+2*L[i]+2*K[i])
print(ans) | p03198 |
INF = 10**10
n = int(eval(input()))
a = list(map(int, input().split()))
dp_fr = [[INF for _ in range(20)] for _ in range(n)]
dp_ba = [[INF for _ in range(20)] for _ in range(n)]
#dp[i][j]: iまで考えてa_iを4^j倍したときの必要最小コスト
for j in range(20):
dp_fr[0][j] = 2*j
for i in range(1, n):
k = -30
while a[i-1] * pow(4, k) < a[i]:
k += 1
for j in range(20):
if j+k < 20:
dp_fr[i][j] = 2*j + dp_fr[i-1][max(j+k, 0)]
for j in range(20):
dp_ba[n-1][j] = 2*j
for i in range(n-2, -1, -1):
k = -30
while a[i+1] * pow(4, k) < a[i]:
k += 1
for j in range(20):
if j+k < 20:
dp_ba[i][j] = 2*j + dp_ba[i+1][max(j+k, 0)]
ans = min(dp_ba[0][0], n + dp_fr[n-1][0])
for i in range(n-1):
ans = min(ans, dp_ba[i+1][0] + i+1 + dp_fr[i][0])
print(ans) | INF = 10**10
n = int(eval(input()))
a = list(map(int, input().split()))
dp_fr = [[INF for _ in range(20)] for _ in range(n)]
dp_ba = [[INF for _ in range(20)] for _ in range(n)]
#dp[i][j]: iまで考えてa_iを4^j倍したときの必要最小コスト
for j in range(20):
dp_fr[0][j] = 2*j
for i in range(1, n):
if a[i-1] < a[i]:
k = 0
while a[i-1] * pow(4, k) < a[i]:
k += 1
for j in range(20):
if j+k < 20:
dp_fr[i][j] = 2*j + dp_fr[i-1][j+k]
else:
dp_fr[i][j] = 2*j + dp_fr[i-1][19] + 2*(i) * (j+k-19)
else:
k = 0
while a[i-1] >= a[i] * pow(4, k+1):
k += 1
for j in range(20):
dp_fr[i][j] = 2*j + dp_fr[i-1][max(j-k, 0)]
for j in range(20):
dp_ba[n-1][j] = 2*j
for i in range(n-2, -1, -1):
if a[i+1] < a[i]:
k = 0
while a[i+1] * pow(4, k) < a[i]:
k += 1
for j in range(20):
if j+k < 20:
dp_ba[i][j] = 2*j + dp_ba[i+1][j+k]
else:
dp_ba[i][j] = 2*j + dp_ba[i+1][19] + 2*(n-i-1) * (j+k-19)
else:
k = 0
while a[i+1] >= a[i] * pow(4, k+1):
k += 1
for j in range(20):
dp_ba[i][j] = 2*j + dp_ba[i+1][max(j-k, 0)]
#print(*dp_fr, sep="\n")
#print(*dp_ba, sep="\n")
ans = min(dp_ba[0][0], n + dp_fr[n-1][0])
for i in range(n-1):
ans = min(ans, dp_ba[i+1][0] + i+1 + dp_fr[i][0])
print(ans) | p03198 |
from math import ceil, log2
def max2(x, y): return x if x >= y else y
def getNums(As, N):
dp = list(range(16))
nums = [0] * N
for i in reversed(list(range(N - 1))):
dx = ceil( log2( As[i] / As[i+1] ) / 2 )
dp2 = [0] * 16
for x in range(16):
nx = x + dx
if nx <= 15:
dp2[x] = dp[max2(0, nx)] + x
else:
dp2[x] = dp[15] + x + (N - 1 - i) * (nx - 15)
dp = dp2
nums[i] = dp[0]
return nums
N = int(eval(input()))
As = list(map(int, input().split()))
numPstvs = getNums(As, N)
numNgtvs = getNums(As[::-1], N)[::-1]
ans = float('inf')
for i, (p, m) in enumerate(zip(numPstvs + [0], [0] + numNgtvs)):
ans = min(ans, 2 * p + 2 * m + i)
print(ans)
| from math import floor, ceil, log2
def getNums(As, N):
nums = [0] * N
accNum = 0
stack = [(N-1, float('inf'))]
dNow = 0
for i in reversed(list(range(N - 1))):
if As[i] <= As[i+1]:
dd = floor( log2( As[i+1] / As[i] ) / 2 )
if dd > 0: stack.append((i, dNow))
dNow -= dd
else:
dTgt = dNow + ceil( log2( As[i] / As[i+1] ) / 2 )
while dNow < dTgt:
pos, d = stack[-1]
if dTgt > d:
accNum += (d - dNow) * (pos - i)
dNow = d
stack.pop()
else:
accNum += (dTgt - dNow) * (pos - i)
if dTgt == d: stack.pop()
dNow = dTgt
break
nums[i] = accNum
return nums
N = int(eval(input()))
As = list(map(int, input().split()))
numPstvs = getNums(As, N)
numNgtvs = getNums(As[::-1], N)[::-1]
ans = float('inf')
for i, (p, m) in enumerate(zip(numPstvs + [0], [0] + numNgtvs)):
ans = min(ans, 2 * p + 2 * m + i)
print(ans)
| p03198 |
#
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
return list(map(int, input().split()))
try :
#raise ModuleNotFoundError
import numpy
def dprint(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
# in python 3.4 **kwargs is invalid???
print(*args, file=sys.stderr)
dprint('debug mode')
except Exception:
def dprint(*args, **kwargs):
pass
inId = 0
outId = 0
if inId>0:
dprint('use input', inId)
sys.stdin = open('input'+ str(inId) + '.txt', 'r') #标准输出重定向至文件
if outId>0:
dprint('use output', outId)
sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #标准输出重定向至文件
atexit.register(lambda :sys.stdout.close()) #idle 中不会执行 atexit
if True:
N, = getIntList()
#print(N)
za = getIntList()
else:
N = 1000
import random
za = [random.randint(1, 1000000000) for i in range(N) ]
dprint('begin')
zleft = [0 for i in range(N+1)]
zright = [0 for i in range(N+1)]
def getwork(zr, za):
zr[0] = 0
st = []
for i in range(N):
if i%10000 ==0:
dprint('---', i)
nt = [[za[i],0], [za[i],0], 1]
st.append(nt)
nr = zr[i]
#dprint(st)
while len(st)>1:
b_2 = st[-2][1][1]
b_1 = st[-1][0][1]
bb = min(b_1,b_2)
b_1 -=bb
b_2 -=bb
b_1p = 4 ** b_1
b_2p = 4 ** b_2
t2 = st[-2][1][0] * b_2p
t1 = st[-1][0][0] * b_1p
if t2 < t1:
nr+= 2* st[-2][2]
st[-2][0][1] +=1
st[-2][1][1] +=1
elif t2 < t1 * 4:
ttt = [ st[-2][0], st[-1][1], st[-2][2] + st[-1][2] ]
st[-2] = ttt
st.pop()
else:
break
#dprint(st)
zr[i+1] = nr
#dprint(nr)
#dprint(st)
assert nr < 1000000000000000
getwork(zleft, za)
dprint('!!!!')
getwork(zright, za[::-1])
#dprint(zleft)
#dprint(zright)
r = zright[N]
for i in range(N+1):
tr = i + zleft[i] + zright[N-i]
r = min(r,tr)
print(r)
dprint('end')
| #
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
return list(map(int, input().split()))
try :
#raise ModuleNotFoundError
import numpy
def dprint(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
# in python 3.4 **kwargs is invalid???
print(*args, file=sys.stderr)
dprint('debug mode')
except Exception:
def dprint(*args, **kwargs):
pass
inId = 0
outId = 0
if inId>0:
dprint('use input', inId)
sys.stdin = open('input'+ str(inId) + '.txt', 'r') #标准输出重定向至文件
if outId>0:
dprint('use output', outId)
sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #标准输出重定向至文件
atexit.register(lambda :sys.stdout.close()) #idle 中不会执行 atexit
if True:
N, = getIntList()
#print(N)
za = getIntList()
else:
N = 100
import random
za = [random.randint(1, 1000000000) for i in range(N) ]
dprint('begin')
zleft = [0 for i in range(N+1)]
zright = [0 for i in range(N+1)]
def getwork(zr, za):
zr[0] = 0
st = []
for i in range(N):
if i%10000 ==0:
dprint('---', i)
nt = [[za[i],0], [za[i],0], 1]
st.append(nt)
nr = zr[i]
#dprint(st)
while len(st)>1:
b_2 = st[-2][1][1]
b_1 = st[-1][0][1]
bb = min(b_1,b_2)
b_1 -=bb
b_2 -=bb
b_1p = 4 ** b_1
b_2p = 4 ** b_2
t2 = st[-2][1][0] * b_2p
t1 = st[-1][0][0] * b_1p
if t2 < t1:
nr+= 2* st[-2][2]
st[-2][0][1] +=1
st[-2][1][1] +=1
elif t2 < t1 * 4:
ttt = [ st[-2][0], st[-1][1], st[-2][2] + st[-1][2] ]
st[-2] = ttt
st.pop()
else:
break
#dprint(st)
zr[i+1] = nr
#dprint(nr)
#dprint(st)
assert nr < 1000000000000000
dprint(st)
getwork(zleft, za)
dprint('!!!!')
getwork(zright, za[::-1])
#dprint(zleft)
#dprint(zright)
r = zright[N]
for i in range(N+1):
tr = i + zleft[i] + zright[N-i]
r = min(r,tr)
print(r)
dprint('end')
| p03198 |
from collections import deque
q = deque([])
def ct(a,b):
ans = 0
while abs(a)<abs(b):
ans += 2
a *= 4
return ans
N = int(eval(input()))
A = [int(a) for a in input().split()]
# A = [3, 1, 4, 1]
# N = len(A)
X = [0] * (N)
Y = [0] * (N)
a = -1
for i in range(N):
b = a
if i > 0:
X[i] = X[i-1]
else:
X[i] = 0
a = A[i]
t = 0
if a > 0:
X[i] += 1
a *= -2
if i > 0:
t = 0
r = b/a
while r >= 4:
q.append(i)
r /= 4
while abs(a)>abs(b):
if len(q) == 0:
X[i] += 2 * i
else:
X[i] += 2 * (i - q.pop())
b *= 4
q = deque([])
a = -1
for i in range(N):
b = a
if i > 0:
Y[i] = Y[i-1]
else:
Y[i] = 0
a = A[N-1-i]
t = 0
if a < 0:
Y[i] += 1
a *= -2
if i > 0:
t = 0
r = b/a
while r >= 4:
q.append(i)
r /= 4
while abs(a)>abs(b):
if len(q) == 0:
Y[i] += 2 * i
else:
Y[i] += 2 * (i - q.pop())
b *= 4
mi = min(X[-1], Y[-1])
for i in range(N-1):
if X[i]+Y[-2-i] < mi:
mi = X[i]+Y[-2-i]
print(mi) | def f(A, s):
X = [0] * N
q = []
a = 0
for i in range(N):
b = a
X[i] = X[i-1]
a = A[i]
if a * s < 0:
X[i] += 1
a *= -2
if i == 0:
continue
r = b/a
while r >= 4:
q.append(i)
r /= 4
while r < 1:
X[i] += 2 * (i - (0 if len(q) == 0 else q.pop()))
r *= 4
return X
N = int(eval(input()))
A = [int(a) for a in input().split()]
X = f(A,-1)
Y = f(A[::-1],1)
mi = min(X[-1], Y[-1])
for i in range(N-1):
mi = min(mi, X[i] + Y[-2-i])
print(mi) | p03198 |
class RollingHash():
def __init__(self, s):
self.length = len(s)
self.base1 = 1009
self.base2 = 1000
self.mod1 = 10**9 + 7
self.mod2 = 10**9 + 9
self.hash1 = [0] * (self.length + 1)
self.hash2 = [0] * (self.length + 1)
self.pow1 = [1] * (self.length + 1)
self.pow2 = [1] * (self.length + 1)
for i in range(self.length):
self.hash1[i+1] = (self.hash1[i] + ord(s[i])) * self.base1 % self.mod1
self.hash2[i+1] = (self.hash2[i] + ord(s[i])) * self.base2 % self.mod2
self.pow1[i+1] = self.pow1[i] * self.base1 % self.mod1
self.pow2[i+1] = self.pow2[i] * self.base2 % self.mod2
def get(self, l, r):
t1 = ((self.hash1[r] - self.hash1[l] * self.pow1[r-l]) % self.mod1 + self.mod1) % self.mod1
t2 = ((self.hash2[r] - self.hash2[l] * self.pow2[r-l]) % self.mod2 + self.mod2) % self.mod2
return (t1, t2)
t_tmp = input().rstrip()
s = input().rstrip()
# Same character goes to infinity
if t_tmp.count(t_tmp[0]) == len(t_tmp) and s.count(s[0]) == len(s) and s[0] == t_tmp[0]:
print((-1))
exit()
t = ""
while len(t) <= len(s):
t += t_tmp
max_ans = (len(t) * 3) // len(s)
t = t * 4
lent = len(t)
lens = len(s)
RHt = RollingHash(t)
RHs = RollingHash(s)
s_hash = RHs.get(0, lens)
match = [0] * (lent - lens + 1)
for i in range(lent - lens + 1):
if RHt.get(i, i+lens) == s_hash:
match[i] = 1
ans = max(match[:lens])
for i in range(len(match) - lens):
if match[i+lens] != 0:
match[i+lens] += match[i]
ans = max(ans, match[i+lens])
if ans > max_ans:
print((-1))
else:
print(ans) | class RollingHash():
def __init__(self, s):
self.length = len(s)
self.base1 = 1009
self.base2 = 1013
self.mod1 = 10**9 + 7
self.mod2 = 10**9 + 9
self.hash1 = [0] * (self.length + 1)
self.hash2 = [0] * (self.length + 1)
self.pow1 = [1] * (self.length + 1)
self.pow2 = [1] * (self.length + 1)
for i in range(self.length):
self.hash1[i+1] = (self.hash1[i] + ord(s[i])) * self.base1 % self.mod1
self.hash2[i+1] = (self.hash2[i] + ord(s[i])) * self.base2 % self.mod2
self.pow1[i+1] = self.pow1[i] * self.base1 % self.mod1
self.pow2[i+1] = self.pow2[i] * self.base2 % self.mod2
def get(self, l, r):
t1 = ((self.hash1[r] - self.hash1[l] * self.pow1[r-l]) % self.mod1 + self.mod1) % self.mod1
t2 = ((self.hash2[r] - self.hash2[l] * self.pow2[r-l]) % self.mod2 + self.mod2) % self.mod2
return (t1, t2)
t_tmp = input().rstrip()
s = input().rstrip()
# Same character goes to infinity
if t_tmp.count(t_tmp[0]) == len(t_tmp) and s.count(s[0]) == len(s) and s[0] == t_tmp[0]:
print((-1))
exit()
t = ""
while len(t) <= len(s):
t += t_tmp
max_ans = (len(t) * 2) // len(s)
t = t * 3
lent = len(t)
lens = len(s)
RHt = RollingHash(t)
RHs = RollingHash(s)
s_hash = RHs.get(0, lens)
match = [0] * (lent - lens + 1)
for i in range(lent - lens + 1):
if RHt.get(i, i+lens) == s_hash:
match[i] = 1
ans = max(match[:lens])
for i in range(len(match) - lens):
if match[i+lens] != 0:
match[i+lens] += match[i]
ans = max(ans, match[i+lens])
if ans > max_ans:
print((-1))
else:
print(ans) | p02962 |
import os
import sys
import math
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
S = sys.stdin.readline().rstrip()
T = sys.stdin.readline().rstrip()
LS = len(S)
LT = len(T)
S *= 3
S *= max(math.ceil(LT / LS * 3), 1)
def solve():
i = 0
ret = 0
seen = [0] * len(S)
while i < len(S):
if not seen[i]:
j = 0
while S.startswith(T, i + j * LT):
seen[i + j * LT] = j
if j * LT >= LS:
return -1
j += 1
ret = max(j, ret)
i += 1
return ret
ans = solve()
print(ans)
| import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
class KMP:
def __init__(self, needle):
"""
https://ja.wikipedia.org/wiki/クヌース–モリス–プラット法
:param typing.Sequence needle: 何を検索するか
"""
self._needle = needle
kmp = [0] * (len(needle) + 2)
kmp[0] = -1
kmp[1] = 0
i = 2
j = 0
while i < len(needle):
if needle[i - 1] == needle[j]:
kmp[i] = j + 1
i += 1
j += 1
elif j > 0:
j = kmp[j]
else:
kmp[i] = 0
i += 1
self._kmp = kmp
def index_of(self, haystack, m=0, i=0):
"""
haystack の何番目に needle があるか。見つからなければ -1
:param typing.Sequence haystack: 何から検索するか
:param int m: The position of the current character in haystack
:param int i: The position of the current character in needle
:rtype: int
"""
while m + i < len(haystack):
if self._needle[i] == haystack[m + i]:
i += 1
if i == len(self._needle):
return m
else:
m += i - self._kmp[i]
if i > 0:
i = self._kmp[i]
return -1
def search(self, haystack):
"""
ret[i]: haystack[i:i+len(needle)] == needle
:param typing.Sequence haystack: 何から検索するか
:rtype: list of bool
"""
ret = [False] * len(haystack)
m = 0
i = 0
while m + i < len(haystack):
m = self.index_of(haystack, m=m, i=i)
if m < 0:
break
ret[m] = True
m += len(self._needle) - self._kmp[len(self._needle) - 1] - 1
i = max(0, self._kmp[len(self._needle) - 1])
return ret
def test(t, s):
ret = []
for i in range(len(s)):
ret.append(s[i:i + len(t)] == t)
return ret
S = sys.stdin.buffer.readline().decode().rstrip()
T = sys.stdin.buffer.readline().decode().rstrip()
# kmp = KMP(T)
# print(kmp.search(S))
S *= 4
while len(S) < len(T) * 4:
S *= 2
kmp = KMP(T)
idx = kmp.search(S)
ans = 0
for k in range(len(T)):
i = k
cnt = 0
while i < len(idx):
if idx[i]:
cnt += 1
else:
ans = max(cnt, ans)
cnt = 0
i += len(T)
ans = max(cnt, ans)
if len(T) * ans >= len(S) // 4 * 3:
print((-1))
else:
print(ans)
| p02962 |
def z_algorithm(s):
n = len(s)
z = [0] * n
z[0] = n
i = 1
lcp = 0
while i < n:
while i+lcp < n and s[i+lcp] == s[lcp]:
lcp += 1
z[i] = lcp
if lcp == 0:
i += 1
continue
k = 1
while i+k < n and k+z[k] < lcp:
z[i+k] = z[k]
k += 1
i += k
lcp -= k
return z
from collections import deque
def topological_sort(graph: list, n_v: int) -> list:
# graph[node] = [(cost, to)]
indegree = [0] * n_v # 各頂点の入次数
for i in range(n_v):
for v in graph[i]:
indegree[v] += 1
cand = deque([i for i in range(n_v) if indegree[i] == 0])
res = []
while cand:
v1 = cand.popleft()
res.append(v1)
for v2 in graph[v1]:
indegree[v2] -= 1
if indegree[v2] == 0:
cand.append(v2)
return res
import sys
def main():
input = sys.stdin.readline
s = input().rstrip()
t = input().rstrip()
n0 = len(s)
m = len(t)
s = s * (m // n0 + 2)
idx = s.find(t)
if idx >= 0:
z = z_algorithm(s[idx:])
# print(z)
graph = [[] for _ in range(n0)]
for i in range(n0):
if i >= idx and z[i-idx] >= m:
graph[i].append( (i + m) % n0 )
ts = topological_sort(graph, n0)
if len(ts) != n0:
ans = -1
else:
# print(ts)
ans = 0
path = [0] * n0
for i in range(n0):
ans = max(ans, path[ts[i]])
for j in graph[ts[i]]:
path[j] = path[ts[i]] + 1
else:
ans = 0
print(ans)
main()
| def z_algorithm(s):
n = len(s)
z = [0] * n
z[0] = n
i = 1
lcp = 0
while i < n:
while i+lcp < n and s[i+lcp] == s[lcp]:
lcp += 1
z[i] = lcp
if lcp == 0:
i += 1
continue
k = 1
while i+k < n and k+z[k] < lcp:
z[i+k] = z[k]
k += 1
i += k
lcp -= k
return z
from collections import deque
def topological_sort(graph: list, n_v: int) -> list:
# graph[node] = [(cost, to)]
indegree = [0] * n_v # 各頂点の入次数
for i in range(n_v):
for v in graph[i]:
indegree[v] += 1
cand = deque([i for i in range(n_v) if indegree[i] == 0])
res = []
while cand:
v1 = cand.popleft()
res.append(v1)
for v2 in graph[v1]:
indegree[v2] -= 1
if indegree[v2] == 0:
cand.append(v2)
return res
import sys
def main():
input = sys.stdin.readline
s = input().rstrip()
t = input().rstrip()
n0 = len(s)
m = len(t)
s = s * (m // n0 + 2)
z = z_algorithm(t + '*' + s)
z = z[m+1:]
# print(z)
graph = [[] for _ in range(n0)]
for i in range(n0):
if z[i] >= m:
graph[i].append( (i + m) % n0 )
ts = topological_sort(graph, n0)
if len(ts) != n0:
ans = -1
else:
# print(ts)
ans = 0
path = [0] * n0
for i in range(n0):
ans = max(ans, path[ts[i]])
for j in graph[ts[i]]:
path[j] = path[ts[i]] + 1
print(ans)
main()
| p02962 |
def partial_match_table(word):
table = [0] * (len(word) + 1)
table[0] = -1
i, j = 0, 1
while j < len(word):
matched = word[i] == word[j]
if not matched and i > 0:
i = table[i]
else:
if matched:
i += 1
j += 1
table[j] = i
return table
def kmp_search(text, word):
table = partial_match_table(word)
i, p = 0, 0
results = []
while i < len(text) and p < len(word):
if text[i] == word[p]:
i += 1
p += 1
if p == len(word):
p = table[p-1]
results.append((i-len(word), i))
i -= 1
elif p == 0:
i += 1
else:
p = table[p]
return results
inf = 10**18
s = input().strip()
t = input().strip()
m=(len(t)+len(s)-1+len(s)-1)//len(s)
es = set()
d = [set() for _ in range(len(s)+1)]
d2 = [set() for _ in range(len(s)+1)]
#print(t, m*s)
#print(kmp_search(m*s, t))
for a, b in kmp_search(m*s, t):
a, b = a%len(s)+1, b%len(s)+1
es.add((a, b))
d[a].add(b)
d2[b].add(a)
#print(es)
fs = set()
r = 0
for x in range(len(s)+1):
if x in fs:
continue
vs = set()
vs.add(x)
fs.add(x)
depths = [inf]*(len(s)+1)
depths[x] = 0
stack = [x]
mt = x
while stack:
v = stack.pop()
if v > 0:
for u in d[v]:
if u in vs:
r = inf
break
stack.append(-v)
stack.append(u)
depths[u] = depths[v] + 1
if depths[u] > depths[mt]:
mt = u
vs.add(u)
fs.add(u)
else:
pass
vs = set()
vs.add(mt)
depths = [inf]*(len(s)+1)
depths[mt] = 0
stack = [mt]
mt2 = mt
while stack:
v = stack.pop()
if v > 0:
for u in d2[v]:
if u in vs:
r = inf
break
stack.append(-v)
stack.append(u)
depths[u] = depths[v] + 1
if depths[u] > depths[mt2]:
mt2 = u
vs.add(u)
fs.add(u)
else:
pass
r = max(depths[mt2], r)
print((r if r != inf else -1)) | def partial_match_table(word):
table = [0] * (len(word) + 1)
table[0] = -1
i, j = 0, 1
while j < len(word):
matched = word[i] == word[j]
if not matched and i > 0:
i = table[i]
else:
if matched:
i += 1
j += 1
table[j] = i
return table
def kmp_search(text, word):
table = partial_match_table(word)
i, p = 0, 0
results = []
while i < len(text) and p < len(word):
if text[i] == word[p]:
i += 1
p += 1
if p == len(word):
p = table[p-1]
results.append((i-len(word), i))
i -= 1
elif p == 0:
i += 1
else:
p = table[p]
return results
inf = 10**18
s = input().strip()
t = input().strip()
m=(len(t)+len(s)-1+len(s)-1)//len(s)
es = set()
d = [set() for _ in range(len(s)+1)]
d2 = [set() for _ in range(len(s)+1)]
#print(t, m*s)
#print(kmp_search(m*s, t))
for a, b in kmp_search(m*s, t):
a, b = a%len(s)+1, b%len(s)+1
es.add((a, b))
d[a].add(b)
d2[b].add(a)
#print(es)
fs = set()
r = 0
for x in range(len(s)+1):
if x in fs:
continue
vs = set()
vs.add(x)
fs.add(x)
depths = dict()
depths[x] = 0
stack = [x]
mt = x
while stack:
v = stack.pop()
if v > 0:
for u in d[v]:
if u in vs:
r = inf
break
stack.append(-v)
stack.append(u)
depths[u] = depths[v] + 1
if depths[u] > depths[mt]:
mt = u
vs.add(u)
fs.add(u)
else:
pass
vs = set()
vs.add(mt)
depths = dict()
depths[mt] = 0
stack = [mt]
mt2 = mt
while stack:
v = stack.pop()
if v > 0:
for u in d2[v]:
if u in vs:
r = inf
break
stack.append(-v)
stack.append(u)
depths[u] = depths[v] + 1
if depths[u] > depths[mt2]:
mt2 = u
vs.add(u)
fs.add(u)
else:
pass
r = max(depths[mt2], r)
print((r if r != inf else -1))
| p02962 |
def partial_match_table(word):
table = [0] * (len(word) + 1)
table[0] = -1
i, j = 0, 1
while j < len(word):
matched = word[i] == word[j]
if not matched and i > 0:
i = table[i]
else:
if matched:
i += 1
j += 1
table[j] = i
return table
def kmp_search(text, word):
table = partial_match_table(word)
i, p = 0, 0
results = []
while i < len(text) and p < len(word):
if text[i] == word[p]:
i += 1
p += 1
if p == len(word):
p = table[p]
results.append((i-len(word), i))
elif p == 0:
i += 1
else:
p = table[p]
return results
inf = 10**18
s = input().strip()
t = input().strip()
m=(len(t)+len(s)-1+len(s)-1)//len(s)
d = [-1] * (len(s)+1)
for a, b in kmp_search(m*s, t):
a, b = a%len(s)+1, b%len(s)+1
d[a] = b
ls = [0]*(len(s)+1)
vs = set()
for i in range(1, len(s)+1):
if i in vs:
continue
c = 0
j = i
while True:
vs.add(i)
i = d[i]
if i == -1:
break
c += 1
if i == j:
c = inf
break
if i in ls:
c += ls[i]
break
if c == inf:
break
ls[j] = c
print((max(ls) if c != inf else -1))
| def partial_match_table(word):
table = [0] * (len(word) + 1)
table[0] = -1
i, j = 0, 1
while j < len(word):
matched = word[i] == word[j]
if not matched and i > 0:
i = table[i]
else:
if matched:
i += 1
j += 1
table[j] = i
return table
def kmp_search(text, word):
table = partial_match_table(word)
i, p = 0, 0
results = []
while i < len(text) and p < len(word):
if text[i] == word[p]:
i += 1
p += 1
if p == len(word):
p = table[p]
results.append((i-len(word), i))
elif p == 0:
i += 1
else:
p = table[p]
return results
inf = 10**18
s = input().strip()
t = input().strip()
m=(len(t)+len(s)-1+len(s)-1)//len(s)
d = [-1] * (len(s)+1)
for a, b in kmp_search(m*s, t):
a, b = a%len(s)+1, b%len(s)+1
d[a] = b
ls = [-1]*(len(s)+1)
vs = set()
for i in range(1, len(s)+1):
if i in vs:
continue
c = 0
j = i
while True:
vs.add(i)
i = d[i]
if i == -1:
break
c += 1
if i == j:
c = inf
break
if ls[i] != -1:
c += ls[i]
break
if c == inf:
break
ls[j] = c
print((max(ls) if c != inf else -1))
| p02962 |
# Date [ 2020-08-11 10:50:12 ]
# Problem [ test.py ]
# Author Koki_tkg
import sys; from decimal import Decimal
import math; from collections import Counter
import bisect; from itertools import combinations
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 6 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def lcm(a: int, b: int) -> int: return (a * b) // math.gcd(a, b)
def Main():
n = read_int()
print(((n - 2) * 180))
if __name__ == '__main__':
Main() | print(((int(eval(input()))-2)*180)) | p03023 |
X, Y = list(map(int, input().split()))
def extgcd(a,b):
r = [1,0,a]
w = [0,1,b]
while w[2]!=1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = r2
w = w2
#[x,y]
return [w[0],w[1]]
def mod_inv(a,m):
x = extgcd(a,m)[0]
return (m+x%m)%m
if (2*Y - X) < 0:
print((0))
elif (2*X - Y) < 0:
print((0))
else:
if (X - 2*Y) % 3 != 0 or (2*X - Y) % 3 != 0:
print((0))
else:
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
m = 10**9+7
res = 1
for i in range(1,a+b+1):
res = res*i%m
for i in range(1,a+1):
res = res*mod_inv(i,m)%m
for i in range(1,b+1):
res = res*mod_inv(i,m)%m
print(res) | X, Y = list(map(int, input().split()))
M = 1000000007
def cmb(n, r):
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
if (2*Y - X) < 0:
print((0))
elif (2*X - Y) < 0:
print((0))
else:
if (X - 2*Y) % 3 != 0 or (2*X - Y) % 3 != 0:
print((0))
else:
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
ans = cmb(a+b, a)
ans = ans % M
print(ans) | p02862 |
x, y = list(map(int, input().split()))
mod = 10**9 + 7
if (x + y) % 3 != 0:
print((0))
exit()
n = (x + y) // 3
a = (2 * y - x) // 3
b = (2 * x - y) // 3
if a == 0 or b == 0:
print((1))
exit()
if a < 0 or b < 0:
print((0))
exit()
MAX = 700000
fac = [1, 1] + [0] * MAX
finv = [1, 1] + [0] * MAX
inv = [0, 1] + [0] * MAX
for i in range(2, MAX):
fac[i] = fac[i - 1] * i % mod
inv[i] = -inv[mod % i] * (mod // i) % mod
finv[i] = finv[i - 1] * inv[i] % mod
def nCr(n, r):
if n < r:
return 0
if n < 0 or r < 0:
return 0
return fac[n] * (finv[r] * finv[n - r] % mod) % mod
print((nCr(n, a)))
| x, y = list(map(int, input().split()))
mod = 10**9 + 7
if (x + y) % 3:
print((0))
exit()
n = (x + y) // 3
a = (2 * y - x) // 3
b = (2 * x - y) // 3
if a < 0 or b < 0:
print((0))
exit()
if a == 0 or b == 0:
print((1))
exit()
def neko(n, r):
p, q = 1, 1
for i in range(r):
p = p * (n - i) % mod
q = q * (i + 1) % mod
return p * pow(q, mod - 2, mod) % mod
print((neko(n, a)))
| p02862 |
x, y = list(map(int, input().split()))
mod = 10**9 + 7
if (x + y) % 3:
print((0))
exit()
n = (x + y) // 3
a = (2 * y - x) // 3
b = (2 * x - y) // 3
if a < 0 or b < 0:
print((0))
exit()
if a == 0 or b == 0:
print((1))
exit()
def neko(n, r):
p, q = 1, 1
for i in range(r):
p = p * (n - i) % mod
q = q * (i + 1) % mod
return p * pow(q, mod - 2, mod) % mod
print((neko(n, a)))
| x, y = list(map(int, input().split()))
mod = 10**9 + 7
if (x + y) % 3:
print((0))
exit()
n = (x + y) // 3
a = (2 * y - x) // 3
b = (2 * x - y) // 3
if a < 0 or b < 0:
print((0))
exit()
if a == 0 or b == 0:
print((1))
exit()
def neko(n, r):
p, q = 1, 1
for i in range(r):
p = p * (n - i) % mod
q = q * (i + 1) % mod
return p * pow(q, mod - 2, mod) % mod
r = min(a, b)
print((neko(n, r)))
| p02862 |
from functools import reduce
x, y = list(map(int, input().split()))
mod = pow(10,9)+7
min_value = min(x, y)
max_value = max(x, y)
#print(min_value, max_value)
dif_value = max_value - min_value
#print(dif_value)
a_value = min_value - dif_value
a_num = int(a_value*2*(1/3))
#print(a_value, a_num)
n = dif_value + a_num
r = int(a_num*0.5)
#print(n, r)
def nCr(n,r,DIV):
if r<n-r:
r=n-r
if r==0:
return 1
f=lambda x,y:x*y%DIV
X=reduce(f,list(range(n-r+1,n+1)))
Y=reduce(f,list(range(1,r+1)))
return X*pow(Y,DIV-2,DIV)%DIV
if a_value % 3 == 0:
print((nCr(n, r, mod)))
else:
print((0)) | from functools import reduce
def nCr(n,r,DIV):
if r<n-r:
r=n-r
if r==0:
return 1
f=lambda x,y:x*y%DIV
X=reduce(f,list(range(n-r+1,n+1)))
Y=reduce(f,list(range(1,r+1)))
return X*pow(Y,DIV-2,DIV)%DIV
mod = pow(10, 9) + 7
x, y = list(map(int, input().split()))
left, right = 0, 0
a, b = max(x, y), min(x, y)
if (2*b - a) % 3 == 0:
d, s = a - b, (2*b - a)//3
p, q = d + s, s
print((nCr(p+q, p, mod)))
else:
print((0)) | p02862 |
M = 10 ** 9 + 7
x, y = list(map(int, input().split()))
r = 0
if (x + y) % 3 == 0:
a, b = (2 * y - x) // 3, (2 * x - y ) // 3
if a >= 0 <= b:
n = a + b + 1
f = [1] * n
for i in range(1, n):
f[i] = f[i - 1] * i % M
r = f[a + b] * pow(f[a] * f[b], M - 2, M) % M
print(r)
| M = 10 ** 9 + 7
x, y = list(map(int, input().split()))
r = 0
if (x + y) % 3 == 0:
a, b = (2 * y - x) // 3, (2 * x - y ) // 3
if a >= 0 <= b:
f = [1]
for i in range(1, a + b + 1):
f.append(f[-1] * i % M)
r = f[a + b] * pow(f[a] * f[b], M - 2, M) % M
print(r)
| p02862 |
M = 10 ** 9 + 7
x, y = list(map(int, input().split()))
r = 0
if (x + y) % 3 == 0:
m = (x + y ) // 3
a, b = (2 * y - x) // 3, (2 * x - y ) // 3
if x >= m <= y:
f = [1]
for i in range(1, m + 1):
f.append(f[-1] * i % M)
r = f[m] * pow(f[a] * f[b], M - 2, M) % M
print(r)
| M = 10 ** 9 + 7
x, y = list(map(int, input().split()))
r = 0
if (x + y) % 3 == 0:
a, b = (2 * y - x) // 3, (2 * x - y ) // 3
if a >= 0 <= b:
f = [1]
for i in range(1, a + b + 1):
f.append(f[-1] * i % M)
r = f[a + b] * pow(f[a] * f[b], M - 2, M) % M
print(r) | p02862 |
inf = 10**9+7
import sys
a = 0
def nCr(n, r):
r = min(r, n - r)
if r == 0: return 1;
if r == 1: return n;
numerator = [n - r + i + 1 for i in range(r)]
denominator = [i + 1 for i in range(r)]
for p in range(2, r + 1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p - 1, r, p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result = (result * numerator[k])%inf
return result
x, y = list(map(int, input().split()))
key = 0
if x == 2*y:
print((1))
sys.exit()
if y == 2*x:
print((1))
sys.exit()
while x>0 and y>0:
x, y = x-3, y-3
key += 1
if x == 2*y:
a = 1
break
if y == 2*x:
a = -1
break
if x < 0 or y < 0:
print((0))
sys.exit()
if a == 0:
print((0))
elif a == 1:
print((int(nCr(key*2+y ,key))))
else:
print((int(nCr(key*2+x ,key)))) | import sys
x, y = list(map(int, input().split()))
inf = 10**9+7
if (x+y)%3 != 0:
print((0))
sys.exit()
a = (2*x-y)//3
b = (2*y-x)//3
if a<0 or b<0:
print((0))
sys.exit()
def nCr(n, r):
r = min(r, n - r)
if r == 0: return 1;
if r == 1: return int(n%inf);
numerator = [n - r + i + 1 for i in range(r)]
denominator = [i + 1 for i in range(r)]
for p in range(2, r + 1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p - 1, r, p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result = (result*numerator[k])%inf
return int(result)
print((nCr(a+b, a))) | p02862 |
x,y=list(map(int,input().split()))
if (x+y)%3!=0 :
print((0))
exit()
a=(2*y-x)//3
b=(2*x-y)//3
if a<0 or b<0 :
print((0))
exit()
def C(n, r ,mod=10**9+7):
if n-r<r: r=n-r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k]) %mod
return result % mod
print((C(a+b,b)))
| x,y=list(map(int,input().split()))
mod=10**9+7
def C(n, r ,mod=10**9+7):
if n-r<r: r=n-r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k]) %mod
return result % mod
a=(-x+2*y)/3
b=(2*x-y)/3
if a<0 or b<0 : print((0)) ; exit()
if a%1!=0 or b%1!=0:
print((0))
exit()
a=int(a) ; b=int(b)
print((C(a+b,a))) | p02862 |
import sys
import math
input = sys.stdin.readline
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 2*10**6+2
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
x,y=MI()
if y>2*x or x>2*y:
print((0))
sys.exit()
elif x%3==0 and y%3==0:
m=x//3
l=y//3
print((cmb(m+l,2*l-m,mod)))
elif x%3==1 and y%3==2:
m=(x-1)//3
l=(y-2)//3
print((cmb(m+l+1,2*l-m+1,mod)))
elif x%3==2 and y%3==1:
m=(x-2)//3
l=(y-1)//3
print((cmb(m+l+1,2*l-m,mod)))
else:
print((0)) | import sys
import math
input = sys.stdin.readline
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
x,y=MI()
if y>2*x or x>2*y:
print((0))
sys.exit()
elif x%3==0 and y%3==0:
m=x//3
l=y//3
print((cmb(m+l,2*l-m,mod)))
elif x%3==1 and y%3==2:
m=(x-1)//3
l=(y-2)//3
print((cmb(m+l+1,2*l-m+1,mod)))
elif x%3==2 and y%3==1:
m=(x-2)//3
l=(y-1)//3
print((cmb(m+l+1,2*l-m,mod)))
else:
print((0))
| p02862 |
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
def cinit(N):
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
X,Y = list(map(int, input().split()))
if (X+Y)%3==0and(X<Y*2 or Y<X*2):
cinit((X+Y)//3)
p = (min(X,Y)*2 - max(X,Y))//3
print((cmb((X+Y)//3,p,mod)))
else:
print((0)) | mod = 10**9+7
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
def cinit(N):
for i in range( 2, N + 1 ):
g1[i] = ( ( g1[i-1] * i ) % mod )
inverse[i] = ( ( -inverse[mod % i] * (mod//i) ) % mod )
g2[i] = ( (g2[i-1] * inverse[i]) % mod )
X,Y = list(map(int, input().split()))
if (X+Y)%3==0and(X<Y*2 or Y<X*2):
N = (X+Y)//3
g1,g2,inverse = [0]*(N+1),[0]*(N+1),[0]*(N+1)
g1[0],g1[1],g2[0],g2[1],inverse[0],inverse[1] = 1,1,1,1,0,1
cinit(N)
p = (min(X,Y)*2 - max(X,Y))//3
print((cmb((X+Y)//3,p,mod)))
else:
print((0)) | p02862 |
def cmb(n, k, mod, fac, ifac):
"""
nCkを計算する
"""
k = min(k, n-k)
return fac[n] * ifac[k] * ifac[n-k] % mod
def make_tables(mod, n):
"""
階乗テーブル、逆元の階乗テーブルを作成する
"""
fac = [1, 1] # 階乗テーブル・・・(1)
ifac = [1, 1] #逆元の階乗テーブル・・・(2)
inverse = [0, 1] #逆元テーブル・・・(3)
for i in range(2, n+1):
fac.append((fac[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
ifac.append((ifac[-1] * inverse[-1]) % mod)
return fac, ifac
X, Y = list(map(int, input().split()))
if X > Y:
X, Y = Y, X
dist = X + Y
if dist % 3 != 0:
print((0))
quit()
n = int((2 * X - Y) / 3)
m = int((2 * Y - X) / 3)
if n < 0 or m < 0:
print((0))
quit()
mod = 10 ** 9 + 7
fac, ifac = make_tables(mod, n + m)
ans = cmb(n + m, m, mod, fac, ifac)
print(ans) | def cmb(n, k, mod, fac, ifac):
"""
nCkを計算する
"""
k = min(k, n-k)
return fac[n] * ifac[k] * ifac[n-k] % mod
def make_tables(mod, n):
"""
階乗テーブル、逆元の階乗テーブルを作成する
"""
fac = [1, 1] # 階乗テーブル・・・(1)
ifac = [1, 1] #逆元の階乗テーブル・・・(2)
inverse = [0, 1] #逆元テーブル・・・(3)
for i in range(2, n+1):
fac.append((fac[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
ifac.append((ifac[-1] * inverse[-1]) % mod)
return fac, ifac
X, Y = list(map(int, input().split()))
dist = X + Y
if dist % 3 != 0:
print((0))
quit()
n = int((2 * X - Y) / 3)
m = int((2 * Y - X) / 3)
if n < 0 or m < 0:
print((0))
quit()
mod = 10 ** 9 + 7
fac, ifac = make_tables(mod, n + m)
ans = cmb(n + m, m, mod, fac, ifac)
print(ans)
| p02862 |
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0:
print((0))
quit()
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n < 0 or m < 0:
print((0))
quit()
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 10 ** 6 # N は必要分だけ用意する
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
print((cmb(n + m, n, p))) | X, Y = list(map(int, input().split()))
def cmb(n, k, mod, fac, ifac):
"""
nCkを計算する
"""
k = min(k, n-k)
return fac[n] * ifac[k] * ifac[n-k] % mod
def make_tables(mod, n):
"""
階乗テーブル、逆元の階乗テーブルを作成する
"""
fac = [1, 1] # 階乗テーブル・・・(1)
ifac = [1, 1] #逆元の階乗テーブル・・・(2)
inverse = [0, 1] #逆元テーブル・・・(3)
for i in range(2, n+1):
fac.append((fac[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
ifac.append((ifac[-1] * inverse[-1]) % mod)
return fac, ifac
if (X + Y) % 3 != 0:
print((0))
quit()
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n < 0 or m < 0:
print((0))
quit()
mod = 10 ** 9 + 7
fac, ifac = make_tables(mod, n + m)
print((cmb(n + m, n, mod, fac, ifac))) | p02862 |
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
def main():
def fur(n,r):
p,q = 1,1
for i in range(r):
p = p*(n-i)%mod
q = q*(i+1)%mod
return p * pow(q,mod-2,mod) % mod
x, y = nm()
if (x + y) % 3 != 0:
print((0))
exit()
n = (2*y - x) // 3 # (X, Y) -> (X+1, Y+2)
m = (2*x - y) // 3 # (X, Y) -> (X+2, Y+1)
if n < 0 or m < 0:
print((0))
exit()
print((fur(n+m, n)))
if __name__ == '__main__':
main() | import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
def fur(n,r):
p,q = 1,1
for i in range(r):
p = p*(n-i)%mod
q = q*(i+1)%mod
return p * pow(q,mod-2,mod) % mod
x, y = nm()
if (x + y) % 3 != 0:
print((0))
exit()
n = (2*y - x) // 3 # (X, Y) -> (X+1, Y+2)
m = (2*x - y) // 3 # (X, Y) -> (X+2, Y+1)
if n < 0 or m < 0:
print((0))
exit()
print((fur(n+m, n)))
| p02862 |
X, Y = list(map(int, input().split()))
MOD = int(1e9 + 7)
def modinv(a, mod=MOD):
return pow(a, mod-2, mod)
def combination(n, r, mod=MOD):
r = min(r, n - r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
if (X + Y) % 3 != 0:
print((0))
exit()
b = (2 * Y - X) // 3
a = X - Y + b
if a < 0 or b < 0:
print((0))
exit()
print((combination(a+b, a, MOD))) | # https://atcoder.jp/contests/abc145/tasks/abc145_d
X, Y = list(map(int, input().split()))
MOD = int(1e9 + 7)
def combination(n, r, mod=MOD):
def modinv(a, mod=MOD):
return pow(a, mod-2, mod)
# nCr with MOD
r = min(r, n - r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# 1回の移動で3増えるので，X+Yは3の倍数 (0, 0) start
if (X + Y) % 3 != 0:
ans = 0
print((0))
else:
# X+Yは3の倍数
# (+1, +2)をn回，(+2, +1)をm回実行
# n + 2m = X
# 2n + m = Y
# 3 m = 2 X - Y
# m = (2 X - Y) // 3
# n = X - 2 * m
m = (2 * X - Y) // 3
n = X - 2 * m
if m < 0 or n < 0:
print((0))
else:
print((combination(m + n, m, MOD)))
| p02862 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.