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

Submission status: Accepted

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


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

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


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

Submission status: Accepted

Solution code:
"""
Author    : co_devil Chirag Garg
Institute : JIIT
"""
from math import *
from sys import stdin, stdout
import itertools
import os
import sys
import threading
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import *
# from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd
# from bisect import bisect_left,bisect_right
# from decimal import *,threading
from fractions import Fraction
mod = int(pow(10, 9)+7)


def ii(): return int(input())


def si(): return str(input())


def mi(): return map(int, input().split())


def li(): return list(mi())


def fii(): return int(stdin.readline())


def fsi(): return str(stdin.readline())


def fmi(): return map(int, stdin.readline().split())


def fli(): return list(fmi())


abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12,
       'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24,
       'z': 25}


def getKey(item): return item[0]


def sort2(l): return sorted(l, key=getKey)


def d2(n, m, num): return [[num for x in range(m)] for y in range(n)]


def isPowerOfTwo(x): return (x and (not (x & (x - 1))))


def decimalToBinary(n): return bin(n).replace("0b", "")


def ntl(n): return [int(i) for i in str(n)]


def powerMod(x, y, p):
    res = 1
    x %= p
    while y > 0:
        if y & 1:
            res = (res * x) % p
        y = y >> 1
        x = (x * x) % p
    return res


graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000


def bfs(d, v):
    q = []
    q.append(v)
    visited[v] = 1
    while len(q) != 0:
        x = q[0]
        q.pop(0)
        for i in d[x]:
            if visited[i] != 1:
                visited[i] = 1
                q.append(i)
        print(x)


def make_graph(e):
    d = {}
    for i in range(e):
        x, y = mi()
        if x not in d:
            d[x] = [y]
        else:
            d[x].append(y)
        if y not in d:
            d[y] = [x]
        else:
            d[y].append(x)
    return d


def gr2(n):
    d = defaultdict(list)
    for i in range(n):
        x, y = mi()
        d[x].append(y)
    return d


def connected_components(graph):
    seen = set()

    def dfs(v):
        vs = set([v])
        component = []
        while vs:
            v = vs.pop()
            seen.add(v)
            vs |= set(graph[v]) - seen
            component.append(v)
        return component

    ans = []
    for v in graph:
        if v not in seen:
            d = dfs(v)
            ans.append(d)
    return ans


def primeFactors(n):
    s = set()
    while n % 2 == 0:
        s.add(2)
        n = n // 2
    for i in range(3, int(sqrt(n)) + 1, 2):
        while n % i == 0:
            s.add(i)
            n = n // i
    if n > 2:
        s.add(n)
    return s


def find_all(a_str, sub):
    start = 0
    while True:
        start = a_str.find(sub, start)
        if start == -1:
            return
        yield start
        start += len(sub)


def SieveOfEratosthenes(n, isPrime):
    isPrime[0] = isPrime[1] = False
    for i in range(2, n):
        isPrime[i] = True
    p = 2
    while (p * p <= n):
        if (isPrime[p] == True):
            i = p * p
            while (i <= n):
                isPrime[i] = False
                i += p
        p += 1
    return isPrime


def dijkstra(edges, f, t):
    g = defaultdict(list)
    for l, r, c in edges:
        g[l].append((c, r))

    q, seen, mins = [(0, f, ())], set(), {f: 0}
    while q:
        (cost, v1, path) = heappop(q)
        if v1 not in seen:
            seen.add(v1)
            path = (v1, path)
            if v1 == t:
                return (cost, path)

            for c, v2 in g.get(v1, ()):
                if v2 in seen:
                    continue
                prev = mins.get(v2, None)
                next = cost + c
                if prev is None or next < prev:
                    mins[v2] = next
                    heappush(q, (next, v2, path))
    return float("inf")


def binsearch(a, l, r, x):
    while l <= r:
        mid = l + (r-1)//2
        if a[mid]:
            return mid
        elif a[mid] > x:
            l = mid-1
        else:
            r = mid+1
    return -1


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

Submission status: Accepted

Solution code:
import numpy as np

n, r = np.asarray(input().split(), dtype=np.int32)

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

print(r)

Submission status: Accepted

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


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

Submission status: Accepted

Solution code:
# /usr/bin/python3
# -*- coding: utf-8 -*-
from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


