Problem:


Score : 100 points

Problem Statement

Takahashi is a member of a programming competition site, ButCoder.

Each member of ButCoder is assigned two values: Inner Rating and Displayed Rating.

The Displayed Rating of a member is equal to their Inner Rating if the member has participated in 10 or more contests. Otherwise, the Displayed Rating will be their Inner Rating minus 100 \times (10 - K) when the member has participated in K contests.

Takahashi has participated in N contests, and his Displayed Rating is R. Find his Inner Rating.

Constraints

All values in input are integers.

1 \leq N \leq 100

0 \leq R \leq 4111

Input

Input is given from Standard Input in the following format:

N R

Output

Print his Inner Rating.

Sample Input 1

2 2919

Sample Output 1

3719

Takahashi has participated in 2 contests, which is less than 10, so his Displayed Rating is his Inner Rating minus 100 \times (10 - 2) = 800.

Thus, Takahashi's Inner Rating is 2919 + 800 = 3719.

Sample Input 2

22 3051

Sample Output 2

3051



Sample input:
2 2919


Sample output:
3719

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

ni = lambda: int(ns())
ns = lambda: stdin.readline().rstrip()
na = lambda: list(map(int, stdin.readline().split()))

# code here
N, R = na()


if N >= 10:
    print(R)
else:
    print(R + 100*(10-N))

Submission status: Accepted

Solution code:
# ABC156A

def f(n, r):
    if n >= 10:
        print(r)
    else:
        print(r + 100 * (10 - n))

n, r = map(int, input().split())
f(n, r)

Submission status: Accepted

Solution code:
n, r = map(int, input().split())

if n >= 10:
    print(r)
else:
    print(r + 100*(10-n))

Submission status: Accepted

Solution code:
N, R = [int(x) for x in input().split()]

print(R + 100 * max(0, (10 - N)))

Submission status: Accepted

Solution code:
n,r = map(int, input().split())
if n >= 10:
    print(r)
else:
     print(r + 100*(10-n))

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n<10:
    
    rating=100*(10-n)+r
else:
    rating=r
    
print(rating)

Submission status: Accepted

Solution code:
N, R = map(int,input().split())
if N < 10:
	print(100*(10-N)+R)
else:
	print(R)

Submission status: Accepted

Solution code:
N,R = map(int,input().split())
if N >= 10:
    print(R)
else:
    print(R + 100*(10-N))

Submission status: Accepted

Solution code:
#A
n, r = map(int, input().split())
if n >= 10:
    print(r)
else:
    print(r + 100 * (10 - n))

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
if n>= 10:
  print(r)
else:
  print(r+100*(10-n))

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

if N < 10:
  print(R + (10-N)*100)
else:
  print(R)

Submission status: Accepted

Solution code:
import itertools
import math
import fractions
import functools

n,r = map(int, input().split())

if n >= 10:
    print(r)
else:
    print(r+100*(10-n))

Submission status: Accepted

Solution code:
n,r = map(int,input().split())
print(r if 10 <= n else r + 1000 - 100*n)

Submission status: Accepted

Solution code:
n,r = map(int, raw_input().split(' '))
def f(n,r):
  if n >= 10:
    return r
  else:
    return r + 100 * (10 - n)
print f(n,r)

Submission status: Accepted

Solution code:
n,r = map(int, input().split())
print(r if n>10 else r+100*(10-n))

Submission status: Accepted

Solution code:
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


def inp():
    '''
    一つの整数
    '''
    return int(input())


def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))


def comb(n, r):
    if n - r < r:
        r = n - r
    res = 1
    for i in range(r):
        res *= (n - i) % mod
        res %= mod
        res *= pow(r - i, mod - 2, mod)
        res %= mod
    return res


n, r = inpl()
print(r + 100 * (10 - min(n, 10)))

Submission status: Accepted

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


def main():
    N, R = map(int, input().split())
    print(R+100*(10-N)) if N < 10 else print(R)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
if n>=10:
    print(r)
else:
    ans = r + 100 * (10 - n)
    print(ans)

Submission status: Accepted

