Problem:


Score : 200 points

Problem Statement

We have a long seat of width X centimeters.
There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.

We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.

At most how many people can sit on the seat?

Constraints

All input values are integers.

1 \leq X, Y, Z \leq 10^5

Y+2Z \leq X

Input

Input is given from Standard Input in the following format:

X Y Z

Output

Print the answer.

Sample Input 1

13 3 1

Sample Output 1

3

There is just enough room for three, as shown below:

Figure

Sample Input 2

12 3 1

Sample Output 2

2

Sample Input 3

100000 1 1

Sample Output 3

49999

Sample Input 4

64146 123 456

Sample Output 4

110

Sample Input 5

64145 123 456

Sample Output 5

109



Sample input:
13 3 1


Sample output:
3

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

x, y, z = LI()
ans = (x - z) // (y+z)
print(ans)

Submission status: Accepted

Solution code:
X,Y,Z = map (int, input ().split ())
X = X-Z
A = (X/(Y+Z))//1
print (round (A))

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())
l = X-Z
print(l//(Y+Z))

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())
L=X-Z
ans=0
for i in range(1000000):
    if L >= (Z+Y)*i:
        ans=i
    else:
        break
print(ans)

Submission status: Accepted

Solution code:
x, y, z = map(int,input().split())

cnt = 1
x -= y + 2*z

while x >= y + z:
    cnt += 1
    x -= y + z
