TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
A,B = map(int,input().split)
if A*B > A+B|A-B : ans = A*B
if A+B > A-B|A*B : ans = A+B
if A-B > A*B|A+B : ans = A-B
print(ans)

A,B = map(int,input().split)
if A+B < A-B < A*B | A-B < A+B < A*B :ans = A*B
if A*B < A-B < A+B | A-B < A*B < A+B :ans = A+B
if A+B < A*B < A-B | A*B < A+B < A-B :ans = A-B
print(ans)

A,B = map(int,input().split)
X = A + B
Y = A - B
Z = A * B
if X > Y and X > Z : print(X)
if Y > Z and Y > X : print(Y)
if Z > X and Z > Y : print(Z)

A,B = map(int,input().split())
X = A + B
Y = A - B
Z = A * B
  if X >= Y and X >= Z:
     print(X)
elif Y >= Z and Y >= X:
     print(Y)
elif Z >= X and Z >= Y:
     print(Z)

A,B = map(int,input().split())
X = A + B
Y = A - B
Z = A * B
  if X >= Y and X >= Z :
     print(X)
elif Y >= Z and Y >= X :
     print(Y)
elif Z >= X and Z >= Y :
     print(Z)

A,B = map(int,input().split)
X = A + B
Y = A - B
Z = A * B
if X > Y and X > Z : print(X)
elif Y > Z and Y > X : print(Y)
elif Z > X and Z > Y : print(Z)

A,B = map(int,input().split)
if A*B > A+B and A*B > A-B : print(A*B)
if A+B > A-B and A+B > A*B : print(A+B)
if A-B > A*B and A-B > A+B : print(A-B)

A,B = map(int,input().split)
if A+B < A-B < A*B | A-B < A+B < A*B :print(A*B)
if A*B < A-B < A+B | A-B < A*B < A+B :print(A+B)
if A+B < A*B < A-B | A*B < A+B < A-B :print(A-B)

A,B = map(int,input().split)
X = A + B
Y = A - B
Z = A * B
  if X >= Y and X >= Z : print(X)
elif Y >= Z and Y >= X : print(Y)
elif Z >= X and Z >= Y : print(Z)

A,B = map(int,input().split)
if A+B < A-B < A*B or A-B < A+B < A*B :ans = A*B
if A*B < A-B < A+B or A-B < A*B < A+B :ans = A+B
if A+B < A*B < A-B or A*B < A+B < A-B :ans = A-B
print(ans)

A,B = map(int,input().split)
if A*B > A+B|A-B : print(A*B)
if A+B > A-B|A*B : print(A+B)
if A-B > A*B|A+B : print(A-B)

A,B = map(int,input().split)
X = A + B
Y = A - B
Z = A * B
if X - Y > 0 and X - Z > 0 : print(X)
elif Y - Z > 0 and Y - X > 0 : print(Y)
elif Z - X > 0 and Z - Y > 0 : print(Z)

A,B = map(int,input().split)
if A*B > A+B or A-B : print(A*B)
if A+B > A-B or A*B : print(A+B)
if A-B > A*B or A+B : print(A-B)

A,B = map(int,input().split())
X = A + B
Y = A - B
Z = A * B
print(max(X,Y,Z))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
x = int(input())
j = x.split()
a = j[0]
b = j[1]
print(max((a+b),(a-b),(a*b)))

x = str(input())
j = x.split()
a = int(j[0])
b = int(j[1])
print(max((a+b),(a-b),(a*b)))


Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a, b = (int(i) for i in input().split())  

if a+b > a-b:
	if a*b>a+b:
    	print("{}".format(a*b))
	else:
    	print("{}"format(a+b))
else:
	if a*b>a-b:
    	print("{}".format(a*b))
	else:
    	print("{}"format(a-b))

a, b = (int(i) for i in input().split())  
sum=a+b
dif=a-b
mul=a*b


