ZhenlongDai/ACPR huggingface dataset:
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
S = list(map(int, input().split()))

K = S[0]
X = S[1]


A = abs(X-K)+1
B = X+K

for i in range(A, B, 1):
  print(i, end="")
  print(" ", end="")



Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 

Fixed submission (verdict: Accepted):
S = list(map(int, input().split()))

K = S[0]
X = S[1]


A = X-K+1
B = X+K

for i in range(A, B, 1):
  print(i, end="")
  print(" ", end="")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)

Failing test case input:
9 63

Expected output:
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71


Actual output:
5556575859606162636465666768697071


Fixed submission (verdict: Accepted):
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)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def fa(K,X):
    L=[X]
    for i in range(0,K-1):
        L.append(X-i+2)
        L.append(X+i-2)
    return set(L)
K,X=map(int,input().split())
print(fa(K,X))

Failing test case input:
14 63

Expected output:
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76


Actual output:
{53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73}


Fixed submission (verdict: Accepted):
def fa(K,X):
    ch=""
    L=[X]
    for i in range(1,K):
        L.append(X-i)
        L.append(X+i)
    L.sort()
    C=str(L)
    ch=C[1:len(C)-1]
    return ch
K,X=map(int,input().split())
print(fa(K,X).replace(",",""))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
i = list(map(int,input().split()))
K = i[0]
X = i[1]
print(range(X-K+1,X-K-1))

Failing test case input:
9 85

Expected output:
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93


Actual output:
range(77, 75)


Fixed submission (verdict: Accepted):
i = list(map(int,input().split()))
K = i[0]
X = i[1]
C = range(X-K+1,X+K)
print(' '.join(map(str,list(C))))

Problem: p02946
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

def input2():
	return map(int,input().split())
  
k,x=input2()

st=x-k+1
fi=x+k-1

for i in range(st,fi+1):
	print(i,end="")

Failing test case input:
16 27

Expected output:
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42


Actual output:
12131415161718192021222324252627282930313233343536373839404142

Fixed submission (verdict: Accepted):

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

k,x=input2()

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

print(*ans)
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
i,k=map(int,input().split())
for i in range(k-i+1,k+i):
    print(i ,end="")

Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
5354555657585960616263646566676869

Fixed submission (verdict: Accepted):
i,k=map(int,input().split())
for a in range(k-i+1,k+i):
    print(a ,end=" ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())
seq = []

for j in range(2):
	for i in range(k):
		buf = str(x + i * (-1) ** j)
		if buf not in seq:
			seq.append(buf)
		
seq.sort()
print(" ".join(seq))

Failing test case input:
11 18

Expected output:
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28


Actual output:
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 8 9


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())
seq = []

for j in range(2):
	for i in range(k):
		buf = x + i * (-1) ** j
		if buf not in seq:
			seq.append(buf)
		
seq.sort()
print(*seq)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = map(int, input().split())
print(*range(x-k+1, x+k-1))


Failing test case input:
11 18

Expected output:
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28


Actual output:
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27


Fixed submission (verdict: Accepted):
k,x = map(int, input().split())
print(*range(x-k+1, k+x))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
input = sys.stdin.readline
def main():
    K, X = map(int, input().split())
    LOWER = max(X - K + 1, -1000000)
    UPPER = min(X + K - 1, 1000000)
    print(LOWER)
    ans = [i for i in range(LOWER, UPPER+1)]
    print(ans)

if __name__ == '__main__':
    main()


Failing test case input:
15 17

Expected output:
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
3
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]


Fixed submission (verdict: Accepted):
import sys
input = sys.stdin.readline
def main():
    K, X = map(int, input().split())
    LOWER = max(X - K + 1, -1000000)
    UPPER = min(X + K - 1, 1000000)
    ans = [str(i) for i in range(LOWER, UPPER+1)]
    print(" ".join(ans))

if __name__ == '__main__':
    main()

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
i = list(map(int,input().split()))
K = i[0]
X = i[1]
print(range(X-K+1,X+K))

Failing test case input:
11 18

Expected output:
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28


Actual output:
range(8, 29)


Fixed submission (verdict: Accepted):
i = list(map(int,input().split()))
K = i[0]
X = i[1]
C = range(X-K+1,X+K)
print(' '.join(map(str,list(C))))
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = map( int,input().split())
a = x-(k-1)
b = x+(k+1)
c = []

for i in range(a,b+1):
    if -1000000 <= i <= 1000000:
        c.append(i)

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

Failing test case input:
4 59

Expected output:
56 57 58 59 60 61 62


Actual output:
56 57 58 59 60 61 62 63 64