Solution code:
n, r = list(map(int, input().split()))
if n >= 10:
    print(r)
else:
    print(r + 100 * (10 - n))

Submission status: Accepted

Solution code:
n, r = map(int, input().split())
if n >= 10:
    ans = r
else:
    ans = r + 100*(10-n)
print(ans)

Submission status: Accepted

Solution code:
n, r = map(int, input().split())
print(r) if n >= 10 else print(r + 100 * (10 - n))

Submission status: Accepted

Solution code:
K,R = map(int,input().split())

if(K >= 10):
  ans = R
else:
  ans = R  + 100*(10-K)
print(ans)

Submission status: Accepted

Solution code:
def main():
    n, r = map(int, input().split())

    inner = 0
    if n >= 10:
        inner = r
    else:
        inner = r + 100*(10-n)

    print(inner)

main()

Submission status: Accepted

Solution code:
import math
import queue
from collections import defaultdict
 
def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))
def readChar():
	return input()
def readChars():
	return input().split()
def factorization(n):
	res = []
	if n%2==0:
		res.append(2)
	for i in range(3,math.floor(n//2)+1,2):
		if n%i==0:
			c = 0
			for j in res:
				if i%j==0:
					c=1
			if c==0:
				res.append(i)
	return res
def fact2(n):
	p = factorization(n)
	res = []
	for i in p:
		c=0
		z=n
		while 1:
			if z%i==0:
				c+=1
				z/=i
			else:
				break
		res.append([i,c])
	return res
def fact(n):#階乗
	ans = 1
	m=n
	for _i in range(n-1):
		ans*=m
		m-=1
	return ans
def comb(n,r):#コンビネーション
	if n<r:
		return 0
	l = min(r,n-r)
	m=n
	u=1
	for _i in range(l):
		u*=m
		m-=1
	return u//fact(l)
def printQueue(q):
	r=qb
	ans=[0]*r.qsize()
	for i in range(r.qsize()-1,-1,-1):
		ans[i] = r.get()
	print(ans)
def dq():
	return queue.deque()
class UnionFind():
	def __init__(self, n):
		self.n = n
		self.parents = [-1]*n

	def find(self, x): # root
		if self.parents[x]<0:
			return x
		else:
			self.parents[x] = self.find(self.parents[x])
			return self.parents[x]

	def union(self,x,y):
		x = self.find(x)
		y = self.find(y)

		if x==y:
			return

		if self.parents[x]>self.parents[y]:
			x,y = y,x

		self.parents[x]+=self.parents[y]
		self.parents[y]=x

	def size(self,x):
		return -1*self.parents[self.find(x)]

	def same(self,x,y):
		return self.find(x)==self.find(y)

	def members(self,x): # much time
		root = self.find(x)
		return [i for i in range(self.n) if self.find(i)==root]

	def roots(self):
		return [i for i,x in enumerate(self.parents) if x<0]

	def group_count(self):
		return len(self.roots())

	def all_group_members(self):
		return {r: self.members(r) for r in self.roots()} # 1~n
def bitArr(n):#ビット全探索
	x = 1
	zero = "0"*n
	ans = []
	ans.append([0]*n)
	for i in range(2**n-1):
		ans.append(list(map(lambda x:int(x),list((zero+bin(x)[2:])[-1*n:]))))
		x+=1
	return ans;
def arrsSum(a1,a2):
	for i in range(len(a1)):
		a1[i]+=a2[i]
	return a1

n,r = readInts()
k=n

if n>=10:
	print(r)
else:
	print(r+100*(10-k))

Submission status: Accepted

Solution code:
n, r = map(int, input().split())

if n >= 10:
    print(r)
else:
    print( r + 100 * (10-n))

Submission status: Accepted

Solution code:
n,m=map(int,input().split())
if n>=10:
    print(m)
else:
    print(m+(100*(10-n)))

Submission status: Accepted

Solution code:
n, r = [int(_) for _ in input().split()]
print(r if n >= 10 else r + 100 * (10 - n))

Submission status: Accepted

Solution code:

N,R = map(int,input().split())
if N>=10:
    print(R)
else:
    print(R+100*(10-N))

Submission status: Accepted

Solution code:
import sys
import math
import bisect

def main():
    n, m = map(int, input().split())
    if n < 10:
        m += 100 * (10 - n)
    print(m)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
N, R = list(map(int, input().split()))
if N < 10:
    print(R + 1000 - 100*N)
else:
    print(R)

Submission status: Accepted

Solution code:
N, R = map(int, input().split(' '))

if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))