if sum > dif:
	if mul>sum:
    	print("{}".format(mul))
	else:
    	print("{}"format(sum))
else:
	if mul>dif:
    	print("{}".format(mul))
	else:
    	print("{}"format(dif))


a, b = (int(i) for i in input().split())  
sum=a+b
dif=a-b
mul=a*b
 
 
if sum > dif:
    if mul>sum:
        print('{}'.format(mul))
    else:
        print('{}'.format(sum))
else:
    if mul>dif:
        print('{}'.format(mul))
    else:
        print('{}'.format(dif))
 


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
x = map(int,raw_input().split())
print(max([x[0]+x[1],x[0]-x[1],x[0]*x[1]]))

x = list(map(int,input().split()))
print(max([x[0]+x[1],x[0]-x[1],x[0]*x[1]]))


Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a.b=[int(x) for x in input().split()]

print(max(a+b,a-b,a*b))

a,b=[int(x) for x in input().split()]
 
print(max(a+b,a-b,a*b))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a = int(input())
b = int(input())
print(max([a+b,a-b,a*b]))


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())
2 for i in range(X - K + 1, X + K):
3 if i < X + K - 1:
4 print(i, end=' ')
5 else:
6 print(i)
1 K, X = map(int, input()

a=int(input())
b=int(input())
print(max([a+b,a-b,a*b]))


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

a=int(input())
b=int(input())
print(max([a+b,a-b,a*b]))


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)


a=int(input())
b=int(input())
print(max([a+b,a-b,a*b]))

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


a, b = map(int, input().split())
print(max([a+b,a-b,a*b]))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
print('整数？')
num_int = list(map(int, input('>>').split()))
A = num_int[0]
B = num_int[1]

if(A+B > A-B):
    if(A+B > A*B):
        print(A+B)
    else:
        print(A*B)
else:
    if(A-B > A*B):
        print(A-B)
    else:
        print(A*B)

num_int = list(map(int, input().split()))
A = num_int[0]
B = num_int[1]

if(A+B > A-B):
    if(A+B > A*B):
        print(A+B)
    else:
        print(A*B)
else:
    if(A-B > A*B):
        print(A-B)
    else:
        print(A*B)

Verdicts: Wrong Answer

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b=map(int,input().split())
pl = a+b
di = a-b
mu = a*b
if pl>di and pl>mu:
    print(pl)
elif di>pl and di>mu:
    print(di)
else mu>di and mu>pl:
    print(mu)

a,b=map(int,input().split())
pl = a+b
di = a-b
mu = a*b
if pl>=di and pl>=mu:
    print(pl)
elif di>=pl and di>=mu:
    print(di)
else:
    print(mu)

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
A = int(input())
B = int(input())

list_ans = [A+B, A-B, A*B]

print(max(list_ans))

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

list_ans = [A+B, A-B, A*B]

print(max(list_ans))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a, b = input().split(' ')
index = a + b
if(a - b > index):
  index = a - b
elif(a * b > index):
  index = a * b
print(index)

a, b = map(int, input().split(' '))
ans = max(a+b, a-b, a*b)
print(ans)


Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b=map(int,input().split())
x=[a+b,a-b,a*b]
print(max(a))


a,b=map(int,input().split())
x=[a+b,a-b,a*b]
print(max(x))


Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
def for_factorial(n):
    val = 1
    for i in range(2, n + 1):
        val *= i
    return int(val/2)
N = int(input())
l = []
_l = [] 
_c = 0 

for i in range(N):
    l.append(input())

for s in l:
    one_l = [c for c in s]
    one_l.sort()
    _one_l = "".join(one_l)
    _l.append(_one_l)

for s in _l[:]:
    c = _l.count(s)
    if c > 1:
        
        _c += for_factorial(c)
        _l.remove(s)
print(_c)

