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

Solution (Python):
import numpy as np
import math
import fractions


class KyoPro:
    AtCoder_Mod = 1000 * 1000 * 1000 + 7

    def ReadListOfNumbers():
        return list(map(int, input().split()))

    @staticmethod
    def MakeStringFromNumbers(a):
        if len(a) == 0:
            return
        s = str(a[0])

        for i in range(1, len(a)):
            s += ' ' + str(a[i])

        return s

    
    @staticmethod
    def BinarySearch(ls, target, func):
        if(func is None):
            def func(a, b): return a < b

        def eq(a, b): return (not func(a, b)) and (not func(b, a))

        left = 0
        right = len(ls) - 1

        while(True):
            if(right - left < 10):
                for i in range(left, right + 1):
                    if(eq(ls[i], target)):
                        return True
                return False

            center = (left + right) // 2
            if(eq(ls[center], target)):
                return True
            if(func(ls[center], target)):
                left = center
            if(func(target, ls[center])):
                right = center


class cin:
    InputList = []

    def __init__(self):
        pass

    def Read(self):
        cin.InputList += input().split()

    def ReadInt(self):
        if(len(cin.InputList) == 0):
            self.Read


def main():
    temp = KyoPro.ReadListOfNumbers()
    x = temp[0]
    y = temp[1]
    z = temp[2]

    y += z
    x -= z

    print(x // y)


main()

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

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

Solution (Python):
X, Y, Z = map(int, input().split())
ans = 0
tmp = Z
while X >= tmp:
    tmp += Y + Z
    if tmp <= X:
        ans += 1

print(ans)

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

Solution (Python):
a, b, c = map(int, input().split())
p = 0
for i in range(a):
  if (b + c) * i + c <= a:
    p = i
  else:
    break
print(p)

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

Solution (Python):

import sys
import copy
import collections
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import math






def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
 
def main():
    x,y,z = map(int, input().split())
    
    x = x-z
    y = y+z
    print(x//y)
            	
if __name__ == "__main__":
	main()

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

Solution (Python):
x, y, z = map(int, input().split())
ans = 0
space = z
while space <= x:
    ans += 1
    space += y+z
if space > x:
    ans -= 1
print(ans)

Solution (Python):
x, y, z = map(int, input().split())
c = 0
while True:
    x -= z + y
    if x >= z:
        c += 1
    else:
        break
print(c)

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

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

Solution (Python):
a, b, c = map(int, input().split())
d = a - c
e = 0
while True:
    if d >= (b + c):
        d = d - (b + c)
        e += 1
    else:
        break
print(e)

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

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

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

n = int(x/(y+z))
res = 0
total = 0
for i in range(n):
    if i  ==  0:
        total += z*2+y
    else:
        total += z+y
    if total <= x:
        res += 1
    else:
        break
print(res)

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

Solution (Python):

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

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()))



sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