Submission status: Accepted

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

if N >= 10:
    print(R)
else:
    print(R + 100*(10-N))

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

if N < 10:
    print(R + 100 * (10 - N))

else:
    print(R)

Submission status: Accepted

Solution code:
N,R = map(int,input().split())

print( R if N >= 10 else R + 100*(10-N))

Submission status: Accepted

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

if n < 10:
    inside_score = r + 100*(10 - n)
    print(inside_score)
else:
    print(r)

Submission status: Accepted

Solution code:
N,R = map(int, input().split())
if N >= 10:
  print(R)
else:
  print(R + 1000 - 100 * N)

Submission status: Accepted

Solution code:
N, R =(int(x) for x in input().split())
print(R if N>= 10 else R + 100 * (10 - N))

Submission status: Accepted

Solution code:
N,R = map(int,input().split())

if N >= 10:
    print(R)
else:
    print(R+(100*(10-N)))

Submission status: Accepted

Solution code:
def main():
    strA = input()
    listA = strA.split(" ")

    N = int(listA[0])
    R = int(listA[1])

    nRate = 0
    if N >= 10:
        nRate = R
    else:
        nRate = R + (100 * (10 - N))

    print(nRate)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N,  R = map(int, input().split())

if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))

Submission status: Accepted

Solution code:
n,r = map(int,input().split())
if n>=10:
    print(r)
else:
    print(r+100*(10-n))

Submission status: Accepted

Solution code:
import fileinput

n, r = map(int, input().split())

if n >= 10:
    print(r)
else:
    rr = r + 100 * (10 - n)
    print(rr)

Submission status: Accepted

Solution code:
def ABC_156_A():
    N,R = map(int, input().split())

    if N >= 10:
        print(R)
    else:
        print(R+100*(10-N))

if __name__ == '__main__':

    ABC_156_A()

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

if N < 10:
    print(R + 100*(10-N))
else:
    print(R)

Submission status: Accepted

Solution code:
n,r = map(int,input().split()) 
if n>=10 :
    print(r)
else :
    print(r+100*(10-n))

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
if n<10:
  print(int(r+100*(10-n)))
else:
  print(r)

Submission status: Accepted

Solution code:
import itertools
import math
import fractions
import functools
n, r = map(int, input().split())
if n >= 10: print(r)
else: print(r + 1000 - 100*n)

Submission status: Accepted

Solution code:
# Template 1.0
import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

n, r= MAP()

if(n<10):
    print(r + 100*(10-n))
else:
    print(r)

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
 
if n<10:
  print(r+100*(10-n))
else:
  print(r)

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
if n<10:
    print(r+100*(10-n))
else:
    print(r)

Submission status: Accepted

Solution code:
n,r=map(int,input().split())

if n>=10:
    print(r)
else:
    print(r+(100*(10-n)))

Submission status: Accepted

Solution code:
N,R = map(int, input().split())

if N >= 10:
    print(R)
else:
    N = 100 * (10 - N)
    print(R + N)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# 
n, r = map(int, input().split())

if n >= 10:
  print(r)
else:
  print(r + 100 * (10 - n))

Submission status: Accepted

Solution code:
N,R = map(int,input().split())

if N <10:
    print(R+100*(10-N))
else:
    print(R)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
if N < 10:
  print(R + (100 * (10 - N)))
else:
  print(R)

Submission status: Accepted

Solution code:
n, r = list(map(int, input().split()))
if n >= 10:
    print(r)
else:
    print(r + (100 * (10 - n)))

Submission status: Accepted

Solution code:
N,R=list(map(int,input().split()))
if N<10:
    R=R+100*(10-N)
    print(R)
