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())
s=list(range(x-k+1,x+k))

print(s)



k,x=map(int,input().split())
s=[str(a)for a in range(x-k+1,x+k)]
s=" ".join(s)
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())
res = [i for i in range(x-k+1,x+k)]
print(res)

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


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, r = 0, 2000001
l = max(X - K + 1, l)
r = min(X + K - 1, r)
lr = range(l, r)
print(*lr)

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)

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):
t = list(map(int, input().split()))


minnum = t[1] - t[0] + 1
length = t[0]*2 - 1

output=[]
for i in range(length):
    output.append(minnum+i)

print(output)

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


minnum = t[1] - t[0] + 1
length = t[0]*2 - 1

output=[]
for i in range(length):
    output.append(minnum+i)

print(*output)

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 = list(map(int, input().split()))
print(' '.join([i for i in range(x-k+1, x+k)]))

k, x = list(map(int, input().split()))
print(' '.join([str(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(' '))
print(' '.join([ for i in range(X - (K + 1), (X + K + 1))]))

K, X = map(int, input().split(' '))
print(' '.join([str(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):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a, b = rm()
print(*list(range(b-a+1:b+a)))












import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a, b = rm()
print(*list(range(b-a+1,b+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())
li =  []
for i in range(k):
    if i == 0:
        li.append(x)
    else:            
        li.append(x+i)
        li.append(x-i)
print(sorted(li))

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)

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):
KX=input().split()
K,X=int(KX[0]),int(KX[1])

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

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

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

tmp = [y for y in range(x-k+1, x+k)]
y = ' '.join(tmp)
print(y)

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

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())
hajime=X-(K-1)
owari=X+(K-1)
if hajime<-1000000:
    hajime=-1000000
if owari>1000000:
    owari=1000000

kotae=list(range(hajime,owari+1))

print(kotae)

K,X = map(int, input().split())
hajime=X-(K-1)
owari=X+(K-1)
if hajime<-1000000:
    hajime=-1000000
if owari>1000000:
    owari=1000000

kotae=tuple(range(hajime,owari+1))

print(kotae)

K,X = map(int, input().split())
hajime=X-(K-1)
owari=X+(K-1)
if hajime<-1000000:
    hajime=-1000000
if owari>1000000:
    owari=1000000

kotae = [str(i) for i in range(hajime,owari+1)] 
print(" ".join(kotae))

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

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)

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):
num = input().split()
a, b = int(num[0]), int(num[1])
tmp = []
for i in range(b-a+1,b+a):
  tmp.append(i)
print(' '.join(tmp))

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

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):
num=input()
K,X=[int(s) for s in num.split(" ")]

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

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

print(list)


num=input()
K,X=[int(s) for s in num.split(" ")]

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

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

ans=" ".join(map(str,list))

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 = (int(i) for i in input().split())  
start = x-k+1
end = x+k-1
print(start,end="")
for i in range(start+1,end):
    print(" "+str(i),end="")
print()

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

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

K=input_num[0]
X=input_num[1]

min_cons=-10**6
max_cons=10**6

max_num=X+K-1
min_num=X-(K-1)

if min_num<min_cons:
    min_num=min_cons

if max_num>max_cons:
    max_num=max_cons

num_list=[i for i in range(min_num,max_num+1)]

print(num_list)



input_num=input().split()
input_num=[int(num) for num in input_num]

K=input_num[0]
X=input_num[1]

min_cons=-10**6
max_cons=10**6

max_num=X+K-1
min_num=X-(K-1)

if min_num<min_cons:
    min_num=min_cons

if max_num>max_cons:
    max_num=max_cons

num_list=[i for i in range(min_num,max_num+1)]
print(*num_list)


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())
MIN = -1000000
MAX = 1000000

print(*list(range(max(MIN, X - K + 1), min(MAX, K + X +1))))


K, X = map(int, input().split())
MIN = -1000000
MAX = 1000000+1

print(*list(range(max(MIN, X - K + 1), min(MAX, K + X))))


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())
LIM = 1000000
ans = [x for x in range(x-k, x+k+1) if x <= LIM and x >= -LIM]
print(' '.join(map(str,ans)))