Fixed submission (verdict: Accepted):
k,x = map(int,input().split())
a = x-(k-1)
b = x+(k-1)
c = []

for i in range(a,b+1):
    if -1000000 <= i <= 1000000:
        c.append(i)

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

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = map(int,input().split())
a = x+k
b = x-k+1
print(list(range(b,a)))
  


Failing test case input:
5 27

Expected output:
23 24 25 26 27 28 29 30 31


Actual output:
[23, 24, 25, 26, 27, 28, 29, 30, 31]


Fixed submission (verdict: Accepted):
k,x = map(int,input().split())
for i in range(x-k+1,x+k):
    print(i,end=' ')

Problem: p02946
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
K,X = list(map(int,input().split()))
a = X-K+1
b = X+K-1
I = list(range(a,b))
print(I)

Failing test case input:
7 010

Expected output:
4 5 6 7 8 9 10 11 12 13 14 15 16


Actual output:
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]


Fixed submission (verdict: Accepted):
K,X = list(map(int,input().split()))
a = X-K+1
b = X+K-1
I = list(range(a,b+1))
print(' '.join(str(ans) for ans in I))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
X,K=map(int,input().split())
A=[]
for i in range(X+K):
  if X-K<i<X+K:
    A+=[i]
for t in A:
  print(t, end = " ")

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 

Fixed submission (verdict: Accepted):
K,X=map(int,input().split())
A=[]
i=X-K+1
while  i<=X+K-1:
  A+=[i]
  i+=1
for s in A:
  print(s, end=" ")

Problem: p02946
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
K, X = map(int, input().split())

print([x for x in range(X - K + 1, X + K)])



Failing test case input:
9 35

Expected output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


Actual output:
[27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43]


Fixed submission (verdict: Accepted):
K, X = map(int, input().split())

print(*[x for x in range(X - K + 1, X + K)])

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int, input().split())
for i in (X-(K-1), X+K):
  print(i, end=" ")

Failing test case input:
5 27

Expected output:
23 24 25 26 27 28 29 30 31


Actual output:
23 32 

Fixed submission (verdict: Accepted):
K, X = map(int, input().split())
for i in range(X-(K-1), X+K):
  print(i, end=" ")
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x=[int(k) for k in input().split(" ")]

print(" ".join([str(_) for _ in range(max(-1000000,x-k+1),min(1000000,x+k-1))]))


Failing test case input:
11 63

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73


Actual output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72


Fixed submission (verdict: Accepted):
k,x=[int(k) for k in input().split(" ")]

print(" ".join([str(_) for _ in range(max(-1000000,x-k+1),min(1000001,x+k))]))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())			

x_min = -1000000
x_max =  1000000

l = x_min
r = x_max

l = max( l, x-k+1 )
r = min( r, x+k-1 )

for i in range(l, r+1):
	print(i, end='')

print("")



Failing test case input:
15 17

Expected output:
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
345678910111213141516171819202122232425262728293031


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())			

x_min = -1000000
x_max =  1000000

l = x_min
r = x_max

l = max( l, x-k+1 )
r = min( r, x+k-1 )

for i in range(l, r+1):
	print(i, end=' ')

print("")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b=map(int,input().split())
mylist = []
for row in range(a):
  c = row+b
  mylist.append(c)
for row in range(a):
  c = -row+b
  mylist.append(c) 
mylist = sorted(set(mylist))
for row in mylist:
	print(row,end='')

Failing test case input:
9 21

Expected output:
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29


Actual output:
1314151617181920212223242526272829

Fixed submission (verdict: Accepted):
a,b=map(int,input().split())
mylist = []
for row in range(a):
  c = row+b
  mylist.append(c)
for row in range(a):
  c = -row+b
  mylist.append(c) 
mylist = sorted(set(mylist))
for row in mylist:
	print(row,end=' ')

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int,input().split())

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

Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
5354555657585960616263646566676869

Fixed submission (verdict: Accepted):
K, X = map(int,input().split())

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

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int, input().split())
print(x for x in range(X-K+1, X+K))

Failing test case input:
9 63

Expected output:
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71


Actual output:
<generator object <genexpr> at 0x7f91392b8110>


Fixed submission (verdict: Accepted):
K,X=map(int,input().split())
print(*[x for x in range(X-K+1,X+K)])
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k ,x = map(int, input().split())
print(list(range(x - k + 1, x + k)))


Failing test case input:
7 010

Expected output:
4 5 6 7 8 9 10 11 12 13 14 15 16


Actual output:
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]


Fixed submission (verdict: Accepted):
k ,x = map(int, input().split())
print(" ".join(map(str, list(range(x - k + 1, x + k)))))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())

