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:
nums = [int(i) for i in input().split()]
x = nums[0]
y = nums[1]
z = nums[2]

capacity = y + 2 * z
ans = 0
while(capacity <= x):
    if capacity == x:
        ans += 1
        break
    else:
        capacity += y + z
        ans += 1
print(ans)

Submission status: Accepted

Solution code:
import math

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

def ans(num, max):
    result = math.floor(max / num)
    print("{0}".format(result))

def main():
    max_length = X - Z
    each_space = Y + Z
    ans(each_space, max_length)

main()

Submission status: Accepted

Solution code:
# coding: utf-8
x,y,z=map(int,input().split())
cnt=z
hum=0
while 1:
    cnt+=y+z#isu to haba tasu
    if cnt>x:#koeruka handan
        break
    hum+=1#koetenakya hairu
print(hum)

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# coding: utf-8


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

seat = x
ans = 0

seat -= z
while True:
    if seat - (y+z) >= 0:
        ans += 1
        seat -= (y+z)
    else:
        break
print(ans)

Submission status: Accepted

Solution code:
a=input().split()
X=int(a[0])
Y=int(a[1])
Z=int(a[2])
p=int( X/(Y+Z) )
q=int( X%(Y+Z) )
if( q>=Z ):
 print(p)
else:
 print(p-1)

Submission status: Accepted

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

def read_line(*types): return [f(a) for a, f in zip(input().split(), types)]

x, y, z = read_line(int, int, int)

def f(i):
    return i * y + (i + 1) * z

i = 0
while True:
    if x < f(i + 1):
        break
    i += 1

print(i)

Submission status: Accepted

Solution code:
A = list(map(int, input().split()))

ans = (A[0]-A[2])//(A[1]+A[2])
print(ans)

Submission status: Accepted

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

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

num = math.floor(chair / (Y+Z))

