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())
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(max(0,n-k+1))

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):
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 = [int(x) for x in input().split()]

print(N-K+1)

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

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

print("{0}".format(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


def solve(N: int, K: int):
    ret = N - K + 1
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    K = int(next(tokens))  
    solve(N, K)

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

import sys
from collections.abc import Iterable
from math import *
from itertools import *
from collections import *
from functools import *
from operator import *
try:
    from math import gcd
except Exception:
    from fractions import gcd


def solve(N: int, K: int):
    return N - (K - 1)


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))  
    result = solve(N, K)
    if isinstance(result, Iterable):
        result = '\n'.join([str(v) for v in result])
    print(result)

if __name__ == '__main__':
    main()

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

print(n-k+1)

Solution (Python):
from math import factorial
n,k = map(int, input().strip().split())

print(max(0, 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 = input().split()

answer = int(N) - int(K) + 1

print(answer)

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):
if __name__ == '__main__':
    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):

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):
x = input().split()
N = int(x[0])
K = int(x[1])

S = N - K + 1
print(str(S))

Solution (Python):
n, k = [int(item) for item in input().split()]

print(n-k+1)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
input = sys.stdin.readline
 


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

	print(ans)

	
	
if __name__ == "__main__":
	main()

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

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

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

print(N - K + 1)

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):
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 = input().split()

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

n_patterns = n - k + 1

if n_patterns <= 0:
    n_patterns = 0

print(n_patterns)

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

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

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

Solution (Python):
line = [int(x) for x in input().split(" ")]
print(line[0] - line[1] + 1)

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

Solution (Python):

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

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

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

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

print(N-K+1)

Solution (Python):
MAX_INT = int(10e10)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

def combi(a,b):
    C = 1
    for j in range(b):
        C = C*(a-j)//(j+1)
    return C

N,K = IL()

print(N-K+1)

Solution (Python):
N,K = map(int, raw_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 = [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())
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):
nums = list(map(int, input().split()))
N, K = nums[0], nums[1]
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):


def solve():
    N, K = list(map(int, input().split()))

    print(N-K+1)

if __name__ == "__main__":
    solve()

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

Solution (Python):
import sys
rr = lambda: sys.stdin.readline().strip()
ri = lambda: int(rr())
rs = lambda: [int(_) for _ in rr().split()]

N, K = rs()
ans = 0

print(N-K+1)

Solution (Python):
N, K = map(int, input().split())
print(max(0, 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):
input = input().split()
N = int(input[0])
K = int(input[1])

print(N-K+1)

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

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

Solution (Python):
N,K = (int(i) for i in 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 = input().strip().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):
p1, p2 = map(int, input().split())
print(p1-p2+1)

Solution (Python):
import sys

n, k = list(map(int, sys.stdin.readline().strip().split(" ")))

print(n-k+1)

Solution (Python):
import numpy as np
import statistics

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

Solution (Python):
import sys

def main():
    input = sys.stdin.readline
    N, K = map(int, input().split())

    return N - K + 1


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

Solution (Python):
N, K = (int(i) for i in 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,M=map(int,input().split())

i=0
ans=1
while True:
    i+=1
    if(i+M>N):
        break
    ans+=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):
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=map(int,input().split())
ans = max(0,N-K+1)
print(ans)

Solution (Python):
n_k = input().split()
n = int(n_k[0])
k = int(n_k[1])
print(n-(k-1))

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


def main():
    N, K = [int(ele) for ele in input().split()]
    if N == K:
        print(1)
    elif K < N:
        print(N-K + 1)


if __name__ == "__main__":
    main()

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

Solution (Python):



def solv(n, k):
    ans = n - k + 1
    return ans


if __name__ == '__main__':

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

    ans = solv(n, k)

    print(ans)

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

Solution (Python):
import sys


A, B = map(int, input().split())

print(A - B + 1)

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N,K=MAP()

print(N-K+1)

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

Solution (Python):
[a,b]=[int(i) for i in 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())
i =n - k + 1
print(i)

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 = 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):
from collections import deque
from heapq import heappush,heappop
import re
def int_raw():
    return int(input())

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

def ints_raw():
    return list(map(int, ss_raw()))

INF = 1<<29

N,K = ints_raw()


def main():
    return N - K +1

print(main())

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().rstrip() 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):
data = list(map(int, input().split()))
N = data[0]
K = data[1]

print(N - K + 1)

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

Solution (Python):
from sys import stdin










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):
from collections import defaultdict
from string import ascii_uppercase
import sys, bisect, math
stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

N,K = read_int()

def solve():
    ans = N - K + 1
    return ans

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

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

print(N-K+1)

Solution (Python):
n,k=map(int,input().split())
if n<k:
    print(0)
else:
    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):
def main():
    N,K = map(int,input().split(" "))
    print(N-K+1)


if __name__ == "__main__":
    main()