l = max(-1000000, x-k+1)
r = min(1000001, x+k)

print([i for i in range(l,r)])

Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
[53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69]


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())

l = max(-1000000, x-k+1)
r = min(1000001, x+k)

print(*[i for i in range(l,r)])

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K,X = map(int,input().split())

a = X - (K - 1)
b = X + (K - 1)
c = []
for i in range(a,b+1):
  c.append(i)
print(c)


Failing test case input:
14 63

Expected output:
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76


Actual output:
[50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76]


Fixed submission (verdict: Accepted):
K,X = map(int,input().split())

a = X - (K - 1)
b = X + (K - 1)
c = []
for i in range(a,b+1):
  c.append(i)
print(*c)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

for i in range(K):
    ans.append(X-i)
    
for i in range(K):
    ans.append(X+i)
    
ans.sort()
ans.remove(X)
print(ans)

Failing test case input:
15 17

Expected output:
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]


Fixed submission (verdict: Accepted):

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

for i in range(K):
    ans.append(X-i)
    
for i in range(K):
    ans.append(X+i)
    
ans.sort()
ans.remove(X)
print(*ans)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = 1000001
k, x = map(int, input().split())

for i in range(x-k+1, x+k-1):
    if -n < i and i < n:
        print(i)

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
-2
-1
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21


Fixed submission (verdict: Accepted):
n = 1000001
k, x = map(int, input().split())

for i in range(x-k+1, x+k):
    if -n < i and i < n:
        print(i, end=' ')
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = map(int,input().split())
li =  []
for i in range(k):
    if i == 0:
        li.append(x)
    else:            
        li.append(x+i)
        li.append(x-i)
print(sorted(li))

Failing test case input:
9 63

Expected output:
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71


Actual output:
[55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71]


Fixed submission (verdict: Accepted):
k,x = map(int,input().split())
li =  []
for i in range(k):
    if i == 0:
        li.append(x)
    else:
        li.append(x+i)
        li.append(x-i)

li.sort()
print(*li)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())
lst1 = []

for i in range(k):
    lst1.append(x-i)
    lst1.append(x+i)

lst2 = sorted(lst1)
lst3 = list(set(lst2))

print(' '.join([str(_) for _ in lst3]))

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 -2 -1


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())
lst1 = []

for i in range(k):
    lst1.append(x-i)
    lst1.append(x+i)

lst2 = sorted(list(set(lst1)))

print(' '.join([str(_) for _ in lst2]))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
X, K = map(int, input().split())
l = range((K-(X-1)),(K + (X)))
a = list(l)
print(a)

Failing test case input:
5 35

Expected output:
31 32 33 34 35 36 37 38 39


Actual output:
[31, 32, 33, 34, 35, 36, 37, 38, 39]


Fixed submission (verdict: Accepted):
X, K = map(int, input().split())
l = range((K-(X-1)),(K + (X)))
a = list(l)
print( " ".join( repr(e) for e in a ) )

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = map(int, input().split())
print(*range(x-k+1, k+x-1))


Failing test case input:
5 35

Expected output:
31 32 33 34 35 36 37 38 39


Actual output:
31 32 33 34 35 36 37 38


Fixed submission (verdict: Accepted):
k,x = map(int, input().split())
print(*range(x-k+1, k+x))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int, input().split())
S = X -(K-1)
while True:
    if S > X + (K -1):
        break
    print(S, end="")
    S += 1

Failing test case input:
15 17

Expected output:
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
345678910111213141516171819202122232425262728293031

Fixed submission (verdict: Accepted):
K, X = map(int, input().split())
S = X -(K-1)
while True:
    if S > X + (K -1):
        break
    print(str(S)+" ", end="")
    S += 1
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = list(map(int, input().split()))
k = n[0]
x = n[1]
s1 = x - k + 1
s2 = x + k - 1
print(list(range( (s1), (s2 + 1)  )))

Failing test case input:
9 46

Expected output:
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54


Actual output:
[38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54]


Fixed submission (verdict: Accepted):
n = list(map(int, input().split()))
k = n[0]
x = n[1]
s1 = x - k + 1
s2 = x + k - 1
a1 = list(range( (s1), (s2 + 1)  ))
print(" ".join(list(map(str, a1))))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a ,b = map(int,input().split())
c = []

for i in range(a):
    c.append(b-i)
    c.append(b+i)

c = set(c)
print("test",sorted(c))


Failing test case input:
9 85

Expected output:
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93


Actual output:
test [77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93]


Fixed submission (verdict: Accepted):
a ,b = map(int,input().split())
c = []

for i in range(a):
    c.append(b-i)
    c.append(b+i)

c = set(c)

