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

x = [i for i in range(1, N+1)]

summ = 0

for i, n in enumerate(x):
	if i + K <= len(x):
		summ=summ+1

print(summ)

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())
    ans = 0
    print(N - K + 1)


if __name__ == '__main__':
    main()

Solution (Python):
n,k = map(int, input().strip().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())


def calc_pattern_of_continuious_integers(N, K):
    return N - K + 1


print(calc_pattern_of_continuious_integers(N, K))

Solution (Python):
import math
def main():
    N, K = map(int, input().split())
    count = 0
    flag = True
    while flag:
        if N - K < 0:
            flag = False
        else:
            N -= 1
            count += 1
    print(count)
main()

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

Solution (Python):


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

print("{}".format(N-K+1))

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

print(N-K+1)

Solution (Python):
'''
A - Consecutive Integers
'''

import itertools

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

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

print(ans)

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


arr = [i for i in range(1,n+1)]

c = 0

for i in range(0,n-k+1):
	
	c += 1

print(c)

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

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

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

print(N-K+1)

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

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

n = []
for i in range(N):
    n.append(i)

num = 0
ind = 0
while (len(n) - K) >= 0:
    n.pop(0)
    num += 1

print(num)

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()))
num = N - K + 1
print(num)

Solution (Python):
import os, sys, re, math

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

Solution (Python):

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

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

ans = l[0] - l[1] + 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

p = [int(i) for i in input().split()]

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

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

print(N - K + 1)

Solution (Python):


num = input().split()
num1 = int(num[0])
retu = int(num[1])
kazu = 0
hint=[]
for i in range(num1):
    hint.append(i)
while len(hint) >= retu:
    kazu+=1
    hint.pop(0)
print(kazu)

Solution (Python):


NK = [int(i) for i in input().split()]

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

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [N, K] = [int(input_raw[0]), int(input_raw[1])]
    print N - K + 1

if __name__ == '__main__':
    main()

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

print(n-k+1)

Solution (Python):
s = input().split(" ")
s = [int(s[i]) for i in range(2)]
A = s[0]
B = s[1]
print(A - B + 1)

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

print(n-k+1)

Solution (Python):
n,k = map(int,input().split())
n1 = n + 1
ans = 0
for i in range(1,n1):
    if n >= k:
        ans += 1
        n -= 1
    else:
        break
print(ans)

Solution (Python):

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

print(N - K + 1)

Solution (Python):
all=1;
s = input()

s = s.split(" ")
n = int(s[0])
k = int (s[1])
answer = n-(k-1)
print(answer)

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

count = 0
for i in range(n[0]):
  next = i + (n[1]-1)
  
  if(next >= n[0]):
    break
    
  count += 1
  
print(count)

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

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

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

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


if __name__ == '__main__':
    main()

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

Solution (Python):



from collections import deque
import heapq
import math
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):

"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""


"""
Created on Sat Apr 13 09:53:12 2019

@author: Owner
"""
import numpy as np
import sys
import collections
import scipy.misc
import math
from operator import itemgetter
import itertools
import copy
import bisect


def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default