k, x = map(int, input().split())
LIM = 1000000
ans = [x for x in range(x-(k-1), x+(k-1)+1) if x <= LIM and x >= -LIM]
print(' '.join(map(str,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())
t=[i for i in range(x-k+1,x+k-1)]
print(" ".join(t))

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


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):
def main():
    l = input().split()
    k, x = int(l[0]), int(l[1])
    min_x = x - k + 1
    max_x = k + x - 1
    print(list(range(min_x, max_x+1)))
    
if __name__=="__main__":
    main()


def main():
    l = input().split()
    k, x = int(l[0]), int(l[1])
    min_x = x - (k - 1)
    max_x = x + (k - 1)
    all = list(range(min_x, max_x+1))
    asn = " ".join([str(s) for s in all])
    print(asn) 
    
if __name__=="__main__":
    main()


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

s = ""
first = X - K + 1
for i in range(K*2 - 1):
    s += str(first + i)
print(s)

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

s = ""
first = X - K + 1
for i in range(K*2 - 1):
    s += " " + str(first + i)
print(s[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):
while True:
    L=lambda:list(map(int,input().split()))
    k,x=L()
    if x>=0 and x<=100 and k>=1 and k<=100:
        break
c =[]
for i in range(x-k+1,x+k,1):
    c.append(i)
c = [str(int) for int in c]
' '.join(c)

while True:
    L=lambda:list(map(int,input().split()))
    k,x=L()
    if x>=0 and x<=100 and k>=1 and k<=100:
        break
c =[]
for i in range(x-k+1,x+k,1):
    c.append(i)
c = [str(int) for int in c]
print(' '.join(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):
ko,x=map(int,input().split())
s=max(x-ko+1,-1000000)
while True:
  print(s,end==" ")
  s+=1
  if s>min(ko+k-1,1000000):break


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

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

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

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

ko,x=map(int,input().split())
s=max(x-ko+1,-1000000)
while True:
  print(s,end=" ")
  s+=1
  if s>min(ko+k-1,1000000):break


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

ko,x=map(int,input().split())
s=max(x-ko+1,-1000000)
print(*list(range(x-ko+1,x+ko)),sep=" ")

Verdicts: Runtime Error

Wrong Answer

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):
x,k=map(int,input().split())
print(*[i for i in range(x-k+1, x+k)])

k,x=map(int,input().split())
print(*[i for i 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=[int(s) for s in input().split()]

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

for j in range(k):
  r.append(x+j)
  
print(r)

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

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

for j in range(k):
  r.append(x+j)
  
print(*r)

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

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

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

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


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

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


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 num in range(X-K+1, X+K-1):
    print(num)

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: 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):
re,x=map(int,input().split())
print(' '.join(map(str,(list(range(x-re+1,x+re)))))

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

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

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

Verdicts: 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,x=map(int,input().split())
list=[]
for i in range(k):
  list.append(x+i)
  list.append(x-i)
list.remove(x)
list.sort()
print(*list sep='')

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


k,x=map(int,input().split())
list=[]
for i in range(k):
  list.append(k+i)
  list.append(k-i)
list.remove(0)
list.sort()
print(*list sep='')

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

Verdicts: 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, x = map(int, input().split())
print(list(range(max(-1000000, x-k+1), min(x+k, 1000001))))


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


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 main():
    k, x = map(int, input().split())
    res = [i for i in range(x-k+1, x+k)]
    print(res)

if __name__ == "__main__":
    main()

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

if __name__ == "__main__":
    main()

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):
a,b=map(int,input().split())
A=list()
for n in range(b-a+1,b+a):
  A.append(n)
print(A)

a,b=map(int,input().split())
A=list()
for n in range(b-a+1,b+a):
  A.append(n)
print(' '.join(map(str,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())
li = [str(2*k-1+i) for i in range(2*k-1)]
l = ' '.join(li)
print(l)

k = int(input())
x = int(input())
li = [str(x-k+1+i) for i in range(2*k-1)]
l = ' '.join(li)
print(l)

k = int(input())
x = int(input())
li = [str(x-k+1+i) for i in range(2*k-1)]
l = ' '.join(li)
print(int(l))

k = int(input())
x = int(input())
li = [str(x-k+1+i) for i in range(2*k-1)]
l = ' '.join(li)
print(l)

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

Verdicts: 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, X = map(int, input().split())
list_ans = []

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

print(list_ans)

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

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

print(*list_ans)

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):
a = 2000001
b = 1000000
k, x = map(int, input().split())

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


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

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


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())
l = [str(i) for i in range(x+1-k,x-1+k)]
print(" ".join(l))

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

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

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


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)

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())
mi = X-K+1
Ma = X+K-1
for i in range(mi,Ma+1):
    A.append(i)
print(*ans)

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

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(int,input().split( )))
list_=[x+i for i in range(-k+1,k)]
print(list_)


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

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 = [i for i in range(x - (k-1), x + (k-1))]
print(*ans)

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