print(*sorted(c))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, N = map(int, input().split())
L = [v for v in range(N - K, N, 1)]
R = [v for v in range(N, N+K, 1)]
L.extend(R)
set(L)
print(sorted(list(L)))


Failing test case input:
16 16

Expected output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]


Fixed submission (verdict: Accepted):
K, N = map(int, input().split())
L = [v for v in range(N - K + 1, N, 1)]
R = [v for v in range(N, N+K, 1)]
L.extend(R)
set(L)
LLL = sorted(list(L))
print(" ".join(list(map(str, LLL))))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n=[int(i) for i in input().split()]
for i in range(-(n[0]-1),n[0]-1):
  print(n[1]+i,end=" ")

Failing test case input:
11 18

Expected output:
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28


Actual output:
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 

Fixed submission (verdict: Accepted):
n=[int(i) for i in input().split()]
for i in range(-(n[0]-1),n[0]):
  print(n[1]+i,end=" ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):



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


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


Failing test case input:
5 27

Expected output:
23 24 25 26 27 28 29 30 31


Actual output:
23 24 25 26 27 28 29 30 

Fixed submission (verdict: Accepted):



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


if K > 1:
    for i in range(X - K + 1, X + K):
        if i == X + K - 1:
            print(i)
        else:
            print(i, end=' ')
else:
    print(X)
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b = map(int,input().split())
x = range(b-a,b+a)
y = list(x)
print(y)

Failing test case input:
4 59

Expected output:
56 57 58 59 60 61 62


Actual output:
[55, 56, 57, 58, 59, 60, 61, 62]


Fixed submission (verdict: Accepted):
a,b = map(int,input().split())
x = range(b-a+1,b+a)
y = list(x)
print(" ".join(map(str, y)))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
import re
INPUT = sys.stdin.readline

def SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()

K,X = MULT_INT_LIST()
ans = []
kuro_min = X-K+1
kuro_max = X+K-1
for i in range(kuro_min,kuro_max):
    ans.append(i)
ans = str(ans)
ans = ans.replace(",", "")
ans = ans.strip('[]') 
print(ans)

Failing test case input:
9 63

Expected output:
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71


Actual output:
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70


Fixed submission (verdict: Accepted):
import sys
import re
INPUT = sys.stdin.readline

def SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()

K,X = MULT_INT_LIST()
ans = []
kuro_min = X-K+1
kuro_max = X+K-1
for i in range(kuro_min,kuro_max+1):
    ans.append(i)
ans = str(ans)
ans = ans.replace(",", "")
ans = ans.strip('[]') 
print(ans)

Problem: p02946
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,k = map(int, input().split())
arr = []
for i in range(a - k + 1, a + k):
  arr.append(i)
for i in arr:
  print(i)


Failing test case input:
5 27

Expected output:
23 24 25 26 27 28 29 30 31


Actual output:
-21
-20
-19
-18
-17
-16
-15
-14
-13
-12
-11
-10
-9
-8
-7
-6
-5
-4
-3
-2
-1
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


Fixed submission (verdict: Accepted):
a,k = map(int, input().split())
arr = []
for i in range(k - a + 1, a + k):
  arr.append(i)
for i in arr:
  print(i,end=" ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int, input().split())

ans = []
for i in range(7 - K + 1, 7 + K):
    if i > -1000000 or i < 1000000:
        ans.append(i)

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


Failing test case input:
9 85

Expected output:
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93


Actual output:
-1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15


Fixed submission (verdict: Accepted):
K, X = map(int, input().split())

ans = []
for i in range(X - K + 1, X + K):
    if i > -1000000 or i < 1000000:
        ans.append(i)

print(" ".join(map(str, ans)))
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = map(int,input().split())
if k==1:
  print(x)
else:
  list_ = list(range(max(-1000000,x-(k-1)),min(1000000,x+(k-1))))
  list_=[str(i) for i in list_]
  answer = " ".join(list_)
  print(answer)

Failing test case input:
4 59

Expected output:
56 57 58 59 60 61 62


Actual output:
56 57 58 59 60 61


Fixed submission (verdict: Accepted):
k,x = map(int,input().split())
if k==1:
  print(x)
else:
  list_ = list(range(max(-1000000,x-(k-1)),min(1000000,x+(k-1))+1))
  list_=[str(i) for i in list_]
  answer = " ".join(list_)
  print(answer)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
data = [int(x) for x in input().split(" ")]

num_0 = int(data[0])
num_1 = int(data[1])

for x in range(data[0]*2-1):
  print(num_1-x+1,end=" ")

Failing test case input:
16 16

Expected output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 

Fixed submission (verdict: Accepted):
data = [int(x) for x in input().split(" ")]

num_0 = int(data[0])
num_1 = int(data[1])
 
for x in range(-num_0+1,num_0):
    print(num_1+x,end=" ")
print("")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x=map(int,input().split())
print([num for num in range(x-k+1,x+k)])

Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
[53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69]


Fixed submission (verdict: Accepted):
k,x=map(int,input().split())
print(*[num for num in range(x-k+1,x+k)])

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K,X=map(int,input().split())
for i in range(X-K+1,X+K-1):
    print(i)

Failing test case input:
9 21

Expected output:
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29


Actual output:
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


Fixed submission (verdict: Accepted):
K,X=map(int,input().split())
for i in range(X-K+1,X+K):
    print(i,end=' ')

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s=list(map(int,input().split()))
i=0
list=[]
for i in range(s[1]-s[0]+1,s[1]+s[0]):
  list.append(i)
print(list)

Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
[53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69]


Fixed submission (verdict: Accepted):
s=list(map(int,input().split()))
i=0
list=[]
for i in range(s[1]-s[0]+1,s[1]+s[0]):
  list.append(i)
print(" ".join(map(str, list)))
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = (int(i) for i in input().split())

arr = []

for i in range(-k + 1, 0):
  for j in range(0, k + 1):
    arr.append(i + j + x) 

result = sorted(list(set(arr)))

if (k == 1):
  result = x

print(result)

  

Failing test case input:
9 85

Expected output:
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93


Actual output:
[77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93]


Fixed submission (verdict: Accepted):
k, x = (int(i) for i in input().split())
arr = []

for i in range(-k + 1, 0):
  for j in range(0, k + 1):
    arr.append(i + j + x) 

sorted_list = sorted(list(set(arr)))

result =  " ".join(map(str, sorted_list))
if (k == 1):
  result = x


print(result)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())
if k > 1:
    print (*([p for p in range(x-k+1,x)] + [p for p in range(x+1, x+k)]))
else:
    print (x)

Failing test case input:
16 27

Expected output:
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42


Actual output:
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())
if k > 1:
    print (*([p for p in range(x-k+1,x+1)] + [p for p in range(x+1, x+k)]))