"""
N, X = map(int, input().split())

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

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())


dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')


ABT = zip(A, B, totAB)
result = 0

sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)


(x >> i) & 1


dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break

add = 1 
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)


li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    


org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)




    for h in range(0,H):
        for w in range(0,W):
            if h == 0 and w == 0:
                pass
            elif h == 0:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h-1][W-w]+1)
            elif w == 0:   
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1)
            else:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1, D[H-h-1][W-w]+1, D[H-h][W-w]+2)
            d_max = max(D[H-h-1][W-w-1], d_max)

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

    
if __name__ == '__main__':
    main()

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

Solution (Python):
from collections import defaultdict, deque, Counter
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 = list(map(int, input().split()))

print(N - (K - 1))

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

Solution (Python):


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

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

    return n, k


def nCr(n,r):
    f = math.factorial
    return f(n) / f(r) / f(n-r)


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



if __name__ == "__main__":
    main()

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

Solution (Python):
num, target = map(int, input().split())

print(num - target + 1)
exit(0)

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

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

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

Solution (Python):
a = input().split()
print(int(a[0])-int(a[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):
[n, k] = input().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())


s = []
for i in range(1,N + 1):
    s.append(str(i))

tmp = [''.join(s[i:i+K]) for i in range(len(s)-K+1)]


print(len(tmp))

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

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

seq = n - k +1
print(seq)

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

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

count = 0
flag = 0

for i in range(N):
    flag = 0
    for j in range(K):
        if i + j < N:
            pass
        else:
            flag = 1

    if flag == 0:
        count += 1
    else:
        break

print(count)

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






    
print(n-k+1)

Solution (Python):
x,y = map(int,input().split())
count = 0
while count+y <= x:
  count += 1

print(count)

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):
m=list(map(int, input().strip().split()))
print(m[0]-m[1]+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__':
	import sys
	sys.exit(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):
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):
n,k = map(int, input().split())
print(n - k + 1)

Solution (Python):
parents = list(map(int,input().split(' ')))
print(parents[0] - parents[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+1-k)

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

print(n-k+1)

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

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

Solution (Python):
a = raw_input().split()
print(int(a[0])-int(a[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):

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


if __name__ == '__main__':
    solve()

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


if __name__ == '__main__':
	main()

Solution (Python):
from sys import stdin

def main():
    n,k = [int(x) for x in stdin.readline().rstrip().split()]
    ans = n - k + 1
    print(ans)
    
if __name__=='__main__':
    main()

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

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



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


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

Solution (Python):



N, K = map(int, input().rstrip().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, 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,raw_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()))

if N < K:
    print(0)
    exit(0)
print(N - K + 1)

Solution (Python):
N, K = (int(i) for i in input().split())
if N < K:
    ans = 0
else:
    ans = N - K+1
print("{}".format(ans))

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

if K > N :
  print(0)
elif K == N:
  print(1)
else:
  print(N - K + 1)

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

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

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

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

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):
A = list(map(int,input().split()))
print(A[0]-A[1]+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 = [int(x) for x in input().split()]

print(n - k + 1)

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

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

Solution (Python):
N, K = input().split()
X = int(N)-int(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()))
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):
data = input().split()
n = int(data[0])
k = int(data[1])

print(n - k  +1)

Solution (Python):
import sys

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

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

print(n-j+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(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):
import sys
input = sys.stdin.readline

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):
l = map(int,raw_input().split())
print 1+l[0]-l[1]

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

print(N + 1 - K)

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

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

Solution (Python):
import sys

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

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

Solution (Python):
from sys import stdin
input=input=stdin.readline().rstrip().split()
for i in range(len(input)):
  input[i]=int(input[i])


output=input[0]-(input[1]-1)
print(output)

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

print(N - K + 1)

Solution (Python):

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

N = data[0]
K = data[1]

print(N - K + 1)

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

Solution (Python):
from io import StringIO
from collections import *
from functools import *
import sys


def main(inputs):
    
    
    n, k = map(int, next(inputs).split())
    return n - k + 1


def gen_inputs(str_=None):
    inputs = StringIO(str_) if str_ else sys.stdin
    while True:
        a = inputs.readline().rstrip()
        yield a
        pass
    pass


if __name__ == "__main__":
    print(main(gen_inputs()))
    pass

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

count = n - k +1
print(count)

Solution (Python):
line=input().split(" ")
n=int(line[0])
k=int(line[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())
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 = 0
for i in range(n):
    if i + k - 1 < n:
        ans += 1
print(ans)

Solution (Python):


import numpy as np
import math
import re

n,k = list(map(int,re.split(" ",input())))

count = 0
for i in range(n-k+1):
    count += 1

print(count)

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

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

Solution (Python):


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

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

Solution (Python):
nk = input()

n = int(nk.split(' ')[0])
k = int(nk.split(' ')[1])

answer = n - k + 1
print(answer)

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):
import numpy as np
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 math
import re

def main(params):
    n,k = params[0].split()
    print int(n) - int(k) + 1
    return int(n) - int(k) + 1

if __name__ == "__main__":
    cnt = 1 
    params = []
    for i in range(cnt):
        param = raw_input()
        params.append(param)
    main(params)

Solution (Python):


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

print(n - (k - 1))

Solution (Python):


import math, itertools, operator
from math import *
from math import factorial as fact
from itertools import permutations, combinations
from functools import reduce
from statistics import mean, median, median_low, median_high, mode

from fractions import gcd






inf = float('inf')

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

def perm(a, b):
    import scipy.special
    return scipy.special.perm(a, b, exact = True)

def comb(a, b):
    import scipy.special
    return scipy.special.comb(a, b, exact = True)

def dfact(n):
    import scipy.special
    return scipy.special.factorial2(n, exact = True)

def prod(l):
    return reduce(operator.mul, l)

def input_ints(inp = input, sep = ' ', conv = int):
    return map(conv, inp().split(sep = sep))




N, K = input_ints()

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

ans = n - k + 1

print(ans)

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

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

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

sys.setrecursionlimit(10 ** 7)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x) - 1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

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

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

ans = N - K + 1
print(ans)

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

ans = 0
for i in range(a):
    if i + b > a:
        break
    else:
        ans += 1
print(ans)

Solution (Python):


import sys
input = sys.stdin.readline



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


print(N - (K - 1))

Solution (Python):
import bisect
import numpy as np
import scipy as sp
from sys import stdin

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

Solution (Python):


"""
Created on Tue Feb 26 17:52:43 2019

@author: nakamuratakayuki
"""

N,K = tuple(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):
h = list(map(int, input().split()))



print(h[0]-h[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):


A, B = map(int, input().split())
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,K=[int(i) for i in input().split(" ")]
print(N-K+1)

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

print(N - K + 1)

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

Solution (Python):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]


    token = lines[0].split()
    n = int(token[0])
    k = int(token[1])

    return (n, k)


def solve(n, k):


    return n - k + 1


def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

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

Solution (Python):

"""
Created on Sat May 11 20:51:09 2019

@author: owner
"""

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

print('{}'.format(N-(k-1)))

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

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

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

readline = sys.stdin.readline

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

ret = N - K + 1

print(ret)

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

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

Solution (Python):








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

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


print(n-k+1)

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

print(N - K + 1)

Solution (Python):
import sys
range = xrange
input = raw_input

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):
n, k = map(int, input().split())
cnt = 0
for i in range(n):
    if i + k >= n:
        print(cnt+1)
        break
    else:
        cnt += 1

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

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

ret = N - K + 1
print(ret)

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

count = 0
for i in range(N-K+1):
    count += 1

print(count)

Solution (Python):


from sys import stdin
import numpy as np
 
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 = map(int, input().split())
print(N-K+1)

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

res = 0
for i in range(N-K+1):
    res += 1
    
print(res)

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

print(N - K + 1)

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

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

count = 0
for i in range(1, a + 1):
    if a >= i + b - 1:
        count += 1
print(count)

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

print(N-K+1)