Problem:


Score: 100 points

Problem Statement

M-kun is a competitor in AtCoder, whose highest rating is X.

In this site, a competitor is given a kyu (class) according to his/her highest rating. For ratings from 400 through 1999, the following kyus are given:

From 400 through 599: 8-kyu

From 600 through 799: 7-kyu

From 800 through 999: 6-kyu

From 1000 through 1199: 5-kyu

From 1200 through 1399: 4-kyu

From 1400 through 1599: 3-kyu

From 1600 through 1799: 2-kyu

From 1800 through 1999: 1-kyu

What kyu does M-kun have?

Constraints

400 \leq X \leq 1999

X is an integer.

Input

Input is given from Standard Input in the following format:

X

Output

Print the kyu M-kun has, as an integer.
For example, if he has 8-kyu, print 8.

Sample Input 1

725

Sample Output 1

7

M-kun's highest rating is 725, which corresponds to 7-kyu.

Thus, 7 is the correct output.

Sample Input 2

1600

Sample Output 2

2

M-kun's highest rating is 1600, which corresponds to 2-kyu.

Thus, 2 is the correct output.



Sample input:
725


Sample output:
7

Submission status: Accepted

Solution code:
x = int(input())

if x >= 1800:
    print(1)
elif x >= 1600:
    print(2)
elif x >= 1400:
    print(3)
elif x >= 1200:
    print(4)
elif x >= 1000:
    print(5)
elif x >= 800:
    print(6)
elif x >= 600:
    print(7)
else:
    print(8)

Submission status: Accepted

Solution code:
n=int(input())
if n>=400 and n<=599:
    print("8")
elif n>=600 and n<=799:
    print("7")
elif n>=800 and n<=999:
    print("6")
elif n>=1000 and n<=1199:
    print("5")
elif n>=1200 and n<=1399:
    print("4")
elif n>=1400 and n<=1599:
    print("3")
elif n>=1600 and n<=1799:
    print("2")
elif n>=1800 and n<=1999:
    print("1")

Submission status: Accepted

