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:
N,R = map(int,input().split())

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

Submission status: Accepted

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

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

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




# if :
#     print("YES")
# else:
#     print("NO")

# if :
#     print("Yes")
# else:
#     print("No")

Submission status: Accepted

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

'''
A=[]
B=[]
for i in range():
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)'''

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

if l[0]<10:
    print(l[1]+100*(10-l[0]))
else:
    print(l[1])

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(i) for i in input().split()]
if(N>=10):
    print(R)
else:
    print(R+ 100*(10-N))

Submission status: Accepted

Solution code:
N, R = [int(i) for i 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+100*(10-n))
else:
    print(r)

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, raw_input().split())
print max(R, R+100*(10-N))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]

# n = int(input())
# 
# s = input()

N, R = list(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())
if N >= 10:
	print(R)
else:
	print(R + 100 * (10 - N))

Submission status: Accepted

Solution code:
from bisect import bisect_right, bisect_left
from collections import Counter, deque
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import groupby, permutations, combinations, product
from sys import stdin, stderr


# 最大公約数（ユークリッドの互除法）
# Python3.5 で math.gcd()が追加され、
# AtCoder環境と最新環境でパッケージが分かれてしまったので、自分で書いておく
def gcd(x, y):
    return x if y == 0 else gcd(y, x % y)


# 拡張ユークリッド互除法
# 正整数x, y について、a*x + b*y == gcd(x,y)なるa,bを返す。
# 特に、互いに素なるx, yについては a*x + b*y == 1 となる a, b。
def exgcd(x, y):
    if y == 0:
        return 1, 0
    a, b = exgcd(y, x % y)
    return b, a - (x // y) * b


# 最小公倍数
def lcm(x, y):
    m = gcd(x, y)
    return (x // m) * (y // m)


def main():
    n, r = [int(x) for x in input().split()]
    if n >= 10:
        return r
    return 100*(10-n) + r


if __name__ == "__main__":
    print(main())

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:
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())
tmp = 100 * (10 - N)
ans = R
if tmp >= 0:
    ans += tmp

print(ans)

Submission status: Accepted

Solution code:
n, r = map(int, raw_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().strip().split())

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

Submission status: Accepted

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

Submission status: Accepted

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

import sys
readline = sys.stdin.readline
read = sys.stdin.read

#n,*a = [int(i) for i in read().split()]
#a = [int(i) for i in readline().split()]
#n = int(input())

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=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:
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	N,R = MI()
	if(N <10):
		print(R + 100 * (10-N))
	else:
		print(R)

if __name__ == '__main__':
	main()

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:

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)

