Problem:
 Score : 100 points    Problem Statement Snuke has N integers: 1,2,\ldots,N .
He will choose K of them and give those to Takahashi.  How many ways are there to choose K consecutive integers?      Constraints  All values in input are integers.  1 \leq K \leq N \leq 50         Input Input is given from Standard Input in the following format:  N  K       Output Print the answer.        Sample Input 1 3 2      Sample Output 1 2  There are two ways to choose two consecutive integers: (1,2) and (2,3) .       Sample Input 2 13 3      Sample Output 2 11

Solution (Python):
n, k =map(int, input().split())
print(n - k + 1)

Solution (Python):
n,k = map(int, input().split())
ans = 0
num = [i for i in range(1, k+1)]
while num[-1] <= n:

    num = [i+1 for i in num]
    ans += 1
print(ans)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
print((lambda x,y:x-y+1)(*map(int,input().split())))

Solution (Python):
def Consecutivebiscuit(n,k):
    return n-k+1
    
n,k = map(int, input().split())
print(Consecutivebiscuit(n,k))

Solution (Python):
N, K = map(int,input().split())
print(N-K+1)

Solution (Python):
n,k = map(int,input().split())
print(n - (k - 1))

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
n,k= list(map(int,input().split()))
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
N, K =map(int,input().split())
print(N - K + 1)

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

print(N - K + 1)

Solution (Python):
N, K = [int(i) for i in input().split()]
print(N - K + 1)

Solution (Python):
i = list(map(int, input().split()))
print(i[0]-i[1] + 1)

