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



Sample input:
3 2


Sample output:
2

Submission status: Accepted

Solution code:
n,k=map(int,input().split())
if n<k:
    print(0)
else:
    print(n-k+1)

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
n, k = [int(x) for x in stdin.readline().rstrip().split()]
ans = n - (k-1)
print(ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

print(N-K+1)

Submission status: Accepted

Solution code:
#coding: utf-8
N, K = map(int, input().split())
print(N - K + 1)

Submission status: Accepted

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

print(n-k+1)

Submission status: Accepted

Solution code:
from sys import stdin
N, K = (int(i) for i in input().split())

print(N-K+1)

Submission status: Accepted

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

print(n-k+1)

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

import numpy as np

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

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

Submission status: Accepted

Solution code:
# coding:utf-8

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

Submission status: Accepted

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

print(N - K + 1)

Submission status: Accepted

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

Submission status: Accepted

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



print(n+1-k)

Submission status: Accepted

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

Submission status: Accepted

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

print(N - K + 1)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math

mod = 10**9+7

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

print(ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

print(N - K + 1)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
data = list(map(lambda x:int(x),input().split()))
print(data[0]-data[1]+1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env 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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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 = read_int()
    N, K = read_int_n()
    print(slv(N, K))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n,k=(int(i) for i in input().split())

print((n-k+1))

Submission status: Accepted

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

print(N-(K-1))

Submission status: Accepted

Solution code:


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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

Solution code:
from sys import stdin

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

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

Submission status: Accepted

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

Submission status: Accepted

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

print(N-K+1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
A,B=map(int,input().split())
print(A-B+1)

Submission status: Accepted

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

print(N-K+1)

Submission status: Accepted

Solution code:
words = lambda t : list(map(t, input().split()))
k,n = words(int)
print(k - n + 1)

Submission status: Accepted

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

Submission status: Accepted

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

print(n-k+1)

Submission status: Accepted

Solution code:
def li():
    return list(map(int, input().split()))


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

Submission status: Accepted

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

if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding:utf-8


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

    ans = N - K + 1
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
list = input().split()

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

Submission status: Accepted

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

print(N - K + 1)

Submission status: Accepted

Solution code:
from sys import stdin
N,K=[int(x) for x in stdin.readline().rstrip().split()]
ans=N-K+1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b=map(int, input().split())  #複数数値入力
print(a - b + 1)

Submission status: Accepted

Solution code:
def getlist():
	return list(map(int, input().split()))

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

Submission status: Accepted

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

val = N-K + 1
print val

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(n - k + 1)

Submission status: Accepted

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

Submission status: Accepted

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

print(N - K + 1)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
n, k = map(int, input().split())

print(n - k + 1)

Submission status: Accepted

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

print(N-K+1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

# coding: utf-8

# In[ ]:

import sys
input = sys.stdin.readline
N, K = map(int, input().split())
#A = list(map(int, input().split()))


# In[ ]:

print(N-K+1)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(N - (K - 1))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


print(n-k+1)

Submission status: Accepted

Solution code:
n,k=list(map(int,input().split()))
#for i in range(n):
#if(a>b):
print(n-k+1)

Submission status: Accepted

Solution code:
import math
import random as rd
import numpy as np

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

print(A-B+1)

Submission status: Accepted

Solution code:

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


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# from sys import exit
N, K = [int(n) for n in input().split()]
# a = [int(input()) for _ in range(N)]
# S = str(input())
# L = len(S)
# T = str(input())
# exit()
ans = 0
for i in range(0, N-K+1):
    ans += 1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#A問題
N, K = map(int, input().split())

print(N+1-K)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

print(n-k+1)

Submission status: Accepted

Solution code:
# https://qiita.com/_-_-_-_-_/items/34f933adc7be875e61d0
# abcde	s=input()	s='abcde'
# abcde	s=list(input())	s=['a', 'b', 'c', 'd', 'e']
# 5(1つだけ)	a=int(input())	a=5
# 1 2	| x,y = s_inpl()   |	x=1,y=2
# 1 2 3 4 5 ... n 　	li = input().split()	li=['1','2','3',...,'n']
# 1 2 3 4 5 ... n 　	li = inpl()	li=[1,2,3,4,5,...,n]
# FFFTFTTFF 　	li = input().split('T')	li=['FFF', 'F', '', 'FF']

# INPUT
# 3
# hoge
# foo
# bar
# ANSWER
# n=int(input())
# string_list=[input() for i in range(n)]

import math
import copy
from collections import defaultdict
from collections import Counter
from collections import deque
# 直積 A={a, b, c}, B={d, e}:のとき，A×B={(a,d),(a,e),(b,d),(b,e),(c,d),(c,e)}: product(A, B)
from itertools import product
# 階乗 P!: permutations(seq), 順列 {}_len(seq) P_n: permutations(seq, n)
from itertools import permutations
# 組み合わせ {}_len(seq) C_n: combinations(seq, n)
from itertools import combinations
from bisect import bisect_left, bisect_right
# import numpy as np

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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:


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


if __name__ == '__main__':
    main()

Submission status: Accepted

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


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

Submission status: Accepted

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

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

print(N-K+1)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
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


# globals
inf = float('inf')
N = 0


def set_inputs():
    global N
    return


def main():
    setrecursionlimit(100000)
    set_inputs()
    # ----------MAIN----------
    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()

Submission status: Accepted

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

Submission status: Accepted

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

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

if __name__ == "__main__":
  main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(N + 1 - K)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

print(N-K+1)

Submission status: Accepted

Solution code:
#!/usr/bin/env 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)


# region fastio

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

# endregion

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

ans = N-K+1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

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

print(n - k + 1)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/python3
# Dmitry _kun_ Sayutin (2019)

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

Submission status: Accepted

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

Submission status: Accepted

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

print(solve())

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python
n, k = map(int, input().split())
print(n - k+1)

Submission status: Accepted

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

Submission status: Accepted

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

print(N-K+1)

Submission status: Accepted

Solution code:
# /usr/bin/python
# -*- coding: utf-8 -*-
import sys


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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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 = ip()                                     #入力整数1つ
n,k= (int(i) for i in input().split())       #入力整数横2つ以上
#a = [int(i) for i in input().split()]        #入力整数配列
#a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列
#n = ip()                      #入力セット(整数改行あり)(1/2)
#a=[ip() for i in range(n)]    #入力セット(整数改行あり)(2/2)
#a=[input() for i in range(n)]    #入力セット(整数改行あり)(2/2)
#jの変数はしようできないので注意
#全足しにsum変数使用はsum関数使用できないので注意
print(n-k+1)

Submission status: Accepted

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

Submission status: Accepted

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

print(N-K+1)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
AtCoder A
"""

# N = int(input())
# A = list(map(int,input().split())) # N row 1 column
# A = int(input()) for _ in range(N) # 1 row N column

# S = str(input()) # str(input()) == input() -> 'abc'
# S = list(input()) # abc -> ['a','b','c']

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

Submission status: Accepted

Solution code:
import queue

"""
N = int(input())
#S = input()
# (N,M) = (int(i) for i in input().split(" "))
# A = [int(i) for i in input().split()]
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)

Submission status: Accepted

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

result = N - K + 1

print(result)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

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)
#input = sys.stdin.readline #文字列入力のときは注意

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



#if ok == 1:
#   print("Yes")
#else:
#   print("No")

Submission status: Accepted

Solution code:
n,k = (int(i) for i in input().split())

print(n-k+1)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#A問題
N,K=map(int,input().split())
print(N-K+1)

Submission status: Accepted

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