TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

if b*2 > a:
    print(0)
else:
    print(b*2 - a)

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

if a>b:
    print(a-b)
elif a<b:
    print(0)
else:
    print(0)

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

if a<b:
    print(a-b)
elif a > b:
    print(0)
else:
    print(0)

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

if b*2 >= a:
    print(0)
else:
    print(b*2 - a)

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

if a>b:
    print(a-b)
elif a<b:
    print(0)

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

if b*2 > a:
    print(0)
else:
    print(b*2 - a)

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

if a<b:
    print(a-b)
elif a > b:
    print(0)
else:
    print(0)

a,b = map(int, input().split())
 
if a<b:
    print(a-b)
elif a > b:
    print(0)


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

if b*2 >= a:
    print(0)
else:
    print(a - b*2)

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Wrong Answer

Runtime Error

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
tmp = input().split(" ")
A = int(tmp[0])
B = int(tmp[1])

import math
print(math.max(A - 2 * B, 0))

tmp = input().split(" ")
A = int(tmp[0])
B = int(tmp[1])

print(max([A - 2 * B, 0]))

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a,b=map(int, input().split())
print(0 if a<=(2b) else a-(2b))

a,b=map(int,input().split())
if a-2b<=0:
  print(0)
else:
  print(a-2b)

a=int(input())
b=int(input())
if a<=2b:
  print(0)
else:
  print(a-2b)

A,B=map(int,input().split())
print(0 if A<=2B else A-2B)

a,b=map(int,input().split())
print(0 if a-(2b)<=0 else a-(2b))

a,b=map(int,input().split())
print(0 if a<=2b else a-2b)

a,b=map(int,input().split())
print(0 if a<=(2*b) else a-(2*b))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A,B=map(int, input().split())
print(0 if B<A*2 else B-A*2)

A,B=map(int, input().split())
print(0 if A<B*2 else A-B*2)

Verdicts: Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

print(min(a-2*b,0))

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

print(max(a-2*b,0))

Verdicts: Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

if a > 2 *b:
    print(0)
else:
    print(a-2*b)

a,b = int(input()),int(input())

if a > 2b:
  print(int(a-2b))
else:
  print(0)

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

if a > 2 *b:
    print(0)
else:
    print(2*b-a)

a = int(input())
b = int(input())

if a > 2b:
  print(int(a - 2b))
else:
  print(0)

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

if a < 2 *b:
    print(0)
else:
    print(a-2*b)

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a,b=map(int,input().split())
if a > b*2:
    print(0)
else:
    print(a-b*2)

a,b=map(int,input().split())
if a < b*2:
    print(0)
else:
    print(a-b*2)

Verdicts: Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

if a-2b>=0:
  print a-2b
else:
  print 0

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

if a-2*b>=0:
  print(a-2*b)