else:
    print(R)

Submission status: Accepted

Solution code:
K,N = map(int ,input().split())

if K>=10:
    print(N)
else:
    print(N+100*(10-K))

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

ans = 0

if N < 10:
    ans = R + 100*(10-N)
else:
    ans = R

print(ans)

Submission status: Accepted

Solution code:
N,R = [int(s) for s in input().split()]

if N >= 10:
    print(R)
else:
    print(R + (100 * (10 - N)))

Submission status: Accepted

Solution code:
n,r=map(int,input().split())

if n>=10:
  print(r)
elif n<10:
  print(r+(100*(10-n)))

Submission status: Accepted

Solution code:
import sys
#from collections import defaultdict, deque, Counter
#from bisect import bisect_left
#import heapq
#import math
#from itertools import groupby as gb
#from itertools import permutations as perm
#from itertools import combinations as comb
#from fractions import gcd
#import numpy as np

stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

#n = int(stdin.readline().rstrip())
#l = list(map(int, stdin.readline().rstrip().split()))
n,r = map(int, stdin.readline().rstrip().split())
#AB = [list(map(int, stdin.readline().rstrip().split())) for _ in range(n)]

if n >= 10:
    print(r)
else:
    print(r+100*(10-n))

Submission status: Accepted

Solution code:
N, R = map(int,input().split())

if N >= 10:
  print(R)
else:
  print(R + 100 * (10 - N))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
N,R=map(int,input().split())
print(R+100*(10-min(N, 10)))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Thu May  7 21:55:53 2020