else:
    print (x)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
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)))

Failing test case input:
9 35

Expected output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


Actual output:
27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43


Fixed submission (verdict: Accepted):
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)))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
x, k = map(int, input().split())

ans = []

for i in range(x-k+1, x+k):
    ans.append(i)

ans = [str(ai) for ai in ans]
print(' '.join(ans))

Failing test case input:
15 17

Expected output:
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
-1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())

ans = []

for i in range(x-k+1, x+k):
    ans.append(i)

ans = [str(ai) for ai in ans]
print(' '.join(ans))
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())


def solve():
    _min = -1000000
    _max = 1000000

    if (x - k + 1) > _min:
        _min = x - k + 1
    if (x + k - 1) < _max:
        _max = x + k - 1

    return list(range(_min, _max + 1))


print(solve())


Failing test case input:
16 16

Expected output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())


def solve():
    _min = -1000000
    _max = 1000000

    if (x - k + 1) > _min:
        _min = x - k + 1
    if (x + k - 1) < _max:
        _max = x + k - 1

    ans = list(map(str, range(_min, _max + 1)))

    return ' '.join(ans)


print(solve())

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):

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

Failing test case input:
9 63

Expected output:
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71


Actual output:
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 

Fixed submission (verdict: Accepted):

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

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())

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

Failing test case input:
11 18

Expected output:
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28


Actual output:
8910111213141516171819202122232425262728

Fixed submission (verdict: Accepted):
k, x = map(int, input().split())

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

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = [int(i) for i in input().split()]
s = set()
for i in range(K):
    s.add(X+i)
    s.add(X-i)

for i in s:
    print(i, end=" ")


Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
64 65 66 67 68 69 53 54 55 56 57 58 59 60 61 62 63 

Fixed submission (verdict: Accepted):
K, X = [int(i) for i in input().split()]
s = set()
for i in range(K):
    s.add(X+i)
    s.add(X-i)

for i in sorted(list(s)):
    print(i, end=" ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K,X = map(int, input().split())

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

print(*ans)

Failing test case input:
16 16

Expected output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31


Actual output:
17 15 18 14 19 13 20 12 21 11 22 10 23 9 24 8 25 7 26 6 27 5 28 4 29 3 30 2 31 1 16


Fixed submission (verdict: Accepted):
K,X = map(int, input().split())

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

ans.sort()
print(*ans)
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())
print(list(range(max(-1000000, x-k+1), min(x+k, 1000001))))


Failing test case input:
7 010