Solution (Python):
a,b=input().split()
print(int(a)-int(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(x) for x in input().split()]

print(N - K + 1)

Solution (Python):
from sys import stdin
import math
import itertools


def makeIntMatrix(lines):
    intMatrix = []
    for a in makeStringMatrix(lines):
        intMatrix.append([int(b) for b in a])
    return intMatrix
 
 
def makeStringMatrix(lines):
    stringMatrix = [line.split() for line in lines]
    return stringMatrix
 
 
def makeInt(line):
    return int(line.rstrip())
 
 
def makeMultiInteger(line):
    return [int(x) for x in line.rstrip().split()]


def solve(input_string):
    n, k = makeMultiInteger(input_string[0])
    return n-k+1


def main():
    input_lines = stdin.readlines()
    answer = solve(input_lines)
    print(answer)


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
n, k = [int(x) for x in stdin.readline().rstrip().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):
from sys import stdin
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):
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 = 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):
import sys
input = sys.stdin.readline

import numpy as np

X,Y = map(int,input().split())

print("{0}".format(X-Y+1))

Solution (Python):


import sys
from collections import deque

INF = float('inf')
MOD = 10 ** 9 + 7
dy, dx = (0, -1, 0, 1), (1, 0, -1, 0)

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()


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

print(N - K + 1)

Solution (Python):
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18

N,K=rl()
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+1-k)

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

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

import copy
import random
import bisect 
import fractions 
import math

mod = 10**9+7

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

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):
data = list(map(lambda x:int(x),input().split()))
print(data[0]-data[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):
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):
N, K  = map(int,input().split())
print(N-K+1)

Solution (Python):


from collections import deque
import itertools as it
import sys
import math

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

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

Solution (Python):


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

print(N-K+1)

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)


def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


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


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, K):
    return N - K + 1


def main():
    
    N, K = read_int_n()
    print(slv(N, K))


if __name__ == '__main__':
    main()

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


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

def submit():
    n, k = read_input()

    print(n - k + 1)
    return

if __name__ == '__main__':
    submit()

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

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

input = lambda: stdin.readline()
main()

Solution (Python):
def main():
    from sys import stdin, stdout

    def read():
        return stdin.readline().rstrip('\n')

    def read_array(sep=None, maxsplit=-1):
        return read().split(sep, maxsplit)

    def read_int():
        return int(read())

    def read_int_array(sep=None, maxsplit=-1):
        return [int(a) for a in read_array(sep, maxsplit)]

    def write(*args, **kwargs):
        sep = kwargs.get('sep', ' ')
        end = kwargs.get('end', '\n')
        stdout.write(sep.join(str(a) for a in args) + end)

    def write_array(array, **kwargs):
        sep = kwargs.get('sep', ' ')
        end = kwargs.get('end', '\n')
        stdout.write(sep.join(str(a) for a in array) + end)

    n, k = read_int_array()
    write(1 + n - k)

main()

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):
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):
words = lambda t : list(map(t, input().split()))
k,n = words(int)
print(k - n + 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):
def li():
    return list(map(int, input().split()))


[n, k] = li()
print(n - k + 1)

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

Solution (Python):
def solve():
    N, K = [int(_) for _ in raw_input().split()]
    ret = N - K + 1
    print str(ret)

if __name__ == '__main__':
    solve()

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

Solution (Python):



def main():
    N, K = map(int, input().split())

    ans = N - K + 1
    print(ans)


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):
list = input().split()

print(int(list[0]) - int(list[1]) + 1)

Solution (Python):
l = raw_input().split()
N = int(l[0])
K = int(l[1])

print(N - K + 1)

Solution (Python):
from sys import stdin
N,K=[int(x) for x in stdin.readline().rstrip().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):
import sys
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

n,k = na()

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):
def getlist():
	return list(map(int, input().split()))

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

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

val = N-K + 1
print val

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

Solution (Python):
n, k = [int(a) for a 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=(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):

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

Solution (Python):
import sys
from fractions import gcd
from functools import reduce
from itertools import combinations

import numpy as np

sys.setrecursionlimit(200000)


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


def ii(t: type = int):
    return t(input())


def il(t: type = int):
    return list(map(t, input().split()))


def imi(N: int, t: type = int):
    return [ii(t) for _ in range(N)]


def iml(N: int, t: type = int):
    return [il(t) for _ in range(N)]


def solve():
    A, B = il()
    ans = A - B + 1
    return ans


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

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

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

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

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

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

stdin = sys.stdin

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

n, k = na()
print(n-k+1)

Solution (Python):
n,k = list(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):
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 = 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):
A = [int(i) for i in input().split()]
print(A[0]+1 - (A[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(n) for n 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())
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())
ans = N - K + 1
print(ans)

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

print(n-k+1)

Solution (Python):
import math
import random as rd
import numpy as np

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

a=list(map(int,input().split(" ")))


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

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

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

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

Solution (Python):

N, K = [int(n) for n in input().split()]





ans = 0
for i in range(0, N-K+1):
    ans += 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):
a,b=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())
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())
ans = n-k+1
print(ans)

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

Solution (Python):
n, k = (int(z) for z 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+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(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,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)