Problem:


Score : 200 points

Problem Statement

There are 2000001 stones placed on a number line. The coordinates of these stones are -1000000, -999999, -999998, \ldots, 999999, 1000000.

Among them, some K consecutive stones are painted black, and the others are painted white.

Additionally, we know that the stone at coordinate X is painted black.

Print all coordinates that potentially contain a stone painted black, in ascending order.

Constraints

1 \leq K \leq 100

0 \leq X \leq 100

All values in input are integers.

Input

Input is given from Standard Input in the following format:

K X

Output

Print all coordinates that potentially contain a stone painted black, in ascending order, with spaces in between.

Sample Input 1

3 7

Sample Output 1

5 6 7 8 9

We know that there are three stones painted black, and the stone at coordinate 7 is painted black. There are three possible cases:

The three stones painted black are placed at coordinates 5, 6, and 7.

The three stones painted black are placed at coordinates 6, 7, and 8.

The three stones painted black are placed at coordinates 7, 8, and 9.

Thus, five coordinates potentially contain a stone painted black: 5, 6, 7, 8, and 9.

Sample Input 2

4 0

Sample Output 2

-3 -2 -1 0 1 2 3

Negative coordinates can also contain a stone painted black.

Sample Input 3

1 100

Sample Output 3

100



Sample input:
3 7


Sample output:
5 6 7 8 9

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
for a in range(x-k+1,x+k):
    print(a ,end=" ")

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
ans = list(range(max(-1000000, X - K + 1), min(1000000, X + K - 1) + 1))
print(" ".join(map(str, ans)))

Submission status: Accepted

Solution code:
i,k=map(int,input().split())
for a in range(k-i+1,k+i):
    print(a ,end=" ")

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
a = k - 1
b = [str(i) for i in range(x-a, x+a+1)]
print(" ".join(b))

Submission status: Accepted

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

li=[str(i) for i in range(x-k+1,x+k)]
li=" ".join(li)

print(li)

Submission status: Accepted

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

mil = 1000000
a = X - K + 1
if a < -mil:a = -mil
for i in range(a,X + K):
    print(i , end = " ")
    if i == mil:break

print()

Submission status: Accepted

Solution code:
a,b=input().split()
a = int(a)
b = int(b)
ans = []
for i in range(b-a+1, b):
    ans.append(str(i))
ans.append(str(b))
for i in range(b+1, a+b):
    ans.append(str(i))
print(' '.join(ans))

Submission status: Accepted

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

l = [str(i) for i in range(x-k+1,k+x)]

print(" ".join(l))

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
list = []
for i in range(-K+1, K):
    list.append(i+X)
print(*list, sep=' ')

Submission status: Accepted

Solution code:
import io

nim,mike=map(int,input().split())
for i in range(mike-nim+1,mike+nim):
    print(i)

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
A = K - 1
B = range(X - A, X + K)
for b in B:
    print(b, end = " ")

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
List = [0 for _ in range(2*K-1)]
for i in range(2*K-1):
  List[i] = str(X - K + 1 + i)
a = (" ").join(List)
print(a)

Submission status: Accepted

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

black_list = []

for i in range(X - K + 1, X + K):
    black_list.append(i)
    
ans = " ".join(map(str, black_list))

print(ans)

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
ans = []
for i in range(x-k+1, x+k):
  ans.append(i)
print(" ".join(map(str, ans)))

Submission status: Accepted

Solution code:
#B
k,x = map(int,input().split())

min_k = x - k + 1
max_k = x + k - 1

ans = []
for i in range(min_k,max_k+1):
    ans.append(i)

print(*ans)

Submission status: Accepted

Solution code:
K,X=map(int, input().split())
ans = ""
for i in range(X-K+1,X+K):
  ans = ans + str(i)+ " " 
print(ans)

Submission status: Accepted

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