@author: shinba
"""

N,R = map(int,input().split())

if N >= 10:
    print(R)
else:
    print(R+100*(10-N))

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
if N >= 10:
  print(R)
else:
  inter_r = 100 * (10-N)
  print(R + inter_r)

Submission status: Accepted

Solution code:
N,R = map(int,input().split())
if N >= 10:
    print(R)
elif N < 10:
    print(R + (100*(10-N)))

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
if a<10:
    print(100*(10-a)+b)
else:
    print(b)

Submission status: Accepted

Solution code:
from sys import stdin


def main():
    n, r = map(int, stdin.readline().split())
    if n >= 10:
        print(r)
    else:
        print(r + 100 * (10 - n))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

if N < 10:
    r = R + 100 * (10 - N)
else:
    r = R
print(r)

Submission status: Accepted

Solution code:
n, r = map(int, input().split())


if n<10:
    ans = r + 100*(10-n)
else:
    ans = r

print(ans)

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
if n < 10:
  print(str(r+100*(10-n))+"\n")
else:
  print(str(r)+"\n")

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n >= 10:
    print(r)
else:
    print(r + 100*(10-n))

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
if a>=10:
    print(b)
else:
    print(b+100*(10-a))

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n < 10:
    print(100 * (10 - n) + r)
else:
    print(r)

Submission status: Accepted

Solution code:
N, R  = list(map(int,input().split()))
if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))

Submission status: Accepted

Solution code:
# A - Beginner

N, R = map(int, input().split())
print(R if 10 <= N else R + 100 * (10 - N))

Submission status: Accepted

Solution code:
N,R = map(int,input().split())
if N >= 10 :
    print(R)
else :
    R = R + 100 * (10 - N)
    print(R)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
if N > 10:
    print(R)
else:
    print(R+100*(10-N))

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n < 10:
    ans = r+100*(10-n)
else:
    ans = r
print(ans)

Submission status: Accepted

Solution code:
def main():
    import sys
    input = sys.stdin.readline

    N, R = map(int, input().split())
    if N < 10:
        K = N
    else:
        K = 10
    print(R+100*(10-K))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
n, r = list(map(int,input().strip().split()))
print(r + ((10-n)*100) if n < 10 else r)

Submission status: Accepted

Solution code:
a,b = map(int,input().split())
ans = b if a >= 10 else b + 100 * (10-a)
print(ans)

Submission status: Accepted

Solution code:
N,R = map(int,input().split())
if N >= 10:
  print(R)
else:
  print(R+100*(10-N))

Submission status: Accepted

Solution code:
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations, accumulate
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
import sys
def I(): return int(input())  # '123' -> 123
def Is(): return map(int, input().split())  # '123 456' -> 123, 456
def LI(): return list(map(int, input().split()))  # '123 456' -> [123, 456]
def TI(): return tuple(map(int, input().split()))  # '123 456' -> (123, 456)
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()  # 'aa bb' -> 'aa','bb' or ['aa','bb']
def LS(): return list(input())  # 'abc123' -> ['a','b','c','1','2','3']
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(1000000)
MOD = 1000000007
INF = float('inf')

n, r = Is()
if n < 10:
    print(r+100*(10-n))
    exit()
print(r)

Submission status: Accepted

Solution code:
n, r = map(int, input().split())
ans = 0
if n >= 10:
    ans = r
else:
    ans = r + 100 * (10 - n)
print(ans)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
if N < 10:
    ans = R + 100 * (10 - N)
else:
    ans = R
print(ans)

Submission status: Accepted

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


def solve(N: int, R: int):
    if N >= 10:
        print(R)
    if N < 10:
        print(R + 100*(10-N))
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    R = int(next(tokens))  # type: int
    solve(N, R)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n, r = list(map(int, input().split()))
ans = 0 #naibu
if n >= 10:
    ans = r
else:
    ans = r + 100 * (10 - n)

print(ans)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n,r = [int(i) for i in readline().split()]

if n >= 10:
    print(r)
else:
    print(r+100*(10-n))

Submission status: Accepted

Solution code:
N,R = (int(x) for x in input().split())

if N >= 10:
    print(R)
else:
    print(R+(10- N)*100)

Submission status: Accepted

Solution code:
n, r = map(int, input().split())
if n < 10:
    print(r+100*(10-n))
else:
    print(r)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())  #数字

if N >= 10:
    print(R)
else:
    print(R + 100*(10-N))

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
if N <= 10:
    print(R + 100*(10 - N))
else:
    print(R)

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
N, R = map(int, input().split())
if N>=10:
    print(R)
else:
    print(R+(100*(10-N)))

Submission status: Accepted

Solution code:
N, R = [int(_) for _ in input().split()]
if N >= 10:
    print(R)
else:
    print(R + 100 * (10 - N))

Submission status: Accepted

Solution code:
N,R=map(int, input().split())

if N>=10:
  ans=R
else:
  ans=R+100*(10-N)
print(ans)

Submission status: Accepted

Solution code:
n , r = map(int , input().split())
ans = 0
if n >= 10:
    ans = r
else:
    ans = r + 100*(10 - n)
print(ans)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

if N > 10:
    print(R)
else:
    print(R + 100 * (10 - N))

Submission status: Accepted

Solution code:
N,R=input().split()
n=int(N)
r=int(R)

if 10<=n:
    a=r
else:
    a=r+100*(10-n)
print(a)

Submission status: Accepted

Solution code:
N,R = map(int,input().split())
if N >= 10:
    print(R)
else:
    print(R+100*(10-N))

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
if n>=10:
    rate=r
else:
    rate=r+100*(10-n)
print(rate)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
print(R + 100*(10-N)) if N < 10 else print(R)

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
if n<10:
    print(r + 100*(10-n))
else:
    print(r)

Submission status: Accepted

Solution code:
n, r = map(int, input().split())
if n <= 10:
    print(r + 100 * (10 - n))
else:
    print(r)

Submission status: Accepted

Solution code:
A = list(map(int, input().split()))
N=A[0]
R=A[1]
if N>=10:
  print(R)
else:
  print(100*(10-N)+R)

Submission status: Accepted

Solution code:
N,R=map(int,input().split())
if N < 10:
    ans=R+(10-N)*100
else:
    ans=R
print(ans)

Submission status: Accepted

Solution code:
N,R = map(int,input().split())
print(R) if N>=10 else print(R+100*(10-N))

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
print(r if n>=10 else r+100*(10-n))

Submission status: Accepted

Solution code:
n, r = map(int, input().split())
ans = r if n > 10 else 100 * (10 - n) + r
print(ans)

Submission status: Accepted

Solution code:
def solve():
    n, r = map(int, input().split())
    return r + max(0, 100 * (10-n))

print(solve())

Submission status: Accepted

Solution code:

n, k = map(int, input().split())
if(n >= 10):
	print(k)
else:
	print(k + 100 * (10 - n))

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
if N >= 10:
  rate = R
else:
  rate = R + 100 * (10 - N)
print(rate)

Submission status: Accepted

Solution code:
N,R=map(int,input().split())

if N>=10:
    print(R)
    
else:
    print(R+100*(10-N))

Submission status: Accepted

Solution code:
N,R = map(int,input().split())
ans =0
if N >= 10:
    ans = R
else:
    ans = R + 100*(10-N)
print(ans)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

if N >= 10:
    print(R)
else:
    print(R + 1000 - 100 * N)

Submission status: Accepted

Solution code:
n,r=map(int,input().split())

ans=r

if n< 10:
  ans=r+100*(10-n)

print(ans)

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if(n >= 10):
    print(r)
else:
    print(r+100*(10-n))

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

if N >= 10:
    print(R)

else:
    print(R + 100*(10-N))

Submission status: Accepted

Solution code:
# coding: utf-8
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N, R = lr()
answer = R
if N < 10:
    answer += (10-N) * 100
print(answer)

Submission status: Accepted

Solution code:
n, r = map(int, (input().split()))
print(100 * max(0, 10 - n) + r)

Submission status: Accepted

Solution code:
n, r = map(int, (input().split()))
print(r + (100 * max(0, (10 - n))))

Submission status: Accepted

Solution code:
N,R=map(int,input().split())
u=0
if N>=10:
  u=R
else:
  u=R+100*(10-N)
print(u)

Submission status: Accepted

Solution code:
#-*- coding: utf-8 -*-
n,r = map(int,input().split())
print(r + (100 * (10-n)) if n < 10 else r)

Submission status: Accepted

Solution code:
a,b=map(int,input().split(" "))
if a<10:
    print(b+100*(10-a))
else:
    print(b)

Submission status: Accepted

Solution code:
N,R = map(int,input().split())
if N >= 10:
    print(R)
else:
    print(R + 100*(10-N))

Submission status: Accepted

Solution code:
def input_num():
	ls = input().strip().split(" ")
	return [int(e) for e in ls]

n,r = input_num()
if n >= 10:
	print(r)
else:
	print(r+100*(10-n))

Submission status: Accepted

Solution code:
N,R=[int(x) for x in input().rstrip().split()]
if 10<=N:
  print(R)
else:
  print(R+100*(10-N))

Submission status: Accepted

Solution code:
N,R = (int(i) for i in input().split())

tmp = 100*(10-N)

if tmp >= 0:
  print(100*(10-N) + R)
else:
  print(R)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

if N < 10:
    print(R + 100 * (10 - N))
else:
    print(R)

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n > 10:
    print(r)
else:
    a = r + (100 * (10-n))
    print(a)

Submission status: Accepted

Solution code:
n, r = map(int, input().split())
ans = 0

if n < 10:
    ans = 100 * (10 - n) + r
    print(ans)
else:
    ans = r
    print(ans)

Submission status: Accepted

Solution code:
n, r = map(int, input().split())

if n >= 10:
    x = r
else:
    x = r + 100*(10-n)

print(x)

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    n, r = map(int,input().split())
    if 10 > n:
        print(r + (100 * (10 - n)))
    else:
        print(r)


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    n, r = map(int,input().split())
    if 10 <= n:
        print(r)
    else:
        print(r + (100 * (10 - n)))


if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
N,R = map(int, input().split())

if N >= 10:
    print(R)
else:
    print(R+(100*(10-N)))

Submission status: Accepted

Solution code:
# input
N, R = map(int, input().split())

if N >= 10:
    print(R)
else:
    print(R + (100 * (10 - N)))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
n, r = map(int, input().split())
if n >= 10:
    print(r)
else:
    print(r+100*(10-n))

Submission status: Accepted

Solution code:
n,r = map(int,input().split())
if n >= 10:
    print(r)
else:
    print(r+100*(10-n))

Submission status: Accepted

Solution code:
N,M = map(int,input().split())
if N > 9:
    print(M)
else:
    print(M + (100 * (10-N)))

Submission status: Accepted

Solution code:
N,R=map(int,input().split())

if N>=10:
  r=R
else:
  r=R+100*(10-N)
  
print(int(r))

Submission status: Accepted

Solution code:
il = input().split()
N = int(il[0])
R = int(il[1])

if (N >= 10):
    print(R)
else:
    print(R + 100*(10-N))

Submission status: Accepted

Solution code:
N,R=map(int,input().split())
if N>=10:
  print(R)
else:
  print(100*(10-N)+R)

Submission status: Accepted

Solution code:
N, R = list(map(int, input().split()))
if N >= 10:
  print(R)
else:
  print(R + 100*(10-N))

Submission status: Accepted

Solution code:
N, R = map(int, input().split())

if N > 10:
  print(R)
else:
  print(100 * (10 - N) + R)

Submission status: Accepted

Solution code:
n,r = map(int,input().split())
if n >= 10:
    print(r)
else:
    print(r+(100*(10-n)))

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
print(r+100*(10-n) if n<10 else r)

Submission status: Accepted

Solution code:
N,R = map(int, input().split())
if N >= 10:
  print(R)
else:
  print(R+100*(10-N))

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n >= 10:
  print(r)
else:
  print(r+100*(10-n))

Submission status: Accepted

Solution code:
n,r = map(int, input().split())
if n < 10:
    k = 100*(10-n)
    s = r + k
else:
    s = r
print(s)

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n >= 10:
    print(r)
else:
    print((100*(10-n))+r)

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
if a>=10:
    print(b)
else:
    print(100*(10-a)+b)

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n >= 10:
    print(r)
else:
    print((100*(10-n))+r)

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n >= 10:
    print(r)
else:
    print(r + (100*(10-n)))

Submission status: Accepted

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

def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def LI(): return list(map(int,input().split()))
def TI(): return tuple(map(int,input().split()))


def main():
    N,R = MI()
    ans = R + 100*(10-N)

    if N<10:
        print(ans)
    else:
        print(R)



if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
N,R = map(int,input().split())

if N >= 10:
    print(R)
else:
    print(R + 100*(10-N))

Submission status: Accepted

Solution code:
n,r = map(int,input().split())
if n<10:
	r = 100*(10-n)+r
print(r)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
if N >= 10:
    X = R
else:
    X = R + 100*(10-N)
print(X)

Submission status: Accepted

Solution code:
n,r = map(int,input().split())

if n >= 10:
	print(r)
else:
	print(r + 100*(10-n))

Submission status: Accepted

Solution code:
N,R = map(int,input().split())
if N < 10 :
    print( R + 100*(10 - N) )
else :
    print( R )

Submission status: Accepted

Solution code:
N,R = map(int,input().split())

if 10<=N:
    print(R)
else:
    print(R+100*(10-N))

Submission status: Accepted

Solution code:
import math
def I():
  return input()
def II():
  return int(input())
def MII():
  return map(int, input().split())
def LMII():
  return list(map(int, input().split()))

n, r = MII()
print(r+100*max((10-n), 0))

Submission status: Accepted

Solution code:
n,r = map(int, input().split())
if n >= 10:
    print(r)
else:
    print(r + 100 * (10 - n))

Submission status: Accepted

Solution code:
N, R = map(int,input().split())

if N >= 10:
  print(R)
else:
  print(R + 1000 - 100 * N)

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
print(R) if N >= 10 else print(R + 100 * (10 - N))

Submission status: Accepted

Solution code:
N,R=map(int,input().split())
if N >=10:
    print(R)
else:
    print(R+(100*(10-N)))

Submission status: Accepted

Solution code:
n,r = map(int,input().split())
if n<10:
    print(r+100*(10-n))
else:
    print(r)

Submission status: Accepted

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

if N < 10:
  print(R+100*(10-N))
else:
  print(R)