def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max,mod=DIV):
    fac,finv,inv = [0]*max, [0]*max, [0]*max
    fac[0]=fac[1]=1
    finv[0]=finv[1]=1
    inv[1]=1
    for i in range(2,max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod -inv[mod%i] * (mod//i)%mod
        finv[i] = finv[i-1]*inv[i]%mod
    class CONV:
        def __init__(self):
            pass
        def ncr(self,n,k):
            if(n<k):
                return 0
            if(n<0 or k<0 ):
                return 0
            return fac[n]*(finv[k]*finv[n-k]%mod)%mod
    return CONV()


def main():
    N,R = isRaw()
    if N < 10:
        return R + 100*(10-N)
    else:
        return R


if __name__ == "__main__":
    print(main())

Submission status: Accepted

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

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:
import sys
input=sys.stdin.readline
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 = map(int,input().split())

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

Submission status: Accepted

Solution code:
#s = input()
#n = int(input())
n,r = map(int,input().split())
#lst1 = list(map(int,input().split()))
minus = 0
if n < 10:
    minus= 100*(10-n)

print(r+minus)

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:
    r+=100*(10-n)
print(r)

Submission status: Accepted

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

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
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 main():
    N, R = LI()
    if N >= 10:
        print(R)
    else:
        ans = R + 100 * (10 - N)
        print(ans)

main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
    return [ int(s) for s in input().split(" ")]

# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

n,r = get_nums_l()

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 = [int(i) for i in input().split()]
print(R + 100 * max(10 - N, 0))

Submission status: Accepted

Solution code:
def main():
    N, R = (int(i) for i in input().split())
    if 10 <= N:
        print(R)
    else:
        print(R + 100*(10-N))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

if N < 10:
    print(K+100*(10-N))
else:
    print(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,r=map(int,input().split())
if n<10:
    r=r+(100*(10-n))
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:
import numpy as np
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(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())
if n >= 10:
    print(r)
else:
    d = 100 * (10 - n)
    print(d + 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((10 - N)* 100 + R)
else:
	print(R)

Submission status: Accepted

Solution code:
import sys
n, r = [int(i) for i in sys.stdin.readline().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 print(R+100*(10-N))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n,r = (int(i) for i in 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())
n = 0
if N>=10:
    n=R
else:
    n=R+100*(10-N)
print(n)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#JMD
#Nagendra Jha-4096

 
import sys
import math

#import fractions
#import numpy
 
###File Operations###
fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile

###Defines...###
mod=1000000007
 
###FUF's...###
def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
##### Main ####
t=1
for tt in range(t):
    #n=int(input())
    a,b= map(int, sys.stdin.readline().split(' '))
    if a>=10:
        print(b)
    else:
        print(b+100*(10-a))
    #a=list(map(int,sys.stdin.readline().split(' ')))
    
    
#####File Operations#####
if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

Submission status: Accepted

Solution code:
def main():

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

if __name__ == '__main__':
    print(main())

Submission status: Accepted

Solution code:
import sys
import math
import collections
#n = int(input())
n, r = map(int, input().split())
#s = input()
#a = list(map(int, input().split()))

if n >= 10:
  print(r)
else:
  x = 100 * (10 - n)
  print(r+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 10<n:
    print(r)
else:
    print(r+(100*(10-n)))

Submission status: Accepted

Solution code:
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7

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(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:
N,R=map(int,input().split())

if N <10:
  a = (10-N)*100
  ans = R+a
else:
  ans = R
  
print(int(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): print(R)
else: print(R + 100 * (10 - N))

Submission status: Accepted

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

if N<=9:
    print(R + (10-N)*100)
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((10-N)*100+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:
    print(100*(10-N)+R)

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:
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
N, R = [int(x) for x in input().strip().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())
print(r if n >= 10 else 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:
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
'''
n = int(input())
n, m = map(int, input().split())
a = list(map(int, input().split()))
a = [int(input()) for i in range n]
p = [list(map(int, input().split()))]

a = input()
a, b = input().split()
a = [input() for i in range n]
'''
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())
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+(10-N)*100)

Submission status: Accepted

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

ans = r

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

print(ans)

Submission status: Accepted

Solution code:
#coding:utf-8
import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    XLMIIS = lambda x: [LMIIS() for _ in range(x)]
    YN = lambda c : print('Yes') if c else print('No')
    MOD = 10**9+7

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
from collections import deque, Counter
def getN():
    return int(input())
def getList():
    return list(map(int, input().split()))
import math
INF = 10 ** 20

def main():
    a,b = getList()
    if a >= 10:
        print(b)
    else:
        print(b + 100*(10-a))

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    N, R = [int(x) for x in input().split()]
    if N >= 10:
        print(R)
    else:
        print(100 * (10 - N) + 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 = 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:
    R += 100*(10-N)
print(R)

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    vn = vk = vn_k = 1
    for i in range(1, n+1):
        vn = vn * i % modp
        if i == k:
            vk = vn
        if i == n-k:
            vn_k = vn
    return vn * get_inv(vk, modp) * get_inv(vn_k, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

def main():
    N,R=mis()
    if N>=10:
        print(R)
    else:
        print(R+100*(10-N))

main()

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:
def main():
    N,R = map(int,input().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+=((10-n)*100)
print(r)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
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

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

Submission status: Accepted

Solution code:
"""
じょえチャンネルおもしろいよ～～～
https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
"""

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())
# = int(input())
# = input()
# = list(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+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:
    buf = 100*(10-n)
    print(r + buf)

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
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:
#!/usr/bin/env python3
import sys


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

    return


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:
# 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:
a, b=  map(int,input().split())

inner = b + max((10 - a),0)*100

print(inner)

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
N,R=map(int,input().split())

ans=R+100*(10-min(N,10))

print(ans)

Submission status: Accepted

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

import sys
sys.setrecursionlimit(300000)


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

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] = [int(i) for i 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)
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 sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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:
def examA():
    N, R = LI()
    ans = R+100*max(0,(10-N))
    print(ans)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

if __name__ == '__main__':
    examA()

"""

"""

Submission status: Accepted

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

if n >= 10:
    n = 10

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+(10-N)*100)

Submission status: Accepted

Solution code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
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 [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  n,r=LI()
  if 10<=n:
    return r
  return r+100*(10-n)

# main()
print(main())

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b=list(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())
print(r if n >= 10 else r+100*(10-n))

Submission status: Accepted

Solution code:
import sys
from operator import itemgetter
from collections import deque, Counter
from itertools import permutations, combinations
from heapq import heapify, heappop, heappush
from bisect import bisect, bisect_left

def solve():
    input = sys.stdin.readline
    N, R = map(int, input().split())
    if N < 10: R += 100 * (10 - N)
    print(R)

    return 0

if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

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

n,r = nm()

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

Submission status: Accepted

Solution code:
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
    return list(map(int,input().split()))
def m(): #複数文字
    return map(int,input().split())
def onem(): #Nとかの取得
    return int(input())
def s(x): #圧縮
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): #listをスペースごとに分ける
    return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
    return max(map(max,x))
def In(x,a): #aがリスト(sorted)
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False
"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""


n,r = m()

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(b+(100*(10-a)))

Submission status: Accepted

Solution code:
def main():
    N, R = map( int, input().split())
    if N >= 10:
        print(R)
        return
    print(R+100*(10-N))
if __name__ == '__main__':
    main()

Submission status: Accepted

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