"""

k,x=map(int,input().split())
for i in range(max(x-k+1,-1000001),min(x+k,1000000+1)):
    print(i,end=" ")

Submission status: Accepted

Solution code:
k , x = map(int, input().split())
'''
a = [ x , x+1 , x-1 , x+2 , x-2 ]
print(sorted(a))
'''
'''
for i in range(2*k-1):
  print(x-k+1 + i)
'''

for i in range(x-k+1,x+k):
    print(i,end=" ")

'''
for i in range(-3,10):
    print(i,end=" ")
'''

Submission status: Accepted

Solution code:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(l):
	n = len(l)
	

k,x = list(map(int, stdin.readline().rstrip().split()))
ans = []
for i in range(x-k+1,x+k):
	ans.append(i)
print(*ans)

Submission status: Accepted

Solution code:
import sys

# 入力を整数に変換して受け取る
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
# 入力全てを整数に変換したものの配列を受け取る
def LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'

# リストを改行区切りで出力する
p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")

k,x=MI()
l=[]

for i in range(x-k+1,x+k):
    if i >= -1000000 or i <= 1000000:
        l.append(i)
p2S(l)

Submission status: Accepted

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

if X + K > 1000000:
    ans = range(X - K + 1, 1000001)
    print(*ans)
elif X - K < -1000000:
    ans = range(-1000000, X + K)
    print(*ans)
else:
    ans = range(X - K + 1, X + K)
    print(*ans)

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
for i in range ((X-K+1),(X+K),1):
    print(i,end=" ")

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
s=""
for i in range(-k+1,k):
    s+=str(x+i)+' '
print(s)

Submission status: Accepted

Solution code:
a,b = map(int, input().split())
res = []
for i in range(2*a-1):
  res.append(b-a+1+i)
print(*res)

Submission status: Accepted

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

L = [ str(X - K + i) for i in range(1,2*K)]

print(" ".join(L))

Submission status: Accepted

Solution code:
k,x = list(map(int,input().split()))
for i in range(x-k+1,x+k):
  print(i)

Submission status: Accepted

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

for i in range(b-(a-1),b+(a-1)+1):
  print(i,' ',end='')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
K,X = (int(x) for x in input().split())
ans = []
for i in range(X-K+1,X+K):
  ans.append(i)
 
ans.sort()

for j in range(len(ans)):
  print(ans[j],end="")
  print(" ",end = "")

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
list = [X]
for i in range(1,K):
    list.append(X+i)
    list.append(X-i)
print(*sorted(list))

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
for i in range(X-K+1, X+K):
    print(i, end=" ")

Submission status: Accepted

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

if X-K+1 < -1000000:
    for i in range(-1000000,X-K):
        print(i,end=" ") 
elif X+K-1 > 1000000:
    for i in range(X-K+1,1000001):
        print(i,end=" ")
else:
    for i in range(X-K+1,X+K):
        print(i,end=" ")

Submission status: Accepted

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

ans = [X]

for i in range(K-1):
    ans.append(X+(i+1))

ans.reverse()
for i in range(K-1):
    ans.append(X-(i+1))

ans.reverse()
print(*ans)

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
print(' '.join(map(str, range(x - k + 1, x + k))))

Submission status: Accepted

Solution code:
inputted = list(map(int, input().split()))
K = inputted[0]
X = inputted[1]

minimum = X - K + 1
maxium = X + K - 1
from_to = abs(minimum) + abs(maxium)

for xi in range(minimum, maxium + 1):
    print(xi, end=' ')

Submission status: Accepted

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

c = []
for i in range(2*k-1):
    c.append(x-(k-1-i))

print(" ".join(map(str,c)))

Submission status: Accepted

Solution code:
from collections import deque
K, N = map(int, input().split())
ans = deque()
ans.append(N)
for i in range(1, K):
    ans.appendleft(N-i)
    ans.append(N+i)
print(*ans)

Submission status: Accepted

Solution code:
K,X=list(map(int,input().split()))
Min = max(X - (K -1),-1000000)
Max = min(X + (K-1),1000000)
ans = []
for i in range(Min,Max+1):
    ans.append(i)
ans = map(str,ans)
ans = ' '.join(ans)
print(ans)

Submission status: Accepted

Solution code:
k, x = map(int,input().split())
print(*[ i for i in range(x-k+1,x+k)])

Submission status: Accepted

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

ans = []
for i in range(x - k + 1, x + k):
    ans.append(i)
print(*ans)

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
for i in range(x-k+1,x+k):
  print(i,end=' ')

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin

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

K,X=nm()
ans=[X-K+1+i for i in range(2*K-1)]
print(*ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
K, X = [int(s) for s in input().split()]

print(' '.join([str(s) for s in range(X - K + 1, X + K, 1)]))

Submission status: Accepted

Solution code:
import os, sys, re, math

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

print(' '.join([str(i) for i in range(X - K + 1, X + K)]))

Submission status: Accepted

Solution code:
K, X = [int(s) for s in input().split(' ')]
ret = [str(x) for x in range(X - K + 1, X + K)]
print(' '.join(ret))

Submission status: Accepted

Solution code:
k, x = [int(i) for i in input().split()]
print (' '.join([str(i) for i in range(x - k + 1, x + k)]))

Submission status: Accepted

Solution code:
k, x = list(map(int, input().split(' ')))
ans = []
for i in range(-1000000, 1000001):
    if abs(x-i) <= k-1:
        ans.append(str(i))
print(' '.join(ans))

Submission status: Accepted

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

num,number=[str(x-(k-1))],x-(k-1)
for i in range(k+(k-2)):
  number+=1
  num.append(str(number))
  
print(" ".join(num))

Submission status: Accepted

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

ans = []

for i in range(X-K+1, X+K):
    ans.append(i)

print(*ans)

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
for i in range(k*2-1):
    print(x-k+i+1,end=" ")

Submission status: Accepted

Solution code:
def q2():
    K, X = (int(i) for i in input().split())
    min_pos = X - K + 1
    max_pos = X + K
    ans = map(lambda x: str(x), range(min_pos, max_pos))
    print(' '.join(list(ans)))


if __name__ == '__main__':
    q2()

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
ans=[]
# 3,7 = 5,6,7,8,9 = X-K+1, X+K-1
for i in range(X-K+1,X+K):
    ans.append(i)
#print(ans)
print(" ".join(map(str,ans)))

Submission status: Accepted

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

for i in range((k-1) * 2 + 1):
    num = x - k + (i + 1)
    if -(10 ** 6) <= num and num <= (10 ** 6):
        print(num, end=' ')

Submission status: Accepted

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

min = X - (K - 1)
max = X + (K - 1)

for i in range(min, max + 1):
  print(i, end=' ')

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
black = []
if X - K + 1 < -1000000:
  for i in range(-1000000, K):
    black.append(i)
elif X + K -1 > 1000000:
  for i in range(1000000-K+1, K):
    black.append(i)
else:
  for i in range(X - K + 1, X + K):
    black.append(i)
print(*black)

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
for i in range(2*k-1):
  print(x-k+1 + i)

Submission status: Accepted

Solution code:
K,X = map(int, input().split())
for _ in range(max(X-K+1,-1000000),min(1000001,X+K)):
  print(_,end=' ')

Submission status: Accepted

Solution code:
K,X = map(int, input().split())
a, b = 0,0
A = []
if X - K+1 < -1000000:
  a = -1000000
else:
  a = X - K+1

if X + K-1 > 1000000:
  b = 1000000
else:
  b = X + K-1

for _ in range(a,b+1):
  print(_,end=' ')

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
list_ans = []

for i in range(K):
    list_ans.append(X-(K-(i+1)))
 
for j in range(K-1):
    list_ans.append(X+j+1) 

print(*list_ans)

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
print(*[i for i in range(max(-1000000, X-K+1), min(1000000, X+K-1) + 1)])

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
a=[]
for i in range(X-K+1,X+K):
  a.append(i)
  
print(*a)

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
ans=[X]
for i in range(1,K):
    ans.append(X-i)
    ans.append(X+i)
print(*sorted(ans))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
X, K = map(int, input().split())
A = ""
for i in range(2*X-1):
    A = A+str(K-(X-(i+1)))+" "
print(A)

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
ns = [str(i) for i in range(x-k+1, x+k)]
print(' '.join(ns))

Submission status: Accepted

Solution code:
import numpy as np
p,q= input().split()
a,b =(int(p), int(q))
list_np = np.arange(-1000000, 1000000,1)
ans_list = []
for i in range(a):
    ans_list.append(b + i)
    ans_list.append(b - i)
ans_list.pop(0)
ans_list.sort()
ans=''

for i in range(a*2 -1):
    if i < a * 2 -1 :
        ans += str(ans_list[i])
        ans +=' '
    else:
        ans +=str(ans_list[i])
        break
print(ans)

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
ans = [int(x) for x in range(x-k+1, x+k)]
print(' '.join(map(str, ans)))

Submission status: Accepted

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

ans = [str(i) for i in range(x-k+1,x+k)]
print(" ".join(ans))

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
ans = []

for i in range(-10**6, 10**6+1):
    if abs(i-X)<K:
        ans.append(i)

print(*ans)

Submission status: Accepted

Solution code:
a,b = map(int,input().split())
c = a*2-1
for i in range(c):
    print(b-a+1+i, end=" ")

Submission status: Accepted

Solution code:
#
# Written by NoKnowledgeGG @YlePhan
# ('ω')
#
#import math
#mod = 10**9+7
#import itertools
#import fractions
#import numpy as np
#mod = 10**4 + 7
"""def kiri(n,m):
  r_ = n / m
  if (r_ - (n // m)) > 0:
    return (n//m) + 1
  else:
    return (n//m)"""
  
def main():
  k,x = map(int,input().split())
  P = []
  
  for i in range(x-k+1,x+k):
    P.append(i)
  
  print(*P)
  
  
if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
maxx=0
minx=0
maxx=1000000 if x+k-1>1000000 else x+k-1
minx=-1000000 if x-k+1<-1000000 else x-k+1
ans=""
for i in range(minx,maxx+1):
  ans+=str(i)+" "
print(ans)

Submission status: Accepted

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

under = x-(k-1)
top = x+(k-1)

ans = ''
for i in range(under,top+1):
    if i == top:
        ans += str(i)
    else:
        ans += str(i)+' '


print(ans)

Submission status: Accepted

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

ans = [i for i in range(x-k+1, x+k)]
print(' '.join(map(str, ans)))

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
fi = x - k + 1
en = x + k - 1
ans = str(fi)
for _ in range(fi + 1, en + 1):
    ans += " " + str(_)
print(ans)

Submission status: Accepted

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

ans = [i for i in range(X-K+1, X+K)]
for i in ans:
    print(i)

Submission status: Accepted

Solution code:
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))

def main():
    K, X = input_nums()
    a = [x for x in range(K*2-1)]
    m = a[len(a)//2]
    d = m - X
    print(*[x - d for x in a])

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
for i in range(X - K + 1, X + K):
  print(i,end = " ")

Submission status: Accepted

Solution code:
#n=int(input())
k,x=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

l=[i for i in range(max(x-k+1,-1000000),min(x+k-1,1000000)+1)]

print(*l,sep=" ")

Submission status: Accepted

Solution code:
a,b=map(int,input().split())
min=b-(a-1) 
if min<-1000000:
  min=-1000000    
max=b+(a-1)
if max>1000000:
  max=1000000
ans=[]

for i in range(min,max+1):
  ans.append(i)
print(*ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
for i in range(2*k-1):
    print(x+1-k+i,end=" ")

Submission status: Accepted

Solution code:
K,X = map(int, input().split())
#print (K,' ',X)

for i in range(K*2-1):
  print (X-K+1+i,' ', end="")

Submission status: Accepted

Solution code:
l = list(map(int,input().split(" ")))
k = l[0]
x = l[1]

c_min = x - k + 1
c_max = x + k - 1

if c_min < -1000000:
    c_min = -1000000
if c_max > 1000000:
    c_max = 1000000

l_ans = []
for i in range(c_min,c_max+1):
    l_ans.append(i)

print(" ".join(map(str,l_ans)))

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
L = []
for i in range(K):
    num = X+i
    L.append(num)
for j in range(K-1):
    num = (X-1) - j
    L.append(num)
L2 = sorted(L)
print(*L2)

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
A=[]
A.append(X)
for i in range(K-1):
    A.append(X-i-1)
    A.append(X+i+1)
B=sorted(A)
for i in B:
    print(i,end=" ")

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
l = max(-1000000, x - k + 1)
r = min(1000000, x + k - 1)
for i in range(l, r + 1):
  print(i)

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
for i in range(X-K+1,X+K):
  print(i,end=' ')

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
for i in range(X-K+1, K+X):
    print(i, end=" ")

Submission status: Accepted

Solution code:
K,X = map(int,input().split())
num = []
num.append(X)
for i in range(X,X+K-1):
  num.append(X-(i-X+1))
  num.append(i+1)
num.sort()
[print(x,'',end='') for x in num]

Submission status: Accepted

Solution code:
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    k,x=INTM()
    ans=[]
    a=max(-1000000, x-k+1)
    b=min(1000000, x+k-1)
    for i in range(a,b+1):
        ans.append(i)
    print(*ans)
if __name__ == '__main__':
    do()

Submission status: Accepted

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

for i in range(X-K+1,X+K):
  print(i,end=" ")

Submission status: Accepted

Solution code:
n,x=map(int,input().split())
for i in range(1,n+1):
  print(x-(n-i),end=" ")
for i in range(n-1):
  print(x+(i+1),end=" ")

Submission status: Accepted

Solution code:
K, X = map(int, input().split(" "))
print(' '.join([str(k) for k in range(X - K + 1, X + K)]))

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
li=[]
for i in range(-1000000,1000001):
  li.append(i)
for i in range(2*k-1):
  if li[x-1-(k-1)+i]>=-1000000:
    print(li[x+1000000-(k-1)+i],end=" ")

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
ans=""
for i in range(X-K+1,X+K):
  ans+=str(i)+" "
print(ans.rstrip(" "))

Submission status: Accepted

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

print(*range(x-k+1, x+k))

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
# プラマイ-1
minx = x - (k -1)
maxx = x + (k -1)

print(*[i for i in range(minx,maxx+1)])

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
ans=[]
for i in range(-k+1+x,k+x):
  print(i,end=' ')

Submission status: Accepted

Solution code:
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

k,x = iim()
l = list(range(x-k+1,x+k))
for item in l:
    print(item,end=' ')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
MaxValue=1000000

if X-K<-1*MaxValue:
  ans=-1*MaxValue
  while ans<X+K:
    print(ans)
    ans+=1

elif X+K>MaxValue:
  ans=X-K+1
  while ans<=MaxValue:
    print(ans)
    ans+=1
else:
  for i in range(X-K+1,X+K):
    print(i)

Submission status: Accepted

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

for i in range(x-k+1,x+k):
    print(i, end=' ')
print()

Submission status: Accepted

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

ans = ''
for i in range(X-K+1,X+K):
  ans += str(i) + ' '

print(ans)

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
KK = K - 1
A = list(range(X-KK, X+KK+1))
print(*A)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
s = x - k + 1
e = x + k - 1

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

print(*list)

Submission status: Accepted

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

for i in range(X-K+1, X+K-1+1):
    print(i, end=' ')

Submission status: Accepted

Solution code:
K,X = map(int,input().split())
L = []
for i in range(X-K+1,X+K):
  L.append(i)
[print(i,end=' ') for i in L]

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
ans = [i for i in range(x-k+1, x+k)]
print(' '.join(map(str,ans)))

Submission status: Accepted

Solution code:
K,X = map(int,input().split())
print(" ".join(list(map(str,[i for i in range(X-K+1,X+K,1)]))))

Submission status: Accepted

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

x = X - (K - 1)
y = X + (K - 1)

l = []
for i in range(x, y+1):
  l.append(str(i))
ans = ' '.join(l)
print(ans)

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
box = []
for i in range(-k+1,k):
     box.append(x + i)
print(' '.join(list(map(str,box))))

Submission status: Accepted

Solution code:
K,X = map(int,input().split())
mi = X-K+1
Ma = X+K-1
A = []
for i in range(mi,Ma+1):
    A.append(i)
print(*A)

Submission status: Accepted

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

for i in range(k*2 - 1):
    print(x - k + 1 + i, end=" ")

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
for i in range(-1000000,1000001,1):
    if abs(i-x)<k:
        print(i,end=' ')
print()

Submission status: Accepted

Solution code:
import math
import os
import random
import re
import sys

if __name__ == '__main__':
    # n = int(input())
    k, x = list(map(int, input().rstrip().split()))

    for i in range(x - k + 1, x + k):
        print(i, end = " ")

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
min1 = x-k+1
max1 = x+k-1
L = []
for i in range(min1,max1+1):
  L.append(i)
print(*L)

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
ans = []
num = X - K
for i in range(K*2-1):
    num += 1
    ans.append(num)
print(*ans)

Submission status: Accepted

Solution code:

[K, X] = list(map(int,input().split()))

min= X-K+1
max= X+K-1

out=[]
for i in range(min,max+1):
    out.append(i)

out = ' '.join(map(str,out))
print(out)

Submission status: Accepted

Solution code:
def main():
    k, x = map(int, input().split())
    print(" ".join(map(str, range(x-k+1, x+k))))

main()

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
left = x-(k-1)
right = x+(k-1)
print(" ".join([str(i) for i in range(left, right+1)]))

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
ans=[]
for i in range(X-K+1,X+K):
    ans.append(i)
print(*ans)

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
for i in range(x-k+1,x+k):
    print(i,end=' ')

Submission status: Accepted

Solution code:
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

K, X = lr()
left = max(X-K+1, -1000000)
right = min(X+K-1, 1000000)
answer = range(left, right+1)
print(*answer)

Submission status: Accepted

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

min_n = x - k + 1
max_n = x + k - 1

for i in range(min_n, max_n+1):
    print(i)

Submission status: Accepted

Solution code:
k,x=map(int, input().split())
A=[]
for i in range(2*k-1):
  A.append(x-k+(i+1))
for i in range(len(A)):
  print(A[i], end=" ")

Submission status: Accepted

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

min_ = x - k + 1
max_ = x + k - 1

res = ""
for i in range(min_, max_ + 1):
  res += str(i)
  res += " "
print(res)

Submission status: Accepted

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

ans = [i for i in range(x-k+1, x+k)]
print(" ".join(map(str, ans)))

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
for i in range(2*k-1):
    print(i+x-k+1,end = ' ')

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
ans = [X]

for i in range(1, K):
    ans.append(X-i)
    ans.append(X+i)
    
ans.sort()

print(*ans)

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
l = range(x-k+1, x+k)
print(*l)

Submission status: Accepted

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

for i in range(k*2-1):
  print(x-k+1)
  k -= 1

Submission status: Accepted

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

mn = max(-1000000, X - K + 1)
mx = min(+1000000, X + K - 1) + 1
ans = " ".join(map(str, range(mn, mx)))

print(ans)

Submission status: Accepted

Solution code:
k, x = map(int, input().split())
b = [x - k + 1]

if k > 1:
  for i in range(x - k + 2, x + k):
    b.append(i)

print(" ".join(map(str, b)))

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
k -= 1
start = x - k
end = x + k + 1
ans = list(range(start,end))
print(*ans)

Submission status: Accepted

Solution code:
k,x = map(int,raw_input().split())
s = " "
for i in xrange(x-k+1,x+k):
    s += str(i) + ' '
print s

Submission status: Accepted

Solution code:
# from math import factorial,sqrt
# from itertools import permutations as permus
# from fractions import gcd
# from collections import deque,Counter
# from decimal import Decimal, getcontext
# # getcontext().prec = 1000
# # eps = Decimal(10) ** (-100)

# import numpy as np
# import scipy as scp

# 入力の受け取り
k,x = map(int,input().split())

st = x-k+1
end = x+k

ans = list(range(st,end))

print(*ans)
# print("{:.10f}".format(ans))
# print(*ans)   # unpackして出力。間にスペースが入る
# for row in board:
#     print(*row,sep="")    #unpackして間にスペース入れずに出力する

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
result = []
for i in range(2 * K - 1):
    result.append(X - K + 1 + i)
print(*result)

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
l = []
for i in range(X - (K - 1), X + K):
    l.append(str(i))
print(" ".join(l))

Submission status: Accepted

Solution code:
#B One Clue
k,x=map(int,input().split())
for i in range(x-k+1,x+k):
    print(i,end=' ')

Submission status: Accepted

Solution code:
#137_B
k, x = map(int,input().split())
inf = 10 ** 6
ans = [i for i in range(max(-inf, x-k+1), min(inf, x +k-1)+1)]
print(*ans)

Submission status: Accepted

Solution code:
k, x = map(int, input().split(' '))
start = x-k+1
end = x+k-1
ans = list(range(start, end+1))
print(*ans)

Submission status: Accepted

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

X_min = max(-1000000, X - K + 1)
X_max = min(+1000000, X + K - 1)

block_stones = [str(X_min + i) for i in range(X_max - X_min + 1)]
print(" ".join(block_stones))

Submission status: Accepted

Solution code:
K,X=map(int,input().split())
A=""
B=2*(K-2)+2
for i in range(B+1):
    A=A+(str(X-K+1+i))+" "
print(A)

Submission status: Accepted

Solution code:
K,X = map(int,input().split())
t = list((range(X-K+1,X+K)))
print(" ".join(map(str,t)))

Submission status: Accepted

Solution code:
k, x = [int(x) for x in input().split()]
print(*list(range(x - k + 1, x + k)))

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
a = []
for x in range(X-K+1,X+K):
    a.append(x)
print(*a)

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
for i in range(x-k+1,x+k):
  print(i,end="")
  if i!=x+k-1:
    print(" ",end="")

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
ans_list = list(range(X - K + 1, X + K))
ans = ""
for a in ans_list:
    ans += str(a) + " "
print(ans)

Submission status: Accepted

Solution code:
k, x = map(int,input().split())
a = []
for i in range(-k+x+1, k+x):
  a.append(str(i))
print(' '.join(a))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
B - One Clue
https://atcoder.jp/contests/abc137/tasks/abc137_b

"""
import sys


def solve(K, X):
    return [i for i in range(X - K + 1, X + K) if -1000000 <= i <= 1000000]


def main(args):
    K, X = map(int, input().split())
    ans = solve(K, X)
    print(*ans)


if __name__ == '__main__':
    main(sys.argv[1:])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
k,x=map(int,input().split())
s=[x-i for i in range(k)]
t=[x+i for i in range(1,k)]
print(*sorted(s+t))

Submission status: Accepted

Solution code:
K,X =map(int,input().split())
l = []
for i in range(X-K+1,X+K):
  l.append(str(i))
##print(l)
print(" ".join(l))

Submission status: Accepted

Solution code:
K, X = map(int,input().split())
for i in range(X-K+1, X+K):
  print(i, end=" ")

Submission status: Accepted

Solution code:
K, X = map(int, input().split())
L = list(range(X-K+1, K+X))
print(*L, sep=" ")

Submission status: Accepted

Solution code:
k,x = map(int,input().split())
print(" ".join(map(str,list(range(x-k+1,x+k)))))

Submission status: Accepted

Solution code:
import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *

sys.setrecursionlimit(100000000)
input = lambda: sys.stdin.readline().rstrip()

K, X = map(int, input().split())
print(' '.join(map(str, [X + i for i in range(-K + 1, K)])))