TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: 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.

Submission attempts (in order):
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())


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


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


def solve():
    _min_tmp = (x - k + 1)
    _max_tmp = (x + k - 1)
    _min = max(-1000000, _min_tmp)
    _max = min(1000000, _max_tmp)

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

    return ' '.join(ans)


print(solve())


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x = map(int, input().split())
print(*range(x-k+1, k+x-1))


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


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

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


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

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K,X=map(int,input().split())
l=list(range(X-K+1,X+K))
print(l)

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):

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


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)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k, x = input().split(' ')
k, x = int(k), int(x)   
arr = []
     
for i in range(k): 
 arr.append(x-i)
 arr.append(x+i)
arr = list(set(arr))
arr.sort()
text = ""
for i in range(len(arr) - 1):
  text += arr[i] + " "
print(text + arr[len(arr) - 1])

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

arr = [x]

for i in range(1, k):
  arr.append(x-i)
  arr.append(x+i)
arr = list(set(arr))
arr.sort()
print(arr)

k, x = input().split(' ')
k, x = int(k), int(x)   
arr = []
         
for i in range(k): 
  arr.append(x-i)
  arr.append(x+i)
arr = list(set(arr))
arr.sort()
text = ""
for i in range(len(arr) - 1):
  text += str(arr[i]) + " "
print(text + str(arr[len(arr) - 1]))

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k, x = map(int, input().split())
[i for i in range(x - k + 1, x + k) if -1000000 <= i <= 1000000]

k, x = map(int, input().split())
print(" ".join([str(i) for i in range(x - k + 1, x + k) if -1000000 <= i <= 1000000]))

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x = map(int,input().split())

minx,maxx = -1000000, 1000000

if minx + (k-1) > x:
    l = [i for i in range(minx,minx+x+1)]
    print("".join(str(l)))
elif maxx - (k-1) < x:
    l = [i for i in range(maxx-x,maxx+1,-1)]
    print("".join(str(l)))
else:
    l = [i for i in range(x-(k-1),x+(k-1)+1)]
    print("".join(str(l)))


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

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

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

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


Verdicts: Wrong Answer

Accepted
Problem: 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.

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


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

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

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

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
x,y=map(int,input().split())
print(int(y-x+1:y+x-1))

K,X=map(int,input().split())
print(*list(range[X-K+1,X+K]))

K,X=map(int,input().split())
print(*list[X-K+1:X+K])

K,X=map(int,input().split())
print(*list(range[X-K+1:X+K]))

K,X=map(int,input().split())
print(*list[X-K+1,X+K])

K,X=map(int,input().split())
print(*list(range(X-K+1,X+K)))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
K = list(map(int, input().split()))

import numpy as np

tmp = []
for i in range(K[1]-K[0]+1, K[1]+K[0]):
    if abs(i) <= 1000000:
        tmp.append(i)

print(tmp)


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)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x = map(int,input().split())
c =[]
for i in range(x-k,x+k):
  c.append(i)
print(" ".join(c))

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
K, X = map(int, input().split())

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



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

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



Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k, x = map(int, input().split())
print(' '.join(list(range(x-k+1, x+k))))

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
k,x=map(int,input().split())
s=[0]*(k*2-1)
for i in range(0,k*2-1):
  s[i]=x-k+1+i
print(s)

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K,X=map(int, input().split())
s1=set([])
s2=set([])
for i in range(K):
  s1.add(X-i)
  s2.add(X+i)
s=s1|s2
print(s)

K,X=map(int, input().split())
print(*range(X-K+1,X+K))

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k, x = map(int, f.readline().split())
min = x - k + 1
max = x + k - 1
txt = str(min)
for i in range(max - min):
    txt = txt + " " + str(min+1)
    min += 1
print(txt)

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
k,x = map(int,input().split())
list=[x-(k-1)+i for i in range(2*k-1)]
print(' '.join(list))

k,x = map(int,input().split())
L=[x-(k-1)+i for i in range(2*k-1)]
print(' '.join(map(str, L)))


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
k, x = (int(i) for i in input().split())

result = list(range(x - k + 1, x + k))

print(result)

k, x = (int(i) for i in input().split())
 
result = list(range(x - k + 1, x + k))

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K, X = map(int, input().split())

lower = X - K + 1
upper = X + K - 1
ans = [i for i in range(lower, upper+1)]
ans_str = " ".join(str(ans))
print(ans_str)



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

l = K // 2
lower = X - l
upper = X + l
ans = [i for i in range(lower, upper+1)]
ans_str = " ".join(ans)
print(ans_str)

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

lower = X - K + 1
upper = X + K - 1
ans = [i for i in range(lower, upper+1)]
ans_str = " ".join(list(map(str, ans)))
print(ans_str)


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
lis = input(" ")