print(cnt)

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split());print((x-z)//(y+z))

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
n=[i for i in range(z,x-z,y+z)]
if n[-1]+y+z<=x:
  print(len(n))
else:
  print(len(n)-1)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

x -= z
y += z
print(x // y)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

print((x - z) // (y + z))

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(100000)


def main():
    x, y, z = [int(i) for i in input().strip().split()]
    x = x - z
    ans = x // (y + z)
    print(ans)

    return


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
X -= Z
print(X//(Y+Z))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
x-= z
print(x//(y+z))

Submission status: Accepted

Solution code:
x,y,z=map(int,(input().split()))
ans=1
x-=(y+2*z)
print(ans+x//(y+z))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

x -= z

print( x // (y+z) )

Submission status: Accepted

Solution code:
X, Y, Z = map(int,input().split())

X = X - Z

print(X//(Y + Z))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
tmp = (x-z)//(y+z)
amari = (x-z)%(y+z)
#print(tmp,amari)
print(tmp)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
x -= z
print(x//(y+z))

Submission status: Accepted

Solution code:
x,y,z=map(int, input().split())
print(int((x-z)/(y+z)))

Submission status: Accepted

Solution code:
x, y, z = [int(i) for i in input().split()]
print((x - z) // (y + z))

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a, b, c = rm()
print((a-c) // (b+c))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
x -= z
y += z
print(x//y)

Submission status: Accepted

Solution code:
#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 = [list(input()) for _ in range(n)]
#a = [int(input()) for _ in range(n)]



x,y,z = map(int, input().split())

ans = x // (y+z)

if (x % (y+z) < z):
    ans -= 1
print(max(0,ans))

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
count=1
x -= 2*z+y
count += x //(y+z)
print(count)

Submission status: Accepted

Solution code:
X, Y, Z = list(map(lambda w: int(w), input().split(" ")))
print(int((X-Z)/(Y+Z)))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

print((x-z)//(y+z))

Submission status: Accepted

Solution code:
X,Y,Z = map(int, input().split())
print((X-Z)//(Y+Z))

Submission status: Accepted

Solution code:
X,Y,Z = map(int, input().split())

print((X - Z)//(Y + Z))

Submission status: Accepted

Solution code:

x,y,z = map(int, raw_input().split())
cumul = x / (y + z)
x %= y + z
if x < z:
	cumul -=1
print max(cumul,0)

Submission status: Accepted

Solution code:
X, Y , Z = map(int, input().split())
X = X - Z
print(X // (Y + Z))

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
x, y, z = M()
ans= 0
for i in range(1, 50000):
    if y*i + z*(i+1) <= x:
        ans = i
    else:
        break
print(ans)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
print((x-z)//(y+z))

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
print(int((x-z)/(y+z)))

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
print(len(range(z+y,x-z+1,z+y)))

Submission status: Accepted

Solution code:
x, y, z = list(map(int, input().split()))

print((x - z) // (y + z))

Submission status: Accepted

Solution code:
#https://atcoder.jp/contests/abc078/tasks/abc078_b
X,Y,Z = map(int,input().split())
X = X - Z
Y = Y + Z
print(X//Y)

Submission status: Accepted

Solution code:
# # Make IO faster
# import sys
# input = sys.stdin.readline

# # get single (or) multiple str
# X = input()

# # get single int
# N = int(input())
# # get multiple int (e.g., 2)
# X, Y = map(int, input().split())
# # get multiple int (e.g., 2) for N lines
# XY = [list(map(int, input().split())) for _ in range(N)]

# from IPython import embed; embed(); exit();

# 全部入り
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

X, Y, Z = MAP()

if Y + 2 * Z > X:
    print(0)
else:
    print(1 + (X - Y - 2 * Z) // (Y + Z))

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())

print((X-Z)//(Y+Z))

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())
s=Z
c=0
while True:
  s+=Y+Z
  if s>X:
    break
  c+=1
print(c)

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    X, Y, Z = map(int, readline().split())

    ans = (X - Z) // (Y + Z)

    print(ans)
    return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())
cnt = 0

while (X-Z) >= (Z+Y):
    X -= (Z+Y)
    cnt += 1
print(cnt)

Submission status: Accepted

Solution code:
x, y, z = map(int,input().split())
x -= z
ans = 0

while x > 0:
    ans += 1
    x -= y
    x -= z
    if x < 0:
        ans -= 1

print(ans)

Submission status: Accepted

Solution code:
x,y,z = map(int, input().split())

ans = 0
t = z + y + z
while t <= x:
  ans += 1
  t += y
  t += z
print(ans)

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())
a = Y+Z
X=X-Z
res = X//a
print(res)

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())
ans = (((X-Z)//(Y+Z)))
print(ans)

Submission status: Accepted

Solution code:
def solve():
    X, Y, Z = map(int, input().split())
    print((X - Z) // (Y + Z))


if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
# n=int(input())
x, y, z = map(int, input().split())
# l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
ans = x // (y + z)
if x - ans*(y + z) < z:
    ans = max(0, ans-1)
print(ans)

Submission status: Accepted

Solution code:
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()


def main():
    x, y, z = map(int,input().split())
    print((x - z) // (y + z))
    


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# ABC078 B - ISU

# Y*[人数]+Z*[人数]+1 <=X
# 3*q+1*q+1<=13
# Y*q+(Z+1)*q<=X
## Y*q+Z*(q+1)<=X
## q<=(X-Z)/(Y+Z) 
# q<=(X)/(Y+Z+1)

import math
x,y,z = map(int,input().split())
t = (x-z)/(y+z)
print(math.floor(t))

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
print((x-z)//(y+z))

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())
 
for i in range(1,X):
  if (Y+Z)*i+Z > X:
    print(i-1)
    break

Submission status: Accepted

Solution code:
X,Y,Z = (int(T) for T in input().split())
print((X-Z)//(Y+Z))

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())
X-=Z
print(X//(Y+Z))

Submission status: Accepted

Solution code:
MM = input().split()
X = int(MM[0])
Y = int(MM[1])
Z = int(MM[2])
x = 0
while True:
  if x*(Y+Z)+Z >X:
    break
  else:
    x +=1
print(x-1)

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split(' '))
print((X-Z)//(Y+Z))

Submission status: Accepted

Solution code:
x,y,z = map(int, input().split())
cnt=0
if x>=y+2*z:
  cnt+=1
  x -= (y+2*z)
cnt += (x//(y+z))
print(cnt)

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
a=x//(y+z)
if x-a*(y+z)>=z:
  print(a)
else:
  print(max(0,a-1))

Submission status: Accepted

Solution code:
x = list(map(int, input().split()))
a = (x[0]-x[2])/(x[1]+x[2])
print(int(a))

Submission status: Accepted

Solution code:
s = input().split()
x = int(s[0])
y = int(s[1])
z = int(s[2])

p = x - z

answer = int(p / (y + z))

print(answer)

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
mitumori=x//(y+z)
if x - mitumori*(y+z)>=z:print(mitumori)
else:print(mitumori-1)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
print((x-z)//(y+z))

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
ans = X - Z
YZ = Y + Z
print(ans // YZ)

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
c = 0
l = Z
while l < X:
    if l + Y + Z <= X:
        l += Y + Z
        c += 1
    else:
        break
print(c)

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
print((x - z) // (y + z))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
ans = (x - z) // (y + z)
print(ans)

Submission status: Accepted

Solution code:
X, Y, Z = list(map(int, input().split()))
X -= Z
print(X // (Y + Z))

Submission status: Accepted

Solution code:
import collections
def main():
    x,y,z=map(int, input().split())
    k = y+z+z
    res = 1
    while((k<x)):
        k+=(z+y)
        if(k>x):
            break
        res+=1
    print(res)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x, y, z = [int(i) for i in input().split(' ')]
x -= z
print(x // (y + z))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
i = 1
while(y+z*2+(z+y)*i <= x):
    i += 1
print(i)

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
if x%(y+z)>=z :
  print(x//(y+z))
else:
  print(x//(y+z)-1)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
x -= z
if x >= 0:
   print(x//(y+z))
else:
    print(0)

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())

def solve(x,y,z):
  cnt = 0
  x -= z
  while True:
    x -= y + z
    if x >= 0:
      cnt += 1
    else:
      return cnt
    
print(solve(X,Y,Z))

Submission status: Accepted

Solution code:
def resolve():
    x, y, z = map(int, input().split())

    x -= z
    count = 0
    while True:
        x = x-(y+z)
        if x >= 0:
            count += 1
        else:
            break
    print(count)
resolve()

Submission status: Accepted

Solution code:
a,b,c=map(int,input().split())
n=a//(b+c)
m=a-n*(b+c)
if m//c==1:
    print(n)
else:
    print(n-1)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

print((x - z) // (y + z))

Submission status: Accepted

Solution code:
X_all, Y_hito, Z_interval = map(int, input().split())

syou = X_all // (Y_hito + Z_interval)

if (syou * (Y_hito + Z_interval) + Z_interval <= X_all):
    ans = syou
else:
    ans = syou - 1

print(ans)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
if x < y:
    print(0)
else:
    l = z
    i = 0
    while l + (z+y) <= x:
        l += (z+y)
        i += 1
    print(i)

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())
ans = X//(Y+Z)
if X%(Y+Z) >= Z:
    print(ans)
else:
    print(ans-1)

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())
ans = X//(Y+Z)
if X%(Y+Z) >= Z:
    print(ans)
else:
    print(ans-1)

Submission status: Accepted

Solution code:
import sys
import time
import math
def inpl():
    return list(map(int, input().split()))
st = time.perf_counter()
# ------------------------------

X, Y, Z = map(int, input().split())
for i in range(1, 1001001001):
	if Y * i + Z * (i+1) > X:
		print(i-1)
		sys.exit()

# ------------------------------
ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)

Submission status: Accepted

Solution code:
x, y, z=map(int, input().split())
print((x-z)//(y+z))

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())

print((X-Z)//(Y+Z))

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())

print((X-Z)//(Z+Y))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

x -= 2 * z
print(x // (y + z) + x % (y + z) // y)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

x,y,z=list(map(int,input().split()))

print((x-z)//(y+z))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())

ans = 0

while y * ans + z * (ans+1) <= x:
    ans += 1

print(ans-1)

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())

print((X - Z) // (Y + Z))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

X, Y, Z = map(int, input().split())

used_space = Y + (Z * 2)
ans = 0

while True:
    if used_space > X:
        break
    used_space = used_space + Y + Z
    ans += 1

print(ans)

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
print((x - z) // (y + z))

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
ans = X // (Y+Z)
if X-(Y+Z)*ans >= Z:
    print(ans)
else:
    print(ans-1)

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
x-=z
print(x//(z+y))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

x -= z

print(x//(y+z))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())

x = x - z
print(int(x/(y+z)))

Submission status: Accepted

Solution code:
###==================================================
### import
#import bisect
#from collections import Counter, deque, defaultdict
#from copy import deepcopy
#from functools import reduce, lru_cache
#from heapq import heappush, heappop
#import itertools
#import math
#import string
import sys
### stdin
def input(): return sys.stdin.readline().rstrip()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip('\n') for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]
### stdout
def OutH(lst, deli=' '): print(deli.join(map(str, lst)))
def OutV(lst): print('\n'.join(map(str, lst)))
### setting
sys.setrecursionlimit(10 ** 6)
### utils
int1 = lambda x: int(x) - 1
### constants
INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)
###---------------------------------------------------

X, Y, Z = iInM()

ans = (X - Z) // (Y + Z)

print(ans)

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())
X-=Z
print(X//(Z+Y))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
ans = (x-z)//(y+z)
print(ans)

Submission status: Accepted

Solution code:
import math
def main():
  x,y,z = list(map(int,input().split()))
  print(int((x-z)/(y+z)))
main()

Submission status: Accepted

Solution code:
X,Y,Z=list(map(int,input().split()))
for i in range(100001):
  if X >= i * Y + ( i + 1 ) * Z:
    ans = i
print(ans)

Submission status: Accepted

Solution code:
import sys
X,Y,Z = map(int,input().split())

if not (1 <= X <= 10 ** 5 and 1 <= Y <= 10 ** 5 and 1 <= Z <= 10 ** 5):
    sys.exit()

if not (Y + 2*Z <= X):
    sys.exit()

max = 0
for I in range(int(X/(Y+Z))+1):
    if X - (Y * I + Z * (I + 1)) >= 0:
        max = I
print(max)

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

X,Y,Z = I()
print((X-Z)//(Y+Z))

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split())
X=X-Z
print(X//(Y+Z))

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())
print(1+(X-Y-2*Z)//(Y+Z))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

print((x-z) // (y+z))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
chair = (x - z) // (y + z)
print(chair)

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())

sum = 0

for i in range(1,X):
    if sum > X:
        ans = i-2
        break
    if sum == X:
        ans = i-1
        break
    else:
        sum = Y*i+Z*(i+1)

print(ans)

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
p = y + z + z
c = 0

while p <= x:
    c += 1
    p = p + y + z

print(c)

Submission status: Accepted

Solution code:
x,y,z = list(map(int,input().split()))

x -= z

print(x//(y+z))

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
print((a-c)//(b+c))

Submission status: Accepted

Solution code:
a,b,c=map(int, input().split())
print((a-b-2*c)//(b+c)+1)

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
print((x-z) // (y+z))

Submission status: Accepted

Solution code:
def mi():
    return map(int, input().split())

def ii():
    return int(input())

def main():
    X, Y, Z = mi()
    k = X//(Y+Z)
    r = X%(Y+Z)
    if r < Z:
        print(k-1)
    else:
        print(k)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
print((X - Z) // (Y + Z))

Submission status: Accepted

Solution code:
x, y, z = [int(s) for s in input().split()]
print((x - z) // (y + z))

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    a[0]-=a[2]*2
    print((a[0]+a[2])//(a[1]+a[2]))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
print((x - z) // (z + y))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
x = x-z
print(x //(y+z))

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())

for i in range(1,10**5):
    if Y*i + Z*(i+1) > X:
        print(i-1)
        break

Submission status: Accepted

Solution code:
X,Y,Z=map(int,input().split());print((X-Z)//(Y+Z))

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
i=(x-(y+2*z))//(y+z)
print(i+1)

Submission status: Accepted

Solution code:
a,s,d=map(int,input().split())
print((a-d)//(s+d))

Submission status: Accepted

Solution code:
X,Y,Z = map(int, input().split())
ans = X//(Y+Z) - 1
if ans*(Y+Z)+(Y+Z+Z) <= X: ans += 1
print(ans)

Submission status: Accepted

Solution code:
#!/usr/bin/python
# -*- Coding: utf-8 -*-

x, y, z = (int(i) for i in input().split())

n = int((x-z)/(y+z))

print(n)

Submission status: Accepted

Solution code:
x,y,z = map(int, input().split())

X = x - 2*z
n = X//(y+z)

if X - (y+z)*n >= y:
  print(n+1)
else:
  print(n)

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())

res=x-z
ans=0
while res>=y+z:
    res-=(y+z)
    ans+=1
print(ans)

Submission status: Accepted

Solution code:
def resolve():
    X, Y, Z = map(int, input().split())
    ans = 0
    while ans*Y+(ans+1)*Z <= X:
        ans += 1
    print(ans-1)
resolve()

Submission status: Accepted

Solution code:
x,y,z=map(int, input().split());print((x-z)//(y+z))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
x -= z
print(x // (y+z))

Submission status: Accepted

Solution code:
def main():
    x,y,z=map(int,input().split())
    x -= z
    print(x//(y+z))
        
if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
x-=z
print(x//(y+z))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())

ans = x // (y+z)
if x < ans * (y+z) + z:
    ans -= 1

print(ans)

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
ans = 0
X -= Z
for _ in range(X):
    if X < (Y + Z):
        print(ans)
        break
    else:
        ans += 1
        X -= (Y + Z)

Submission status: Accepted

Solution code:
x,y,z=map(int,input().split())
ans=0
while(1):
    ans+=1
    if ans*y+(ans+1)*z>x:
        print(ans-1)
        exit()

Submission status: Accepted

Solution code:
z,y,x=map(int,input().split())
z-=x*2+y
count=1
while(1):
  z-=y+x
  if z<0:
    break
  count+=1
print(count)

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
print((A-C)//(B+C))

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
ans = x // (y + z)
if x % (y + z) < z:
  ans -= 1
print(ans)

Submission status: Accepted

Solution code:
x,y,z = map(int, input().split())

print ((x-z) // (y+z ))

Submission status: Accepted

Solution code:
a,b,c=map(int,input().split())
print(int((a-c)/(b+c)))

Submission status: Accepted

Solution code:
X,Y,Z = map(int,input().split())
count = 0
wide = Z+Y+Z
while X >= wide:
    count+=1
    wide +=Z+Y
print(count)

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
ans = 0
for i in range(10**5):
    if i*y + (i+1)*z <= x:
        pass
    else:
        break
print(i-1)

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
X -= Z
people = 0
while X >= 0:
    X -= (Y + Z)
    if X >= 0:
        people += 1
print(people)

Submission status: Accepted

Solution code:
def ABC_78_B():
    X,Y,Z = map(int, input().split())
    sum=0
    N=0
    while sum<= X:
        sum = Y*N+Z*(N+1)
        N+=1  
    print(N-2)


if __name__ == '__main__':

    ABC_78_B()

Submission status: Accepted

Solution code:
x, y, z = (int(i) for i in input().split())

ans, mod = divmod(x, y+z)
if mod >= z:
    print(ans)
else:
    print(ans-1)

Submission status: Accepted

Solution code:
X, Y, Z = list(map(int, input().split()))
print((X-Z)//(Z+Y))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())

x -= z

print(x // (y + z))

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
for i in range(100000):
    if X / (i* Y + (i + 1) * Z) >= 1:
        pass
    else:
        print(i - 1)
        break

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
X -= 2 * Z

ans, r = divmod(X, Y + Z)
if r >= Y:
    ans += 1
print(ans)

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
print((X-Z) // (Y+Z))

Submission status: Accepted

Solution code:
x,y,z = map(int,input().split())
s = z
count = 0

for i in range(10**99):
  s += y
  if s <= x-z:
    count += 1
  elif s> x-z:
    break
  s+= z
  
print(count)

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

x, y, z = map(int, readline().split())
q = x // (y + z)
r = x % (y + z)
ans = q if z <= r else q - 1
print(ans)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

def main():
    x,y,z = map(int, input().split())

    print((x-z)//(y+z))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    x, y, z = mi()
    print((x-z)//(y+z))


if __name__ == "__main__":
    main()