A, B = map(int, input().split())
M = []
kakeru = A*B
tasu = A+B
hiku = A-B
M.append(kakeru)
M.append(tasu)
M.append(hiku)
M.sort(reverse = True)
print(M[0])


Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
from sys import stdin

a,b = [int(x) for x in stdin.readline().rstrip().split()]

arr =[]

arr.append(a+b)
arr.append(a-b)
arr.append(a*b)

print(arr.max())

from sys import stdin
 
a,b = [int(x) for x in stdin.readline().rstrip().split()]
 
arr =[]
 
arr.append(a+b)
arr.append(a-b)
arr.append(a*b)
 
print(max(arr))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b=map(int, input().split())
print(max(a+b,a-b,a*b)

if A+B > A-B and A*B:
  print(A+B)
elif A-B > A+B and A*B :
  print(A-B)
else A*B > A+B and A-B :
  print(A*B)

a,b=map(int, input().split())
print(max(a+b,a-b,a*b))


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
A,B = map(int,(input().split()))


tasu = A+B
hiku = A-B
kakeru = A*B




if tasu >= hiku and tasu >= kakeru:
    print("1",tasu)
elif hiku >= tasu and hiku >= kakeru:
    print("2",hiku)
else:
    print("3",kakeru)




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


tasu = A+B
hiku = A-B
kakeru = A*B




if tasu >= hiku and tasu >= kakeru:
    print(tasu)
elif hiku >= tasu and hiku >= kakeru:
    print(hiku)
else:
    print(kakeru)




Verdicts: Wrong Answer

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b = map(int, input().split())
SUM = a+b
SUB = a-b
PRO = a*b
print(max(SUM,SUB,PRO)

a,b = map(int, input().split())
SUM = a+b
SUB = a-b
PRO = a*b
print(max(SUM,SUB,PRO))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b = map(int,input().split())
list = [a+b,a-b,a*b]
print(sum(list))

a,b = map(int,input().split())
list = [a+b,a-b,a*b]
print(max(list))

Verdicts: Wrong Answer

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b = map(int, input().split())
print([a+b, a-b, a×b])

a,b = map(int, input().split())
print(max([a+b, a-b, a×b]))

a,b = map(int, input().split())
print(max([a+b, a-b, a*b]))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
num = input().split(" ")
a = int(num[0])
b = int(num[1])
return max(a+b, a-b, a*b)

num = input().split(" ")
a = int(num[0])
b = int(num[1])
print(max(a+b, a-b, a*b))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b=map(int,input().split())
x=max(a+b,a-b,a*b)

a,b=map(int,input().split())
x=max(a+b,a-b,a*b)
print(x)

Verdicts: Wrong Answer

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b = int(input().split())
wa = a + b
sa = a - b
seki = a * b
list = [wa,sa,seki]
print(max(list))

a,b = int(input()).split()
wa = a + b
sa = a - b
seki = a * b
list = [wa,sa,seki]
print(max(list))

a,b = map(int,input().split())
wa = a + b
sa = a - b
seki = a * b
list = [wa,sa,seki]
print(max(list))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
A, B = map(int, input(), split())

x = A + B
y = A - B
z = A * B
print(max(x, y, z))

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

x = A + B
y = A - B
z = A * B
print(max(x, y, z))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
def main():
 a,b = map(int,input().split())
 print(min(a + b, a - b, a * b))
main()

def main():
 a,b = map(int,input().split())
 print(max(a + b, a - b, a * b))
main()

Verdicts: Wrong Answer

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b = map(int, input().split())

print(max(a+b,a*b,a-b,a/b))

a,b = map(int, input().split())

print(max(a+b,a*b,a-b))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a, b = list(map(int, input().split()))
print(max(a+b, max(a-b, a*b))

a, b = list(map(int, input().split()))
print(max(a+b, max(a-b, a*b)))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a = input()
b = input()
max([a+b, a-b, a*b])

a, b = map(int, input().split())
print(max(a+b, a-b, a*b))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
N = int(input())
S = []
for i in range(N):
    s = str(input())
    s = ''.join(sorted(s))
    S.append(s)

count = 0
for i in range(N):
    Si = S[i]
    for k in range(N):
        if i==k:
            None
        else:
            Sk = S[k]
            if Sk == Si:
                count += 1

print(count / 2)


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

X = []
X.append(A+B)
X.append(A-B)
X.append(A*B)

X.sort()

print(X[0])




import heapd

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


Blist = [[] for _ in range(M)]
for i in range(N):
    A, B = map(int, input().split())
    if A <= M: 
        Blist[A-1].append(-B) 

ans = 0
q = [] 


for  i in range(M):
    for b in Blist[i]: 
        heapd.heappush(q, b)
    if len(q) > 0: 
        ans -= heapd.heappop(q)

print(ans)




import heapq

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


Blist = [[] for _ in range(M)]
for i in range(N):
    A, B = map(int, input().split())
    if A <= M: 
        Blist[A-1].append(-B) 

ans = 0
q = [] 


for i in range(M):
    for b in Blist[i]: 
        heapq.heappush(q, b)
    if len(q) > 0: 
        ans -= heapq.heappop(q)

print(ans)


N = int(input())
S = []
for i in range(N):
    s = str(input())
    s = ''.join(sorted(a))
    S.append(s)

count = 0
for i in range(N):
    Si = S[i]
    for k in range(N):
        if i==k:
            None
        else:
            Sk = S[k]
            if Sk == Si:
                count += 1

print(count / 2)


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

X = []
X.append(A+B)
X.append(A-B)
X.append(A*B)

X.sort()

print(X[2])


Verdicts: Runtime Error

Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
A,B = map(int,input().split())

max(A+B,A-B,A*B)

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

print(max(A+B,A-B,A*B))

Verdicts: Wrong Answer

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a, b = map(int, input().split())
print(max(a+b, a-b a*b))

a,b=map(int,input().split())
print(max(a+b,a-b,a*b))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
# -*- coding: utf-8 -*-
def main():
    A,B = map(int(input().split()))
    ans = []
    ans.append(A+B)
    ans.append(A-B)
    ans.append(A*B)
    print(max(ans))

if __name__ == '__main__':
    main()

# -*- coding: utf-8 -*-
def main():
    A,B = map(int,input().split())
    ans = []
    ans.append(A+B)
    ans.append(A-B)
    ans.append(A*B)
    print(max(ans))

if __name__ == '__main__':
    main()

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
A,B = map(int,input().split())
print(MAX(A+B,A-B,A*B))

A,B=map.(int,input().split())
c = A + B
d = A- B
e = A*B
print(max([c,d,e]))

A,B =map(int,input().split())
max(A+B,A-B,A*B)

A,B=map(int,input().split())
c = A + B
d = A - B
e = A*B
print(max([c,d,e])

A,B=map(int,input().split())
c = A + B
d = A - B
e = A * B
print(max([c,d,e]))

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a , b  = int(input.split())
add = a + b
sub = a - b
mul = a * b
if add >= sub and add >= mul:
	max = add
elif sub >= add and sub >= mul:
  	max = sub
else:
    max = mul
print(max)

import scipy
A,B = map(int,input().split())
print(max(A + B,A * B,A - B))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
N = int(input())
s = [list(input()) for i in range(N)]
 
from itertools import combinations
 
a = 0
for i,j in combinations(s,2):
  if set(i) == set(j):
    a+=1
print(a)

from itertools import combinations

N = int(input())
s = [list(input()) for i in range(N)]
 
a = 0
for i,j in combinations(s,2):
  if set(i) == set(j):
    a+=1
print(a)

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

a1 = A+B
a2 = A-B
a3 = A*B

am = max([a1,a2,a3])

print(am)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a, b = input().split()
print(max(a+b,a-b,a*b))


a, b = map(int,input().split())
print(max(a+b,a-b,a*b))


Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a, b =map(int, input())
l=[
  a+b,
  a-b,
  a*b
]
print(max(l))

a, b =map(int, input().split())
l=[
  a+b,
  a-b,
  a*b
]
print(max(l))


Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b=map(int,input().split())
print(max(a,b))

a,b=map(int,input().split())
print(max(a+b,a-b,a*b))

Verdicts: Wrong Answer

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
n = int(input())
d = {}
ans = 0
for i in range(n):
    s = ''.join(sorted(input()))
    if s in d.keys():
        ans += d[s]
        d[s] += 1
    d.setdefault(s, 1)
print(ans)


a,b=map(int,input().split())
print(max(a+b,a-b,a*b))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b=map(int,input(),split())
for i in range(2*a-1):
  print(b-a+1,end="")

a,b=map(int,input(),split())
print(max(a+b,a-b,a*b))

a,b=map(int,input(),sprit())
print(max(a+b,a-b,a*b))

a,b=map(int,input().split())
print(max(a+b,a-b,a*b))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b=map(int,input(),split())
print(max(a+b,a-b,a*b))

a, b = int(input().split())
m = a + b
m = m < a - b if m = a - b else m
m = m < a * b if m = a * b else m
print(m)

a,b=map(int,input().split())
print(max(a+b,a-b,a*b))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a, b = map(int,input().split())
x = a + b
y = a - b
z = a * b
O = sorted(list(x, y, z),reverse=True)
print(O[0])



a, b = map(int, input().split())
x = a + b
y = a - b
z = a * b
O = [x,y,z]
O = sorted(O,reverse=1)
print(O[0]


a, b = map(int, input().split())
x = a + b
y = a - b
z = a * b
O = [x,y,z]
O = sorted(O,reverse=1)
print(O[0])

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b = map(int,input().split())

print(max(list(a+b,a-b,a*b)))


a,b = map(int,input().split())
print(max[a+b,a-b,a*b])


a,b = map(int,input().split())
print(max([a+b,a-b,a*b]))


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
(lambda x, y: print(max(a+b, a-b, a*b)))(map(int,input().split()))

(lambda x, y: print(max(x+y, x-y, x*y)))(*map(int,input().split()))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
from collections import Counter


def anagrams(word1,word2):
    def counter(s):
        return Counter(s.upper().replace(' ',''))
    return counter(word1) == counter(word2)

N=int(input())

count=0

list=[]

for i in range(N):
    list.append(input())

for i in list:
    list.remove(i)
    if len(list)==2:
        if anagrams(list[0],list[1])==True:
            count+=1
        break
    for j in list:
        if anagrams(i,j)==True:
            count+=1
print(count)

a,b=map(int, input().split())

tmp1=a+b
tmp2=a-b
tmp3=a*b

list=[tmp1,tmp2,tmp3]

print(max(list))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a.b=map(int,input().split())
print(max(a+b,a-b,a*b))

a,b=map(int,input().split())
print(max(a+b,a-b,a*b))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a,b=map(int,input())
l=[a+b,a-b,a*b]
print(max(l))

a,b=map(int,input().split());print(max(a*b,a+b,a-b))

Verdicts: Runtime Error

Accepted
Problem: We have two integers: A and B.  Print the largest number among A + B, A - B, and A \times B.

Submission attempts (in order):
a = int(input())
b = int(input())
add = a+b
minus = a-b
multi = a*b
print(max(add,minus, multi))

a,b = map(int, input().split())
add = a+b
minus = a-b
multi = a*b
print(max([add,minus, multi]))


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(v) for v in input().split(" ")]

t=" ".join([str(v) for v in range(-k+1,k)])
print(t)


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


output = " ".join([str(v) for v in range(X - (K - 1), X + K)])

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

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

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());q=max(-1000000,b-a+1);w=min(1000000,b+a-1);A=[i for i in range(q,w+1)];print([A][0]*)

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

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

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

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())
C=[i for i in range(X-K+1,X+K)]

print(*C, '')


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

print(*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)])

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