Solution code:
a=int(input())
print(max(8-(a-400)//200,1))

Submission status: Accepted

Solution code:
kyu = int(input())

if 400 <= kyu  <= 599:
    print(8)
elif 600 <= kyu  <= 799:
    print(7)
elif 800 <= kyu  <= 999:
    print(6)
elif 1000 <= kyu  <= 1199:
    print(5)
elif 1200 <= kyu  <= 1399:
    print(4)
elif 1400 <= kyu  <= 1599:
    print(3)
elif 1600 <= kyu  <= 1799:
    print(2)
else:
    print(1)

Submission status: Accepted

Solution code:
x = int(input())
res = 10 - x // 200
print(res)

Submission status: Accepted

Solution code:
X = int(input())

n = 0
if X <= 599:
    n = 8
elif X <= 799:
    n = 7
elif X <= 999:
    n = 6
elif X <= 1199:
    n = 5
elif X <= 1399:
    n = 4
elif X <= 1599:
    n = 3
elif X <= 1799:
    n = 2
elif X <= 1999:
    n = 1

print(n)

Submission status: Accepted

Solution code:

X = int(input())

if X >=1800:
    print('1')
elif X >=1600:
    print('2')
elif X >=1400:
    print('3')
elif X >=1200:
    print('4')
elif X >=1000:
    print('5')
elif X >=800:
    print('6')
elif X >=600:
    print('7')
elif X >=400:
    print('8')

Submission status: Accepted

Solution code:
a=int(input())

if 400<=a<=599:
	print(8)
elif 600<=a<=799:
	print(7)
elif 800<=a<=999:
	print(6)
elif 1000<=a<=1199:
	print(5)
elif 1200<=a<=1399:
	print(4)
elif 1400<=a<=1599:
	print(3)
elif 1600<=a<=1799:
	print(2)
elif 1800<=a<=1999:
	print(1)

Submission status: Accepted

Solution code:
a = int(input())

if 400<=a and a<=599:
    print('8')
elif 600<=a and a<=799:
    print('7')
elif 800<=a and a<=999:
    print('6')
elif 1000<=a and a<=1199:
    print('5')
elif 1200<=a and a<=1399:
    print('4')
elif 1400<=a and a<=1599:
    print('3')
elif 1600<=a and a<=1799:
    print('2')
elif 1800<=a and a<=1999:
    print('1')

Submission status: Accepted

Solution code:
n=int(input())
if(n>=400 and n<=599):
    print(8)
if(n>=600 and n<=799):
    print(7)
if(n>=800 and n<=999):
    print(6)
if(n>=1000 and n<=1199):
    print(5)
if(n>=1200 and n<=1399):
    print(4)
if(n>=1400 and n<=1599):
    print(3)
if(n>=1600 and n<=1799):
    print(2)
if(n>=1800 and n<=1999):
    print(1)

Submission status: Accepted

Solution code:
n=int(input())
print(10-n//200)

Submission status: Accepted

Solution code:
print(10 - int(float(input())/200))

Submission status: Accepted

Solution code:
X =int( input())
if 400<= X and X<=599:
  print("8")
elif 600<= X and X<=799:
  print("7")
elif 800<= X and X<=999:
  print("6")
elif 1000<= X and X<=1199:
  print("5")
elif 1200<= X and X<=1399:
  print("4")
elif 1400<= X and X<=1599:
  print("3")
elif 1600<= X and X<=1799:
  print("2")
elif 1800<= X and X<=1999:
  print("1")

Submission status: Accepted

Solution code:
print(8 - (int(input()) // 200 - 2))

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 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 I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    n = I()

    return 10 - n // 200

print(main())

Submission status: Accepted

Solution code:
x = int(input())
a = x // 200
print((8 - a) + 2)

Submission status: Accepted

Solution code:
X = int(input())

if X >= 400 and X <= 599:
  print(8)
if X >= 600 and X <= 799:
  print(7)
if X >= 800 and X <= 999:
  print(6)
if X >= 1000 and X <= 1199:
  print(5)
if X >= 1200 and X <= 1399:
  print(4)
if X >= 1400 and X <= 1599:
  print(3)
if X >= 1600 and X <= 1799:
  print(2)
if X >= 1800 and X <= 1999:
  print(1)

Submission status: Accepted

Solution code:
X=int(input())
if X<=599:
  print(8)
elif 600<=X<=799:
  print(7)
elif 800<=X<=999:
  print(6)
elif 1000<=X<=1199:
  print(5)
elif 1200<=X<=1399:
  print(4)
elif 1400<=X<=1599:
  print(3)
elif 1600<=X<=1799:
  print(2)
elif 1800<=X<=1999:
  print(1)

Submission status: Accepted

Solution code:
x=int(input())
if x<600:
  print(8)
elif x<800:
  print(7)
elif x<1000:
  print(6)
elif x<1200:
  print(5)
elif x<1400:
  print(4)
elif x<1600:
  print(3)
elif x<1800:
  print(2)
else:
  print(1)

Submission status: Accepted

Solution code:
X = int(input())
print(10 - X//200)

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    X = int(input())
    if 400 <= X <= 599:
        print(8)
    elif 600 <= X <= 799:
        print(7)
    elif 800 <= X <= 999:
        print(6)
    elif 1000 <= X <= 1199:
        print(5)
    elif 1200 <= X <= 1399:
        print(4)
    elif 1400 <= X <= 1599:
        print(3)
    elif 1600 <= X <= 1799:
        print(2)
    else:
        print(1)


    

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n = int(input())

print(10 - n//200)

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 = I()
if 400 <= x <= 599:
    print(8)
elif 600 <= x <= 799:
    print(7)
elif 800 <= x <= 999:
    print(6)
elif 1000 <= x <= 1199:
    print(5)
elif 1200 <= x <= 1399:
    print(4)
elif 1400 <= x <= 1599:
    print(3)
elif 1600 <= x <= 1799:
    print(2)
elif 1800 <= x <= 1999:
    print(1)

Submission status: Accepted

Solution code:
n = int(input())

if(n>=400 and n<600):print(8)
elif(n>=600 and n<800):print(7)
elif(n>=800 and n<1000):print(6)
elif(n>=1000 and n<1200):print(5)
elif(n>=1200 and n<1400):print(4)
elif(n>=1400 and n<1600):print(3)
elif(n>=1600 and n<1800):print(2)
elif(n>=1800 and n<2000):print(1)

Submission status: Accepted

Solution code:
x=int(input())
if 400 <= x <= 599:
  print(8)
elif 600 <= x <= 799:
  print(7)
elif 800 <= x <= 999:
  print(6)
elif 1000 <= x <= 1199:
  print(5)
elif 1200 <= x <= 1399:
  print(4)
elif 1400 <= x <= 1599:
  print(3)
elif 1600 <= x <= 1799:
  print(2)
elif 1800 <= x <= 1999:
  print(1)
else:
  none

Submission status: Accepted

Solution code:
X=int(input())
if X<=599:
    k=8
elif 600<=X<=799:
    k=7
elif 800<=X<=999:
    k=6
elif 1000<=X<=1199:
    k=5
elif 1200<=X<=1399:
    k=4
elif 1400<=X<=1599:
    k=3
elif 1600<=X<=1799:
    k=2
else:
    k=1
print(k)

Submission status: Accepted

Solution code:
x=int(input())
now=400
for i in range(100):
    if now<=x<=now+199:
        print(8-i)
        break
    else:
        now+=200

Submission status: Accepted

Solution code:
import math
import collections
import fractions
import itertools
import functools
import operator

def solve():
    x = int(input())
    kyu = 8
    for i in range(400, 1801, 200):
        if i <= x <= i+199:
            print(kyu)
        kyu -= 1
    return 0

if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
import math as mt
import sys, string
from collections import Counter, defaultdict
input = sys.stdin.readline

MOD = 1000000007

# input functions
I = lambda : int(input())
M = lambda : map(int, input().split())
Ms = lambda : map(str, input().split()) 
ARR = lambda: list(map(int, input().split()))


def main():
    n = I()
    n -= 400
    print(8 - n//200)

# testcases
tc = 1
for _ in range(tc):
    main()

Submission status: Accepted

Solution code:
N=int(input())
if N>=400 and 599>=N:
  print('8')
if N>=600 and 799>=N:
  print('7')
if N>=800 and 999>=N:
  print('6')
if N>=1000 and 1199>=N:
  print('5')
if N>=1200 and 1399>=N:
  print('4')
if N>=1400 and 1599>=N:
  print('3')
if N>=1600 and 1799>=N:
  print('2')
if N>=1800 and 1999>=N:
  print('1')

Submission status: Accepted

Solution code:
a = int(input())
if (a >= 400) and (a <= 599) :
    print(8)
if (a >= 600) and (a <= 799) :
    print(7)
if (a >= 800) and (a <= 999) :
    print(6)
if (a >= 1000) and (a <= 1199) :
    print(5)
if (a >= 1200) and (a <= 1399) :
    print(4)
if (a >= 1400) and (a <= 1599) :
    print(3)
if (a >= 1600) and (a <= 1799) :
    print(2)
if (a >= 1800) and (a <= 1999) :
    print(1)

Submission status: Accepted

Solution code:
X=int(input())

kyu= 10 - X//200

print(kyu)

Submission status: Accepted

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

from pprint import pprint
from collections import deque, defaultdict
import itertools
import math
import sys

sys.setrecursionlimit(10 ** 6)
INF = float('inf')


rating = int(input())

if 400 <= rating <= 599:
    ans = 8
elif 600 <= rating <= 799:
    ans = 7
elif 800 <= rating <= 999:
    ans = 6
elif 1000 <= rating <= 1199:
    ans = 5
elif 1200 <= rating <= 1399:
    ans = 4
elif 1400 <= rating <= 1599:
    ans = 3
elif 1600 <= rating <= 1799:
    ans = 2
elif 1800 <= rating <= 1999:
    ans = 1

print(ans)

Submission status: Accepted

Solution code:
X=int(input())
grade=[10,9,8,7,6,5,4,3,2,1]
print(grade[X//200])

Submission status: Accepted

Solution code:
x = int(input())
ans = 8 - (x-400) // 200
print(ans)

Submission status: Accepted

Solution code:
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction

mod = 10 ** 9 + 7
mod1 = 998244353

# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")




# --------------------------------------------------binary------------------------------------
n=int(input())
n-=400
print(8-n//200)

Submission status: Accepted

Solution code:
print(abs(int(input())-2199)//200)

Submission status: Accepted

Solution code:
n=int(input())
print(abs(n-2199)//200)

Submission status: Accepted

Solution code:
x = int(input())

rl = 400

for i in range(8, 0, -1):
    if (rl <= x) and (x <= rl+199):
        print(i)
    rl += 200

Submission status: Accepted

Solution code:
A = int(input())
for i in range(8):
  if A < 400 + (i+1)*200:
    print(8-i)
    break
  else:
    continue

Submission status: Accepted

Solution code:
x = int(input())
 
if 400 <= x <= 599:
    print(8)
elif 600 <= x <= 799:
    print(7)
elif 800 <= x <= 999:
    print(6)
elif 1000 <= x <= 1199:
    print(5)
elif 1200 <= x <= 1399:
    print(4)
elif 1400 <= x <= 1599:
    print(3)
elif 1600 <= x <= 1799:
    print(2)
elif 1800 <= x <= 1999:
    print(1)

Submission status: Accepted

Solution code:
x = int(input())
if x <= 599:
    print(8)
elif x <=799:
    print(7)
elif x <= 999:
    print(6)
elif x <= 1199:
    print(5)
elif x <= 1399:
    print(4)
elif x <= 1599:
    print(3)
elif x <= 1799:
    print(2)
elif x <= 1999:
    print(1)

Submission status: Accepted

Solution code:
X = int(input())

print(8-(X-400)//200)

Submission status: Accepted

Solution code:
x = int(input())
cl = 10 - x // 200
print(cl)

Submission status: Accepted

Solution code:
x = int(input())

if 400 <= x <= 599:
    print(8)
elif 600 <= x <= 799:
    print(7)
elif 800 <= x <= 999:
    print(6)
elif 1000 <= x <= 1199:
    print(5)
elif 1200 <= x <= 1399:
    print(4)
elif 1400 <= x <= 1599:
    print(3)
elif 1600 <= x <= 1799:
    print(2)
elif 1800 <= x <= 1999:
    print(1)

Submission status: Accepted

Solution code:
x = int(input())
x -= 400
for i in range(1, 9):
	if x <= i * 200 - 1:
		print(9 - i)
		exit()

Submission status: Accepted

Solution code:
x = int(input())
print(8 - (x - 400) // 200)

Submission status: Accepted

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

def get_input() -> tuple:
    """
    標準入力を取得する.

    Returns:\n
        tuple: 標準入力
    """
    X = int(input())

    return X

def main(X: int) -> None:
    """
    メイン処理.

    Args:\n
        X (int): 最高レーティング（400 <= X <= 1999）
    """
    # 求解処理
    ans = 10 - (X // 200)

    # 結果出力
    print(ans)

if __name__ == "__main__":
    # 標準入力を取得
    X = get_input()

    # メイン処理
    main(X)

Submission status: Accepted

Solution code:
N = int(input())
print(10 - N//200)

Submission status: Accepted

Solution code:
 
# from math import factorial as fac
from collections import defaultdict
# from copy import deepcopy
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange
# print(f.readline())
# sys.setrecursionlimit(10**6)

	
def print_case_iterable(case_num, iterable):
	print("Case #{}: {}".format(case_num," ".join(map(str,iterable))))

def print_case_number(case_num, iterable):
	print("Case #{}: {}".format(case_num,iterable))

def print_iterable(A):
	print (' '.join(A))

def read_int():
	return int(f.readline().strip())
def read_int_array():
	return [int(x) for x in f.readline().strip().split(" ")]
def rns():
	a =  [x for x in f.readline().split(" ")]
	return int(a[0]), a[1].strip()
def read_string():
	return list(f.readline().strip())
def ri():
	return int(f.readline().strip())
def ria():
	return [int(x) for x in f.readline().strip().split(" ")]
def rns():
	a =  [x for x in f.readline().split(" ")]
	return int(a[0]), a[1].strip()
def rs():
	return list(f.readline().strip())
def bi(x):
	return bin(x)[2:]





from collections import deque
import math
NUMBER = 10**9 + 7
# NUMBER = 998244353
def factorial(n) : 
	M = NUMBER
	f = 1
  
	for i in range(1, n + 1):  
		f = (f * i) % M # Now f never can  
						# exceed 10^9+7  
	return f
def mult(a,b):
	return (a * b) % NUMBER

def minus(a , b):
	return (a - b) % NUMBER

def plus(a , b):
	return (a + b) % NUMBER

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		g, y, x = egcd(b % a, a)
		return (g, x - (b // a) * y, y)

def modinv(a):
	m = NUMBER
	g, x, y = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m
def choose(n,k):
	if n < k:
		assert false
	return  mult(factorial(n), modinv(mult(factorial(k),factorial(n-k)))) % NUMBER
from collections import deque, defaultdict 
import heapq


from types import GeneratorType
def bootstrap(f, stack=[]):
	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to

	return wrappedfunc


def dfs(g, timeIn, timeOut,depths,parents): 
	# assign In-time to node u 
	cnt = 0
	# node, neig_i, parent, depth
	stack = [[1,0,0,0]]
	while stack:
		v,neig_i,parent,depth = stack[-1]
		parents[v] = parent
		depths[v] = depth
		# print (v)
		if neig_i == 0:
			timeIn[v] = cnt    
			cnt+=1
		while neig_i < len(g[v]):
			u = g[v][neig_i]
			if u == parent:
				neig_i+=1
				continue
			stack[-1][1] = neig_i + 1
			stack.append([u,0,v,depth+1])
			break
		if neig_i == len(g[v]):
			stack.pop()
			timeOut[v] = cnt
			cnt += 1
  
# def isAncestor(u: int, v: int, timeIn: list, timeOut: list) -> str: 
# 	return timeIn[u] <= timeIn[v] and timeOut[v] <= timeOut[u] 

cnt = 0
@bootstrap
def dfs(v,adj,timeIn, timeOut,depths,parents,parent=0,depth=0):
	global cnt
	parents[v] = parent
	depths[v] = depth
	timeIn[v] = cnt
	cnt+=1
	for u in adj[v]:
		if u == parent:
			continue
		yield dfs(u,adj,timeIn,timeOut,depths,parents,v,depth+1)
	timeOut[v] = cnt
	cnt+=1
	yield 

def gcd(a,b): 
	if a == 0: 
		return b 
	return gcd(b % a, a) 
  
# Function to return LCM of two numbers 
def lcm(a,b): 
	return (a*b) / gcd(a,b) 
def get_num_2_5(n):
	twos = 0
	fives = 0
	while n>0 and n%2 == 0:
		n//=2
		twos+=1
	while n>0 and n%5 == 0:
		n//=5
		fives+=1
	return (twos,fives)
def shift(a,i,num):
	for _ in range(num):
		a[i],a[i+1],a[i+2] = a[i+2],a[i],a[i+1]

def equal(x,y):
	return abs(x-y) <= 1e-9
# def leq(x,y):
# 	return x-y <= 1e-9
def getAngle(a, b, c):
	ang = math.degrees(math.atan2(c[1]-b[1], c[0]-b[0]) - math.atan2(a[1]-b[1], a[0]-b[0]))
	return ang + 360 if ang < 0 else ang
def getLength(a,b):
	return math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)


from heapq import heapify, heappush, heappop

def bfs(adj):
	s = set()
	d = defaultdict(set)
	# print('\n'.join(map(str,E.items())))
	q = deque([])
	s.add(0)
	d[0].add(0)
	q.append((0,0))
	while len(q) > 0:
		v,depth = q.popleft()
		for u in adj[v]:
			if u not in s:
				s.add(u)
				d[depth+1].add(u)
				q.append((u,depth+1))
		# print(q)
	return d



def isSubsetSum(arr, n, summ): 
	  
	# The value of subarr[i][j] will be  
	# true if there is a 
	# subarr of arr[0..j-1] with summ equal to i 
	subarr =([[False for i in range(summ + 1)]  
			for i in range(n + 1)]) 
	  
	# If summ is 0, then answer is true  
	for i in range(n + 1): 
		subarr[i][0] = True
		  
	# If summ is not 0 and arr is empty,  
	# then answer is false  
	for i in range(1, summ + 1): 
		 subarr[0][i]= False
			  
	# Fill the subarr table in botton up manner 
	for i in range(1, n + 1): 
		for j in range(1, summ + 1): 
			if j<arr[i-1]: 
				subarr[i][j] = subarr[i-1][j] 
			if j>= arr[i-1]: 
				subarr[i][j] = (subarr[i-1][j] or 
								subarr[i - 1][j-arr[i-1]]) 
	  
	# uncomment this code to print table  
	# for i in range(n + 1): 
	# for j in range(summ + 1): 
	# print (subset[i][j], end =" ") 
	# print() 
	return subarr[n][summ] 

@bootstrap
def dfs(v,adj,vis,black):
	vis[v] = 1
	for u in adj[v]:
		if vis[u]==2:
			continue
		if vis[u] == 1:
			black.add((v,u)) 
			continue
		yield dfs(u,adj,vis,black)
	vis[v] = 2
	yield


def solution(n):
	n-=400
	n = 1600 - n
	return (n+199)//200


def main():
	T = 1
	# T = ri()
	for i in range(T):
		n = ri()
		# n,m = ria()
		# a = ria()

		# s = rs()
		# b = rs()
		# n,k,l	= ria()
		# a = ria()
		# adj = [list() for _ in range(n)]
		# for _ in range(m):
		# 	a,b=ria();
		# 	a-=1; b-=1
		# 	adj[a].append(b)

		x = solution(n)

		# continue
		if 'xrange' not in dir(__builtins__):
			print(x) # print("Case #"+str(i+1)+':',x)
		else:
			print >>output,str(x)
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()

if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()
#example usage:
#    for l in res:
#       print >>output, str(len(l)) + ' ' +  ' '.join(l)

if __name__ == '__main__':
	main()

Submission status: Accepted

Solution code:
x = int(input())

y = x - 400

print(8 - y//200)

Submission status: Accepted

Solution code:
x = int(input())
print((1999-x)//200+1)

Submission status: Accepted

Solution code:
x=int(input())

if(x>=600):
    if(x>=800):
        if(x>=1000):
            if(x>=1200):
                if(x>=1400):
                    if(x>=1600): 
                        if(x>=1800): print('1')
                        else: print('2')
                    else: print('3')
                else: print('4')
            else: print('5')
        else: print('6')
    else: print('7')
else: print('8')

Submission status: Accepted

Solution code:
def main():
    x = int(input())
    print(10 - x // 200)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
x = int(input())
j = 8
for low in range(400, 2000, 200):
  if low <= x < low + 200:
    print(j)
    break
  j -= 1

Submission status: Accepted

Solution code:
"""
    Satwik_Tiwari ;) .
    24th july , 2020  - Friday
"""

#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function

from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase

from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter  # Counter(list)  return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned

#==============================================================================================
#fast I/O region
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

# inp = lambda: sys.stdin.readline().rstrip("\r\n")

#===============================================================================================
#some shortcuts

mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var))  #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n")  #as stdout.write always print sring.
def testcase(t):
    for p in range(t):
        solve()
def printlist(a) :
    for p in range(0,len(a)):
        out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(a,b):
    ans = 1
    while(b>0):
        if(b%2==1):
            ans*=a
        a*=a
        b//=2
    return ans
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True

#===============================================================================================
# code here ;))

def solve():
    x = int(inp())
    if(x<600):
        print(8)
    elif(x<800):
        print(7)
    elif(x<1000):
        print(6)
    elif(x<1200):
        print(5)
    elif(x<1400):
        print(4)
    elif(x<1600):
        print(3)
    elif(x<1800):
        print(2)
    else:
        print(1)



testcase(1)
# testcase(int(inp()))

Submission status: Accepted

Solution code:
X=int(input())
if 400<=X<=599:
    print(8)
elif 600<=X<=799:
    print(7)
elif 800<=X<=999:
    print(6)
elif 1000<=X<=1199:
    print(5)
elif 1200<=X<=1399:
    print(4)
elif 1400<=X<=1599:
    print(3)
elif 1600<=X<=1799:
    print(2)
elif 1800<=X<=1999:
    print(1)

Submission status: Accepted

Solution code:
x=int(input())

#ans=0
#if x>=400 and x<600:ans=8
#if x>=600 and x<800:ans=7
#if x>=800 and x<1000:ans=6
#if x>=1000 and x<1200:ans=5
#if x>=1200 and x<1400:ans=4
#if x>=1400 and x<1600:ans=3
#if x>=1600 and x<1800:ans=2
#if x>=1800 and x<2000:ans=1

ans=8-(x-400)//200
print(ans)

Submission status: Accepted

Solution code:
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8') 
inf = float('inf') ;mod = 10**9+7 
mans = inf ;ans = 0 ;count = 0 ;pro = 1

read = sys.stdin.buffer.read
x = int(read())
print(10 - x//200)

Submission status: Accepted

Solution code:
X = int(input())

rankArr=[2000,1800,1600,1400,1200,1000,800,600,400]

for i in range(1,len(rankArr)):
  if rankArr[i] <= X and X < rankArr[i-1] :
    print(i)
    exit()

Submission status: Accepted

Solution code:
x=int(input())
if(x>=400 and x<=599):
  print("8")
if(x>=600 and x<=799):
  print("7")
if(x>=800 and x<=999):
  print("6")
if(x>=1000 and x<=1199):
  print("5")
if(x>=1200 and x<=1399):
  print("4")
if(x>=1400 and x<=1599):
  print("3")
if(x>=1600 and x<=1799):
  print("2")
if(x>=1800 and x<=1999):
  print("1")

Submission status: Accepted

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

# A - Kyu in AtCoder
X = int(input())

print(10 - X // 200)

Submission status: Accepted

Solution code:
X=int(input())

ans=[0,0,8,7,6,5,4,3,2,1]

print(ans[int(X/200)])

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 = int(readline())

    ans = 10 - X // 200

    print(ans)

    return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
X = int(input())

if X <= 599:
    print(8)
elif X <= 799:
    print(7)
elif X <= 999:
    print(6)
elif X <= 1199:
    print(5)
elif X <= 1399:
    print(4)
elif X <= 1599:
    print(3)
elif X <= 1799:
    print(2)
elif X <= 1999:
    print(1)

Submission status: Accepted

Solution code:
x = int(input())

print(10 - x//200)

Submission status: Accepted

Solution code:
# A - Kyu in AtCoder
def main():
    X = int(input())
    print(10 - X // 200)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
x = int(input())
for i in range(2,10):
    if i <= x/200 < i+1:
        print(10-i)

Submission status: Accepted

Solution code:
X = int(input())

if 400 <= X <= 599:
  print(8)
elif 600 <= X <= 799:
  print(7)
elif 800 <= X <= 999:
  print(6)
elif 1000 <= X <= 1199:
  print(5)
elif 1200 <= X <= 1399:
  print(4)
elif 1400 <= X <= 1599:
  print(3)
elif 1600 <= X <= 1799:
  print(2)
elif 1800 <= X <= 1999:
  print(1)

Submission status: Accepted

Solution code:
# A - Kyu in AtCoder
def main():
    X = int(input())
    if X < 600:
        res = 8
    elif X < 800:
        res = 7
    elif X < 1000:
        res = 6
    elif X < 1200:
        res = 5
    elif X < 1400:
        res = 4
    elif X < 1600:
        res = 3
    elif X < 1800:
        res = 2
    else:
        res = 1
    print(res)


if __name__ == "__main__":
    main()