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


















import math
import copy
from collections import defaultdict
from collections import Counter
from collections import deque

from itertools import product

from itertools import permutations

from itertools import combinations
from bisect import bisect_left, bisect_right


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]

def i_inpl(): return int(input())
def s_inpl(): return map(int,input().split())
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")



N, K = s_inpl()

print(N-K+1)

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    n, k = f()
    print(n -k +1)

solve()

Solution (Python):


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
from collections import deque
sys.setrecursionlimit(10*5)


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

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

print(N - K + 1)

Solution (Python):



N,K =[int(x) for x in 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):

def main():
    buf = input()
    buflist = buf.split()
    N = int(buflist[0])
    K = int(buflist[1])
    print((N+1)-K)

if __name__ == '__main__':
    main()

Solution (Python):
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from math import ceil, floor
from sys import setrecursionlimit

import heapq as hq
import itertools as its
import operator as op



inf = float('inf')
N = 0


def set_inputs():
    global N
    return


def main():
    setrecursionlimit(100000)
    set_inputs()
    
    n, k = get_li()
    print(n - k + 1)
    return


def get_int():
    return int(input())


def get_float():
    return float(input())


def get_str():
    return input().strip()


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


def get_lf():
    return [float(f) for f in input().split()]


def get_lc():
    return list(input().strip())


def get_data(n, types, sep=None):
    if len(types) == 1:
        return [types[0](input().strip()) for _ in range(n)]
    return list(zip(*(
        [t(x) for t, x in zip(types, input().strip().split(sep=sep))]
        for _ in range(n)
    )))


if __name__ == '__main__':
    main()

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 = map(int, input().split())
print(n - k + 1)

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


if __name__ == "__main__":
    main()

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

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

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

Solution (Python):


def readInts():
  return [int(s) for s in input().split(" ")]

def main():
  N, K = readInts()
  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 = 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, M = map(int, input().split())
print(N-M+1)

Solution (Python):
import sys


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):
N,K=(int(x) for x in input().split())
print(N-K+1)

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

Solution (Python):


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

print(N-K+1)

Solution (Python):

"""<https://github.com/cheran-senthil/PyRival>"""
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()


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

    print(n - k + 1)




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._buffer = BytesIO()
        self._fd = file.fileno()
        self._writable = "x" in file.mode or "r" not in file.mode
        self.write = self._buffer.write if self._writable else None

    def read(self):
        if self._buffer.tell():
            return self._buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self._buffer.tell()
            self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
        self.newlines -= 1
        return self._buffer.readline()

    def flush(self):
        if self._writable:
            os.write(self._fd, self._buffer.getvalue())
            self._buffer.truncate(0), self._buffer.seek(0)


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b"\r\n")



if __name__ == "__main__":
    main()

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 = 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):
n,k=map(int,input().split())
print(n-k+1)

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

print(N-K+1)

Solution (Python):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits



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


def INT(): return int(input())


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


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


sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

n, k = MAP()

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):
import atexit
import io
import sys

buff = io.BytesIO()
sys.stdout = buff


@atexit.register
def write():
    sys.__stdout__.write(buff.getvalue())

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

Solution (Python):
def gcd_core(a, b):
    if b == 0:
        return a
    else:
        return gcd_core(b, a % b)


def gcd(arr):
    g = gcd_core(arr[0], arr[1])
    for i in range(2, len(arr)):
        g = gcd_core(g, arr[i])
    return g


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 = [int(item) for item 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):
a,b=map(int,input().split())
print(a-b+1)

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

print(nk[0] - nk[1] + 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):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits



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


def INT(): return int(input())


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


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


sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

n, k = MAP()

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 = map(int, input().split())
Ans = N-K+1
print(int(Ans))

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

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

Solution (Python):
def solve():
    N,K = map(int,input().split())
    ans = N - K + 1
    return ans

print(solve())

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 = 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,X = map(int,input().split())
print(N - X +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):
a,b=map(int,raw_input().split())
print a-b+1

Solution (Python):
I=lambda:map(int,input().split())
N,K=I()
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=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):

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 makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]

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

Solution (Python):
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):


import sys


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

Solution (Python):
from sys import stdin
import math
import fractions
from collections import deque

INF = 10 ** 10

N, K = [int(x) for x in stdin.readline().rstrip().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 = 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+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):
a, b = map(int,input().split())
print(str(a-b+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):
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 = map(int, input().split())
print(n - k + 1)

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

Solution (Python):
N,T = (int(i) for i in input().split())
print(N-T+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):
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions
import itertools
import copy
import collections
from operator import itemgetter

def j(q):
    if q==1: print("Yes")
    elif q == 0:print("No")
    exit(0)


"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def printrow(a):
    for i in range(len(a)):
        print(a[i])
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)



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):
N, K = map(int, input().split())
print(N-K+1)

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

Solution (Python):
import sys
import collections
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
nsm = lambda: map(str, sys.stdin.readline().split())

n, k = nm()
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 = 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):

"""
AtCoder A
"""








def main():
    A, B = list(map(int,input().split()))
    print(A-B+1)
    
if __name__ == "__main__":
    main()

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

input = sys.stdin.readline
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 = list(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 = map(int, input().split())
print(n-k+1)

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

print(N-K+1)

Solution (Python):
import queue

"""
N = int(input())



A = []
for i in range(N):
	A.append(int(input()))

print(A)

"""
(N,M) = (int(i) for i in input().split(" "))
print(N-M+1)

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

result = N - K + 1

print(result)

Solution (Python):
import sys

input = sys.stdin.readline
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):
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):
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(input())
def S(): return list(input())
n,k=IL()
print(n-k+1)

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

Solution (Python):
import sys
input = sys.stdin.readline

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



import sys
from collections import deque, Counter
import bisect
import math
from itertools import accumulate, product, permutations, combinations, groupby
from fractions import gcd 
import heapq
sys.setrecursionlimit(10**6)


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

Solution (Python):
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions
import itertools
import copy
import collections
from operator import itemgetter

def j(q):
    if q==1: print("Yes")
    elif q == 0:print("No")
    exit(0)


"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def printrow(a):
    for i in range(len(a)):
        print(a[i])
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)



n,k= (int(i) for i in 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())
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):
import sys, math, collections, heapq, itertools
F = sys.stdin
def single_input(): return F.readline().strip("\n")
def line_input(): return F.readline().strip("\n").split()
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while a % b > 0: a, b = b, a % b
    return b
  
def solve():
    N, K = map(int, line_input())
    print(N - K + 1)
    return 0
  
if __name__ == "__main__":
    solve()

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(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 = 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(num) for num 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):
N, K = map(int, input().split())
print(N - K + 1)

Solution (Python):

"""<https://github.com/cheran-senthil/PyRival>"""
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()


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




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._buffer = BytesIO()
        self._fd = file.fileno()
        self._writable = "x" in file.mode or "r" not in file.mode
        self.write = self._buffer.write if self._writable else None

    def read(self):
        if self._buffer.tell():
            return self._buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self._buffer.tell()
            self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
        self.newlines -= 1
        return self._buffer.readline()

    def flush(self):
        if self._writable:
            os.write(self._fd, self._buffer.getvalue())
            self._buffer.truncate(0), self._buffer.seek(0)


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b"\r\n")



if __name__ == "__main__":
    main()

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

x = N - K + 1
print(x)

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

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

x = N - K + 1
print(x)

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

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()

print(N-K+1)

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

Solution (Python):
n,k = (int(num) for num in 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 collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())

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

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

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