if __name__ == "__main__":
    main()


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


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())
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())
print(' '.join(map(str,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,b=map(int, input().split())

c = b + a - 1
d = b - a + 1

n_list = []

if c == d:
    print(c)
elif c != d:
    max_n = max(c,d)
    min_n = min(c,d)
    for i in range(min_n, max_n+1):
        n_list.append(i)

print(n_list)

a,b=map(int, input().split())

c = b + a - 1
d = b - a + 1

n_list = []

if c == d:
    print(c)
elif c != d:
    max_n = max(c,d)
    min_n = min(c,d)
    for i in range(min_n, max_n+1):
        n_list.append(i)
    print(n_list)

a,b=map(int, input().split())

c = b + a - 1
d = b - a + 1

n_list = []

if c == d:
    print(c)
elif c != d:
    max_n = max(c,d)
    min_n = min(c,d)
    for i in range(min_n, max_n+1):
        n_list.append(i)
    

#     print(i, end ="")
print( " ".join( repr(e) for e in n_list ) )

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

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

ans = [X]

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

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

ans.reverse()
print("".join(ans))


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

ans = [X]

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

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

ans.reverse()
print(*ans)


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(k) for k in input().split(" ")]

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


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

print(" ".join([str(_) for _ in range(max(-1000000,x-k+1),min(1000001,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=[x]
for i in range(1,k):
    ans.insert(0,x-i)
    ans.append(x+i)
    
print(ans)

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

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

an=map(str,ans)
a=' '.join(an)
    
print(a)

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):
I=input()
K=int(I.split()[0])
X=int(I.split()[1])
 
x=0
R=[]
 
for i in range(K*2-1):
    x=X+1+i
    R.append(x)
    
print(' '.join(map(str,R)))

I=input()
K=int(I.split()[0])
X=int(I.split()[1])

x=0
R=[]

for i in range(K*2-1):
    x=X+1*i
    R.append(x)
    
print(' '.join(map(str,R)))


I=input()
K=int(I.split()[0])
X=int(I.split()[1])
 
x=0
R=[]
 
for i in range(K*2-1):
    x=X-K+1+i
    R.append(x)
    
print(' '.join(map(str,R)))

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),X+(K-1)))

K,X = map(int, input().split())
lists = list(range(X-(K-1),X+K))
ans = map(str, lists)
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(x-k+1,x+k):
    if x < x+k-1:
        print(i, end ="")
    else:
        print(i)

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

a,b = [int(x) for x in input().split()]
print(max([a + b,a-b,a*b]))


k,x = [int(x) for x in 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):
def stones(input):
  	k = int(input[0])
    x = int(input[1])
    if k is 1:
        print(x)
        return x
    j = [i for i in range(x - k, x + k)]
    s = ' '.join(map(str, j))
    print(s)
    return


stones(input())

def stones(input):
    k, x = map(int, input.split())
    if k is 1:
        print(x)
        return x
    j = [i for i in range(x - k, x + k)]
    s = ' '.join(map(str, j))
    print(s)
    return s
 
 
stones(input())

def stones(input):
    k, x = map(int, input.split())
    if k is 1:
        print(x)
        return x
    j = [i for i in range(x - k, x + k)]
    s = ' '.join(map(str, j))
    print(s)
    return
 
 
stones(input())

def stones(input):
    k, x = map(int, input.split())
    if k is 1:
        print(x)
        return x
    j = [i for i in range(x - k + 1, x + k)]
    s = ' '.join(map(str, j))
    print(s)
    return
 
 
stones(input())

Verdicts: Runtime Error

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):
import numpy as np
X,K = map(int,input().split())
a=list(np.arange(np.max([-1000000,X-K+1]),np.min([1000000,X+K-1])))
print(' '.join(map(str, a)))

import numpy as np
X,K = map(int,input().split())
a=list(np.arange(np.max([-1000000,K-X+1]),np.min([1000000,K+X])))
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):
import numpy as np
firstline=input().split()
K=int(firstline[0])
X=int(firstline[1])
np.arange(X-K+1,X+K)



import numpy as np
firstline=input().split()
K=int(firstline[0])
X=int(firstline[1])
blackstone=np.arange(X-K+1,X+K)
array_info(blackstone)

firstline=input().split()
K=int(firstline[0])
X=int(firstline[1])
print(X-(K-1),X-(K-2),...,X,...,X-(K-2),X-(K-1))

line = input().split()
K = int(line[0])
X = int(line[1])

ans = list(range(X-K+1,X+K))
print(' '.join(map(str,ans)))

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

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



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


K, X = [int(i) for i in input().split()]
l = K - 1
ans = " ".join([str(i) for i in list(range(X - l, X + l + 1))])
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())
left=max(-10000,x-k+1)
right=min(10000,x+k-1)
#ans=right-left+1
#print(ans)
for i in range(left,right+1):
  print(i ,end="/n")

