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:
from sys import stdin
n,k = map(int,stdin.readline().rstrip().split())
if n >= 10:
    print(k)
else:
    print((10-n)*100+k)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline

##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)

##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力

# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと

##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順

# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順

##### 無限 #####
# inf = float('inf')

def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

inf = float('inf')

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

if __name__ == "__main__":
	main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

# 回数が10回より少ない時
# R = inner_R - 100 * (10 - 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:
  n = 10
print(r + 100 * (10 -n))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys

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

if __name__ == "__main__":
    resolve()

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

Submission status: Accepted

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

resolve()

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

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

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    n, r = [int(i) for i in input().split()]
    
    result = r
    if n < 10:
        result = r + 100 * (10 - n)
    print(result)

Submission status: Accepted

Solution code:
inp = input().split()
n = int(inp[0])
r = int(inp[1])
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:
X, Y = map(int, input().split())
if X >= 10:
    print(Y)
else:
    print(Y+(100*(10-X)))

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 = 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())
print(R + 100 * (10 - min(10,N)))

Submission status: Accepted

Solution code:
from sys import *

input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()


n, r = mi()
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=input().split()

Naibu = int(N[1]) + 100*(10-int(N[0]))
if int(N[0])<=9:
    print(Naibu)
else:
    print(N[1])

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

Submission status: Accepted

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


if __name__ == "__main__":
    n, r = map(int, input().split())

    main(n, r)

Submission status: Accepted

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

Submission status: Accepted

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

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 sys

read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines


# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
# import numpy as np

def main():
	n,r=map(int,input().split())
	print(r+100*(10-min(10,n)))
	
	
if __name__ == "__main__":
	main()

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:
# https://atcoder.jp/contests/abc156/tasks/abc156_a
import sys
sys.setrecursionlimit(12345678)
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop


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


if __name__ == '__main__':
    main()

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:

import numpy as np
from functools import *
import sys
sys.setrecursionlimit(100000)



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


def II():
    return int(input())

directions=np.array([[1,0],[0,1],[-1,0],[0,-1]])
directions = list(map(np.array, directions))

mod = 10**9+7


def factorial(n):
    fact = 1
    for integer in range(1, n + 1):
        fact *= integer
    return fact



def serch(x, count):
    #print("top", x, count)
            

    for d in directions:
        nx = d+x
        #print(nx)
        if np.all(0 <= nx) and np.all(nx < (H, W)):
            if field[nx[0]][nx[1]] == "E":
                count += 1 
                field[nx[0]][nx[1]] = "V"
                count = serch(nx, count)  
                continue
            if field[nx[0]][nx[1]] == "#":
                field[nx[0]][nx[1]] = "V"
                count = serch(nx, count)    
                 
    return count

N,R=acinput()



if N>=10:
    K=R
else:

    K=R+(100*(10-N))

print(int(K))

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:
a = input().split()
x = int(a[0])
y = int(a[1])
if x>=10:
    print(y)
else:
    print(y+1000-100*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:
from sys import stdin

x = [int(x) for x in stdin.readline().rstrip().split()]
n = x[0]
r = x[1]

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

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:
s = list(map(int, input().split()))
ans = 0

if s[0]<=10:
    ans = s[1]+100*(10-s[0])
else:
    ans = s[1]

print(ans)

Submission status: Accepted

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

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

print(I)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

if N <= 10:
  K += (10 - N) * 100

print(K)

Submission status: Accepted

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

Submission status: Accepted

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

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:
num = input().split()
N = int(num[0])
R = int(num[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:
  print(R)
else:
  print(R+100*(10-N))

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
if N >= 10:
    rating = R

else:
    rating = R + (100 * (10-N))

print(rating)

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

Submission status: Accepted

Solution code:
import sys


def input():
    return sys.stdin.readline()[:-1]


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

Submission status: Accepted

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

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


if __name__ == "__main__":
    main()

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

Submission status: Accepted

Solution code:
s = input().split()

K = int(s[0])
N = int(s[1])

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

Submission status: Accepted

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

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

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 = (int(x) for x in input().split())
print(r + max(0, 100 * (10 - n)))

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

if n >= 10:
    print(r)

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

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:
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:
#!/usr/bin/env python3
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:
#from math import sqrt
#from heapq import heappush, heappop
#from collections import deque
#s, t = [int(v) for v in int(input())]


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

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


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

Submission status: Accepted

Solution code:
#A - Beginner
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 <= 9:
  S = R + 100*(10-N)
  print(S)
else:
  S = R
  print(S)

Submission status: Accepted

Solution code:
i = input().split()

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

IR = 0

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

print(IR)

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())
print(r+max(100*(10-n),0))

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 - min(n, 10)))