Solution (Python):
n,k = (int(i) for i in input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
tmp = input()
nul = tmp.rfind(' ')
n = int(tmp[:nul:])
k = int(tmp[nul + 1::])

print(n - (k - 1))

Solution (Python):
import math
N,K = list(map(int,input().split()))


print(N-K+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
a = list(map(int, input().split()))

answer = a[0] -	a[1] + 1

print(answer)

Solution (Python):
N,K = map(int,input().split())
answer = int(N) - int(K) + 1
print(str(answer))

Solution (Python):
a, b = map(int, input().split())
print(a-b+1)

Solution (Python):
import math

n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

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

a = N+1-K
print(a)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

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

print(N + 1 - K)

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

print(N-K+1)

Solution (Python):
N,K = map(int, input().split())
print(N-K+1)

Solution (Python):
from collections import defaultdict
import math


def kari():
    map(int, input().split())
    list(map(int, input().split()))
    math.ceil()

def main():
    a, b = map(int, input().split())
    print(a- b + 1)


if __name__ == '__main__':
    main()

Solution (Python):
n,m=map(int,input().split())
print(n-m+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):


import sys
import copy

sys.setrecursionlimit(1000000)





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

print(N - K + 1)

Solution (Python):
n,k=input().split()

n = int(n)
k = int(k)

ans = n - k + 1
print (ans)

Solution (Python):
a, b = (int(i) for i in input().split())  
t = a - b + 1
print(t)

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

print(n-k+1)

Solution (Python):
n, k=map(int, input().split())
print(n-k+1)

Solution (Python):
n, k = list(map(int, input().split()))
print(n-k+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
a,b=map(int,input().split())
print(a-b+1)

Solution (Python):
a,b=map(int,input().split())
print(a-b+1)

Solution (Python):
N, K = map(int, list(input().split()))
print(N-K+1)

Solution (Python):
i = list(map(int, input().split()))
print(i[0] - i[1] + 1)

Solution (Python):
a,b=map(int,input().split());print(a-b+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
a,b = map(int, input().split())
print(a-b+1)

Solution (Python):
a, b = map(int, input().split())
print(a-b+1)

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

print( N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
N, K = list(map(int, input().split()))
print(N - K + 1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):



import itertools

intext = input()
[n, k] = map(int, intext.split())
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
print(eval(input().replace(' ','-~-')))

Solution (Python):
l=[int(i) for i in input().split()]
print(l[0]-l[1]+1)

Solution (Python):
n, k =input().split()
print(int(n) - int(k) + 1)

Solution (Python):
i = list(map(int,input().split()))
print(i[0]-i[1]+1)

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

print(N - K + 1)

Solution (Python):
print(eval(input().replace(' ','+1-')))

Solution (Python):
print(eval(input().replace(' ','+1-')))

Solution (Python):
a, b = (int(_) for _ in input().split())  
print(a-b+1)

Solution (Python):
i = list(map(int,input().split()))
print(i[0]-i[1]+1)

Solution (Python):



def main():
    n, k = map(int, input().split())
    print(n - k + 1)


if __name__ == '__main__':
    main()

Solution (Python):
a, b = (int(_) for _ in input().split())  
print(a-b+1)

Solution (Python):



def main():
    n, k = map(int, input().split())
    print(n - k + 1)


if __name__ == '__main__':
    main()

Solution (Python):
a, b = (int(_) for _ in input().split())  
print(a-b+1)

Solution (Python):
a, b = (int(_) for _ in input().split())  
print(a-b+1)

Solution (Python):
i = list(map(int, input().split()))
print(i[0] - i[1] + 1)

Solution (Python):
i = list(map(int,input().split()))
print(i[0]-i[1]+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
i = list(map(int,input().split()))
print(i[0]-i[1]+1)

Solution (Python):
i = list(map(int,input().split()))
print(i[0]-i[1]+1)

Solution (Python):
print(eval(input().replace(' ','+1-')))

Solution (Python):
i = list(map(int,input().split()))
print(i[0]-i[1]+1)

Solution (Python):
n,m=map(int,input().split())
print(n-m+1)

Solution (Python):
print(eval(input().replace(' ','+1-')))

Solution (Python):
i = list(map(int,input().split()))
print(i[0]-i[1]+1)

Solution (Python):
i = list(map(int,input().split()))
print(i[0]-i[1]+1)

Solution (Python):
n,m=map(int,input().split())
print(n-m+1)

Solution (Python):
n,m=map(int,input().split())
print(n-m+1)

Solution (Python):
n,m=map(int,input().split())
print(n-m+1)

Solution (Python):
i = list(map(int,input().split()))
print(i[0]-i[1]+1)

Solution (Python):
n,m=map(int,input().split())
print(n-m+1)

Solution (Python):
n,m=map(int,input().split())
print(n-m+1)

Solution (Python):
n,m=map(int,input().split())
print(n-m+1)

Solution (Python):
N, K = [int(i) for i in input().split(" ")]
print(N - K + 1)

Solution (Python):
list = list(map(int,input().split()))
row = list[0]
col = list[1]
print((row-col)+1)

Solution (Python):
def solve():
    N,K = list(map(int,input().split())) 
    if K <= N:
        print(N-K+1)
    else:
        print(0)

solve()

Solution (Python):
list = list(map(int,input().split()))
row = list[0]
col = list[1]
print((row-col)+1)

Solution (Python):
list = list(map(int,input().split()))
row = list[0]
col = list[1]
print((row-col)+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):
n, k = map(int, input().split())
print((n-k)+1)

Solution (Python):
n, k = map(int, input().split())
print((n-k)+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):


list1 = input().split()
print(int(list1[0]) - int(list1[1]) + 1)

Solution (Python):
n,k = [int(x) for x in input().strip().split(" ")]
print(n-k+1)

Solution (Python):
N, K = map(int ,input().split())
print(N - K + 1)

Solution (Python):
NK = input().split()
NK = [int(s) for s in NK]

out = (NK[0] - NK[1]) + 1

print(out)

Solution (Python):
t = input()
l = t.split(" ")
N = int(l[0])
K = int(l[1])
count = 0
numbers = list(range(1, N+1))
while True:
    if len(numbers) >= K:
        numbers.pop(0)
        count = count + 1
    else:
        print(count)
        break

Solution (Python):
N, K = map (int, input().split())
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):

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

print(n-k+1)

Solution (Python):
A,B=map(int, input().split())
print(A-B+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print((n-k)+1)

Solution (Python):
a,b = list(map(int,input().split()))
print(a-b+1)

Solution (Python):
n, k = list(map(int, input().split()))
print(n - k + 1)

Solution (Python):
N, K = map(int, input().split(" "))
ans = N-K+1
print(ans)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
a,b=map(int,input().split())
print(a-b+1)

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

print(n-k+1)

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

diff = n - k + 1
print(diff)

Solution (Python):
def inpl():
    return list(map(int, input().split()))
  
N, K = inpl()

print(N-K+1)

Solution (Python):
N, K = map(int,input().split())
print(N-K+1)

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

print(N-K+1)

Solution (Python):
N, K = [int(s) for s in input().split(" ")]
print(N-K+1)

Solution (Python):


if __name__=="__main__":
  N, K = map(int, input().split())
  print(N-K+1)

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

print(N-K+1)

Solution (Python):
N,K=input().split()
print(int(N)-int(K)+1)

Solution (Python):
y,z = map(int, input().split())
print(y + 1 - z )

Solution (Python):
Input = input().split()
N = int(Input[0])
K = int(Input[1])
print(N-K+1)

Solution (Python):



import numpy as np
import scipy as sp

def main():
    try:
        input_list = input().split()
        N = int(input_list[0])
        K = int(input_list[1])
        print(N-K+1);
    except:
        pass

if __name__ == '__main__':
    main()

Solution (Python):
N, K = map(int, input().split())
ans = 0
for i in range(1, N + 1):
  if i + K - 1 <= N:
    ans += 1
  else:
    break

print('{}'.format(ans))

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

print(N-K+1)

Solution (Python):
x=input()
xx=x.split()
b=int(xx[0])
c=int(xx[1])
a=b-c+1
print(a)

Solution (Python):
N, K = (int(i) for i in input().split())

print(N-K+1)

Solution (Python):


import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))



def main():
    N, K = i2nn()
    print(N - K + 1)
main()

Solution (Python):
N, K = map(int, input().split()) 
print(N-(K-1))

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
inp = input()
n, m = map(int, inp.split())

print(n-m+1)

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

print(N+1-K)

Solution (Python):



n, k = [int(i) for i in input().split()]

print(n-k+1)

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

ans = int(N-K+1)

print(ans)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
def consecutive_integers(N: int, K: int)->int:
    return N - (K-1)


if __name__ == "__main__":
    N, K = map(int, input().split())

    ans = consecutive_integers(N, K)
    print(ans)

Solution (Python):
b, c = map(int, input().split())

print(b - c + 1)

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

print(n-(k-1))

Solution (Python):
from sys import stdin

N = [int(x) for x in stdin.readline().rstrip().split()]

print(N[0] - N[1] + 1)

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

print(N-K+1)

Solution (Python):
inp = list(map(int,input().split()))
n = inp[0]
k = inp[1]

n -= k
count = 1

while(n != 0):
    n -= 1
    count += 1

print(count)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
if __name__ == '__main__':
    N, K = map(int, input().split())

    answer = N - K + 1
    print(answer)

Solution (Python):
N,K = (int(i) for i in input().split())

print(N - K + 1)

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

z = 0
flag = True

for i in range(1, n+1):
    for j in range(1, k+1):
        if(j+z > n):
            flag = False
            break
    if(flag == True):
        z+=1

print(z)

Solution (Python):
a, b= map(int,input().split())
print(a - (b - 1))

Solution (Python):
N,K = map(int,input().split())
print(N-(K-1))

Solution (Python):
n, k = map(int,input().split())
print(n-k+1)

Solution (Python):
N,K = (int(i) for i in input().split())

print(N - K + 1)

Solution (Python):
n, k = list(int(x) for x in input().split())

ans = 0

for i in range(1, n + 1):
    x = i + (k - 1)
    if x <= n:
        ans += 1

print(ans)

Solution (Python):
N, K = map(int, input().split())
1<= K <= N <= 50

Y = N - K + 1

print(Y)

Solution (Python):

import numpy as np

n, k = map(int, input().split())
numlist = np.arange(1,n+1)
j = 0
if k == 1:
    print(n)
else:
    for i in range(0,n-1):
        a = numlist[i:i+k]
        if a[k-1] == n:
            j += 1
            break
        else:
            j += 1
            pass
    print(j)

Solution (Python):

def main():
    N, K = map(int, [int(x) for x in input().split()])
    return print(N-K+1)


if __name__ == "__main__":
    main()

Solution (Python):
N, K = [int(x) for x in input().split(' ')]

output = N - K + 1

print(int(output))

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):
n,k = map(int, input().split())
print(n-k+1)

Solution (Python):
n = list(map(int, input().split()))
a =[]
c = 1
b = []

for i in range(1, n[0]+1):
    b.append(i)

for j in range(1, n[1]+1):
    a.append(j)

for k in range(b[-1]):
    if b[-1] == a[-1]:
        print(c)
        break
    else:
        a[-1] += 1
        c += 1

Solution (Python):


def infinite_product(n, k):
    inpr = 1
    if k == 0:
        k = 1
    
    for i in range(n, k+1):
        inpr *= i
    
    return inpr


s = input().split()
N = int(s[0])
K = int(s[1])

print(N-K+1)

Solution (Python):
n,k = [int(i) for i in input().split()]
print(n-k+1)

Solution (Python):
p=input().rstrip().split(' ')
if int(p[0])==int(p[1]):
    print(1)
elif int(p[1])>int(p[0]):
    print(0)
else:
    print(int(p[0])-int(p[1])+1)

Solution (Python):
def main():
    A, B = [int(i) for i in input().split()]
    print(A - B + 1)
if __name__ == "__main__":
    main()

Solution (Python):

import sys





"""Template"""


class IP:
    """
    入力を取得するクラス
    """
    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


class Idea:
    def __init__(self):
        pass

    def HF(self, p):
        """
        Half enumeration
        半分全列挙です
        pの要素の和の組み合わせを作ります。
        ソート、重複削除行います
        :param p: list : 元となるリスト
        :return: list : 組み合わせられた和のリスト
        """
        return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))

    def Bfs2(self, a):
        """
        bit_full_search2
        bit全探索の改良版
        全探索させたら2進数のリストと10進数のリストを返す
        :return: list２つ : １個目 2進数(16桁)  2個目 10進数
        """
        
        
        
        value = []
        for i in range(1 << len(a)):
            output = []

            for j in range(len(a)):
                if self.bit_o(i, j):
                    """右からj+1番目のiが1かどうか判定"""
                    
                    output.append(a[j])
            value.append([format(i, 'b').zfill(16), sum(output)])

        value.sort(key=lambda x: x[1])
        bin = [value[k][0] for k in range(len(value))]
        val = [value[k][1] for k in range(len(value))]
        return bin, val

    def S(self, s, r=0, m=-1):
        """
        ソート関係行います。色々な設定あります。
        :param s: 元となるリスト
        :param r: reversするかどうか 0=False 1=True
        :param m: （2次元配列）何番目のインデックスのソートなのか
        :return: None
        """
        r = bool(r)
        if m == -1:
            s.sort(reverse=r)
        else:
            s.sort(reverse=r, key=lambda x: x[m])

    def bit_n(self, a, b):
        """
        bit探索で使います。0以上のときにTrue出します
        自然数だからn
        :param a: int
        :param b: int
        :return: bool
        """
        return bool((a >> b & 1) > 0)

    def bit_o(self, a, b):
        """
        bit探索で使います。1のときにTrue出すよ
        oneで1
        :param a: int
        :param b: int
        :return: bool
        """
        return bool(((a >> b) & 1) == 1)

    def ceil(self, x, y):
        """
        Round up
        小数点切り上げ割り算
        :param x: int
        :param y: int
        :return: int
        """
        return -(-x//y)

    def ave(self, a):
        """
        平均を求めます
        :param a: list
        :return: int
        """
        return sum(a) / len(a)

    def xor(self, x1, x2):
        return int(bin(x1 ^ x2), 2)


"""ここからメインコード"""


def main():
    
    r, e = range, enumerate
    ip = IP()
    id = Idea()

    """この下から書いてね"""
    n, k = ip.IL()
    print(n-k+1)



main()

Solution (Python):
n,k=[int(i) for i in input().split()]
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):
N, K = map(int, input().split())
print(N-(K-1))

Solution (Python):
n,k = input().split()
N = int(n)
K = int(k)
print(N-K+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

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

print(n - k + 1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
N, K = [int(c) for c in input().split()]
print(N - K + 1)

Solution (Python):
N,K = map(int,input().split())
print(N - K + 1)

Solution (Python):
n, k = list(map(int, input().split()))
print(n - ( k -1))

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):



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

answer = n-k+1
if n < k :
        answer = 0
print( answer )

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

ans = N - K + 1
print(ans)

Solution (Python):
N,K = map(int,input().split())
print(N - (K-1))

Solution (Python):
import sys
import itertools

N, K = map(int, sys.stdin.readline().split())

ans = N - K + 1

print(ans)

Solution (Python):
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

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

print(N-(K-1))

Solution (Python):
n,k = map(int,input().split()) 
print ((n-k)+1)

Solution (Python):
n,m=list(map(int,input().split()))
print(n-m+1)

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

print(N+1-K)

Solution (Python):
Array = [int(x) for x in input().split()]
N = Array[0]
K = Array[1]

print(N-(K-1))

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

print(N-K+1)

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

for i in range(k):
      nm=[i,1+i ]
for j in range (n):
      nm1=[i,1+i]
print(n-k+1)

Solution (Python):
N, K = list(map(int, input().split(' ')))

print(N - (K-1))

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):

N,K= list(map(int,input().split()))
print(N-K+1)

Solution (Python):
a = raw_input()
n,k = a.split(" ")
print int(n)-int(k)+1

Solution (Python):
a = raw_input()
n,k = a.split(" ")
print int(n)-int(k)+1

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
n,k=map(int, input().split()) 
a = range(1, n)
k = k - 1
print(len([a[i:i+k] for i in range(n-k)]))

Solution (Python):
n, k = [int(i) for i in input().split()]
print(n - k + 1)

Solution (Python):


N, K = map(int, raw_input().split())

print str(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(max(0, n - k + 1))

Solution (Python):
from sys import stdin

A, B = stdin.readline().rstrip().split()

print(int(A) - int(B) + 1)

Solution (Python):
n, k = (int(i) for i in input().split())
print(n-k+1)

Solution (Python):
N, K =map(int,input().split())
print(N-(K-1))

Solution (Python):
N,K = map(int,input().split())
print(N-K+1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
a, b = map(int, input().split())
ans = 0

for i in range(1, a+1):
    if i + b - 1 <= a:
        ans = ans + 1

print(ans)

Solution (Python):
import sys
import random
import itertools
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
n,k = map(int,input().split())
print(n-k+1)

Solution (Python):
n, k = (int(i) for i in input().split()) 
a =  n - k + 1
print( a)

Solution (Python):
import collections as c
ip = lambda : map(int, input().split())


N,K = ip()
print(N-K+1)

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

print(N - K + 1)

Solution (Python):
N,K= map(int, input().split())
print(N-K +1)

Solution (Python):
n, k = map(int,input().split() )
count = 0
for i in range(0,n+1):
    
    if i + k <= n:
        count+=1
    else:
        pass
print(count)

Solution (Python):
N,K = (int(i) for i in input().split())
n = [i for i in range(1,N+1)]
ans = []
for i in range(len(n)-K+1):
    tmp = []
    for j in range(K):
        tmp.append(n[j+i])
    ans.append(tmp)
print(len(ans))

Solution (Python):
n, k = [int(_) for _ in input().split()]
print(n-k+1)

Solution (Python):
n, m = map(int, input().split())
print(n - m + 1)

Solution (Python):
def main():
    n, k = map(int, input().split())

    print(n-k+1)


if __name__=='__main__':
    main()

Solution (Python):

import itertools
from collections import Counter
from collections import defaultdict
import bisect


def main():
    N, K = map(int, input().split())
    print(N - K + 1)

if __name__ == '__main__':
    main()

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
n,k=map(int, input().split())
print(n-(k-1))

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

print(N-K+1)

Solution (Python):
n, k = map(int, input().split(" "))
print(n-k+1)

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
N, K = map(int, input().split())
l = []
count = 0
j = 0
for i in range(1,N+1):
  l.append(i)
while True:
  j += 1
  if j + K-2 >= len(l):
    break
  count += 1
print(count)

Solution (Python):
def combinations(N, K):
    N = int(N)
    K = int(K)
    if N == K:
        return 1
    else:
        return N - K + 1
    
N, K = input().split(' ')

print(combinations(N, K))

Solution (Python):
n, k = map(int, input().split())
print(n-k+1)

Solution (Python):
a, b = map(int,input().split())
print(a-b+1)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

Solution (Python):


from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


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


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    if y > x // 2:
        y = x - y

    ret = 1

    for i in range(0, y):
        j = x - i
        i = i + 1

        ret = ret * j
        ret = ret // i

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance





def main():
    n, k = intin()
    print(n - k + 1)


if __name__ == '__main__':
    main()

Solution (Python):
N,K = map(int, input().split())
print(N-K+1)

Solution (Python):
n, k = [int(n) for n in input().split()]
print(n - k + 1)

Solution (Python):
l = list(map(int,input().split()))

print(l[0] - l[1] + 1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
n, k = map(int, input().split())
print(n - k + 1)

Solution (Python):



def main(N, K):
    
    

    return N - K + 1


if __name__ == "__main__":
    N, K = list(map(int, input().split()))
    print(main(N, K))

Solution (Python):
n,k = map(int,input().split())
c = 0
print(n-k+1)

Solution (Python):
import numpy as np

n,k=list(map(int,input().split()))
print(n-k+1)

Solution (Python):
n, k = [int(i) for i in input().split(" ")]
print(n - k + 1)

Solution (Python):
N,K = map(int,input().split())
A = N-K+1
print(A)

Solution (Python):
n,k = map(int,input().split())
print(n-(k-1))

Solution (Python):
n = input().split()

max_num = int(n[0])
kernel = int(n[1])

print(max_num - kernel + 1)

Solution (Python):



inp = input().split()
N = int(inp[0])
K = int(inp[1])

c = N - K + 1

print(c)

Solution (Python):
line = input().split(" ")
N = int(line[0])
M = int(line[1])

count = 0
    
for i in range(1, N+1):
    for j in range(M):
        if i+j > N:
            break
        if j == M-1:
            count += 1

print(count)

Solution (Python):
N,K = (int(i) for i in input().split())
print (N - K + 1)

Solution (Python):
N,K = list(map(int,input().split(" ")))

ans = N-K+1
print(ans)

Solution (Python):
N, K = map(int, input().split(" "))
print(N - K + 1)

Solution (Python):
N,K=(int(i) for i in input().split())
print(N-K+1)

Solution (Python):
n,k=list(map(int,input().split()))
print(n-k+1)

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

print(N-K+1)

Solution (Python):
n,k=map(int,input().split())
print(n+1-k)

Solution (Python):
N, K = map(int, input().split())
print(N-K+1)

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

ans = N - K + 1
print(ans)

Solution (Python):
list = [int(i) for i in input().split()]
print(list[0] - list[1] +1)

Solution (Python):
n,k = map(int,input().split())
flag = True
count = 0
while flag:
    if k <= n:
        count += 1
        k += 1
    else:
        flag = False
print(count)

Solution (Python):
N,K=map(int,input().split())
print(N-(K-1))

Solution (Python):
n , k = map(int , input().split())
ans = n - k + 1
print(ans)

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

print(int( N - (K - 1) ) )

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

print(n - k + 1)

Solution (Python):
N, K = map(int, input().split())
t = N - K + 1
print(t)

Solution (Python):
N, K =  map(int,input().split())
print(N-K+1)

Solution (Python):

v = [int(d) for d in input().split()]





print(v[0]-v[1]+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
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 list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)


def main():
    a,b = LI()

    return max(a - b + 1, 0)


print(main())

Solution (Python):
N, M = map(int, input().split())
print (N-M+1)

Solution (Python):
n,k=map(int,input().split())
print(n-k+1)

Solution (Python):

import sys


def solve(N: int, K: int):
    print(N-(K-1))
    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))  
    K = int(next(tokens))  
    solve(N, K)

if __name__ == '__main__':
    main()

Solution (Python):
import math

n,k = (int(i) for i in input().split()) 
print(n-k+1)

Solution (Python):
N,K=map(int,input().split())
print(N-K+1)

Solution (Python):
a,b = [ int(x) for x in input().split() ]
print( a-b+1 )

Solution (Python):
def main():
    NK = list(map(int, input().split()))
    N, K = NK[0], NK[1]
    ans = 0
    while N >= K:
        N = N - 1
        ans += 1
    print(ans)
main()