else:
  print(0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

a,b = map(int,input().split())
print(max(0,(a-2)))

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

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
from functools import reduce
from operator import add

n = int(input())
l1 = [int(i) for i in input().split()]
print(reduce(add, [l1[a]*l1[b] for a in range(n-1) for b in range(a+1,n)]))



A,B = map(int,input().split())
ans=int(A-B*2)
print(ans if ans >= 0 else 0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

C = A- 2*B

if C >=0:
  print(C)
else:
  print(0)

A, B = map(int,input().split())
 
C = A- 2*B
 
if C >=0:
  print(C)
else:
  print(0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

if a <= b*2:
  print("0")
else:
  print(a-b*2)

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

if a <= b*2:
  print("0")
else:
  print(a-b*2)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

answer=a-2*B

if answer<0:
  print(0)
else:
  print(answer)



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


ans = A - 2 * B 


if ans < 0:
  print(0)
else:
  print(ans)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a = int(input())
b = int(input())
s = a-2*b
if(s > 0):
    print(s)
else:
    print(0)



a = int(input())
b = int(input())
s = a-2*b
if(s >= 0):
    print(s)
else:
    print(0)



a = int(input())
b = int(input())
print(max(0,a-2*b))



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



Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

if int(a) - int(b) * 2 > 0:
	print(int(a) - int(b) * 2)
else
	print(0)

a, b = input().split()

if int(a) - int(b) * 2 > 0:
    print(int(a) - int(b) * 2)
else:
    print(0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):

a, b = map(int, input.split(''))
ans = a - 2 * b
if ans < 0:
	ans = 0
print(ans)

a, b = map(int, input.split(''))
ans = a - 2 * b
if ans < 0:
  ans = 0
 print(ans)


a, b = map(int, input().split(' '))
ans = a - 2 * b
if ans < 0:
	ans = 0
print(ans)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
import itertools
n = int(input())
d = list(map(int, input().split()))
a = 0
for x in itertools.combinations(d, 2):
    a += x[0]*x[1]
print(a)

a, b = map(int, input().split())
if a - 2*b < 0:
    print("0")
else:
    print(a-2*b)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

len_ = A-*B

if len_<=0:
    print(0)
else:
    print(len_)

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

len_ = A-2*B

if len_<=0:
    print(0)
else:
    print(len_)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

if A-B*2 >= B*2:
    print(A-B*2)
else:
    print(0)

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

if A-B*2 > B*2:
    print(A-B*2)
else:
    print(0)

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

if A >= B*2:
    print(0)
else:
    print(A-B*2)

A,B = map(int,input().split())
print(max(0,A-B*2))

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
print(max(int(input()) - 2*int(input()), 0))

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

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A,B=map(int,input().split())
if A<=2*B:
  print(0)
else:
  print(2*B-A)

A,B=map(int,input().split())
if A<=2*B:
  print(0)
else:
  print(A-2*B)

Verdicts: Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
if __name__ == "__main__":
	N = int(input())
	L = list(map(int, input().split()))
	L.sort()
	sum = 0
	for c in range(2, N):
		for b in range(c - 1, 0, -1):
			for a in range(b - 1, -1, -1):
				if L[a] + L[b] > L[c]:
					# print(a, b, c)
					sum += 1
				else:
					break
	print(sum)

if __name__ == "__main__":
	N = int(input())
	L = list(map(int, input().split()))
	L.sort()
	sum = 0
	for c in range(2, N):
		for b in range(c - 1, 0, -1):
			for a in range(b - 1, -1, -1):
				if L[a] + L[b] > L[c]:
					# print(a, b, c)
					sum += 1
				else:
					break
	print(sum)

if __name__ == "__main__":
	A, B = map(int, input().split())
	ans = A - 2 * B
	if ans < 0:
		ans = 0
	print(ans)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a,b=int(input.split())
if b*2>=a:
  print(0)
else: print(a-b*2)

a=input().split()
b=int(a[0])
c=int(a[1])
if c*2>=b:
  print(0)
else: print(b-c*2)


Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
n=int(input())
l=sorted([int(i) for i in input().split()],reverse=True)

#print(l)
co=0
for i in range(n-2):
    c=l[i]
    x=0
    for j in range(i+1,n-1):
        b=l[j]
        for k in range(j+1,n):
            a=l[k]
            if c<(a+b):
                co+=1
            else:
                x=1
                break
        if x==1:
            break

print(co)

a, b = map(int ,input().split())
print(0 if a-2*b<0 else a-2*b)


Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
def main():
A, B = map(int, input().split())
 print(A-2*B) if A > 2*B else print("0")
  
mail()

A, B = map(int, input().split())
 print(A-2*B) if A > 2*B else print("0")

def main():
A, B = map(int, input().split())
 print(A-2*B) if A > 2*B else print(0)
  
main()

A, B = map(int, input().split())
 print(A-2*B) if A > 2*B else print(0)

A, B = map(int, input().split())
print(A-2*B) if A > 2*B else print(0)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
N = int(input())
L = sorted(map(int,input().split()),reverse=True)
num = 0

for i in range(N-2):
    for j in range(i+1,N-1):
        for k in range(j+1,N):
            array = [L[i],L[j],L[k]]
            if(array[0]>=array[1]+array[2]):
                break
            else:
                num += 1
print(num)


A,B = map(int,input().split())
if(A>=2*B):
    print(A-2*B)
else:
    print(0)


Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a, b = input().split()
print(min(0, int(a) - int(b) * 2))

a, b = input().split()
print(min(0, a - b * 2))

a, b = input().split()
print(max(0, int(a) - int(b) * 2))

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a,b = map(input().split(' '))
print(maximum(a-2*b,0))

a,b = map(input().split(' '))
print(max(a-2*b,0))

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
def solve(A: int, B: int):
    ans = max(0, A - (2 * B))
    print(ans)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(A, B)


if __name__ == '__main__':
    main()


#!/usr/bin/env python3
import sys


def solve(A: int, B: int):
    ans = max(0, A - (2 * B))
    print(ans)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(A, B)


if __name__ == '__main__':
    main()


Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A = input()
B = input()
B *= 2
if A < B:
    print('0')
else:
    print(A - B)

a = list(map(int, input().split()))
A = a[0]
B = a[1]
if A <= B * 2:
    print(0)
else:
    print(A - B * 2)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A,B = map(int,input().split())
ans = min(0,A-(2`B)
print(ans)

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

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a = int(input())
b = int(input())

print(a-b*2 if a-b*2 >= 0 else 0)

a,b = (int(i) for i in input().split())
print(a-b*2 if a-b*2 >= 0 else 0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
import bisect
n = int(input())
l = list(map(int, input().split()))
count = 0
l.sort()
for i in range(len(l)-1, 1, -1):
  for j in range(i-1, 0, -1):
    count += max(j - (bisect.bisect_right(l, l[i] - l[j])), 0)
print(count)



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

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A = int(input('横方向の窓の長さ'))
B = int(input('横方向のカーテンの長さ'))

c = A - 2 * B
if c > 0:
  print(c)
else:
  print(0)

A,B = map(int,(input()).split())
 
c = A - 2 * B
if c > 0:
  print(c)
else:
  print(0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A, B = map(int, input().split())
print(max(0, A-B*2)

A, B = map(int, input().split())
print(max(0, A-B*2))


Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A,B=map(int,input().split())
if A>2B:
  print(A-2*B)
else:
  print(0)

A,B=map(int,input().split())
if A>2B:
  print(A-2B)
else:
  print(0)

A,B=map(int,input().split())
if A>2B:
  print(A-2B)
else:
  print(0)

A,B=map(int,input().split())
if A>=2*B:
  print(A-2*B)
else:
  print(0)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a,b=map(int,input().split())
c=a-2*b
if c>o:
    print(c)
else:
    print(0)

a,b=map(int,input().split())
c=a-2*b
if c>0:
    print(c)
else:
    print(0)


Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

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

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
x = input().split()

a = x[0]
b = x[1]

if a > b * 2:
  ret = a - b * 2
else:
  ret = 0
  
print(ret)

a, b = int(input().split())
 
if a > b * 2:
  ret = a - b * 2
else:
  ret = 0
  
print(ret)

a, b = input().split()

if a > b * 2:
  ret = a - b * 2
else:
  ret = 0
  
print(ret)



x = input().split()
 
a = x[0]
b = x[1]
 
if a > b * 2:
  print(a - b * 2)
else:
  print(0)

a, b = map(int, input().split())
 
if a > b * 2:
  ret = a - b * 2
else:
  ret = 0
  
print(ret)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a,b = map(int,input().split())
print(a-b*2 if a-b*2>=0 0 else)

a,b = map(int,input().split())
print(a-b*2 if a-b*2>=0 else 0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
N=int(input())
S=str(input())

a=N

for i in range(N-1):
    if S[i]==S[i+1]:
        a-=1

print(a)






from sys import stdin
A, B = [int(x) for x in stdin.readline().rstrip().split()]
if A > 2*B:
  print(A - 2*B)
elif A <= 2*B:
  print(0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a, b = [int(i) for i in input().split()]
print(max(0, a - 2 * b)

a, b = [int(i) for i in input().split()]
print(max(0, a - 2 * b))

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A,B = map(int, input().split())
B *= 2
if A >= B:
  print(0)
else:
  print(A-B)

A,B = map(int, input().split())
B *= 2
if A <= B:
  print(0)
else:
  print(A-B)

Verdicts: Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
i = input(map(int, input().split()))
A = i[0]
B = i[1]

if A-B*2>0;
	print(A-B*2)
  else;
	print(0)
    

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

# Input
i = list(map(int, input().split()))

# Process
X = i[0] - i[1]*2

# Output
if X > 0:
    print(X)
else:
    print(0)


Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A, B = int(input().split())
if A - 2 * B <= 0:
  print(0)
else:
  print(A-2*B)

A, B = map(int, input().split())
if A - 2 * B <=0:
  print(0)
else:
  print(A - 2 * B)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
s=input().split()
if s[1]-2*s[2]<0:
  print(0)
else:
  print(s[1]-2*s[2])

s=list(map(int,input().split()))
if s[1]-2*s[2]<0:
  print(0)
else:
  print(s[1]-2*s[2])

n=input()
if n[0]-2*n[1]<0:
  print(0)
else:
  print(n[0]-2*n[1])

n=list(map(int,input().split()))
if n[0]-2*n[1]<0:
  print(0)
else:
  print(n[0]-2*n[1])

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
import math

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

answer=0

if A-2B<=0:
    answer=0
else :
    answer=A-2B

print(answer)
     

import math

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

answer=0

if A-2*B<=0:
    answer=0
else :
    answer=A-2*B

print(answer)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
n, *l = map(int, open(0).read().split())
sl = sorted(l,reverse=True)
ans = 0
for i in range (n):
  for j in range (i+1,n):
    for k in range(j+1,n):
      if sl[i]-sl[j] < sl[j] and sl[i]<sl[j]+sl[k]:
        ans = ans + 1
print(ans)

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

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
i = input()
ar = i.split()
print(max(ar[0]-2*ar[1], 0))


i = input()
ar = i.split()
print(max(int(ar[0])-int(2*ar[1]), 0))


i = input()
ar = i.split()
print(max(int(ar[0])-2*int(ar[1]), 0))


Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a, b = map(int, input().split())
s = a - b
if s >= 0:
  print(s)
else:
  print("0")

a, b = map(int, input().split())
s = a - 2 * b
if s >= 0:
  print(s)
else:
  print("0")

Verdicts: Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

heal = 0

for i in range(N):
    for j in range(i+1 , N):
        heal += deliciaus[i] * deliciaus[j]
    
print(heal)

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

if a <= 2*b:
    print(0)
if a > 2*b:
    print(a - 2*b)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

if 2b>=a:
	print(0)
else:
	print(a-2b)

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

if 2*b>=a:
	print(0)
else:
	print(a-2*b)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a,b=map(int,input().split())
c = b*2 - a
if c > 0:
    print(0)
else:
    print(c)

a,b=map(int,input().split())
c = a - b*2
if c < 0:
    print(0)
else:
    print(c)

Verdicts: Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
import itertools

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

print(sum(x*y for x, y in itertools.combinations(t, 2)))


a, b = map(int, input().split())
print(a - 2*b) if a - 2*b > 0 else print(0)


Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A, B = map(int, input().split())
print(A - 2*B if A - 2*B > 0 else: 0)

A, B = map(int, input().split())
print(A - 2*B if A - 2*B > 0 else 0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a,s=map(int,input(),split())
print(max(a-2*s,0))

a,s=map(int,input().split())
print(max(a-2*s,0))

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
if B * 2 >= A:
  print 0
else:
  print A-B*2

ABInput = str(input())
 
AB = ABInput.split(" ")
 
A = AB[0]
B = AB[1]
 
TotalCartain = B * 2
 
if TotalCartain > A or TotalCartain == A:
  print (0)
else:
  print (A-TotalCartain)

N = str(input())
Ds = str(input()).split(" ")
answer = 0
 
for di in range(len(Ds)):
  for dii in range(di):
    sum = Ds[di] + Ds[dii] 
    answer += sum
 
print (answer)


ABInput = str(input())
 
AB = ABInput.split(" ")
 
A = AB[0]
B = AB[1]

TotalCartain = B * 2

if TotalCartain > A or TotalCartain = A:
  print (0)
else:
  print (A-TotalCartain)

ABInput = str(input())

AB = ABInput.split(" ")

A = AB[0]
B = AB[1]

if B * 2 >= A:
  print 0
else:
  print A-B*2

ABInput = str(input())
 
AB = ABInput.split(" ")
 
A = AB[0]
B = AB[1]
 
if B * 2 >= A:
  print (0)
else:
  print (A-B*2)

ABInput = str(input())
 
AB = ABInput.split(" ")
 
A = int(AB[0])
B = int(AB[1])
 
TotalCartain = B * 2
 
if TotalCartain > A or TotalCartain == A:
  print (0)
else:
  print (A-TotalCartain)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
A, B = map(int, input())
 
print(max([0, A - 2 * B]))

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

print(max(0, A - 2 * B))

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

print(max(0, A - 2 * B))


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
n=int(input())
tako=list(map(int,input().split()))
ans=0
for i in range(n):
    for j in range(1,n+1):
        ans+=tako[i]*tako[j]
print(ans)

a,b=map(int,input().split())
if a-b*2>0:
    print(a-b*2)
else:
    print(0)

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a, b=map(int, input().split())
if a-2*b>=0:
    print(a-2b)
else:
    print(0)

a, b=map(int, input().split())
if a-2*b>=0:
    print(a-2b)
else:
  print(0)

a, b=map(int, input().split())
if a-2*b>=0:
    print(a-2*b)
else:
    print(0)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a,b=map(int,input().split())
if a>b:
    a,b=b,a
c=max(0,a-2*b)
print(c)   


a,b=map(int,input().split())
c=max(0,a-2*b)
print(c)

Verdicts: Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
s=list(map(int,input().split()))
a=int(s[1])
b=0
if a*a>=s[0]:
  print(0)
else:
  print(s[0]-a*a)

s=list(map(int,input().split()))
if 2*s[1]>=s[0]:
  print(0)
else:
  print(s[0]-2*s[1])

Verdicts: Wrong Answer

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
n = int(input())
tastes = list(map(lambda x:int(x), input().split()))

ans = 0

while len(tastes)>0:
    x = tastes.pop()
    for y in tastes:
        ans += x * y
        
print(ans)


n = int(input())
tastes = list(map(lambda x:int(x), input().split()))

ans = 0

while len(tastes)>0:
    x = tastes[0]
    del tastes[0]
    for y in tastes:
        ans += x * y
            
print(ans)


a, b = list(map(lambda x: int(x), input().split()))

ans = max(0, a - (2*b))

print(ans)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

Submission attempts (in order):
a, b = map(int(), input().split())
if a - b * 2 > 0:
  print(a-b*2)
else:
  print(0)


a, b = map(int(), input())
if a - b * 2 > 0:
  print(a-b*2)
else:
  print(0)

a, b = map(int, input().split())
if a - b * 2 > 0:
  print(a-b*2)
else:
  print(0)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

if A < B * 2:
    print(0)
else:
    print(A - 2*B)

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

if A[0] < A[1] * 2:
    print(0)
else:
    print(A[0] - 2*A[1])

Verdicts: Runtime Error

Accepted
Problem: The window of Takahashi's room has a width of A. There are two curtains hung over the window, each of which has a horizontal length of B. (Vertically, the curtains are long enough to cover the whole window.)  We will close the window so as to minimize the total horizontal length of the uncovered part of the window. Find the total horizontal length of the uncovered parts of the window then.

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

if(A>B*2):
  aaa=A*B
  print(aaa)
else:
  print(0)
  

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

if(A>B*2):
  aaa=A*B
  print(aaa)
else:
  print(0)
  

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

if(A>B*2):
  aaa=A-B*2
  print(aaa)
else:
  print(0)
  

Verdicts: Wrong Answer

Runtime Error

Accepted