Expected output:
4 5 6 7 8 9 10 11 12 13 14 15 16


Actual output:
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())
print(*list(range(max(-1000000, x-k+1), min(x+k, 1000001))))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x= map(int, input().split())
l=[x]
for i in range(1, k):
  l.append(x-i)
  l.append(x+i)
l.sort()
l = list(map(str, l))

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:

Fixed submission (verdict: Accepted):
k, x= map(int, input().split())
l=[x]
for i in range(1, k):
  l.append(x-i)
  l.append(x+i)
l.sort()
l = list(map(str, l))
print(' '.join(l))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K,X = map(int,input().split())
 
ans = ""
 
for i in range(K-(X-1),K+(X+1)):
	ans += "i"
      
print(ans)

Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii


Fixed submission (verdict: Accepted):
K,X = map(int,input().split())
 
ans = ""
 
for i in range(X-(K-1),X+(K+1)-1):
	ans = ans + " " + str(i)
      
print(ans.lstrip())

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


def main():
    nyuuryoku = list(map(int, input().split()))
    k = nyuuryoku[0]
    x = nyuuryoku[1]
    num_list = []

    num_list.append(x)

    for i in range(k):
        if(x+i < 100000):
            num_list.append(x+i)

    for i in range(k):
        if(x-i > -100000):
            num_list.append(x-i)

    num_list_uniq = list(set(num_list))
    print(num_list_uniq.sort())

if __name__ == "__main__":
    main()

Failing test case input:
9 35

Expected output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


Actual output:
None


Fixed submission (verdict: Accepted):


def main():
    nyuuryoku = list(map(int, input().split()))
    k = nyuuryoku[0]
    x = nyuuryoku[1]
    num_list = []

    num_list.append(x)

    for i in range(k):
        if(x+i < 100000):
            num_list.append(x+i)

    for i in range(k):
        if(x-i > -100000):
            num_list.append(x-i)

    num_list_uniq = sorted(list(set(num_list)))
    print(*num_list_uniq)

if __name__ == "__main__":
    main()

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b= map(int,input().split())
for i in range(-a+1,a):
    print(b+a)


Failing test case input:
14 63

Expected output:
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76


Actual output:
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77


Fixed submission (verdict: Accepted):
a,b= map(int,input().split())
for i in range(-a+1,a):
    print(b+i, end=" ")
print()
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


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

Failing test case input:
14 63

Expected output:
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76


Actual output:
505152535455565758596061626364656667686970717273747576

Fixed submission (verdict: Accepted):


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

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = map(int,input().split())
for i in range(2*k-1):
    print(i + 1 - x - k,"",end="")

Failing test case input:
7 010

Expected output:
4 5 6 7 8 9 10 11 12 13 14 15 16


Actual output:
-16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 

Fixed submission (verdict: Accepted):
k,z = map(int,input().split())
for i in range(2*k - 1):
    print(z - k + i + 1,end=" ")

Problem: p02946
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
k,x=map(int,input().split())
print(*range(x-k,x+k+1))

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
-3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23


Fixed submission (verdict: Accepted):
k,x=map(int,input().split())
print(*range(x-k+1,x+k))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x=map(int,input().split())
ans=[]
for i in range(2*k-1):
    ans.append(x-k+1+i)
print(ans)

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
[-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]


Fixed submission (verdict: Accepted):
k,x=map(int,input().split())
ans=[]
for i in range(2*k-1):
    ans.append(x-k+1+i)
print(' '.join(map(str, ans)))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = list(map(int, input().split()))

s = []

for i in range(x-k+1, x+k):
    s.append(i)

print(s)


Failing test case input:
9 35

Expected output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


Actual output:
[27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43]


Fixed submission (verdict: Accepted):
k, x = list(map(int, input().split()))

s = []

for i in range(x-k+1, x+k):
    s.append(i)

s = map(str, s)

l = ' '.join(s)

print(l)
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys

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

min_x = k - x + 1
if(min_x < -1000000):
	min_x = -1000000

max_x = k + x - 1
if(max_x > 1000000):
	max_x = 1000000

for i in range(min_x,max_x+1):
	sys.stdout.write(str(i))
	if i != max_x:
		sys.stdout.write(" ")



Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
-51 -50 -49 -48 -47 -46 -45 -44 -43 -42 -41 -40 -39 -38 -37 -36 -35 -34 -33 -32 -31 -30 -29 -28 -27 -26 -25 -24 -23 -22 -21 -20 -19 -18 -17 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

Fixed submission (verdict: Accepted):
import sys

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

min_x = x - k + 1
if(min_x < -1000000):
	min_x = -1000000