yn = 'YNeos'
ynflg = False
cnt = 0
ans = None

def lcm(a, b):
    return (a*b) // gcd(a,b)

def intinput():
    return int(input())

def mulinputs():
    return map(int,input().split())

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas




N, R = mulinputs()

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

Submission status: Accepted

Solution code:
import sys

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

N, R = lr()
if N >= 10:
    answer = R
else:
    answer = R + 100 * (10 - N)

print(answer)

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
readline = sys.stdin.readline

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

    return 0


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys


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


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

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

Submission status: Accepted

Solution code:
import sys


def main(S):
    pass


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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:

#gcdは3.4.3だとfractionsにある
from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

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

yes = "Yes"
no = "No"

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


main()

Submission status: Accepted

Solution code:
#n=int(input())
n,r=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i 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:
a, b = [int(i) for i in input().split()]
if a < 10:
    print(b + 100 * (10 - a))
else:
    print(b)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
INF = 10**30

def main():
    n, r = list(map(int, input().strip().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())

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

print(ans)

Submission status: Accepted

Solution code:
import fractions
import collections
from collections import deque
import math
import itertools

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:
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


def MI(): return map(int, input().split())


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YNL = {False: 'No', True: 'Yes'}
YNU = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False
# show_flg = True


def main():
    N, R = MI()

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

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

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

print(ans)

Submission status: Accepted

Solution code:
NN = 2020202
MOD = 10**9+7
INF = float("inf")

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

print(R)

Submission status: Accepted

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

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

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:
#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:
# coding: utf-8

import sys
import math
import collections
import itertools
from inspect import currentframe
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def MI() : return map(int, input().split())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def chkprint(*args) : names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}; print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

N, R = MI()

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

Submission status: Accepted

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

import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

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

Submission status: Accepted

Solution code:
import sys, math
def input():
    return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict, Counter
from math import factorial
from bisect import bisect_left # bisect_left(list, value)
#from fractions import gcd

sys.setrecursionlimit(10**7)
N, R = map(int, input().split())

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

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

N, R = list(map(int, read().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:
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:
    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)
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:
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:
    ans = R
else:
    ans = R + 100 * (10 - N)
print(ans)

Submission status: Accepted

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




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:
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)

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

ans = R
if N < 10:
    ans += 100 * (10-N)
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:
def s_in():
    return input()

def n_in():
    return int(input())

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

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

N, R = l_in()

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

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

Submission status: Accepted

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


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

Submission status: Accepted

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


if __name__ == '__main__':
    resolve()

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

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == '__main__':
    main()

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:
  print(R)
else:
  x=R+1000-N*100
  print(x//1)

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

Submission status: Accepted

Solution code:
import heapq
import sys
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

Submission status: Accepted

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


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


def main():
    n, r = (int(z) for z in input().split())
    res = compute(n, r)
    print(res)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

if(N>=10):
    print(R)
    exit()

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

Submission status: Accepted

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

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
from copy import deepcopy
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))


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

Submission status: Accepted

Solution code:

import itertools
import sys
import math
import numpy as np
from collections import deque
from itertools import combinations
from functools import reduce
from functools import lru_cache
sys.setrecursionlimit(10**9)


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



if __name__ == "__main__":
  main()

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())
if N < 10:
    R += 100 * (10-N)
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:
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(input()) #整数読み込み
def ifn(): return float(input()) #浮動小数点読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return map(int, input().split()) #整数map取得
def fmn(): return map(float, input().split()) #浮動小数点map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, input().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def m_add(a,b): return (a+b) % MOD

N,R = imn()

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
import itertools
from collections import deque
import copy
import bisect

MOD = 10 ** 9 + 7
INF = 10 ** 18 + 7
input = lambda: sys.stdin.readline().strip()

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 sys
import math
def i():return int(sys.stdin.readline().replace("\n",""))
def i2():return map(int,sys.stdin.readline().replace("\n","").split())
def s():return str(sys.stdin.readline().replace("\n",""))
def l():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def lx():return list(map(lambda x:int(x)*-1,sys.stdin.readline().replace("\n","").split()))
def t():return tuple(map(int,sys.stdin.readline().replace("\n","").split()))

if __name__ == "__main__":pass

n,r = i2()
print(r if n >= 10 else 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(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))