Submission status: Accepted

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

Submission status: Accepted

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


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

print(innerR)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

Solution code:
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))


N, R = mi()

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

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:
# coding: utf-8
# Your code here!
I=list(map(int, input().split()))
N=I[0]
R=I[1]
if N>=10:
    print(R)
else:
    rating=R+100*(10-N)
    print(rating)

Submission status: Accepted

Solution code:
# coding: utf-8

n, r = [int(x) for x in input().rstrip().split(" ")]
print(r + max(0, 10-n)*100)

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 = [int(x) for x in input().split()]
K = 0 if N >= 10 else 10 - N
print( R + 100 * 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:
#!/usr/bin/env python

from sys import stdin, stderr

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

   return 0

if __name__ == '__main__': main()

Submission status: Accepted

Solution code:
N, R = map(int, input().split())
if N >= 10:
    ans = R
else:
    ans = 100 * (10-N) + R
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:
    x = r
    print(x)
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=[int(x) for x in input().split()]
if n<10:
    z=r+(100*(10-n))
else:
    z=r
print(z)

Submission status: Accepted

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


if n >= 10:
  print(r)

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

Submission status: Accepted

Solution code:
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+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:
    ans = r
else:
    ans = r + 1000 - 100 * n
print(ans)

Submission status: Accepted

Solution code:
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n, r = list(map(int, readline().split()))
    print(r + 100 * (10 - n) if n < 10 else r)


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:
n,r = map(int,input().split())
if n>=10:
    print(r)
else:
    print(r+100*(10-n))

Submission status: Accepted

Solution code:
def solve(n, r):
    return r + (n < 10) * 100 * (10 - n)

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

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:
temp = input()
N, R = list(map(int, temp.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:
# coding: utf-8
# submission # - User: herp_sy
# https://atcoder.jp/contests/
#
# lang: Python3 (3.4.3)

import math
import statistics
import numpy as np
import queue
import itertools

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())
print(r+100*max([0,10-n]))

Submission status: Accepted

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

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

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

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

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

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:
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

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

Submission status: Accepted

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

#output
if N >= 10:
    S = R
else:
    S = R + 100*(10-N)

print(S)

Submission status: Accepted

Solution code:
n,r=map(int,input().split())
r+=0 if n>=10 else 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:
N,R = map(int,input().split())

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

Submission status: Accepted

Solution code:
str = input().split()
N = int(str[0])
R = int(str[1])
if (10<=N):
	print(R)
else:
	print(100*(10-N)+R)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# A - Beginner
def main():
    N, R = map(int, input().split())
    ans = R + 100 * max(0, 10 - N)
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from sys import stdin
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(n,r):
	ans = max(r,r+(100*(10-n)))
	return ans

N,R = map(int, stdin.readline().rstrip().split())
ans = solve(N,R)
print(ans)

Submission status: Accepted

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

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_disp = map(int, input().split())
print(R_disp + 100 * (10 - N) if N < 10 else R_disp)

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

Submission status: Accepted

Solution code:
InputValue = input().split(' ')

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

if 0<=R<=4111 and 1<=N<=100:
    if N>=10:
        IR = R
        print(IR,end='\n')
    elif N<10:
        IR = R + 100*(10-N)
        print(IR,end='\n')

Submission status: Accepted

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

Submission status: Accepted

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

  
if huga[0]>=10:
  print(huga[1])
else:
    
  print(huga[1]+100*(10-huga[0]))

Submission status: Accepted

Solution code:
def main():
  n, r = map(int,input().split())
  n = min(n, 10)
  ans = r + 1000 - 100*n
  print(ans)
main()

Submission status: Accepted

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

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

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,r=map(int,input().split())
print(r+max(0,10-n)*100)

Submission status: Accepted

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