k,x=map(int,input().split())
left=max(-10000,x-k+1)
right=min(10000,x+k-1)
ans=right-left+1
print(ans)

k,x=map(int,input().split())
left=max(-10000,x-k+1)
right=min(10000,x+k-1)
#ans=right-left+1
#print(ans)
ans=[]
for i in range(left,right+1):
  ans.append(i)
print(*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())
','.join([str(i) for i in range(x-k+1, x+k-1+1)]).replace(',', ' ')

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

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

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

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

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

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

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

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 = int(input())
X = int(input())
A=X-K+1
B=X+K-1
L=[]
for i in range(A,B):
  if i > 1000000 or i < -1000000:
    continue
  L.attend(str(i))
print(*L)

K = int(input())
X = int(input())
A=X-K+1
B=X+K-1
L=[]
for i in range(A,B):
  if i > 1000000 or i < -1000000:
    continue
  L.attend(i)
print(*L)

K = int(input())
X = int(input())
A=X-K+1
B=X+K-1
L=[]
for i in range(A,B):
  if i > 1000000 or i < -1000000:
    continue
  L.attend(i)
print(*L[0])

K,X = map(int,input().split())
A=X-K+1
B=X+K-1
L=[]
for i in range(A,B+1):
  if i > 1000000 or i < -1000000:
    continue
  L.append(str(i))
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())