K = int(lis[0])
X = int(lis[1])

mini = X - (K - 1)
maxm = X + (K - 1)
list_a = []
for i in range(0, (K - 1) * 2 + 1):
    list_a.append(str((X - (K - 1)) + i))

print(" ".join(list_a))

lis = input().split(" ")

K = int(lis[0])
X = int(lis[1])

mini = X - (K - 1)
maxm = X + (K - 1)
list_a = []
for i in range(0, (K - 1) * 2 + 1):
    list_a.append(str((X - (K - 1)) + i))

print(" ".join(list_a))

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a,b=map(int, input().split()) 
box = [i for i in range(b-a+1,b+a)]
print(box)


a,b=map(int, input().split()) 
box = [i for i in range(b-a+1,b+a)]
print(*box)


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
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=(" "))

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K, X = map(int, input().split())

lis = list(range(X-K+1,X+K))
print(lis)

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

lis = list(range(X-K+1,X+K))
ans = ""
for char in lis:
  ans = ans + str(char) + " "
print(ans[:-1])


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K, X = map(int, input().split())
print(list(range(X - K + 1, X + K)))

K, X = map(int, input().split())
A = list(range(X - K + 1, X + K))
print(*A, sep = ' ')

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k, x = input().split()
print(*list(range(x-k+1, x+k)))


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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
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)))

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K,X = map(int,input().split())
x = " ".join(map(str,list(range(X-K,X+K))))
print(x)

K,X = map(int,input().split())
print(*range(X-K-+1,X+K)))

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


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: 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.

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

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=' ')

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

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k, x = map(int, input().split())
print(' '.join([x for x in range(x - k + 1, x + k)]))


k, x = map(int, input().split())
print(' '.join([x in range(x - k + 1, x + k)]))

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


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a = list(map(int,input().split()))
ans = ""
kaisu = a[0] * 2 +1
for i in kaisu:
    b = a[1] - a[0] + 1 + i
    ans = ans + str(b) + " "
print(ans[:-1])

a = list(map(int,input().split()))
ans = ""
kaisu = a[0] * 2 +1
for i in range(kaisu):
    b = a[1] - a[0] + 1 + i
    ans = ans + str(b) + " "
print(ans[:-1])

a = list(map(int,input().split()))
ans = ""
kaisu = a[0] * 2 - 1
for i in range(kaisu):
    b = a[1] - a[0] + 1 + i
    ans = ans + str(b) + " "
print(ans[:-1])

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
#B
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)

#B
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)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):

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

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

print(list(range(B, A+1)))


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

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

print(' '.join(map(str, range(B, A+1))))

Verdicts: Wrong Answer

Accepted
Problem: 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.

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

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K, X = map(int, input().split())
print(X+k-1 for x in range(-K, K) if -10**6 <= X+k-1 >= 10**6)


K, X = map(int, input().split())
print(x for x in range(X-K+1, X+K))

K, X = map(int, input().split())
print(x for x in range(X-K+1, X+K) if -10**6 <= x >= 10**6)

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


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x=map(int,input().split())
print(*[x for x in range(X-K+1,X+K)])

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
K, X = list(map(lambda n: int(n), input().split(" ")))
print(" ".join(list(range(K - X + 1, K + X - 1))))

K, X = list(map(lambda n: int(n), input().split(" ")))
print(" ".join(list(map(lambda s: str(s), list(range(X - K + 1, X + K))))))

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
1 K, X = map(int, input().split())
2 print(' '.join(map(str, range(X - K + 1, X + K))))

K, X = map(int, input().split())
print(' '.join(map(str, range(X - K + 1, X + K))))


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
n, x = map(int,input().split())
a = []
if n - 1 == 0:
  print(x)
else:
  for i in range(2 * n -1):
  	a.append(i - n + 1)
  print(*a)

k, x = map(int,input().split())
a = []
if k - 1 == 0:
  print(x)
else:
  for i in range(0,2 * k - 1):
  	a.append(x - k + 1 + i)
  print(*a)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k = int(input())
x = int(input())

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

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

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

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
a,b=map(int,input().split())
l=[]
for x in range(a):
    l.append(b-x)
    l.append(b+x)
l.remove(b)
print(sorted(l))

a,b=map(int,input().split())
l=[]
for x in range(a):
    l.append(b-x)
    l.append(b+x)
l.remove(b)
print(" ".join(map(str,sorted(l))))

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x = map(int,input().split())

lis = [x]
x_1 = x
x_2 = x

for i in range(k-1):
    x_1 += 1
    x_2 -= 1
    lis.append(x_1)
    lis.append(x_2)
new_list = sorted(lis)