X, Y, Z = MAP()
X -= Z
y = Y + Z
print(X // y)

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

Solution (Python):
X, Y, Z = [int(xyz) for xyz in input().split()]
ans = 0
X -= Z
while X >= Y+Z:
  X -= Y+Z
  ans += 1
print(ans)

Solution (Python):

import math
X, Y, Z = map(int, input().split())
print(math.floor((X - Z) / (Y + Z)))

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

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

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

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

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

a = x // (y + z)
b = (y + z) * a

ans = a

if b + z > x:
    ans -= 1

print(ans)

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

Solution (Python):
X, Y, Z = map(int, input().split())
ans = 0

while X > Y + Z:
    X -= Y + Z
    ans += 1
if X < Z:
    ans -= 1
print(ans)

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

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

n = 1

while True:
    if y * n + z * (n+1) <= x:
        n += 1
    else:
        print(n-1)
        break

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

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

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

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

Solution (Python):
x,y,z = map(int,input().split())
cnt=0
s=z+z+y
while(True):
    if s>x:
        break
    else:
        cnt+=1
    s+=y+z
print(cnt)

Solution (Python):
X, Y, Z = map(int, input().split())
ans = 1
X -= (Y + 2 * Z)
if X < 0:
    print(0)
elif X == 0:
    print(1)
else:
    while X >= 0:
        X -= (Y + Z)
        if X >= 0:
            ans += 1
        else:
            break
    print(ans)

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

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

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

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

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

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


add_s = x % (y + z)  
if add_s < z:
  print(x // (y+z) - 1)
else:
  print(x // (y+z))

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

L = X - Z
if L <= 0:
    print(0)
print(L // (Y+Z))

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

Solution (Python):



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

while True:
    if X >= Y * i + Z * (i + 1):
        i += 1
        continue
    else:
        print (i - 1)
        exit()

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

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

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

Solution (Python):
x,y,z=map(int,input().split())
for i in range(100001):
    if (z+y)*i+z>x:
        print(i-1)
        break

Solution (Python):


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

X -= Z

print( X // (Y+Z) )

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

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

x=x-z

print(x//(y+z))

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

Solution (Python):
x,y,z = map(int,input().split())
n = x//(y+z)
while (n+1)*z + n*y > x:
    n= n-1
print(n)

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

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

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

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

Solution (Python):

import sys


def solve(X: int, Y: int, Z: int):
    print((X-Z)//(Y+Z))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    Y = int(next(tokens))  
    Z = int(next(tokens))  
    solve(X, Y, Z)

if __name__ == '__main__':
    main()

Solution (Python):
S=input().split()
X,Y,Z=int(S[0]),int(S[1]),int(S[2])
print((X-Z)//(Y+Z))

Solution (Python):
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

X, Y, Z = nl()

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

Solution (Python):


def solve():
    X, Y, Z = list(map(int, input().split()))

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

    print(ans)


if __name__ == "__main__":
    solve()

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

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

print(ans)

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

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

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

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

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


abc()

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

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

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

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

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

Solution (Python):
import bisect
import os
from collections import Counter, deque
from fractions import gcd
from functools import lru_cache
from functools import reduce
import functools
import heapq
import itertools
import math
import numpy as np
import re
import sys

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")


X, Y, Z = list(map(int, sys.stdin.readline().split()))

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

Solution (Python):
chair,width,isolate = map(int,input().split())
print((chair-isolate)//(width+isolate))

Solution (Python):


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

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

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

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

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

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

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

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

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

Solution (Python):



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

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

Solution (Python):


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



if __name__ == '__main__':
    main()

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

rem = x % (y+z)
if rem >= z:
  print(x // (y+z))
else:
  print(x // (y+z) - 1)

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

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

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

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


main()

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

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

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

if rest // Z ==0:
    print(ans - 1)
else:
    print(ans)

Solution (Python):











import sys
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial
from heapq import heappop, heappush, heappushpop
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    X, Y, Z = MI()
    X -= Z
    print(X//(Y+Z))
if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
X, Y, Z = [int(i) for i in input().split()]
print((X - Z) // (Y + Z))

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

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

count = 0
length = 0
while x >= (length + z):
  count += 1
  length += (y + z)

print(count - 1)

Solution (Python):

import sys
def input(): return sys.stdin.readline().rstrip()
def mi(): return map(int, input().split())


X, Y, Z = mi()




yz = X - (Y+ 2*Z)
print(1+yz//(Y+Z))

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

Solution (Python):
from sys import stdin
sp = stdin.readline().split()
X, Y, Z = int(sp[0]), int(sp[1]), int(sp[2])

l = X - 2 * Z - Y
print(l // (Y + Z) + 1)

Solution (Python):

import sys
INF = float("inf")


def solve(X: int, Y: int, Z: int):

    N = X // (Y+Z)
    if (Y+Z)*N + Z <= X:
        print(N)
    else:
        print(N-1)
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    Y = int(next(tokens))  
    Z = int(next(tokens))  
    solve(X, Y, Z)


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
X,Y,Z=[int(x) for x in stdin.readline().rstrip().split()]
ans = (X-Z) // (Y+Z)
print(ans)

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





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

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

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

Solution (Python):

x, y, z = [ int(v) for v in input().split() ]

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

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

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

Solution (Python):
from collections import Counter
from collections import deque
from functools import reduce
from pprint import pprint

import bisect
import copy
import fractions
import math
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def MI(): return map(int, sys.stdin.readline().split())
def II(): return int(sys.stdin.readline())
def IS(): return input()
def C(x): return Counter(x)
def GCD_LIST(numbers): return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers): return reduce(LCM, numbers)
def LCM(m, n): return (m * n // fractions.gcd(m, n))
def unite(x, y):
    
    x = root(x)
    y = root(y)
    if x == y:
        return
    
    node[x] = y
def same(x,y): return bool(root(x) == root(y))
def root(x):
    if node[x] == x:  
        return x
    else:
        node[x] = root(node[x])  
        return node[x]
def dfs(v):
    
    visited[v] = True
    for v2 in range(n):
        if graph[v][v2] == False:  
            continue
        if visited[v2] == True:  
            continue
        dfs(v2)


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

Solution (Python):
x,y,z = map(int,input().split())
sum = y + z*2
cnt = 1
while True:
    sum += y+z
    if x>=sum:
        cnt+=1
    else:
        break
print(cnt)

Solution (Python):
X,Y,Z = map(int,input().split())
X1 = X - 2*Z
count = 0

while X1 >= Y:
    count += 1
    X1 -= (Y + Z)
print(count)

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

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

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

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

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

Solution (Python):

x, y, z = map(int, input().split())
for i in range(10**5):
    if y*i+z*(i+1) > x:
        print(i-1)
        break

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

for n in range(X//Y,0,-1):
  if n*Y+(n+1)*Z <= X:
    print(n)
    exit()

Solution (Python):

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

N=1
while True:
  if N*Y+(N+1)*Z>X:
    break
  else:
    N+=1


print(N-1)

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LS()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007


def A():
    return


def B():
    return


def C():
    return


def D():
    x,y,z = LI()
    for i in range(1000000)[::-1]:
        if i*y+(i+1)*z <= x:
            print(i)
            quit()
    return


def E():
    d = [(1,0),(-1,0),(0,1),(0,-1)]
    h,w = LI()
    s = SR(h)
    for i in range(h):
        for j in range(w):
            if s[i][j] == "
                su = 0
                for dy,dx in d:
                    y = i+dy
                    x = j+dx
                    if 0 <= y < h and 0 <= x < w:
                        if s[y][x] == "
                            su += 1
                if su == 0:
                    print("No")
                    quit()
    print("Yes")
    return


def F():
    a,b,c,X,Y = LI()
    ans = float("inf")
    for z in range(300001):
        if z%2 == 0:
            m = c*z
            x = z//2
            y = z//2
            m += a*max(0,X-x)
            m += b*max(0,Y-y)
            if m < ans:
                ans = m
    print(ans)
    return


def G():
    n = I()
    x = LI()
    f = [(i,x[i]) for i in range(n)]
    f.sort(key = lambda x:x[1])
    g = [(f[i][0],i) for i in range(n)]
    g.sort(key = lambda x:x[0])
    for i in range(n):
        if g[i][1] < n//2:
            print(f[n//2][1])
        else:
            print(f[n//2-1][1])
    return


def H():
    return


def I_():
    return


def J():
    return


if __name__ == "__main__":
    D()

Solution (Python):
x,y,z = map(int,input().split())
a = int(x/(y+z))
b = x%(y+z)

if b < z:
    print(a-1)
else:
    print(a)

Solution (Python):


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

ans = 0
for i in range(10**5):
    ans += 1
    if ans*y + z*(ans+1) > x:
        break
print(ans-1)

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

Solution (Python):
x,y,z = map(int,input().split())
ans = 0 
for i in range(100000):
    if (y+z)*i + z <= x:
        ans = i
    else:
        break
print(ans)

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

Solution (Python):
X, Y, Z = map(int, input().split())
cnt = 0
width = Z
while width <= X:
    width += Y + Z
    if width <= X:
        cnt += 1
else:
    print(cnt)

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

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

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

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

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

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

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

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

Solution (Python):
a, b, c = (int(i) for i in input().split())  
print((a-c)//(b+c))

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

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

print(x//(y+z))

Solution (Python):
x,y,z=map(int,input().split())
max=0
for i in range(1,x+1):
	if i*y+(i+1)*z<=x:
		max=i
	if x<i*y+(i+1)*z:
		break
print(max)

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

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

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

ans = 0
remain = x - z
while True:
  if remain < y+z:
    break
  remain -= y+z
  ans +=1
print(ans)

Solution (Python):
from functools import reduce
import math

def main():
    
    
    
    

    
    
    
    
    
    

    
    

    
    
    
    
    
    
    
    
    
    INF = float("inf")

    
    MOD = 10**9+7
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    
    
    
    
    X, Y, Z = (int(_) for _ in input().split())
    
    print((X-Z)//(Y+Z))
    
if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
x,y,z=map(int,input().split())
for i in range(1,10**5+1):
    if y*i+z*(i+1)<=x<y*(i+1)+z*(i+2):
        print(i)
        break

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

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

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    x,y,z = f()
    cnt = x//(y+z)

    if  x%(y+z) >= z:
        print(cnt)
    else:
        print(cnt-1)


solve()

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

Solution (Python):

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


def submit():
    x, y, z = read_input()

    
    

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

if __name__ == '__main__':
    submit()

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

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

print(ans)

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

Solution (Python):


import sys
import math



def main(x,y,z):
	ret = 0
	while(1):
		if ret*(y+z)+z > x:
			return ret-1
		else:
			ret += 1


if __name__ == "__main__":
	X,Y,Z = map(int, input().split())
	print(main(X,Y,Z))

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

Solution (Python):
x, y, z = map(int, input().split())
count = x//(y+z)

if count*(y+z) + z <= x:
    print(count)
else:
    print(count-1)

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

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

Solution (Python):
import sys
from collections import Counter

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

Solution (Python):

x, y, z = list(map(int, input().rstrip().split()))
print((x - z) // (y + z))

Solution (Python):
X,Y,Z = [int(x) for x in input().split()]
print((X-Z)//(Y+Z))

Solution (Python):

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

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

Solution (Python):
x, y, z = map(int, input().split())
for i in range(200000):
    if x < y * i + z * (i + 1):
        print(i - 1)
        break

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

Solution (Python):
[X,Y,Z] = list(map(int,input().split()))
ans = -1
for i in range(100010):
    L = Y*i+Z*(i+1)
    if L <= X:
        ans = i
print(ans)

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

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

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

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

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

Solution (Python):
i = input().split()
x = int(i[0])
y = int(i[1])
z = int(i[2])
flag = True
n = 0
while(flag):
    n = n + 1
    if x< n*y + (n+1)* z:
        flag = False
print(n-1)

Solution (Python):
temp = input().split()

X = int(temp[0])
Y = int(temp[1])
Z = int(temp[2])

l = X
p_num = 0

while l >= Y+2*Z:
    p_num += 1
    l -= (Y+Z)

print(p_num)

Solution (Python):
txt = input()
dic = txt.split(" ")

x=int(dic[0])
y=int(dic[1])
z=int(dic[2])
zy= y+z
k=0

while(zy*k+z<=x):
    k+=1

print(k-1)

Solution (Python):
x,y,z = map(int,input().split())
n = x // (z + y)
c = 0
for i in range(1,n+1):
    if ( y + z ) * i + z <= x:
        c = i
    else:
        break
print(c)

Solution (Python):




N = input()
X, Y, Z = N.split()

Xh = int(X, 10)
Yh = int(Y, 10)
Zh = int(Z, 10)

sum = 0

for i in range(1, Xh):
    if (Yh+Zh)*i+Zh <= Xh:
        sum += 1
    else:
        break

print(sum)

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

print(ans)

Solution (Python):
x,y,z=map(int,input().split())
ans=0
p=0
while p<=x:
    ans+=1
    p=(ans+1)*z+ans*y

print(ans-1)

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

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

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

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

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

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

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

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

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

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

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

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

X -= (Y+Z)*ans

if X >= Y+2*Z:
    ans += 1
    X -= Y+2*Z
if X >= Y+Z:
    ans += 1

print(ans)

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

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

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

Solution (Python):
x,y,z=map(int,input().split())
l=x-z

print(l//(y+z))

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

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

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

Solution (Python):
x,y,z=map(int,input().split())
for i in range(1,100001):
    if i*y+(i+1)*z>x:
        key=i-1
        break
        
print(key)

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

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

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

n = 0
ans = 0
while n <= X:
    if Y * n + (1 + n) * Z <= X:
        ans = n
    n += 1
print(ans)

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

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

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

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

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

Solution (Python):
x, width, space = map(int, input().split())
N = 0
if x < width+space:
  print("0")
else:
    total_space = width + (space)
    N = (x- space) // total_space
print(N)

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

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

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

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

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

Solution (Python):
a, b, c = map(int, input().split())

print((a - c)// (b + c))

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

N = 0
while (N*Y+(N+1)*Z<=X):
    N+=1
print(N-1)

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

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

ans = 0
width_sum = 0

while 1:
    if width_sum + Y + Z <= X-Z:
        width_sum += Y + Z
        ans += 1
    else:
        break

print(ans)

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

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

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

Solution (Python):
import math
a,b,c=map(int,input().split())
a-=c
print(math.floor(a/(b+c)))

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

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

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

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

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

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

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

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

Solution (Python):
def solve(string):
    x, y, z = map(int, string.split())
    return str((x - z) // (y + z))


if __name__ == '__main__':
    print(solve(input()))