a = x - k + 1
b = x + k

y = []

for i in range(a,b):
    y.append(i)
print(*y,sep=',')

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

a = x - k + 1
b = x + k

y = []

for i in range(a,b):
    y.append(i)
print(*y,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):
int = list(map(int,input().split()))

k=int.pop(0)
x=int.pop(1)

p=range((x+1)-k,x+k)

print(p)

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

k = int[0]
x = int[1]


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


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

k = int[0]
x = int[1]

p = range(x + 1 - k,x + k)

print(list[p])

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

k = int[0]
x = int[1]

p = range(x + 1 - k,x + k)

print(list(p))

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

k = int[0]
x = int[1]

p = range((x + 1) - k,x + k)

print(p)

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

k = int[0]
x = int[1]

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


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

k = int[0]
x = int[1]

p=x + 1 
q=p - k
r=x + k
print(list(range(q,r)))


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

a=int[0]
b=int[1]

x=range((b+1)-a,(b-1)+a)

print(x)

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

a=int[0]
b=int[1]

x=range((b+1)-a,b+a)

print(x)

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

k = int[0]
x = int[1]

p=x + 1 
q=p - k
r=x + k

s =list(range(q,r))
print(*s)


Verdicts: Runtime Error

Wrong Answer

Runtime Error

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

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

Verdicts: Wrong Answer

Accepted