print(" ".join(new_list))

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

lis = [x]

for i in range(1,k):
    lis.append(x-1)
    lis.append(x+1)
new_list = sorted(lis)

print(" ".join(new_list))

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

lis = [x]

for i in range(1,k):
    lis.append(x-1)
    lis.append(x+1)
new_list = sorted(lis)

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

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

lis = [x]

for i in range(1,k):
    lis.append(x-1)
    lis.append(x+1)
new_list = sorted(lis)

print(*new_list)

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

lis = [X]

for i in range(K-1):
    right = X + 1
    left  = X - 1
    lis.append(right)
    lis.append(left)

new_list = sorted(lis)

print(new_list)

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

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

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

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x=map(int,input().split())
s=[0]*((2*(k-1))+1)
for i in range((2*(k-1))+1):
  s[i]=x-(k-1)+i
  
print(s)

k,x=map(int,input().split())
s=[0]*((2*(k-1))+1)
for i in range((2*(k-1))+1):
    s[i]=x-(k-1)+i
    
print(" ".join(map(str,s)))

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
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)

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

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)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
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)))

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

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x = map(int, input().split())
lst=[]
for i in list(range(x-(k-1),x+(k-1))):
  lst.append(str(i))
print(" ".join(lst))  

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

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

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x = map(int, input().split())

a = min(-1000000,x - (k-1))
b = max(1000000,x+(k-1))

L = [str(i) for i in range(a,b+1)]
print(" ".join(L))


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

a = min(-1000000,x - (k-1))
b = max(1000000,x+(k-1))

L = [i for i in range(a,b+1)]
print(" ".join(L))

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

a = min(-1000000,x - (k-1))
b = max(1000000,x+(k-1))

L = [i for i in range(a,b+1)]
print(" ".join(L))


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

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
K, X = [int(n) for n in input().split()]
print(" ".join([n for n in range(X-(K-1), X+(K-1)]))

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
 K, X = map(int, input().split())
 for i in range(X - K + 1, X + K):
 if i < X + K - 1:
 print(i, end=' ')
 else:
 print(i)


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


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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
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)
print(sorted(L))


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


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


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k, x = map(int, input().split())
a = x-k+1
b = x+k-1
print(i for i in range(a, b+1))

k, x = map(int, input().split())
a = x-k+1
b = x+k-1
print(' '.join(list(map(str, range(a, b+1)))))

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
  K, X = map(int, input().split(' '))
  print(*(range((X + 1) - K, (X + K))))

# B - One Clue
def main():
  K, X = map(int, input().split(' '))
  print(*(range((X + 1) - K, (X + K))))

if __name__ == "__main__":
    main()
 

Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
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(" ")



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

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

print(" ".join(l))


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K, X = map(int,input().split())
for i in range(X - K + 1,K + X):
    if i < X + K - 1:
        print(i,end = '')
    else:
        print(i)


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


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K, X = map(int, input().split())

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

print(output)


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

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

print(X+K-1)


Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K,X = map(int,input().split())
i = X - K + 1
lis = []
while i <= n + K - 1:
  lis.append(i)
  i += 1
print(lis)

K,X = map(int,input().split())
i = X - K + 1
lis = []
while i <= X + K - 1:
  lis.append(i)
  i += 1
print(lis)

K,X = map(int,input().split())
i = X - K + 1
lis = []
while i <= X + K - 1:
  lis.append(str(i))
  i += 1

s = ' '.join(lis)
print(s)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
K,X = map(int,input().split())

list = []

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

print(" ".join(map(int,list))


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

list = []

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

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


Verdicts: Runtime Error

Accepted
Problem: 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.

Submission attempts (in order):
# coding: utf-8
# Your code here!
k,x=map(int,input().split())

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



# coding: utf-8
# Your code here!
k,x=map(int,input().split())

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



Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x=map(int,input().split())

l=0
r=0

if x-(k-1)<-1000000:
  l=-1000000

if x-(k-1)>=-1000000:
  l=x-(k-1)

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

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

print(l)
print(r)

ans=list(range(l,r+1))
s=' '.join([str(n) for n in ans])
print(s)

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

l=0
r=0

if x-(k-1)<-1000000:
  l=-1000000

if x-(k-1)>=-1000000:
  l=x-(k-1)

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

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

ans=list(range(l,r+1))
s=' '.join([str(n) for n in ans])
print(s)

Verdicts: Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
# -*- coding: utf-8 -*-

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

# -*- coding: utf-8 -*-

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


# -*- coding: utf-8 -*-

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


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: 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.

Submission attempts (in order):
k,x = map(int,input().split())
print(list(range(x-k+1,x+k)))


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

Verdicts: Wrong Answer

Accepted