ans = [i for i in range(x - (k-1), x + (k))]
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())
min_ans=x-k+1
max_ans=x+k-1
ans_list=list(range(min_ans,max_ans+1))
print(" ".join(ans_list))

k,x=map(int, input().split())
min_ans=x-k+1
max_ans=x+k-1
ans_list=list(range(min_ans,max_ans+1))
for i in range(len(ans_list)):
  ans_list[i]=str(ans_list[i])
ans=" ".join(ans_list)
print(ans)


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())
output_num = (k*2)-1
start_num = x-(k-1)
print(*range(start_num, output_num, 1))

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

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

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


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


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


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


Verdicts: Wrong Answer

Wrong Answer

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 = list(map(int, input().split()))
posi = [p for p in range(x-k+1, x+k-1)]
print(' '.join(posi))


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

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

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


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

a = list(range(x-(k-1), x+k))
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())
a = []
for i in range(-k+x+1, k+x):
  a.append(i)
print(' '.join(a))

k, x = map(int,input().split())
a = []
for i in range(-k+x+1, k+x):
  a.append(str(i))
print(' '.join(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())

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

print(a)

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

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

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,x=map(int,input().split())
if x>k:
  print(*range(x-k,x+k))
elif x<k:
  print(*range(x-k+1, x+k))
else:
  print(x)

k,x=map(int,input().split())
if x>k:
  print(*range(x-k,x+k))
elif x<k:
  print(*range(x-k+1, x+k))
elif k==1:
  print(x)

k,x=map(int,input().split())
if x>k:
  print(*range(x-k,x+k))
elif x<k:
  print(*range(x-k+1, x+k))
elif x==1:
  print(x)

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

k,x=map(int,input().split())
if k>2:
  print(*range(x-k,x+k))
else:
  print(x)

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

Verdicts: Wrong Answer

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())
for i in range (K-X+1,K+X):
    if i < X + K -1:
        print(i,end=' ')
    else:
        print(i)

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

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

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


Xmin = X-K+1
Xmax = X+K-1

if Xmin < -1000000:
  Xmin = -1000000

if Xmax>1000000:
  Xmax=1000000
  
Xrange = list(range(Xmin,Xmax,1))

print(" ".join( repr(e) for e in Xrange ) )

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


Xmin = X-K+1
Xmax = X+K-1

if Xmin < -1000000:
  Xmin = -1000000

if Xmax>1000000:
  Xmax=1000000
  
Xrange = list(range(Xmin,Xmax+1,1))

print(" ".join( repr(e) for e in Xrange ) )

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(input().split())
start=max(-1000000,x-k+1)
end=min(1000000,x+k-1)
print(" ".join(range(start,end+1)))


k, x = map(int, input().split())
start = max(-1000000, x-k+1)
end = min(1000000, x+k-1)
print(" ".join(map(str, range(start, end+1))))


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())
l=[x]
for i in range(1, k):
  l.append(x-i)
  l.append(x+i)
l.sort()
l = list(map(str, l))

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

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 range(0,k):
  lst.append(x+i)
  lst.append(x-i)

lst = list(set(lst))

print([i for i in lst if i  <= 1000000 and i >= -1000000])


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

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

lst = list(set(lst))

lst = ([i for i in lst if i  <= 1000000 and i >= -1000000])
print(' '.join(map(str,sorted(lst))))


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

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


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