max_x = x + k - 1
if(max_x > 1000000):
	max_x = 1000000

for i in range(min_x,max_x+1):
	sys.stdout.write(str(i))
	if i != max_x:
		sys.stdout.write(" ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x=map(int,input().split())
for i in range(-abs(x-k)+1,abs(x-k)):
    print(i, end=' ')

Failing test case input:
11 63

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73


Actual output:
-51 -50 -49 -48 -47 -46 -45 -44 -43 -42 -41 -40 -39 -38 -37 -36 -35 -34 -33 -32 -31 -30 -29 -28 -27 -26 -25 -24 -23 -22 -21 -20 -19 -18 -17 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 

Fixed submission (verdict: Accepted):
K, X = map(int, input().split())
for x in range(X-K+1, X+K):
    print(x, end=" ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x = (int(i) for i in input().split())

mini = x - k + 1
maxi = x + k - 1

l = list(range(max([mini,-1000000]),min([1000000,maxi])))
if not l:
  print(x)
else:
  for a in range(len(l)):
    print(l[a],end=" ")

Failing test case input:
9 35

Expected output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


Actual output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 

Fixed submission (verdict: Accepted):
k,x = (int(i) for i in input().split())

mini = x - k + 1
maxi = x + k

l = list(range(max([mini,-1000000]),min([1000000,maxi])))
if not l:
  print(x)
else:
  for a in range(len(l)):
    print(l[a],end=" ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())
ans = [int(x) for x in range(x-k+1, x+k-1)]
for i in ans:
    print(i, end=' ')

Failing test case input:
9 46

Expected output:
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54


Actual output:
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 

Fixed submission (verdict: Accepted):
k, x = map(int, input().split())
ans = [int(x) for x in range(x-k+1, x+k)]
print(' '.join(map(str, ans)))
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
n = list(map(int,input().split()))
k = n[0]
x = n[1]
ans = []

k_1 = k - 1

for n in range(x-k_1,x+k_1+1):
  ans.append(n)
  
print(ans)
  


Failing test case input:
9 35

Expected output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


Actual output:
[27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43]


Fixed submission (verdict: Accepted):
n = list(map(int,input().split()))
k = n[0]
x = n[1]
ans = []

k_1 = k - 1

for n in range(x-k_1,x+k_1+1):
    n = str(n)
    ans.append(n)

aa = " ".join(ans)    
print(aa)

Problem: p02946
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
k,x=map(int,input().split())
for i in range(k*2-1):
  if(i==k*2-2):
    print((k-x)+i)
  else:
    print((k-x)+i,end=(" "))

Failing test case input:
11 63

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73


Actual output:
-52 -51 -50 -49 -48 -47 -46 -45 -44 -43 -42 -41 -40 -39 -38 -37 -36 -35 -34 -33 -32


Fixed submission (verdict: Accepted):
k,x=map(int,input().split())
for i in range(k*2-1):
  if(i==k*2-2):
    print((x-(k-1))+i)
  else:
    print((x-(k-1))+i,end=(" "))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K,X=map(int,input().split())
out = []
for i in range(X-K+1,K+X):
  out.append(str(i))
  print(" ".join(out))

Failing test case input:
11 18

Expected output:
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28


Actual output:
8
8 9
8 9 10
8 9 10 11
8 9 10 11 12
8 9 10 11 12 13
8 9 10 11 12 13 14
8 9 10 11 12 13 14 15
8 9 10 11 12 13 14 15 16
8 9 10 11 12 13 14 15 16 17
8 9 10 11 12 13 14 15 16 17 18
8 9 10 11 12 13 14 15 16 17 18 19
8 9 10 11 12 13 14 15 16 17 18 19 20
8 9 10 11 12 13 14 15 16 17 18 19 20 21
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28


Fixed submission (verdict: Accepted):
K,X=map(int,input().split())
out = []
for i in range(X-K+1,K+X):
  out.append(str(i))
print(" ".join(out))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x=map(int,input().split())

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

Failing test case input:
9 85

Expected output:
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93


Actual output:
[77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93]


Fixed submission (verdict: Accepted):
k,x=map(int,input().split())

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

an=map(str,ans)
a=' '.join(an)
    
print(a)
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
kx = [int(i) for i in input().split()]
k,x = kx[0],kx[1]
c = k*2 - 1
g = [j + x - k + 1for j in range(c)]
print(g)

Failing test case input:
4 59

Expected output:
56 57 58 59 60 61 62


Actual output:
[56, 57, 58, 59, 60, 61, 62]


Fixed submission (verdict: Accepted):
kx = [int(i) for i in input().split()]
k,x = kx[0],kx[1]
c = k*2 - 1
g = [j + x - k + 1 for j in range(c)]
ss = ""
for s in g:
	ss += str(s) + " "
print(ss.strip())

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k,x=map(int,input().split())

if x-k+1<=-1000000:
  a=-1000000
else: a=x-k+1
if x+k-1>=1000000:
  b=1000000
else:b=x+k-1

print([i for i in range(a,b+1)])

Failing test case input:
9 46

Expected output:
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54


Actual output:
[38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54]


Fixed submission (verdict: Accepted):
k,x=map(int,input().split())

if x-k+1<=-1000000:
  a=-1000000
else: a=x-k+1
if x+k-1>=1000000:
  b=1000000
else:b=x+k-1

print(*range(a,b+1))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X = map(int, input().split())
l, r = 0, 2000000
l = max(X - K + 1, l)
r = min(X + K - 1, r)
lr = range(l, r + 1)
print(*lr)

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Fixed submission (verdict: Accepted):
K, X = map(int, input().split())
l = max(X - K + 1, -1000000)
r = min(X + K - 1, 1000000)
lr = range(l, r+1)
print(*lr)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
k, x = map(int, input().split())

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

Failing test case input:
9 63

Expected output:
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71


Actual output:
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70


Fixed submission (verdict: Accepted):
k, x = map(int, input().split())

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

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):


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


Failing test case input:
9 21

Expected output:
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29


Actual output:
[13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]


Fixed submission (verdict: Accepted):


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

Problem: p02946
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
k,n=map(int,input().split())
for i in range(k-1):
  print(n-k+i)
print(n)
for i in range(k-1):
  print(n+i+1)


Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
-3
-2
-1
0
1
2
3
4
5
6
7
8
10
11
12
13
14
15
16
17
18
19
20
21
22


Fixed submission (verdict: Accepted):
k,n=map(int,input().split())
for i in range(k-1):
  print(n-k+i+1,end=" ")
print(n,end=" ")
for i in range(k-1):
  print(n+i+1,end=" ")
Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
s = input().split() 
k = int(s[0])
x = int(s[1])

aa = x - k + 1
if aa < -1000000:
  aa = 0
bb = x + k - 1
if bb > 1000000:
  bb = 1000000

for i in range(aa, bb-1):
  print(i, end=" ")
  
print(bb)

Failing test case input:
9 35

Expected output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43


Actual output:
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 43


Fixed submission (verdict: Accepted):
s = input().split() 
k = int(s[0])
x = int(s[1])

aa = x - k + 1
if aa < -1000000:
  aa = 0
bb = x + k - 1
if bb > 1000000:
  bb = 1000000

for i in range(aa, bb+1):
  print(i, end=" ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
lines = input().split(" ")
K = int(lines[0])
X = int(lines[1])
arr = []
 
if K == 1:
  print(X)
else:
  for i in range(X , X + K):
    arr.append(i)
    
  for j in range(X - K + 1 , X):
    arr.append(j)
    
arr.sort()
print(arr)

Failing test case input:
9 46

Expected output:
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54


Actual output:
[38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54]


Fixed submission (verdict: Accepted):
lines = input().split(" ")
K = int(lines[0])
X = int(lines[1])
arr = []

if K == 1:
  print(X)
else:
  for i in range(X , X + K):
    arr.append(i)
    
  for j in range(X - K + 1 , X):
    arr.append(j)
    
arr.sort()
map_result = map(str, arr)
result = ' '.join(map_result)
print(result)

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a = list(map(int,input().split()))
for i in range(max(-1000000, a[1]-a[0]+1), min(1000000,a[1]-a[0]+1)+1) :
  print(i,end = " ")

Failing test case input:
9 21

Expected output:
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29


Actual output:
13 

Fixed submission (verdict: Accepted):
a = list(map(int,input().split()))
for i in range(max(-1000000, a[1]-a[0]+1), min(1000000,a[1]+a[0]-1)+1) :
  print(i,end = " ")

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K,X = map(int,input().split())
ans = []
for i in range(-K,K+1):
  ans.append(str(i+X))
print(' '.join(ans))

Failing test case input:
13 10

Expected output:
-2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22


Actual output:
-3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23


Fixed submission (verdict: Accepted):
K,X = map(int,input().split())
ans = []
for i in range(-K+1,K):
  ans.append(str(i+X))
print(' '.join(ans))

Problem: p02946
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
K, X =map(int, input().split())

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

Failing test case input:
9 61

Expected output:
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69


Actual output:
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68


Fixed submission (verdict: Accepted):
K, X =map(int, input().split())
 
for i in range(X-K+1, X+K):
  print(i, end=" ")