print(num)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""078-b"""

import sys
import pprint
import re

import itertools
pp = pprint.PrettyPrinter(indent=2)

def main():
    """Main function."""
    x, y, z = list(map(int, input().split(' ')))

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


if __name__ == '__main__':
    sys.exit(main())

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X,Y,Z = [int(i) for i in input().split()]

counter = 0
sum = Z
while True:
    sum += Y+Z
    if sum > X:
        print(counter)
        break
    else:
        counter += 1

Submission status: Accepted

Solution code:
#!/usr/bin/python

from sys import stdin

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

# 13 3 1
# X >= (Y + Z) * n + Z
# (X - Z) / (Y + Z) >= n

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

Submission status: Accepted

Solution code:
x,y,z = [int(i) for i in input().split()]
def sum(n):
    return y * n + z * (n+1)
ans = (x-z) // (y + z)
print(ans)

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split(' '))
first = Y + 2*Z
follower = Y + Z
total = 0
if first < X:
    #total += first
    length = X - first
    num = length // follower + 1
elif first == X:
    num = 1
else:
    num = 0
print(num)

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 = x//(y+z)
if x-n*(y+z) >= z:
    print(n)
else:
    print(n-1)

Submission status: Accepted

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

S = int(X / (Y + Z))
T = X % (Y + Z)

if T < Z:
    S -= 1

print(S)

Submission status: Accepted

Solution code:
def main():
    x, y, z = map(int, input().split())
    x -= 2*z

    i, cnt = 0, 0
    while (1):
        if i%2 == 0:
            x -= y
            if x < 0:
                break
            cnt += 1
        else:
            x -= z
            if x < 0:
                break
        i += 1
    print(cnt)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

xyz = list(map(int, input().split()))
x = xyz[0]
y = xyz[1]
z = xyz[2]

width = z + y + z

num = 0

while(width <= x):
    width = width + y + z
    num = num + 1

print(num)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    x, y, z = map(int, input().split())

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

Submission status: Accepted

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

X,Y,Z=list( int(i) for i in input().split() )

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np


def getInput():
    """

    :return: list of list of str. 1st dim: row, 2nd dim: column.
    """
    separator = ' '
    ret_array = []
    while True:
        try:
            row = input().split(sep=separator)
            ret_array.append(row)
        except EOFError:
            break
    return ret_array


g = getInput()

# number
xyz = np.array(list(map(int, g[0])), dtype=np.int32)
print(np.int32(np.floor((xyz[0] - xyz[2]) / (xyz[1] + xyz[2]))))

Submission status: Accepted

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

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

Submission status: Accepted

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

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

main()

Submission status: Accepted

Solution code:
import sys

S = list(map(int,input().split()))

i=0
while(1):
	if S[1]*i+S[2]*(i+1)>S[0]:
		i-=1
		break
	i+=1
print(i)

Submission status: Accepted

Solution code:
#http://abc078.contest.atcoder.jp/
# -*- coding: utf-8 -*-
x,y,z = map(int,input().split())
print((x-z)//(y+z))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
X, Y, Z = map(int, input().split())
a, b = divmod(X, Y+Z)
if Z > b:
    a -= 1
print(a)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
from sys import stdin, stdout
from math import floor
def IL():return list(map(int, stdin.readline().split()))

def main():
    
    x,y,z = IL()
    x -= z
    print(floor(x/(y+z)))
if __name__ == "__main__": main()

Submission status: Accepted

Solution code:
import math
X,Y,Z=map(int,raw_input().split(' '))

#nY+(n+1)Z=X
#n(Y+Z)=X-Z
#n=X-Z/Y+Z

print int(math.floor((X-Z)*1.0/(Y+Z)))

Submission status: Accepted

Solution code:
import sys
line = sys.stdin.readline().strip()
x, y, z = map(int, line.split()[:3])
r = (x - z) // (y + z)
print(r)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
x, y, z = list(map(int, sys.stdin.readline().strip().split(" ")))

num = 0
x -= z
while x >= (y+z):
    x -= (y+z)
    num += 1
print(str(num))

Submission status: Accepted

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

l = 0
c = 0
while True:
    l += z
    if l >= x:
        break
    else:
        l += y
        if l+z > x:
            break
        else:
            c += 1

print(c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

x = x - 2 * z
count = 0
while x >= y:
    x = x - y - z
    count += 1

print(count)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

import copy
import math
A,B,C = input().split(" ")
A = int(A)
B = int(B)
C = int(C)

A = A - C
print(math.floor(A/(B+C)))

Submission status: Accepted

Solution code:
import sys,collections
sys.setrecursionlimit(10**7)
def Is(): return [int(x) for x in sys.stdin.readline().split()]
def Ss(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

x,y,z = Is()

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

Submission status: Accepted

Solution code:
import numpy as np
import bisect

X , Y ,Z = input().split()
X = int(X)
Y = int(Y)
Z = int(Z)
x = X - Z
print(int(x / (Y + Z)))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c=[int(i) for i in input().split()]
s=0
i=0
while s<=a-2*c:
    i=i+1
    s=b*i+c*(i-1)

print(i-1)

Submission status: Accepted

Solution code:
val = [int(x) for x in input().split()]

print((val[0]-val[2])//(val[1] + val[2]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
xyz = input().split()
x = int(xyz[0])
y = int(xyz[1])
z = int(xyz[2])
ans = (x - z) / (y + z)
print(math.floor(ans))

Submission status: Accepted

Solution code:
#!/usr/bin/env python
x, y, z = map(int, input().split())
print((x-z)//(y+z))

Submission status: Accepted

Solution code:
#B問題

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

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

print(ans)

Submission status: Accepted

Solution code:
# cook your dish here
# from math import * 
#for _ in range(int(input().strip())):
x,y,z=map(int,input().split())
print((x-z)//(y+z))

Submission status: Runtime Error

Solution code:

a,b,c = map(int,input().split())
#lis = list(map(int,input().split()))
print((a-c)//(b+z))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
64145 123 456

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
using System;
using System.Linq;
using System.Collections.Generic;
class Program
{
    static void Main(string[] args)
    {
      string[] input = Console.ReadLine().Split();
      int x = int.Parse(input[0]);
      int y = int.Parse(input[1]);
      int z = int.Parse(input[2]);
      
      Console.WriteLine( (x-z)/(y+z) );
      
    }
}

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
x=int(input(""))
y=int(input(""))
z=int(input(""))
answer= (x-z)//(z+y)
print(answer)
exit()

Submission status: Runtime Error

Solution code:
x=int(input(""))
y=int(input(""))
z=int(input(""))
answer= (x-z)//(z+y)
print(answer);

Submission status: Runtime Error

Solution code:
x=int(input(""))
y=int(input(""))
z=int(input(""))
answer= (x-z)//(z+y)
print(answer)

Submission status: Runtime Error

Solution code:
x=int(input(""))
y=int(input(""))
z=int(input(""))

print(x//(z+y))

Submission status: Runtime Error

Solution code:
x=int(input())
y=int(input())
z=int(input())

print(x//(z+y))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
package main

/*
	予め片方の一端を引いたぶんでかんがえればいいね
	(X-Z) // ((Y+Z)
*/

import (
	"bufio"
	"fmt"
	"os"
	"reflect"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

func main() {
	sc.Split(bufio.ScanWords)
	defer out.Flush() // !!!!coution!!!! you must use Fprint(out, ) not Print()
	/* --- code ---*/
	x, y, z := nextInt(), nextInt(), nextInt()
	fmt.Fprint(out, (x-z)/(y+z))
}

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}

func nextFloat64() float64 {
	a, _ := strconv.ParseFloat(next(), 64)
	return a
}

func nextInts(n int) []int {
	ret := make([]int, n)
	for i := 0; i < n; i++ {
		ret[i] = nextInt()
	}
	return ret
}
func nextFloats(n int) []float64 {
	ret := make([]float64, n)
	for i := 0; i < n; i++ {
		ret[i] = nextFloat64()
	}
	return ret
}
func nextStrings(n int) []string {
	ret := make([]string, n)
	for i := 0; i < n; i++ {
		ret[i] = next()
	}
	return ret
}

func PrintOut(src interface{}, joinner string) {
	switch reflect.TypeOf(src).Kind() {
	case reflect.Slice:
		s := reflect.ValueOf(src)
		for idx := 0; idx < s.Len(); idx++ {
			fmt.Fprintf(out, "%v", s.Index(idx))
			if idx < s.Len()-1 {
				fmt.Fprintf(out, "%s", joinner)
			} else {
				fmt.Fprintln(out)
			}
		}
	default:
		fmt.Fprintln(out, "fuck")
	}
}

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))

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

ans = 1
memo = y+2*z

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

print(ans-1)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

print((x-1)//(Y+Z))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

for i in range(49999):
  if (y*i) + z+(i+1) <= x
  cnt += 1
  
print(cnt)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

rem=x-y

print(int(rem/(y+z))

Submission status: Runtime Error

Solution code:
//includes
#include<iostream>
#include<vector>
#include<set>
#include<tuple>
#include<algorithm>
#include<cmath>
#include<string>
#include<stack>
#include<map>
#include<queue>
#include<iomanip>
#include<numeric>
#include<assert.h>
#include<cstring>
#include<unordered_map>
#include<bitset>

//macros and consts
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define all(a) (a).begin(),(a).end()
#define FOR(i,a,b) for(int i = (a); i < (b); i++)
#define FORE(i,a) for(auto &i : a)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define accm accumulate
#define Fi first
#define Se second
#define INF 1e9
#define mINF -1e9
#define endl "\n"
#define cont continue
#define brk break

//shorter types
using namespace std;
using ll = long long;
using vi = std::vector<int>;
using vc = std::vector<char>;
using vll = std::vector<long long>;
using vs = std::vector<string>;
using Mi = map<int,int>;
using Mll = map<ll,ll>;
using UMi = unordered_map<int,int>;
using UMll = unordered_map<ll,ll>;
using Pi = pair<int,int>;
using Pll = pair<ll,ll>;
using vPi = vector<Pi>;
using vPll = vector<Pll>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<ll>>;
using vvc = vector<vector<char>>;
using vvs = vector<vector<string>>;
using pqgi = priority_queue<int,vector<int>,greater<int>>;
using pqsi = priority_queue<int,vector<int>,less<int>>;
using pqgll = priority_queue<int,vector<int>,greater<int>>;
using pssll = priority_queue<int,vector<int>,less<int>>;
template<class T>
using vec = vector<T>;

//frequent functions and data
class Cpmath{
  public:
    template<typename T>
    static T gcd(T a, T b){
      if (a == 0) 
        return b; 
      return gcd(b % a, a); 
    }
    template<typename T>
    static T findGCD(vector<T> &arr, size_t n){
      T result = arr[0]; 
      for (size_t i = 1; i < n; i++) 
        result = gcd(arr[i], result); 
      return result; 
    }
    template<typename T>
    static bool is_prime(T n){
      if(n == 1){
        return false;
      }
      for(size_t i = 2 ; i <= pow(n,0.5) ; i++){
        if(n % i == 0){
          return false;
        }
      }
      return true;
    }
    static ll fact(ll n){
      if(n == 0){
        return 1LL;
      }
      else{
        return n * fact(n - 1);
      }
    }
    static ll permutation(int n, int r){
      assert(n >= r);
      ll ret = 1;
      for(int i = n ; i > n - r ; i--){
        ret *= i;
      }
      return ret;
    }
};

class NCR{
  private:
    static const int MAX = 210000;
    static const int MOD = 998244353;
    ll fac[MAX],finv[MAX],inv[MAX];
  public:
    void COMinit(){
      fac[0] = fac[1] = 1;
      finv[0] = finv[1] = 1;
      inv[1] = 1;
      for(int i = 2 ; i < MAX ; i++){
        fac[i] = fac[i-1] * i % MOD;
        inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
        finv[i] = finv[i-1] * inv[i] % MOD;
      }
    }
    ll COM(int n,int k){
      if(n < k) return 0;
      if(n < 0 || k < 0){
        return 0;
      }
      return fac[n] * (finv[k] * finv[n-k] % MOD) % MOD;
    }
};

struct BipartiteMatching {
    vector<vector<int>> E; int n, m; vector<int> match, dist;
    void init(int _n,int _m){n=_n,m=_m;E.resize(n+m+2);match.resize(n+m+2);dist.resize(n+m+2);}
    bool bfs() {
        queue<int> que;
        FOR(i, 1, n + 1) {
            if (!match[i]) dist[i] = 0, que.push(i);
            else dist[i] = INF;
        }
        dist[0] = INF;
        while (!que.empty()) {
            int u = que.front(); que.pop();
            if (u) for(auto &v : E[u]) if (dist[match[v]] == INF) {
                dist[match[v]] = dist[u] + 1;
                que.push(match[v]);
            }
        }
        return (dist[0] != INF);
    }
    bool dfs(int u) {
        if (u) {
            for(auto &v : E[u]) if (dist[match[v]] == dist[u] + 1) if (dfs(match[v])) {
                match[v] = u; match[u] = v;
                return true;
            }
            dist[u] = INF;
            return false;
        }
        return true;
    }
    void add(int a, int b) { b += n; E[a + 1].push_back(b + 1); E[b + 1].push_back(a + 1); }
    int whois(int x) { return match[x + 1] - 1; }
    int solve() {
        FOR(i, 0, n + m + 1) match[i] = 0;
        int res = 0;
        while (bfs()) FOR(i, 1, n + 1) if (!match[i] && dfs(i)) res++;
        return res;
    }
};

struct SegmentTree{
  private:
    int n;
    vector<int> node;
  public:
    SegmentTree(vector<int> v){
      int sz = v.size();
      n = 1;
      while(n < sz) n *= 2;
      node.resize(2 * n - 1 , INF);
      for(int i = 0 ; i < sz ; i++){
        node[i + n - 1] = v[i];
      }
      for(int i = n - 2 ; i >= 0 ; i--){
        node[i] = min(node[2*i+1],node[2*i+2]);
      }
    }
    void update(int x, int val){
      x += (n - 1);
      node[x] = val;
      while(x > 0){
        x = (x - 1) / 2;
        node[x] = min(node[2*x+1],node[2*x+2]);
      }
    }
    int getmin(int a, int b , int k = 0, int l = 0, int r = -1){
      if(r < 0){
        r = n;
      }
      if(r <= a || b <= l){
        return INF;
      }
      if(a <= l && r <= b){
        return node[k];
      }
      int vl = getmin(a,b,2*k+1,l,(l+r)/2);
      int vr = getmin(a,b,2*k+2,(l+r)/2,r);
      return min(vl,vr);
    }
};

template<class Abel> struct WUnionFind {
    vector<int> par;
    vector<int> rank;
    vector<Abel> diff_weight;

    WUnionFind(int n = 1, Abel SUM_UNITY = 0) {
        init(n, SUM_UNITY);
    }

    void init(int n = 1, Abel SUM_UNITY = 0) {
        par.resize(n); rank.resize(n); diff_weight.resize(n);
        for (int i = 0; i < n; ++i) par[i] = i, rank[i] = 0, diff_weight[i] = SUM_UNITY;
    }

    int root(int x) {
        if (par[x] == x) {
            return x;
        }
        else {
            int r = root(par[x]);
            diff_weight[x] += diff_weight[par[x]];
            return par[x] = r;
        }
    }

    Abel weight(int x) {
        root(x);
        return diff_weight[x];
    }

    bool issame(int x, int y) {
        return root(x) == root(y);
    }

    bool merge(int x, int y, Abel w) {
        w += weight(x); w -= weight(y);
        x = root(x); y = root(y);
        if (x == y) return false;
        if (rank[x] < rank[y]) swap(x, y), w = -w;
        if (rank[x] == rank[y]) ++rank[x];
        par[y] = x;
        diff_weight[y] = w;
        return true;
    }

    Abel diff(int x, int y) {
        return weight(y) - weight(x);
    }
};

struct UnionFind{
  vector<int> par;
  UnionFind(int n) : par(n,-1) {}
  void init(int n) {par.assign(n,-1);}
  int root(int x){
    if(par[x] < 0) return x;
    else return par[x] = root(par[x]);
  }
  bool issame(int x,int y){
    return root(x) == root(y);
  }
  bool merge(int x,int y){
    x = root(x);
    y = root(y);
    if (x == y) return false;
    if (par[x] > par[y]){
      swap(x,y);
    }
    par[x] += par[y];
    par[y] = x;
    return true;
  }
  int size(int x){
    return -par[root(x)];
  }
};

void YN(bool a){
  cout << (a?"YES":"NO") << endl;
}

void Yn(bool a){
  cout << (a?"Yes":"No") << endl;
}
void yn(bool a){
  cout << (a?"yes":"no") << endl;
}
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
template<typename T>
inline int digitsum(T num){
  int ret = 0;
  while(num){
    ret += num % 10;
    num /= 10;
  }
  return ret;
}
template<typename InputIt,typename T>
inline bool argexist(InputIt first,InputIt last,const T& x){
  if(std::find(first,last,x) != last){
    return true;
  }
  else{
    return false;
  }
}
template<typename InputIt,typename T>
inline int argfind(InputIt first, InputIt last, const T& x){
  auto it = find(first,last,x);
  return distance(first,it);
}
template<typename InputIt>
inline int argmax(InputIt first, InputIt last) {
    auto it = max_element(first, last);
    return distance(first, it);
}
template<typename InputIt>
inline int argmin(InputIt first, InputIt last) {
    auto it = min_element(first, last);
    return distance(first, it);
}
// you need sort before using this func
template<typename T>
inline void erasebv(vector<T>& c,T v){
  c.erase(remove(begin(c),end(c),v),end(c));
}
template<typename T>
inline void UNIQ(T& c) {
    c.erase(unique(begin(c), end(c)), end(c));
}
template<typename T>
inline T POP_BACK(vector<T>& que) {
    T x = que.back(); que.pop_back();
    return x;
}
template<typename T>
inline T POP_BACK(deque<T>& que) {
    T x = que.back(); que.pop_back();
    return x;
}
template<typename T>
inline T POP_FRONT(deque<T>& que) {
    T x = que.front(); que.pop_front();
    return x;
}
template<typename T, typename C>
inline T POP(stack<T,C>& stk) {
    T x = stk.top(); stk.pop();
    return x;
}
template<typename T, typename C>
inline T POP(queue<T,C>& que) {
    T x = que.front(); que.pop();
    return x;
}
template<typename T, typename Cont, typename Cmp>
inline T POP(priority_queue<T,Cont,Cmp>& que) {
    T x = que.top(); que.pop();
    return x;
}
template<typename T1, typename T2> ostream& operator<<(ostream& s, const pair<T1, T2>& p) {return s << "(" << p.first << ", " << p.second << ")";}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
  int len = v.size();
  for (int i = 0; i < len; ++i) {
    s << v[i]; if (i < len - 1) s << "\t";
  }
  return s;
}
template<typename T> ostream& operator<<(ostream& s, const vector< vector<T> >& vv) {
  int len = vv.size();
  for (int i = 0; i < len; ++i) {
  s << vv[i] << endl;
  }
  return s;
}

//graphs
namespace GraphLib{
  using Weight = int;
  struct Edge{
    int src,dst;
    Weight weight;
    Edge(int src,int dst,Weight weight):
      src(src),dst(dst),weight(weight){}
  };
  bool operator < (const Edge &e, const Edge &f) {
    return e.weight != f.weight ? e.weight > f.weight :
      e.src != f.src ? e.src < f.src : e.dst < f.dst;
  }
  using Edges = vector<Edge>;
  using Graph = vector<Edges>;
  using Array = vector<Weight>;
  using Matrix = vector<Array>;
  
  void shortestPath(const Graph &g, int s,
      vector<Weight> &dist, vector<int> &prev) {
    int n = g.size();
    dist.assign(n, INF); dist[s] = 0;
    prev.assign(n, -1);
    priority_queue<Edge> Q; // "e < f" <=> "e.weight > f.weight"
    for (Q.push(Edge(-2, s, 0)); !Q.empty(); ) {
      Edge e = Q.top(); Q.pop();
      if (prev[e.dst] != -1) continue;
      prev[e.dst] = e.src;
      FORE(f,g[e.dst]) {
        if (dist[f.dst] > e.weight+f.weight) {
          dist[f.dst] = e.weight+f.weight;
          Q.push(Edge(f.src, f.dst, e.weight+f.weight));
        }
      }
    }
  }
  vector<int> DijkstraBuildPath(const vector<int> &prev, int t) {
    vector<int> path;
    for (int u = t; u >= 0; u = prev[u])
      path.push_back(u);
    reverse(path.begin(), path.end());
    return path;
  }
}


//here begins your code
int X,Y,Z;
signed main(){
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  cin >> X >> Y >> Z;
  ll ret = 0;
  int i;
  for(i = 1 ; i < 100000 ; i++){
    if(Y * i + Z * (i + 1) > X){
      ret = i - 1;
      brk;
    }
  }
  cout << ret << endl;
  return 0;
}

Submission status: Runtime Error

Solution code:
if Y=n:
    z=n-1
    X＞n+(n-1)=2n-1
    これを満たすnが求める人数

Submission status: Runtime Error

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

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

print(math.floor(U))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
X, y, Z = map(int, input().split())
def solve():
  for i in range(int(X/Y)):
    if(X < i*Y+(i+1)*Z):
      print(i-1)
      return

solve()

Submission status: Runtime Error

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

Submission status: Runtime Error

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

A, B = input().split()

if int(A, 16) = int(B, 16):
    print('=')
elif int(A, 16) > int(B, 16):
    print('>')
elif int(A, 16) < int(B, 16):
    print('<')

Submission status: Runtime Error

Solution code:
# -*- coding: utf-8 -*-
X,Y,Z = map(int,input().split())
a = []
while X >= Z+Y:
  a.append(1)
else:
  break
print(sum(a))

Submission status: Runtime Error

Solution code:
from sys import stdin
 
x,y,z = stdin.readline().split( )

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

Submission status: Runtime Error

Solution code:
from sys import stdin
 
x,y,z = stdin.readline().split()

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
X=input()
Y=input()
Z=input()

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

Submission status: Runtime Error

Solution code:
X=int(input())
Y=int(input())
Z=int(input())

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

Submission status: Runtime Error

Solution code:

int X = 13
int Y = 3
int Z = 1
int W

W = (X/(Y+Z))-1

print("%d", W)

Submission status: Runtime Error

Solution code:
l = input().split()
print((l[0]-l[2])/(l[1]+l[2]))

Submission status: Runtime Error

Solution code:
int X = 13
int Y = 3
int Z = 1
int W

W = (X/(Y+Z))-1

print W

Submission status: Runtime Error

Solution code:
l = raw_input().split()
print((float(l[0])-float(l[2]))/(float(l[1])+float(l[2])))

Submission status: Runtime Error

Solution code:
l = raw_input().split()
h = float(l[0])/(float(l[1])+float(l[2]))
print(int(h-1))

Submission status: Runtime Error

Solution code:
l = raw_input().split()
h = int(l[0])/(int(l[1])+int(l[2]))
print(h)

Submission status: Runtime Error

Solution code:
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8

import math
import re
import sys
 
args = sys.argv

X = args[0]
Y = args[1]
Z = args[2]

# 人数
a = (X-Z)/(Y+Z)

print(int(a))