print(ans)

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

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


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


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())
print([i for i in range(x-(k-1), x+(k-1)+1)])

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

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

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

list=[]

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

list=str(list)

print(''.join(list))

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

list=[]

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

Verdicts: Wrong Answer

Accepted
Problem: We will call a string obtained by arranging the characters contained in a string a in some order, an _anagram_ of a.  For example, `greenbin` is an anagram of `beginner`. As seen here, when the same character occurs multiple times, that character must be used that number of times.  Given are N strings s_1, s_2, \ldots, s_N. Each of these strings has a length of 10 and consists of lowercase English characters. Additionally, all of these strings are distinct. Find the number of pairs of integers i, j (1 \leq i < j \leq N) such that s_i is an anagram of s_j.

Submission attempts (in order):
from collections import Counter
import math
n=int(input())
s=[['']*10]*n

def com(n, r):
    if n>=r:
        return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
    else:
        return 0
for i in range(n):
    s[i]=list(input())
    s[i].sort()
s=map(tuple,s)
c=dict(Counter(s))
print(c)
x=0
for i in c.values():
    x+=com(i,2)
print(x)

from collections import Counter
import math
n=int(input())
s=[['']*10]*n

def com(n, r):
    if n>=r:
        return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
    else:
        return 0
for i in range(n):
    s[i]=list(input())
    s[i].sort()
s=map(tuple,s)
c=dict(Counter(s))
x=0
for i in c.values():
    x+=com(i,2)
print(x)

Verdicts: Wrong Answer

Accepted
Problem: We will call a string obtained by arranging the characters contained in a string a in some order, an _anagram_ of a.  For example, `greenbin` is an anagram of `beginner`. As seen here, when the same character occurs multiple times, that character must be used that number of times.  Given are N strings s_1, s_2, \ldots, s_N. Each of these strings has a length of 10 and consists of lowercase English characters. Additionally, all of these strings are distinct. Find the number of pairs of integers i, j (1 \leq i < j \leq N) such that s_i is an anagram of s_j.

Submission attempts (in order):
from collections import defaultdict
from math import factorial

N = int(input())
st = set()
d = defaultdict(int)
for _ in range(N):
    s = input()
    s_sorted = "".join(sorted(s))
    if s_sorted in st:
        d[s_sorted] += 1
    else:
        st.add(s_sorted)

ans = 0
# for _, v in d.items():
#     x = factorial(v + 1) / factorial(2)
#     ans += x

print(round(ans))


from math import factorial

N = int(input())
d = {}
for _ in range(N):
    s = input()
    s_sorted = "".join(sorted(s))
    if not d.get(s_sorted):
        d[s_sorted] = 1
    else:
        d[s_sorted] += 1

ans = 0
for _, v in d.items():
    if v == 1:
        continue
    ans += v * (v - 1) // 2

print(round(ans))


Verdicts: Wrong Answer

Accepted
Problem: We will call a string obtained by arranging the characters contained in a string a in some order, an _anagram_ of a.  For example, `greenbin` is an anagram of `beginner`. As seen here, when the same character occurs multiple times, that character must be used that number of times.  Given are N strings s_1, s_2, \ldots, s_N. Each of these strings has a length of 10 and consists of lowercase English characters. Additionally, all of these strings are distinct. Find the number of pairs of integers i, j (1 \leq i < j \leq N) such that s_i is an anagram of s_j.

Submission attempts (in order):
import collections
N = int(input())
s = []
for i in range(N):
  word = input()
  s.append(word)

c = collections.Counter(s)

sum = 0
for value in c.values():
  sum += (value * (value-1) / 2)

print(int(sum))

import collections
N = int(input())
s = []
for i in range(N):
  word = input()
  chars = []
  sortedWord = ''

  for j in range(10):
    chars.append(word[j])
    chars.sort()

  #print(chars)
  
  for j in range(10):
    sortedWord += chars[j]

  

  s.append(sortedWord)

c = collections.Counter(s)

sum = 0
for value in c.values():
  sum += (value * (value-1) / 2)

print(int(sum))


Verdicts: Wrong Answer

Accepted