problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k | fixed_code stringlengths 12 526k | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M | fixed_submission_id int64 2 1.54M | user_id stringlengths 10 10 | language stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p02818 | n = list(map(int,input().split()))
ans1 = n[1] - n[2]
ans2 = (n[0] + n[1]) - n[2]
if ans1 <= 0:
ans1 = 0
if ans1 > 0:
ans2 = n[1]
elif ans2 <= 0:
ans2 = 0
print(ans1,ans2)
| n = list(map(int,input().split()))
ans1 = n[0] - n[2]
ans2 = (n[0] + n[1]) - n[2]
if ans1 <= 0:
ans1 = 0
if ans1 > 0:
ans2 = n[1]
elif ans2 <= 0:
ans2 = 0
print(ans1,ans2)
| [
"literal.number.integer.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 622,248 | 622,249 | u900848911 | python |
p02818 | a,b,c=map(int,input().split())
if a >= c:
print(a-c,0)
else:
print(0,max(a+b-c,0)) | a,b,c=map(int,input().split())
if a >= c:
print(a-c,b)
else:
print(0,max(a+b-c,0)) | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"io.output.change"
] | 622,252 | 622,254 | u772118381 | python |
p02818 | a,b,c=input().split()
if a >= c:
print(a-c,b)
else:
print(0,max(a+b-c,0)) | a,b,c=map(int,input().split())
if a >= c:
print(a-c,b)
else:
print(0,max(a+b-c,0)) | [
"call.add",
"call.arguments.change"
] | 622,256 | 622,254 | u772118381 | python |
p02818 | A,B,K = map(int, input().split())
takahashi_cookie = A
aoki_cookie = B
iteration = K
if 0 <= takahashi_cookie - iteration:
takahashi_cookie -= iteration
elif 0 <= aoki_cookie + takahashi_cookie - iteration:
aoki_cookie = aoki_cookie + takahashi_cookie - iteration
takahashi_cookie = 0
else:
takahashi_cookie = 1
aoki_cookie = 1
print(str(takahashi_cookie) + ' ' + str(aoki_cookie))
| A,B,K = map(int, input().split())
takahashi_cookie = A
aoki_cookie = B
iteration = K
if 0 <= takahashi_cookie - iteration:
takahashi_cookie -= iteration
elif 0 <= aoki_cookie + takahashi_cookie - iteration:
aoki_cookie = aoki_cookie + takahashi_cookie - iteration
takahashi_cookie = 0
else:
takahashi_cookie = 0
aoki_cookie = 0
print(str(takahashi_cookie) + ' ' + str(aoki_cookie))
| [
"literal.number.integer.change",
"assignment.value.change"
] | 622,257 | 622,258 | u898428248 | python |
p02818 | A,B,K = map(int, input().split())
takahashi_cookie = A
aoki_cookie = B
iteration = K
if 0 <= takahashi_cookie - iteration:
takahashi_cookie -= iteration
elif 2 <= aoki_cookie + takahashi_cookie - iteration:
aoki_cookie = aoki_cookie + takahashi_cookie - iteration
takahashi_cookie = 0
else:
takahashi_cookie = 1
aoki_cookie = 1
print(str(takahashi_cookie) + ' ' + str(aoki_cookie))
| A,B,K = map(int, input().split())
takahashi_cookie = A
aoki_cookie = B
iteration = K
if 0 <= takahashi_cookie - iteration:
takahashi_cookie -= iteration
elif 0 <= aoki_cookie + takahashi_cookie - iteration:
aoki_cookie = aoki_cookie + takahashi_cookie - iteration
takahashi_cookie = 0
else:
takahashi_cookie = 0
aoki_cookie = 0
print(str(takahashi_cookie) + ' ' + str(aoki_cookie))
| [
"literal.number.integer.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 622,259 | 622,258 | u898428248 | python |
p02818 | A,B,K = map(int,input().split())
if A <= K:
print(0, B-(K-A))
else:
print(A-K, B) | A,B,K = map(int,input().split())
if A <= K:
print(0, max(B-(K-A),0))
else:
print(A-K, B) | [
"call.add",
"call.arguments.add"
] | 622,266 | 622,267 | u266874640 | python |
p02818 | taka, aoki, action = map(int, input().split())
if taka >= action:
print(taka-action, aoki)
else:
print(0, max(aoki-(action-taka, 0))) | taka, aoki, action = map(int, input().split())
if taka >= action:
print(taka-action, aoki)
else:
print(0, max(taka+aoki-action, 0)) | [
"call.arguments.change",
"expression.operation.binary.remove"
] | 622,270 | 622,271 | u418948864 | python |
p02818 | from sys import stdout
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
a,b,k = inm()
print("{} {}".format(max(0,a-k), b-max(0,k-a)))
| from sys import stdout
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
DBG = True # and False
BIG = 999999999
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
a,b,k = inm()
print("{} {}".format(max(0,a-k), max(0,b-max(0,k-a))))
| [
"call.add",
"call.arguments.change"
] | 622,277 | 622,278 | u102445737 | python |
p02818 | a, b, k = map(int, input().split())
print(max(a - k, 0), b - max(k - a, 0))
| a, b, k = map(int, input().split())
print(max(a - k, 0), max(b - max(k - a, 0), 0))
| [
"call.add",
"call.arguments.add"
] | 622,288 | 622,289 | u572002343 | python |
p02818 | a,b,k=map(int,input().split())
if k<a:
print(k-a,b)
elif a<=k<a+b:
print(0,b-(k-a))
else:
print(0,0)
| a,b,k=map(int,input().split())
if k<a:
print(a-k,b)
elif a<=k<a+b:
print(0,b-(k-a))
else:
print(0,0) | [
"expression.operation.binary.remove"
] | 622,292 | 622,293 | u901582103 | python |
p02818 | a,b,k = map(int,input().split())
A = max(a-k,0)
B = max(b-k+a,0)
print(A,B) | a,b,k = map(int,input().split())
A = max(a-k,0)
B = max(b-max(k-a,0),0)
print(A,B) | [
"call.add",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 622,296 | 622,297 | u192154323 | python |
p02818 | A,B,K = map(int, input().split())
if (A+B)-K < 0:
print(0,0)
elif A-K<0:
print(0,A+B-K)
elif A-K>0:
print(A-K,B) | A,B,K = map(int, input().split())
if (A+B)-K <= 0:
print(0,0)
elif A-K<=0:
print(0,A+B-K)
elif A-K>0:
print(A-K,B) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 622,300 | 622,301 | u230621983 | python |
p02818 | a, b, k = input().split(' ')
a = int(a)
b = int(b)
k = int(k)
if (k > a + b):
print('0 0')
else:
if (k < a):
print(a-k, end = ' ')
print(b)
else:
print('0',end = ' ')
print(b - k) | a, b, k = input().split(' ')
a = int(a)
b = int(b)
k = int(k)
if (k >= a + b): print('0 0')
else:
if (k <= a):
print(a-k, end = ' ')
print(b)
else:
print('0',end = ' ')
print(b - k + a) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 622,302 | 622,303 | u705147591 | python |
p02818 | a, b, k = input().split(' ')
a = int(a)
b = int(b)
k = int(k)
if (k >= a + b): print('0 0')
else:
if (k <= a):
print(a-k, end = ' ')
print(b)
else:
print('0',end = ' ')
print(b - k) | a, b, k = input().split(' ')
a = int(a)
b = int(b)
k = int(k)
if (k >= a + b): print('0 0')
else:
if (k <= a):
print(a-k, end = ' ')
print(b)
else:
print('0',end = ' ')
print(b - k + a) | [
"expression.operation.binary.add"
] | 622,304 | 622,303 | u705147591 | python |
p02818 | list=input().split()
A=int(list[0])
B=int(list[1])
K=int(list[2])
if A >= K:
print((A-K) + " " + B)
else:
print("0 "+ str(max(B-(K-A),0)) ) | list=input().split()
A=int(list[0])
B=int(list[1])
K=int(list[2])
if A >= K:
print(str((A-K)) + " " + str(B))
else:
print("0 "+ str(max(B-(K-A),0)) ) | [
"call.arguments.add",
"call.arguments.change",
"call.add"
] | 622,313 | 622,314 | u824327013 | python |
p02818 | A, B, K = [int(_) for _ in input().split()]
X = max(0, A - K)
Y = min(A + B - K, B)
print(X, Y)
| A, B, K = [int(_) for _ in input().split()]
X = max(0, A - K)
Y = max(0, min(A + B - K, B))
print(X, Y)
| [
"call.add",
"call.arguments.change"
] | 622,315 | 622,316 | u942697937 | python |
p02818 | a,b,k=map(int,input().split())
print(a-min(a,k),b-min(b,a-min(a,k))) | a,b,k=map(int,input().split())
print(a-min(a,k),b-min(b,k-min(a,k))) | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 622,317 | 622,318 | u713008740 | python |
p02818 | a,b,k=map(int,input.split())
printf(a-min(a,k),b-min(b,a-min(a,k))) | a,b,k=map(int,input().split())
print(a-min(a,k),b-min(b,k-min(a,k))) | [
"call.add",
"identifier.change",
"call.function.change",
"io.output.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 622,320 | 622,318 | u713008740 | python |
p02818 | # coding: utf-8
import numpy as np
from functools import lru_cache
import time
def main():
if True:
A,B,K = list(map(
int, input().split()))
else:
pass
A = A - K
B = B if A > 0 else B + A
print(max(A,0),B)
if __name__ =='__main__':
main() | # coding: utf-8
import numpy as np
from functools import lru_cache
import time
def main():
if True:
A,B,K = list(map(
int, input().split()))
else:
pass
A = A - K
B = B if A > 0 else B + A
print(max(A,0),max(B,0))
if __name__ =='__main__':
main() | [
"call.add",
"call.arguments.add"
] | 622,322 | 622,323 | u721047793 | python |
p02818 | A, B, K = map(int, input().split())
print(max(A - K, 0), min(A + B - K, B))
| A, B, K = map(int, input().split())
print(max(A - K, 0), max(min(A + B - K, B), 0))
| [
"call.add",
"call.arguments.add"
] | 622,326 | 622,327 | u796942881 | python |
p02818 | # -*- coding: utf-8 -*-
a,b,k = map(int,input().split())
"""
for i in range(k):
if a >= 1:
a -= 1
elif b >= 1:
b -= 1
print(a,b)
"""
if k <= a and a >= 1:
a = a - k
elif k <= b and b >= 1:
c = a
a = 0
b = b - (k - c)
else:
a = 0
b = 0
print(a, b)
| # -*- coding: utf-8 -*-
a,b,k = map(int,input().split())
"""
for i in range(k):
if a >= 1:
a -= 1
elif b >= 1:
b -= 1
print(a,b)
"""
if k <= a and a >= 1:
a = a - k
elif k <= a + b and b >= 1:
c = a
a = 0
b = b - (k - c)
else:
a = 0
b = 0
print(a, b)
| [
"control_flow.branch.if.condition.change"
] | 622,332 | 622,333 | u977661421 | python |
p02818 | a, b, k = map(int, input().split())
if k - a > 0:
a = 0
k -= a
if k - b > 0:
b = 0
print(str(a) + " " + str(b))
else:
b -= k
print(str(a) + " " + str(b))
else:
a -= k
print(str(a) + " " + str(b)) | a, b, k = map(int, input().split())
if k - a > 0:
k -= a
a = 0
if k - b > 0:
b = 0
print(str(a) + " " + str(b))
else:
b -= k
print(str(a) + " " + str(b))
else:
a -= k
print(str(a) + " " + str(b)) | [
"assignment.remove",
"assignment.add"
] | 622,336 | 622,337 | u821906920 | python |
p02818 | a, b, k = map(int, input().split())
if k <= a:
print(str(k-a) + " " + str(b))
elif k <= a + b:
print(str(0) + " " + str(b-(k-a)))
else:
print(str(0) + " " + str(0)) | a, b, k = map(int, input().split())
if k <= a:
print(str(a-k) + " " + str(b))
elif k <= a + b:
print(str(0) + " " + str(b-(k-a)))
else:
print(str(0) + " " + str(0)) | [
"expression.operation.binary.remove"
] | 622,348 | 622,349 | u998082063 | python |
p02818 | a,b,k = map(int,input().split())
print(max(0,a-k), max(b+a-k, 0)) | a,b,k = map(int,input().split())
print(max(0,a-k), max(b+min(a-k,0), 0))
| [
"call.add",
"call.arguments.add"
] | 622,352 | 622,353 | u298297089 | python |
p02818 | a,b,k=map(int,input().split())
if a>=k:
aans=a-k;
bans=b
else:
aans=0;
bans=b-(k-a)
print(aans,bans) | a,b,k=map(int,input().split())
if a>=k:
aans=a-k;
bans=b
else:
aans=0;
bans=max(0,b-(k-a))
print(aans,bans)
| [
"call.add",
"call.arguments.change"
] | 622,360 | 622,361 | u130900604 | python |
p02818 | a,b,k=map(int, input().split())
if a-k>=0:
print(a-k, b)
elif a-k<0:
print(0, b+(a-k)) | a,b,k=map(int, input().split())
if a-k>=0:
print(a-k, b)
elif a-k<0:
print(0, max(0,b+(a-k))) | [
"call.arguments.add",
"call.arguments.change"
] | 622,362 | 622,363 | u260216890 | python |
p02818 | A, B, K = map(int, input().split())
if A >= K:
print(A - K, B)
else:
print(0, B - (K - A))
| A, B, K = map(int, input().split())
if A >= K:
print(A - K, B)
else:
print(0, max(0, B - (K - A))) | [
"call.arguments.add",
"call.arguments.change"
] | 622,364 | 622,365 | u577138895 | python |
p02818 | a,b,n = list(map(int, input().split()))
if a+b<=n:
a=0
b=0
else:
if n>a:
b -= n-a
a=0
if b < 0:
b = 0
else:
a = n-a
print("%d %d" %(a,b)) | a,b,n = list(map(int, input().split()))
if a+b<=n:
a=0
b=0
else:
if n>a:
b -= n-a
a=0
if b < 0:
b = 0
else:
a = a - n
print("%d %d" %(a,b))
| [
"expression.operation.binary.remove"
] | 622,368 | 622,369 | u527616458 | python |
p02818 | a,b,n = list(map(int, input().split()))
if a+b<=n:
a=0
b=0
else:
if n>a:
b-=(n-a)
a=0
if b<0:
b=0
else:
a=n-a
print("%d %d" %(a,b)) | a,b,n = list(map(int, input().split()))
if a+b<=n:
a=0
b=0
else:
if n>a:
b -= n-a
a=0
if b < 0:
b = 0
else:
a = a - n
print("%d %d" %(a,b))
| [
"expression.operation.binary.remove"
] | 622,371 | 622,369 | u527616458 | python |
p02818 | a,b,k = map(int,input().split())
if k > a:
a=0
k-=a
if k > b:
b=0
else:
b-=k
else:
a-=k
print(' '.join([str(a),str(b)])) | a,b,k = map(int,input().split())
if k > a:
k-=a
a=0
if k > b:
b=0
else:
b-=k
else:
a-=k
print(' '.join([str(a),str(b)])) | [
"assignment.remove",
"assignment.add"
] | 622,375 | 622,376 | u514894322 | python |
p02818 | A,B,K = map(int,input().split())
if (A - K) <= 0 and 0 < B - K + A :
B = B - K + A
print(0,B)
elif (A - K) <= 0 and B - K + A < 0:
print(0,0)
elif 0 < (A - K):
print(A-K,B) | A,B,K = map(int,input().split())
if (A - K) <= 0 and 0 < B - K + A :
B = B - K + A
print(0,B)
elif (A - K) <= 0 and B - K + A <= 0:
print(0,0)
elif 0 < (A - K):
print(A-K,B) | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 622,379 | 622,380 | u850772037 | python |
p02818 | a,b,k = map(int,input().split())
if k < a:
a -= k
elif a < k < a+b:
b -= (k - a)
a = 0
elif k >= a+b:
a = 0
b = 0
print("{} {}".format(a,b))
| a,b,k = map(int,input().split())
if k <= a:
a -= k
elif a < k < a+b:
b -= (k - a)
a = 0
elif k >= a+b:
a = 0
b = 0
print("{} {}".format(a,b))
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 622,383 | 622,384 | u952406466 | python |
p02818 | a, b, k =map(int,input().split())
if a>k:
print(a-k,b)
elif a+b>=k:
print(0,b-k-a)
else:
print(0,0) | a, b, k =map(int,input().split())
if a>k:
print(a-k,b)
elif a+b>=k:
print(0,b-(k-a))
else:
print(0,0) | [
"call.arguments.change"
] | 622,403 | 622,404 | u871440947 | python |
p02818 | a,b,k = map(int,input().split())
ans_a = max(a-k, 0)
ans_b = b - max(k-a,0)
print(ans_a, ans_b) | a,b,k = map(int,input().split())
ans_a = max(a-k, 0)
ans_b = max(b - max(k-a,0),0)
print(ans_a, ans_b) | [
"call.add",
"call.arguments.add"
] | 622,407 | 622,408 | u896791216 | python |
p02818 | Takahashi, Aoki, count = input().split()
tk = int(Takahashi)
ak = int(Aoki)
c = int(count)
t = 0
if tk >= c:
tk = tk - c
else:
tk = 0
c = c - tk
if ak >= c:
ak = ak - c
else:
ak = 0
print(tk, ak) | Takahashi, Aoki, count = input().split()
tk = int(Takahashi)
ak = int(Aoki)
c = int(count)
t = 0
if tk >= c:
tk = tk - c
else:
c = c - tk
tk = 0
if ak >= c:
ak = ak - c
else:
ak = 0
print(tk, ak) | [
"assignment.remove",
"assignment.add"
] | 622,441 | 622,442 | u488925368 | python |
p02818 | A, B, K = map(int, input().split())
print(max(A - K, 0), B - max(K - A, 0))
| A, B, K = map(int, input().split())
print(max(A - K, 0), max(B - max(K - A, 0), 0))
| [
"call.add",
"call.arguments.add"
] | 622,456 | 622,457 | u332906195 | python |
p02818 | A,B,K = map(int,input().split())
if A-K>=0:
print(A-K,end=" ")
print(B)
elif A-K<0 and K-A-B>=0:
print("0",end=" ")
print(B-(K-A))
else:
print("0 0") | A,B,K = map(int,input().split())
if A-K>=0:
print(A-K,end=" ")
print(B)
elif A-K<0 and A+B-K>=0:
print("0",end=" ")
print(B-(K-A))
else:
print("0 0") | [
"expression.operation.binary.remove",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 622,458 | 622,459 | u497952650 | python |
p02818 | a = list(map(int,input().split()))
A = a[0]
B = a[1]
K = a[2]
A1 = A - K
if A1 < 0:
B1 = A1 + B
A1 = 0
if B1 < 0:
B1 = 0
print(A1,end=" ")
print(B1) | a = list(map(int,input().split()))
A = a[0]
B = a[1]
K = a[2]
A1 = A - K
B1 = B
if A1 < 0:
B1 = A1 + B
A1 = 0
if B1 < 0:
B1 = 0
print(A1,end=" ")
print(B1)
| [
"assignment.add"
] | 622,462 | 622,463 | u099022530 | python |
p02818 | a,b,k=map(int,input().split())
A=max(a-k,0)
B=max(b-(k-A),0)
print(A,B) | a,b,k=map(int,input().split())
A=max(a-k,0)
B=max(b-(k-(a-A)),0)
print(A,B) | [
"call.arguments.change"
] | 622,468 | 622,469 | u314252953 | python |
p02818 | a,b,k=map(int,input().split())
#食べられた後のa
A=a
#食べられた後のb
B=b
K=k
if a>=k:
A=a-k
print(A,B)
if a<k:
B=b-(k-a)
A=0
if k-a>=b:
B=0
print(A,B)
else:
A=0
B=0
print(A,B) | a,b,k=map(int,input().split())
#食べられた後のa
A=a
#食べられた後のb
B=b
K=k
if a>=k:
A=a-k
print(A,B)
elif a<k:
B=b-(k-a)
A=0
if k-a>=b:
B=0
print(A,B)
else:
A=0
B=0
print(A,B) | [
"control_flow.branch.if.replace.remove",
"control_flow.branch.else_if.replace.add"
] | 622,472 | 622,473 | u314252953 | python |
p02818 | a, b, k = map(int, input().split())
if a >= k: print(a - k, b)
else:
print(0, max(k - a - b, b - k + a)) | a, b, k = map(int, input().split())
if a >= k: print(a - k, b)
else:
print(0, max(0, b - k + a)) | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change",
"expression.operation.binary.remove"
] | 622,477 | 622,478 | u912997017 | python |
p02818 | a,b,k = [int(i) for i in input().split()]
if a + b >= k:
print(0,0)
elif k >= a:
print(0, b - (k-a))
else:
print(a-k,b) | a,b,k = [int(i) for i in input().split()]
if a + b <= k:
print(0,0)
elif k >= a:
print(0, b - (k-a))
else:
print(a-k,b) | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 622,479 | 622,480 | u183840468 | python |
p02818 | a,b,k=map(int,input().split())
d=a+b
if(k>=d):
print("0 0")
elif(d>k and a<k):
print("0 ",d-k)
elif(d>k and a>k):
print(a-k,b)
elif(a<k and d>=k):
print("0 ",d-k)
| a,b,k=map(int,input().split())
d=a+b
if(k>=d):
print("0 0")
elif(d>k and a<k):
print("0 ",d-k)
elif(d>k and a>=k):
print(a-k,b)
elif(a<k and d>=k):
print("0 ",d-k)
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 622,481 | 622,482 | u998008108 | python |
p02818 | a, b, k = map(int, input().split())
if a >= k:
a = a-k
elif a + b >= k:
a = 0
b = b - (k-a)
else:
a = 0
b = 0
print(str(a)+" "+str(b)) | a, b, k = map(int, input().split())
if a >= k:
a = a-k
elif a + b >= k:
b = b - (k-a)
a = 0
else:
a = 0
b = 0
print(str(a)+" "+str(b)) | [
"assignment.remove",
"assignment.add"
] | 622,495 | 622,496 | u272336707 | python |
p02818 | a,b,k = map(int, input().split())
if k <= a:
print(a-k,b)
elif a<k and k<= b:
print(0,a+b-k)
else:
print(0,0) | a,b,k = map(int, input().split())
if k <= a:
print(a-k,b)
elif a<k and k-a<= b:
print(0,a+b-k)
else:
print(0,0)
| [
"control_flow.branch.if.condition.change"
] | 622,517 | 622,518 | u560988566 | python |
p02818 | a, b, k = map(int, input().split())
if a+b < k:
print('0 0')
elif a < k:
print('{} {}'.format(0, a+b-k))
else:
print('{} {}'.format(a-k, 0)) | a, b, k = map(int, input().split())
if a+b < k:
print('0 0')
elif a < k:
print('{} {}'.format(0, a+b-k))
else:
print('{} {}'.format(a-k, b))
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"io.output.change"
] | 622,525 | 622,523 | u306142032 | python |
p02818 | from sys import stdin as st
def main():
l = [int(e) for e in st.readline().split()]
if l[0] <= l[2]:
l[2] -= l[0]
l[0] = 0
if l[1] == l[2]:
print('0 0')
else:
l[1] -= l[2]
l[2] = 0
print('%d %d' % (l[0], l[1]))
else:
l[0] -= l[2]
l[2] = 0
print('%d %d' % (l[0], l[1]))
main()
| from sys import stdin as st
def main():
l = [int(e) for e in st.readline().split()]
if l[0] <= l[2]:
l[2] -= l[0]
l[0] = 0
if l[1]<=l[2]:
print('0 0')
else:
l[1] -= l[2]
l[2] = 0
print('%d %d' % (l[0], l[1]))
else:
l[0] -= l[2]
l[2] = 0
print('%d %d' % (l[0], l[1]))
main()
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 622,530 | 622,531 | u505493564 | python |
p02818 | A,B,K = map(int, input().split())
if A >= K:
print(*[A-K+B,B])
elif B >= (K-A):
print(*[0,B-K+A])
else:
print(*[0,0]) | A,B,K = map(int, input().split())
if A >= K:
print(*[A-K,B])
elif B >= (K-A):
print(*[0,B-K+A])
else:
print(*[0,0]) | [
"expression.operation.binary.remove"
] | 622,533 | 622,534 | u847758719 | python |
p02818 |
a,b,c = map(int,input().split())
if c<a:
print(a-c,b)
else:
print(0,b+a-c) | a,b,c = map(int,input().split())
if c<a:
print(a-c,b)
else:
print(0,max(b+a-c,0))
| [
"call.add",
"call.arguments.add"
] | 622,537 | 622,539 | u785578220 | python |
p02818 | a,b,k=map(int,input().split())
if a<=k:
a=0
if b<=k-a:
b=0
else:
b=b-k+a
else:
a=a-k
print(str(a)+" "+str(b)) | a,b,k=map(int,input().split())
if a<=k:
if b<=k-a:
b=0
else:
b=b-k+a
a=0
else:
a=a-k
print(str(a)+" "+str(b)) | [
"assignment.remove",
"assignment.add"
] | 622,540 | 622,541 | u723792785 | python |
p02818 | #coding:utf-8
a, b, k = map(int, input().split())
if k <= a:
a = a - k
elif a < k and k <= (a + b):
b = k - a
a = 0
elif (a + b) < k:
a = 0
b = 0
print(a, b) | #coding:utf-8
a, b, k = map(int, input().split())
if k <= a:
a = a - k
elif a < k and k <= (a + b):
b = b - (k - a)
a = 0
elif (a + b) < k:
a = 0
b = 0
print(a, b) | [
"assignment.change"
] | 622,542 | 622,543 | u167908302 | python |
p02818 | a, b, k = map(int, input())
c = min(a,k)
a -= c
k -= c
b -= min(b, k)
print(a, b) | a, b, k = map(int, input().split())
c = min(a,k)
a -= c
k -= c
b -= min(b, k)
print(a, b) | [
"call.add"
] | 622,550 | 622,551 | u114801897 | python |
p02818 | a,b,c=map(int,input().split())
if a<=c:
print(max(a+b-c,0))
else:
print(a-c) | a,b,c=map(int,input().split())
if a<=c:
print(0,max(a+b-c,0))
else:
print(a-c,b) | [
"call.arguments.add"
] | 622,554 | 622,555 | u905582793 | python |
p02818 | inpl = lambda: list(map(int,input().split()))
A, B, K = inpl()
if K <= A:
print(A, B)
elif K <= A+B:
print(0, A+B-K)
else:
print(0, 0) | inpl = lambda: list(map(int,input().split()))
A, B, K = inpl()
if K <= A:
print(A-K, B)
elif K <= A+B:
print(0, A+B-K)
else:
print(0, 0) | [
"expression.operation.binary.add"
] | 622,562 | 622,563 | u894258749 | python |
p02818 | inpl = lambda: list(map(int,input().split()))
A, B, K = inpl()
if K <= A:
print(A, B)
elif K <= A+B:
print(0, A+B-K)
else:
print(0) | inpl = lambda: list(map(int,input().split()))
A, B, K = inpl()
if K <= A:
print(A-K, B)
elif K <= A+B:
print(0, A+B-K)
else:
print(0, 0) | [
"call.arguments.add"
] | 622,564 | 622,563 | u894258749 | python |
p02818 | a=[int(i) for i in input().split()]
if a[0]+a[1]<=a[2]:
print(0,0)
else:
if a[0]<=a[2]:
print(0,a[1]-(a[2]-a[0]))
elif a[0]>a[2]:
print(a[2]-a[0],a[1]) | a=[int(i) for i in input().split()]
if a[0]+a[1]<=a[2]:
print(0,0)
else:
if a[0]<=a[2]:
print(0,a[1]-(a[2]-a[0]))
elif a[0]>a[2]:
print(a[0]-a[2],a[1]) | [
"literal.number.integer.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 622,567 | 622,569 | u557729026 | python |
p02818 | a=[int(i) for i in input().split()]
if a[0]+a[1]<=a[2]:
print(0,0)
elif a[0]<=a[2]:
print(0,a[1]-(a[2]-a[0]))
elif a[0]>a[2]:
print(a[2]-a[0],a[1]) | a=[int(i) for i in input().split()]
if a[0]+a[1]<=a[2]:
print(0,0)
else:
if a[0]<=a[2]:
print(0,a[1]-(a[2]-a[0]))
elif a[0]>a[2]:
print(a[0]-a[2],a[1]) | [
"literal.number.integer.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 622,570 | 622,569 | u557729026 | python |
p02818 | a,b,k=input().split()
if(k<=a):
print(a-k,b)
elif(k>a and k<=a+b):
print(0,b-k+a)
else:
print(0,0) | a,b,k=map(int,input().split())
if(k<=a):
print(a-k,b)
elif(k>a and k<=a+b):
print(0,b-k+a)
else:
print(0,0) | [
"call.add",
"call.arguments.change"
] | 622,577 | 622,579 | u615402829 | python |
p02818 | A,B,K=map(int,input().split())
a=0
b=0
if A>=K:
a=A-K
elif B-(K-A)>=0:
b=B-(K-A)
else:
pass
print(a,b)
| A,B,K=map(int,input().split())
a=0
b=0
if A>=K:
a=A-K
b=B
elif B-(K-A)>=0:
b=B-(K-A)
else:
pass
print(a,b)
| [
"assignment.add"
] | 622,583 | 622,584 | u547608423 | python |
p02818 | A, B, K =map(int, input().split())
if K<A:
A_after=A-K
elif K>=A:
A_after=0
if K-A<B:
B_after=B-(K-A)
elif K-A>=B:
B_after=0
print(A_after, B_after) | A, B, K =map(int, input().split())
if K<A:
A_after=A-K
B_after=B
elif K>=A:
A_after=0
if K-A<B:
B_after=B-(K-A)
elif K-A>=B:
B_after=0
print(A_after, B_after) | [
"assignment.add"
] | 622,586 | 622,587 | u985835425 | python |
p02818 | import sys
sys.setrecursionlimit(1000000000000000)
a, b, k = map(int, input().split())
if a >= k:
a = a - k
print("{} {}".format(a, b))
elif k > a and a + b >= k:
b = a + b - k
print("{} {}".format(0, b))
else:
print("{} {}".format(0, 0))
| import sys
sys.setrecursionlimit(1000000000)
a, b, k = map(int, input().split())
if a >= k:
a = a - k
print("{} {}".format(a, b))
elif k > a and a + b >= k:
b = a + b - k
print("{} {}".format(0, b))
else:
print("{} {}".format(0, 0))
| [
"literal.number.integer.change",
"call.arguments.change"
] | 622,593 | 622,594 | u931118906 | python |
p02815 | from bisect import bisect_left
n=int(input())
c=sorted(list(map(int,input().split())))
mod=10**9+7
#2のx乗を前計算(mod)(0~N-1)
p=[1]*(n+1)
for i in range(n):
p[i+1]=p[i]*2
p[i+1]%=mod
ans=0
#それ以上のもの
for i in range(n):
b=bisect_left(c,c[i])
x=n-b-1
ans+=(p[x]+x*p[x-1])*c[i]*p[b]
ans%=mod
print(ans*p[n]%mod) | from bisect import bisect_left
n=int(input())
c=sorted(list(map(int,input().split())))
mod=10**9+7
#2のx乗を前計算(mod)(0~N-1)
p=[1]*(n+1)
for i in range(n):
p[i+1]=p[i]*2
p[i+1]%=mod
ans=0
#それ以上のもの
for i in range(n):
b=bisect_left(c,c[i])
x=n-i-1
ans+=(p[x]+x*p[x-1])*c[i]*p[i]
ans%=mod
print(ans*p[n]%mod) | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"variable_access.subscript.index.change"
] | 622,630 | 622,631 | u989345508 | python |
p02805 | n=int(input())
xy=[list(map(int,input().split())) for _ in range(n)]
sgm=pow(10.-7)
def func(c):
allp=[]
for i in range(n-1):
for j in range(i+1,n):
xi,yi=xy[i]
xj,yj=xy[j]
dx=xi-xj
dy=yi-yj
d=((xi-xj)**2+(yi-yj)**2)**0.5
if c**2-(d/2)**2<0:return False
h=(c**2-(d/2)**2)**0.5
mx,my=(xi+xj)/2,(yi+yj)/2
if dx==0:
allp.append([mx-h,my])
allp.append([mx+h,my])
elif dy==0:
allp.append([mx,my-h])
allp.append([mx,my+h])
else:
dx,dy=dy,-dx
dh=(dy**2+dx**2)**0.5
dx*=h/dh
dy*=h/dh
allp.append([mx+dx,my+dy])
allp.append([mx-dx,my-dy])
for px,py in allp:
flg=True
for x,y in xy:
if ((px-x)**2+(py-y)**2)**0.5>c+sgm:
flg=False
break
if flg:
return True
return False
r=2*max([abs(x) for x,y in xy])+max([abs(y) for x,y in xy])
l,r=0,r
for i in range(300):
c=(l+r)/2
if func(c):
l,r=l,c
else:
l,r=c,r
print(c)
#print(c**2) | n=int(input())
xy=[list(map(int,input().split())) for _ in range(n)]
sgm=pow(10,-7)
def func(c):
allp=[]
for i in range(n-1):
for j in range(i+1,n):
xi,yi=xy[i]
xj,yj=xy[j]
dx=xi-xj
dy=yi-yj
d=((xi-xj)**2+(yi-yj)**2)**0.5
if c**2-(d/2)**2<0:return False
h=(c**2-(d/2)**2)**0.5
mx,my=(xi+xj)/2,(yi+yj)/2
if dx==0:
allp.append([mx-h,my])
allp.append([mx+h,my])
elif dy==0:
allp.append([mx,my-h])
allp.append([mx,my+h])
else:
dx,dy=dy,-dx
dh=(dy**2+dx**2)**0.5
dx*=h/dh
dy*=h/dh
allp.append([mx+dx,my+dy])
allp.append([mx-dx,my-dy])
for px,py in allp:
flg=True
for x,y in xy:
if ((px-x)**2+(py-y)**2)**0.5>c+sgm:
flg=False
break
if flg:
return True
return False
r=2*max([abs(x) for x,y in xy])+max([abs(y) for x,y in xy])
l,r=0,r
for i in range(400):
c=(l+r)/2
if func(c):
l,r=l,c
else:
l,r=c,r
print(c)
#print(c**2) | [
"misc.typo",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.integer.change",
"control_flow.loop.range.bounds.upper.change"
] | 622,698 | 622,699 | u707124227 | python |
p02805 | from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
return input()
def LS():
return [i for i in input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
def check(x,y,r):
for s,t in c:
if (x-s)**2+(y-t)**2>r:
return False
return True
def cir3(x1,y1,x2,y2,x3,y3):
p = ((y1-y3)*(y1**2 -y2**2 +x1**2 -x2**2) -(y1-y2)*(y1**2 -y3**2 +x1**2 -x3**2)) / (2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3))
q = ((x1-x3)*(x1**2 -x2**2 +y1**2 -y2**2) -(x1-x2)*(x1**2 -x3**2 +y1**2 -y3**2)) / (2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3))
r=((x1-p)**2+(y1-q)**2)
return p,q,r
def rot(x,y,q):
s=x*math.cos(q)-y*math.sin(q)
t=x*math.sin(q)+y*math.cos(q)
return (s,t)
def cir2(x1,y1,x2,y2):
p,q=(x1+x2)/2,(y1+y2)/2
r=((x1-p)**2+(y1-q)**2)
return p,q,r
ans=inf
n=I()
c=[]
CC=[]
rx=random.randint(1,10**3)
ry=random.randint(1,10**3)
for i in range(n):
x,y=LI()
x+=rx
y+=ry
CC.append((x,y))
def solve():
ans=inf
q=math.pi*random.randint(1,10**4)/10**4
for i in range(n):
x,y=CC[i]
x,y=rot(x,y,q)
c.append((x,y))
for i in range(n):
for j in range(i+1,n):
po=c[i]+c[j]
x1,y1,x2,y2=po
p,q,r=cir2(x1,y1,x2,y2)
if check(p,q,r):
ans=min(ans,r)
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
x1,y1,x2,y2,x3,y3=CC[i]+CC[j]+CC[k]
a,b= (x2-x1),(y2-y1)
C,D= (x3-x1),(y3-y1)
if a*D==b*C:
continue
x1,y1,x2,y2,x3,y3=c[i]+c[j]+c[k]
p,q,r=cir3(x1,y1,x2,y2,x3,y3)
if check(p,q,r):
ans=min(ans,r)
return ans
an=inf
for rn in range(1):
an=min(an,solve())
print(an**0.5)
| from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
return input()
def LS():
return [i for i in input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
class Comb:
def __init__(self,n,mo=10**9+7):
self.fac=[0]*(n+1)
self.inv=[1]*(n+1)
self.fac[0]=1
self.fact(n)
for i in range(1,n+1):
self.fac[i]=i*self.fac[i-1]%mo
self.inv[n]*=i
self.inv[n]%=mo
self.inv[n]=pow(self.inv[n],mo-2,mo)
for i in range(1,n):
self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
return
def fact(self,n):
return self.fac[n]
def invf(self,n):
return self.inv[n]
def comb(self,x,y):
if y<0 or y>x:
return 0
return self.fac[x]*self.inv[x-y]*self.inv[y]%mo
show_flg=False
show_flg=True
def check(x,y,r):
for s,t in c:
if (x-s)**2+(y-t)**2>r+1e-6:
return False
return True
def cir3(x1,y1,x2,y2,x3,y3):
p = ((y1-y3)*(y1**2 -y2**2 +x1**2 -x2**2) -(y1-y2)*(y1**2 -y3**2 +x1**2 -x3**2)) / (2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3))
q = ((x1-x3)*(x1**2 -x2**2 +y1**2 -y2**2) -(x1-x2)*(x1**2 -x3**2 +y1**2 -y3**2)) / (2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3))
r=((x1-p)**2+(y1-q)**2)
return p,q,r
def rot(x,y,q):
s=x*math.cos(q)-y*math.sin(q)
t=x*math.sin(q)+y*math.cos(q)
return (s,t)
def cir2(x1,y1,x2,y2):
p,q=(x1+x2)/2,(y1+y2)/2
r=((x1-p)**2+(y1-q)**2)
return p,q,r
ans=inf
n=I()
c=[]
CC=[]
rx=random.randint(1,10**3)
ry=random.randint(1,10**3)
for i in range(n):
x,y=LI()
x+=rx
y+=ry
CC.append((x,y))
def solve():
ans=inf
q=math.pi*random.randint(1,10**4)/10**4
for i in range(n):
x,y=CC[i]
x,y=rot(x,y,q)
c.append((x,y))
for i in range(n):
for j in range(i+1,n):
po=c[i]+c[j]
x1,y1,x2,y2=po
p,q,r=cir2(x1,y1,x2,y2)
if check(p,q,r):
ans=min(ans,r)
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
x1,y1,x2,y2,x3,y3=CC[i]+CC[j]+CC[k]
a,b= (x2-x1),(y2-y1)
C,D= (x3-x1),(y3-y1)
if a*D==b*C:
continue
x1,y1,x2,y2,x3,y3=c[i]+c[j]+c[k]
p,q,r=cir3(x1,y1,x2,y2,x3,y3)
if check(p,q,r):
ans=min(ans,r)
return ans
an=inf
for rn in range(1):
an=min(an,solve())
print(an**0.5)
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 622,724 | 622,725 | u623819879 | python |
p02805 | # 解法3(山登り法)
import numpy as np
N=int(input())
x=np.zeros([N,2])
for i in range(N):
x[i,:] = list(map(float,input().split()))
def norm(x,y):return np.sqrt(((x - y)**2).sum())
x0 = x.mean(0)
old = x0
rate = 0.05
decay = 0.99
epsilon=1e-15
while 1:
d = np.sqrt(((x - old)**2).sum(1))
max_, argmax = d.max(), d.argmax()
direction = x[argmax, :] - old
new = old + direction*rate
rate *= decay
if norm(new,old) <= epsilon:break
old = new
print(norm(direction, 0)) | # 解法3(山登り法)
import numpy as np
N=int(input())
x=np.zeros([N,2])
for i in range(N):
x[i,:] = list(map(float,input().split()))
def norm(x,y):return np.sqrt(((x - y)**2).sum())
x0 = x.mean(0)
old = x0
rate = 0.06
decay = 0.999
epsilon=1e-15
while 1:
d = np.sqrt(((x - old)**2).sum(1))
max_, argmax = d.max(), d.argmax()
direction = x[argmax, :] - old
new = old + direction*rate
rate *= decay
if norm(new,old) <= epsilon:break
old = new
print(norm(direction, 0)) | [
"literal.number.float.change",
"assignment.value.change"
] | 622,728 | 622,727 | u401686269 | python |
p02805 | # -*- coding: utf-8 -*-
import sys
import itertools
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
XY = []
for i in range(N):
x,y = map(int,readline().split())
XY.append(x+y*1j)
center = []
for z0,z1 in itertools.combinations(XY,2):
center.append((z0+z1)/2)
for z0,z1,z2 in itertools.combinations(XY,3):
a = z1-z0
b = z2-z0
nume = a*b*(a.conjugate()-b.conjugate())
deno = a.conjugate()*b - a*b.conjugate()
if deno == 0:
continue
c = nume / deno
center.append(c)
XY = np.array(XY)
center = np.array(center)
ans = abs(XY[:,None] - center[None,:]).max(axis=0).min()
print(ans) | # -*- coding: utf-8 -*-
import sys
import itertools
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
XY = []
for i in range(N):
x,y = map(int,readline().split())
XY.append(x+y*1j)
center = []
for z0,z1 in itertools.combinations(XY,2):
center.append((z0+z1)/2)
for z0,z1,z2 in itertools.combinations(XY,3):
a = z1-z0
b = z2-z0
nume = a*b*(a.conjugate()-b.conjugate())
deno = a.conjugate()*b - a*b.conjugate()
if deno == 0:
continue
c = nume / deno
c += z0
center.append(c)
XY = np.array(XY)
center = np.array(center)
ans = abs(XY[:,None] - center[None,:]).max(axis=0).min()
print(ans)
| [] | 622,731 | 622,732 | u515740713 | python |
p02805 | from numpy.linalg import det
from numpy.linalg import solve
import numpy as np
import math
def find_cross_point(x1, y1, x2, y2, x3, y3):
A = np.array([[x2-x1, y2-y1], [x3-x2, y3-y2]])
B = np.array([(x2**2+y2**2-x1**2-y1**2)/2, (x3**2+y3**2-x2**2-y2**2)/2])
if det(A) == 0:
return (float("inf"), float("inf"))
C = solve(A, B)
return C
N = int(input())
ans = 10**10
plots = []
for i in range(N):
x, y = map(int, input().split())
plots.append((x, y))
# 2点の間が直線になる時
for i in range(N):
for j in range(i+1, N):
sub = 0
m_x, m_y = (plots[i][0]+plots[j][0])/2, (plots[i][1]+plots[j][1])/2
for k in range(N):
sub = max(sub, math.hypot(m_x-plots[k][0], m_y-plots[k][1]))
ans = min(ans, sub)
# 3点を円が通る時
for i in range(N):
for j in range(i+1, N):
for k in range(j+1, N):
sub = 0
x1, y1 = plots[i]
x2, y2 = plots[j]
x3, y3 = plots[k]
mx, my = find_cross_point(x1, y1, x2, y2, x3, y3)
for p in range(N):
sub = max(sub, math.hypot(m_x-plots[p][0], m_y-plots[p][1]))
ans = min(ans, sub)
print(ans)
| from numpy.linalg import det
from numpy.linalg import solve
import numpy as np
import math
def find_cross_point(x1, y1, x2, y2, x3, y3):
A = np.array([[x2-x1, y2-y1], [x3-x2, y3-y2]])
B = np.array([(x2**2+y2**2-x1**2-y1**2)/2, (x3**2+y3**2-x2**2-y2**2)/2])
if det(A) == 0:
return (float("inf"), float("inf"))
C = solve(A, B)
return C
N = int(input())
ans = 10**10
plots = []
for i in range(N):
x, y = map(int, input().split())
plots.append((x, y))
# 2点の間が直線になる時
for i in range(N):
for j in range(i+1, N):
sub = 0
m_x, m_y = (plots[i][0]+plots[j][0])/2, (plots[i][1]+plots[j][1])/2
for k in range(N):
sub = max(sub, math.hypot(m_x-plots[k][0], m_y-plots[k][1]))
ans = min(ans, sub)
# 3点を円が通る時
for i in range(N):
for j in range(i+1, N):
for k in range(j+1, N):
sub = 0
x1, y1 = plots[i]
x2, y2 = plots[j]
x3, y3 = plots[k]
m_x, m_y = find_cross_point(x1, y1, x2, y2, x3, y3)
for p in range(N):
sub = max(sub, math.hypot(m_x-plots[p][0], m_y-plots[p][1]))
ans = min(ans, sub)
print(ans)
| [
"assignment.variable.change",
"identifier.change"
] | 622,745 | 622,746 | u780962115 | python |
p02805 | import math
from itertools import combinations
n = int(input())
xy = [list(map(int,input().split())) for i in range(n)]
def enc(i,j,k):
a,b = i
c,d = j
e,f = k
aa = a * a
bb = b * b
cc = c * c
dd = d * d
ee = e * e
ff = f * f
if (2 * (e - a)*(b - d) - 2 * (c - a) * (b - f)) == 0:
ymax = max(b,d,f)
ymin = min(b,d,f)
xmax = max(a,c,e)
xmin = min(a,c,e)
(px,py) = ((xmax-xmin)/2,(ymax-ymin)/2)
r = math.hypot(xmax-xmin,ymax-ymin)/2
else:
py = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee- ff)) / (2 * (e - a)*(b - d) - 2 * (c - a) * (b - f))
px = (2 * (b - f) * py - aa - bb + ee + ff) / (2 * (e - a)) \
if (c == a) else (2 * (b - d) * py - aa - bb + cc + dd) / (2 * (c - a))
r = math.hypot(px - a, py - b)
return (r,px,py)
def judge(r,px,py):
ls = [math.hypot(px-x,py-y) for x,y in xy]
if max(ls) <= r:
return True
else:
return False
ans = 10**18
for i,j in combinations(xy,2):
x1,y1 = i
x2,y2 = j
px = (x1+x2)/2
py = (y1+y2)/2
r = math.hypot(x1-x2,y1-y2)/2
if judge(r,px,py):
ans = min(ans,r)
for i,j,k in combinations(xy,3):
r,px,py = enc(i,j,k)
if judge(r,px,py):
ans = min(ans,r)
print(ans) | import math
from itertools import combinations
n = int(input())
xy = [list(map(int,input().split())) for i in range(n)]
def enc(i,j,k):
a,b = i
c,d = j
e,f = k
aa = a*a
bb = b*b
cc = c*c
dd = d*d
ee = e*e
ff = f*f
if (2*(e-a)*(b-d)-2*(c-a)*(b-f)) == 0:
ymax = max(b,d,f)
ymin = min(b,d,f)
xmax = max(a,c,e)
xmin = min(a,c,e)
(px,py) = ((xmax-xmin)/2,(ymax-ymin)/2)
r = math.hypot(xmax-xmin,ymax-ymin)/2
else:
py = ((e-a)*(aa+bb-cc-dd)-(c-a)*(aa+bb-ee-ff))/(2*(e-a)*(b-d)-2*(c-a)*(b-f))
px = (2*(b-f)*py-aa-bb+ee+ff)/(2*(e-a))\
if (c == a) else (2*(b-d)*py-aa-bb+cc+dd)/(2*(c-a))
r = math.hypot(px-a, py-b)
return (r,px,py)
def judge(r,px,py):
ls = [math.hypot(px-x,py-y) for x,y in xy]
if max(ls) <= r+10**-7:
return True
else:
return False
ans = 10**18
for i,j in combinations(xy,2):
x1,y1 = i
x2,y2 = j
px = (x1+x2)/2
py = (y1+y2)/2
r = math.hypot(x1-x2,y1-y2)/2
if judge(r,px,py):
ans = min(ans,r)
for i,j,k in combinations(xy,3):
r,px,py = enc(i,j,k)
if judge(r,px,py):
ans = min(ans,r)
print(ans) | [
"control_flow.branch.if.condition.change"
] | 622,773 | 622,774 | u905582793 | python |
p02805 | import math
from itertools import combinations
n = int(input())
xy = [list(map(int,input().split())) for i in range(n)]
def enc(i,j,k):
a,b = i
c,d = j
e,f = k
aa = a * a
bb = b * b
cc = c * c
dd = d * d
ee = e * e
ff = f * f
if (2 * (e - a)*(b - d) - 2 * (c - a) * (b - f)) == 0:
ymax = max(b,d,f)
ymin = min(b,d,f)
xmax = max(a,c,e)
xmin = min(a,c,e)
(px,py) = ((xmax-xmin)/2,(ymax-ymin)/2)
r = math.hypot(xmax-xmin,ymax-ymin)/2
else:
py = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee- ff)) / (2 * (e - a)*(b - d) - 2 * (c - a) * (b - f))
px = (2 * (b - f) * py - aa - bb + ee + ff) / (2 * (e - a)) \
if (c == a) else (2 * (b - d) * py - aa - bb + cc + dd) / (2 * (c - a))
r = math.hypot(px - a, py - b)
return (r,px,py)
def judge(r,px,py):
ls = [math.hypot(px-x,py-y) for x,y in xy]
if max(ls) <= r:
return True
else:
return False
ans = 10**18
for i,j in combinations(xy,2):
x1,y1 = i
x2,y2 = j
px = (x1+x2)/2
py = (y1+y2)/2
r = math.hypot(x1-x2,y1-y2)/2
if judge(r,px,py):
ans = min(ans,r)
for i,j,k in combinations(xy,3):
r,px,py = enc(i,j,k)
if judge(r,px,py):
ans = min(ans,r)
print(ans) | import math
from itertools import combinations
n = int(input())
xy = [list(map(int,input().split())) for i in range(n)]
def enc(i,j,k):
a,b = i
c,d = j
e,f = k
aa = a * a
bb = b * b
cc = c * c
dd = d * d
ee = e * e
ff = f * f
if (2 * (e - a)*(b - d) - 2 * (c - a) * (b - f)) == 0:
ymax = max(b,d,f)
ymin = min(b,d,f)
xmax = max(a,c,e)
xmin = min(a,c,e)
(px,py) = ((xmax-xmin)/2,(ymax-ymin)/2)
r = math.hypot(xmax-xmin,ymax-ymin)/2
else:
py = ((e - a) * (aa + bb - cc - dd) - (c - a) * (aa + bb - ee- ff)) / (2 * (e - a)*(b - d) - 2 * (c - a) * (b - f))
px = (2 * (b - f) * py - aa - bb + ee + ff) / (2 * (e - a)) \
if (c == a) else (2 * (b - d) * py - aa - bb + cc + dd) / (2 * (c - a))
r = math.hypot(px - a, py - b)
return (r,px,py)
def judge(r,px,py):
ls = [math.hypot(px-x,py-y) for x,y in xy]
if max(ls) <= r+10**-7:
return True
else:
return False
ans = 10**18
for i,j in combinations(xy,2):
x1,y1 = i
x2,y2 = j
px = (x1+x2)/2
py = (y1+y2)/2
r = math.hypot(x1-x2,y1-y2)/2
if judge(r,px,py):
ans = min(ans,r)
for i,j,k in combinations(xy,3):
r,px,py = enc(i,j,k)
if judge(r,px,py):
ans = min(ans,r)
print(ans) | [
"control_flow.branch.if.condition.change"
] | 622,773 | 622,775 | u905582793 | python |
p02805 | import sys; input = sys.stdin.buffer.readline
from collections import defaultdict
import math
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
def ccw(ax, ay, bx, by, cx, cy):
x1 = bx - ax; y1 = by - ay
x2 = cx - ax; y2 = cy - ay
cross = x1 * y2 - x2 * y1
if cross > 0:
return 1
elif cross < 0:
return - 1
else:
return 0
class triangle(object):
def __init__(self, Ax, Ay, Bx, By, Cx, Cy):
self.a = ((Cx - Bx) ** 2 + (Cy - By) ** 2) ** 0.5
self.b = ((Ax - Cx) ** 2 + (Ay - Cy) ** 2) ** 0.5
self.c = ((Bx - Ax) ** 2 + (By - Ay) ** 2) ** 0.5
self.alpha = math.acos((self.b ** 2 + self.c ** 2 - self.a ** 2) / (2 * self.b * self.c))
self.preA = (self.a ** 2) * (self.b ** 2 + self.c ** 2 - self.a ** 2)
self.preB = (self.b ** 2) * (self.c ** 2 + self.a ** 2 - self.b ** 2)
self.preC = (self.c ** 2) * (self.a ** 2 + self.b ** 2 - self.c ** 2)
self.Rx = (self.preA * Ax + self.preB * Bx + self.preC * Cx) / (self.preA + self.preB + self.preC)
self.Ry = (self.preA * Ay + self.preB * By + self.preC * Cy) / (self.preA + self.preB + self.preC)
self.R = self.a / (2 * math.sin(self.alpha))
def dist(Ax, Ay, Bx, By):
return (((Ax - Bx) ** 2 + (Ay - By) ** 2) ** 0.5)
def judge(N, node, R, Rx, Ry):
jud = "Yes"
for i in range(N):
x = node[i][0]; y = node[i][1]
if dist(Rx, Ry, x, y) > R:
jud = "No"
if jud == "Yes":
return R
else:
return INF
#処理内容
def main():
N = int(input())
node = []
for i in range(N):
x, y = getlist()
node.append([x, y])
if N == 2:
R = dist(node[0][0], node[0][1], node[1][0], node[1][1]) / 2
print(R)
return
ans = INF
#2点を直径とする円
for i in range(N):
for j in range(i + 1, N):
Rx = (node[i][0] + node[j][0]) / 2
Ry = (node[i][1] + node[j][1]) / 2
R = dist(node[i][0], node[i][1], node[j][0], node[j][1]) / 2
ans = min(ans, judge(N, node, R, Rx, Ry))
#3点を通る外接円
for i in range(N):
for j in range(i + 1, N):
for k in range(j + 1, N):
x1 = node[i][0]; y1 = node[i][1]
x2 = node[j][0]; y2 = node[j][1]
x3 = node[k][0]; y3 = node[k][1]
if ccw(x1, y1, x2, y2, x3, y3) == 0:
continue
T = triangle(x1, y1, x2, y2, x3, y3)
Rx = T.Rx; Ry = T.Ry; R = T.R
ans = min(ans, judge(N, node, R, Rx, Ry))
print(ans)
if __name__ == '__main__':
main() | import sys; input = sys.stdin.buffer.readline
from collections import defaultdict
import math
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
def ccw(ax, ay, bx, by, cx, cy):
x1 = bx - ax; y1 = by - ay
x2 = cx - ax; y2 = cy - ay
cross = x1 * y2 - x2 * y1
if cross > 0:
return 1
elif cross < 0:
return - 1
else:
return 0
class triangle(object):
def __init__(self, Ax, Ay, Bx, By, Cx, Cy):
self.a = ((Cx - Bx) ** 2 + (Cy - By) ** 2) ** 0.5
self.b = ((Ax - Cx) ** 2 + (Ay - Cy) ** 2) ** 0.5
self.c = ((Bx - Ax) ** 2 + (By - Ay) ** 2) ** 0.5
self.alpha = math.acos((self.b ** 2 + self.c ** 2 - self.a ** 2) / (2 * self.b * self.c))
self.preA = (self.a ** 2) * (self.b ** 2 + self.c ** 2 - self.a ** 2)
self.preB = (self.b ** 2) * (self.c ** 2 + self.a ** 2 - self.b ** 2)
self.preC = (self.c ** 2) * (self.a ** 2 + self.b ** 2 - self.c ** 2)
self.Rx = (self.preA * Ax + self.preB * Bx + self.preC * Cx) / (self.preA + self.preB + self.preC)
self.Ry = (self.preA * Ay + self.preB * By + self.preC * Cy) / (self.preA + self.preB + self.preC)
self.R = self.a / (2 * math.sin(self.alpha))
def dist(Ax, Ay, Bx, By):
return (((Ax - Bx) ** 2 + (Ay - By) ** 2) ** 0.5)
def judge(N, node, R, Rx, Ry):
jud = "Yes"
for i in range(N):
x = node[i][0]; y = node[i][1]
if dist(Rx, Ry, x, y) > R + 0.00001:
jud = "No"
if jud == "Yes":
return R
else:
return INF
#処理内容
def main():
N = int(input())
node = []
for i in range(N):
x, y = getlist()
node.append([x, y])
if N == 2:
R = dist(node[0][0], node[0][1], node[1][0], node[1][1]) / 2
print(R)
return
ans = INF
#2点を直径とする円
for i in range(N):
for j in range(i + 1, N):
Rx = (node[i][0] + node[j][0]) / 2
Ry = (node[i][1] + node[j][1]) / 2
R = dist(node[i][0], node[i][1], node[j][0], node[j][1]) / 2
ans = min(ans, judge(N, node, R, Rx, Ry))
#3点を通る外接円
for i in range(N):
for j in range(i + 1, N):
for k in range(j + 1, N):
x1 = node[i][0]; y1 = node[i][1]
x2 = node[j][0]; y2 = node[j][1]
x3 = node[k][0]; y3 = node[k][1]
if ccw(x1, y1, x2, y2, x3, y3) == 0:
continue
T = triangle(x1, y1, x2, y2, x3, y3)
Rx = T.Rx; Ry = T.Ry; R = T.R
ans = min(ans, judge(N, node, R, Rx, Ry))
print(ans)
if __name__ == '__main__':
main() | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 622,779 | 622,780 | u627417051 | python |
p02805 | import sys; input = sys.stdin.buffer.readline
from collections import defaultdict
import math
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
def ccw(ax, ay, bx, by, cx, cy):
x1 = bx - ax; y1 = by - ay
x2 = cx - ax; y2 = cy - ay
cross = x1 * y2 - x2 * y1
if cross > 0:
return 1
elif cross < 0:
return - 1
else:
return 0
class triangle(object):
def __init__(self, Ax, Ay, Bx, By, Cx, Cy):
self.a = ((Cx - Bx) ** 2 + (Cy - By) ** 2) ** 0.5
self.b = ((Ax - Cx) ** 2 + (Ay - Cy) ** 2) ** 0.5
self.c = ((Bx - Ax) ** 2 + (By - Ay) ** 2) ** 0.5
self.alpha = math.acos((self.b ** 2 + self.c ** 2 - self.a ** 2) / (2 * self.b * self.c))
self.preA = (self.a ** 2) * (self.b ** 2 + self.c ** 2 - self.a ** 2)
self.preB = (self.b ** 2) * (self.c ** 2 + self.a ** 2 - self.b ** 2)
self.preC = (self.c ** 2) * (self.a ** 2 + self.b ** 2 - self.c ** 2)
self.Rx = self.preA * Ax + self.preB * Bx + self.preC * Cx / (self.preA + self.preB + self.preC)
self.Ry = self.preA * Ay + self.preB * By + self.preC * Cy / (self.preA + self.preB + self.preC)
self.R = self.a / (2 * math.sin(self.alpha))
def dist(Ax, Ay, Bx, By):
return (((Ax - Bx) ** 2 + (Ay - By) ** 2) ** 0.5)
def judge(N, node, R, Rx, Ry):
jud = "Yes"
for i in range(N):
x = node[i][0]; y = node[i][1]
if dist(Rx, Ry, x, y) > R + 0.000001:
jud = "No"
if jud == "Yes":
return R
else:
return INF
#処理内容
def main():
N = int(input())
node = []
for i in range(N):
x, y = getlist()
node.append([x, y])
if N == 2:
R = dist(node[0][0], node[0][1], node[1][0], node[1][1]) / 2
print(R)
return
ans = INF
#2点を直径とする円
for i in range(N):
for j in range(i + 1, N):
Rx = (node[i][0] + node[j][0]) / 2
Ry = (node[i][1] + node[j][1]) / 2
R = dist(node[i][0], node[i][1], node[j][0], node[j][1]) / 2
ans = min(ans, judge(N, node, R, Rx, Ry))
#3点を通る外接円
for i in range(N):
for j in range(i + 1, N):
for k in range(j + 1, N):
x1 = node[i][0]; y1 = node[i][1]
x2 = node[j][0]; y2 = node[j][1]
x3 = node[k][0]; y3 = node[k][1]
if ccw(x1, y1, x2, y2, x3, y3) == 0:
continue
T = triangle(x1, y1, x2, y2, x3, y3)
Rx = T.Rx; Ry = T.Ry; R = T.R
ans = min(ans, judge(N, node, R, Rx, Ry))
print(ans)
if __name__ == '__main__':
main() | import sys; input = sys.stdin.buffer.readline
from collections import defaultdict
import math
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
def ccw(ax, ay, bx, by, cx, cy):
x1 = bx - ax; y1 = by - ay
x2 = cx - ax; y2 = cy - ay
cross = x1 * y2 - x2 * y1
if cross > 0:
return 1
elif cross < 0:
return - 1
else:
return 0
class triangle(object):
def __init__(self, Ax, Ay, Bx, By, Cx, Cy):
self.a = ((Cx - Bx) ** 2 + (Cy - By) ** 2) ** 0.5
self.b = ((Ax - Cx) ** 2 + (Ay - Cy) ** 2) ** 0.5
self.c = ((Bx - Ax) ** 2 + (By - Ay) ** 2) ** 0.5
self.alpha = math.acos((self.b ** 2 + self.c ** 2 - self.a ** 2) / (2 * self.b * self.c))
self.preA = (self.a ** 2) * (self.b ** 2 + self.c ** 2 - self.a ** 2)
self.preB = (self.b ** 2) * (self.c ** 2 + self.a ** 2 - self.b ** 2)
self.preC = (self.c ** 2) * (self.a ** 2 + self.b ** 2 - self.c ** 2)
self.Rx = (self.preA * Ax + self.preB * Bx + self.preC * Cx) / (self.preA + self.preB + self.preC)
self.Ry = (self.preA * Ay + self.preB * By + self.preC * Cy) / (self.preA + self.preB + self.preC)
self.R = self.a / (2 * math.sin(self.alpha))
def dist(Ax, Ay, Bx, By):
return (((Ax - Bx) ** 2 + (Ay - By) ** 2) ** 0.5)
def judge(N, node, R, Rx, Ry):
jud = "Yes"
for i in range(N):
x = node[i][0]; y = node[i][1]
if dist(Rx, Ry, x, y) > R + 0.00001:
jud = "No"
if jud == "Yes":
return R
else:
return INF
#処理内容
def main():
N = int(input())
node = []
for i in range(N):
x, y = getlist()
node.append([x, y])
if N == 2:
R = dist(node[0][0], node[0][1], node[1][0], node[1][1]) / 2
print(R)
return
ans = INF
#2点を直径とする円
for i in range(N):
for j in range(i + 1, N):
Rx = (node[i][0] + node[j][0]) / 2
Ry = (node[i][1] + node[j][1]) / 2
R = dist(node[i][0], node[i][1], node[j][0], node[j][1]) / 2
ans = min(ans, judge(N, node, R, Rx, Ry))
#3点を通る外接円
for i in range(N):
for j in range(i + 1, N):
for k in range(j + 1, N):
x1 = node[i][0]; y1 = node[i][1]
x2 = node[j][0]; y2 = node[j][1]
x3 = node[k][0]; y3 = node[k][1]
if ccw(x1, y1, x2, y2, x3, y3) == 0:
continue
T = triangle(x1, y1, x2, y2, x3, y3)
Rx = T.Rx; Ry = T.Ry; R = T.R
ans = min(ans, judge(N, node, R, Rx, Ry))
print(ans)
if __name__ == '__main__':
main() | [
"literal.number.float.change",
"control_flow.branch.if.condition.change"
] | 622,781 | 622,780 | u627417051 | python |
p02805 | import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n = int(input())
C = [complex(*map(int, input().split())) for _ in range(n)]
res = INF
for k in range(n):
p1 = C[k]
for j in range(k):
p2 = C[j]
for i in range(j):
p3 = C[i]
a = abs(p2 - p3) ** 2
b = abs(p3 - p1) ** 2
c = abs(p1 - p2) ** 2
numerator = a * (b + c - a) * p1 + b * (c + a - b) * p2 + c * (a + b - c) * p3
denominator = a * (b* + c - a) + b * (c + a - b) + c * (a + b - c)
if denominator == 0.0:
continue
center = numerator / denominator
radius = -INF
for p in C:
radius = max(radius, abs(center - p))
res = min(radius, res)
for j in range(n):
for i in range(n):
center = (C[i] + C[j]) / 2
radius = -INF
for p in C:
radius = max(radius, abs(center - p))
res = min(radius, res)
print(res)
resolve() | import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n = int(input())
C = [complex(*map(int, input().split())) for _ in range(n)]
res = INF
for k in range(n):
p1 = C[k]
for j in range(k):
p2 = C[j]
for i in range(j):
p3 = C[i]
a = abs(p2 - p3) ** 2
b = abs(p3 - p1) ** 2
c = abs(p1 - p2) ** 2
numerator = a * (b + c - a) * p1 + b * (c + a - b) * p2 + c * (a + b - c) * p3
denominator = a * (b + c - a) + b * (c + a - b) + c * (a + b - c)
if denominator == 0.0:
continue
center = numerator / denominator
radius = -INF
for p in C:
radius = max(radius, abs(center - p))
res = min(radius, res)
for j in range(n):
for i in range(n):
center = (C[i] + C[j]) / 2
radius = -INF
for p in C:
radius = max(radius, abs(center - p))
res = min(radius, res)
print(res)
resolve() | [] | 622,789 | 622,790 | u440566786 | python |
p02805 | N=int(input())
XY=[list(map(int,input().split())) for i in range(N)]
from itertools import combinations
a=9999
def f(X,Y,R2,a):
if not any([(X-x)**2+(Y-y)**2>R2 for x,y in XY]):
a=min(a,R2**.5)
return a
for (x1,y1),(x2,y2),(x3,y3) in combinations(XY,3):
e1=(x2-x3)**2+(y2-y3)**2
e2=(x3-x1)**2+(y3-y1)**2
e3=(x1-x2)**2+(y1-y2)**2
p=e1*(e2+e3-e1)
q=e2*(e3+e1-e2)
r=e3*(e1+e2-e3)
if p+q+r==0:continue
X=(p*x1+q*x2*r*x3)/(p+q+r)
Y=(p*y1+q*y2+r*y3)/(p+q+r)
R2=(X-x1)**2+(Y-y1)**2+10e-15
a=f(X,Y,R2,a)
for (x1,y1),(x2,y2) in combinations(XY,2):
X=(x1+x2)/2
Y=(y1+y2)/2
R2=(X-x1)**2+(Y-y1)**2+10e-15
a=f(X,Y,R2,a)
print(a) | N=int(input())
XY=[list(map(int,input().split())) for i in range(N)]
from itertools import combinations
a=9999
def f(X,Y,R2,a):
if all([(X-x)**2+(Y-y)**2<R2 for x,y in XY]):
a=min(a,R2**.5)
return a
for (x1,y1),(x2,y2),(x3,y3) in combinations(XY,3):
e1=(x2-x3)**2+(y2-y3)**2
e2=(x3-x1)**2+(y3-y1)**2
e3=(x1-x2)**2+(y1-y2)**2
p=e1*(e2+e3-e1)
q=e2*(e3+e1-e2)
r=e3*(e1+e2-e3)
if p+q+r==0:continue
X=(p*x1+q*x2+r*x3)/(p+q+r)
Y=(p*y1+q*y2+r*y3)/(p+q+r)
R2=(X-x1)**2+(Y-y1)**2+10e-9
a=f(X,Y,R2,a)
for (x1,y1),(x2,y2) in combinations(XY,2):
X=(x1+x2)/2
Y=(y1+y2)/2
R2=(X-x1)**2+(Y-y1)**2+10e-9
a=f(X,Y,R2,a)
print(a) | [
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.compare.change",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"literal.number.float.change"
] | 622,817 | 622,818 | u509368316 | python |
p02818 | # your code goes here
a,b,c=map(int,input().split())
if a==0 and b==0:
print("0 0")
elif a==0 and b>0:
if b>c:
print("0",b-c)
elif c>=b:
print("0 0")
elif b==0 and a>0:
if a>c:
print(a-c,"0")
elif c>=a:
print("0 0")
elif a+b==c:
print("0 0")
elif a>c:
print(a-c,'',b)
elif c>=a:
i=c-a;
if(b>i):
j=b-i
else:
j=i-b
print("0",j) | # your code goes here
a,b,c=map(int,input().split())
if a==0 and b==0:
print("0 0")
elif a==0 and b>0:
if b>c:
print("0",b-c)
elif c>=b:
print("0 0")
elif b==0 and a>0:
if a>c:
print(a-c,"0")
elif c>=a:
print("0 0")
elif a+b==c:
print("0 0")
elif a>c:
print(a-c,'',b)
elif c>=a:
i=c-a;
if(b>i):
j=b-i
else:
j=0
print("0",j) | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 622,829 | 622,830 | u586273727 | python |
p02818 | A,B,K=map(int,input().split())
if A-K<=0:
B=B+A-K
A=0
if B<=0:
B=0
if A-K>0:
B=B-(A-K)
A=A-K
print(A,B)
| A,B,K=map(int,input().split())
if A-K<=0:
B=B+A-K
A=0
if B<=0:
B=0
if A-K>0:
B=B
A=A-K
print(A,B)
| [
"expression.operation.binary.remove"
] | 622,831 | 622,832 | u503294750 | python |
p02818 | a,b,k=map(int,input().split())
cnt=0
if k>=(a+b):
print("{} {}".format(0,0))
elif k>=a and k-a<=b:
print("{} {}".format(0,b-k-a))
elif k<a:
print("{} {}".format(a-k,b)) | a,b,k=map(int,input().split())
cnt=0
if k>=(a+b):
print("{} {}".format(0,0))
elif k>=a and k-a<=b:
print("{} {}".format(0,b-k+a))
elif k<a:
print("{} {}".format(a-k,b)) | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 622,844 | 622,845 | u061127257 | python |
p02818 | a, b, k = [int(i) for i in input().split(' ')]
if(k>a):
k -= a
a = 0
if(k>b):
b = 0
else:
b -= k
print(str(a) + ' ' + str(b)) | a, b, k = [int(i) for i in input().split(' ')]
if(k>a):
k -= a
a = 0
if(k>b):
b = 0
else:
b -= k
else:
a -= k
print(str(a) + ' ' + str(b)) | [] | 622,855 | 622,856 | u278296307 | python |
p02818 | in_li = list(map(int,input().split()))
A = in_li[0]
B = in_li[1]
K = in_li[2]
if A + B >= K :
print("0 0")
else :
if A > K :
print(A-K,"",B)
elif B > K - A :
print("0",B-(K-A))
| in_li = list(map(int,input().split()))
A = in_li[0]
B = in_li[1]
K = in_li[2]
if A + B <= K :
print("0 0")
else :
if A > K :
print(A-K,"",B)
elif B > K - A :
print("0",B-(K-A))
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 622,863 | 622,864 | u028733310 | python |
p02818 | # -*- coding: utf-8 -*-
A, B, K=map(int, input().split())
if K >= A:
K1 = K - A
A = 0
if K1 >= B:
B = 0
else:
B = B - K1
else:
A = K - A
print(A, B) | # -*- coding: utf-8 -*-
A, B, K=map(int, input().split())
if K >= A:
K1 = K - A
A = 0
if K1 >= B:
B = 0
else:
B = B - K1
else:
A = A - K
print(A, B) | [
"expression.operation.binary.remove"
] | 622,869 | 622,870 | u662062459 | python |
p02818 | A,B,K = map(int, input().split())
if A >= K:
A = A - K
if A < K:
B = B - K + A
A = 0
if B < 0:
B = 0
print(A,B) | A,B,K = map(int, input().split())
if A >= K:
A = A - K
elif A < K:
B = B - K + A
A = 0
if B < 0:
B = 0
print(A,B) | [
"control_flow.branch.if.replace.remove",
"control_flow.branch.else_if.replace.add"
] | 622,884 | 622,885 | u528793636 | python |
p02818 | a, b, k = map(int, input().split())
if a >= k:
print(a - k, b)
else:
print(0, b - (k - a)) | a, b, k = map(int, input().split())
if a >= k:
print(a - k, b)
else:
print(0, max(0, b - (k - a))) | [
"call.arguments.add",
"call.arguments.change"
] | 622,890 | 622,891 | u340781749 | python |
p02818 | [a, b, k] = [int(x) for x in input().split()]
if a>=k:
a=a-k
else:
a=0
k=k-a
if b>=k:
b=b-k
else:
b=0
print(int(a),int(b)) | [a, b, k] = [int(x) for x in input().split()]
if a>=k:
a=a-k
else:
k=k-a
a=0
if b>=k:
b=b-k
else:
b=0
print(int(a),int(b)) | [
"assignment.remove",
"assignment.add"
] | 622,892 | 622,893 | u010462426 | python |
p02818 | #!python3
def resolve():
A, B, K = map(int, input().rstrip().split())
if K < A:
print(K- A, B)
elif K < A + B:
print(0, A + B -K)
else:
print(0, 0)
if __name__ == "__main__":
resolve()
| #!python3
def resolve():
A, B, K = map(int, input().rstrip().split())
if K < A:
print(A-K, B)
elif K < A + B:
print(0, A + B -K)
else:
print(0, 0)
if __name__ == "__main__":
resolve()
| [
"expression.operation.binary.remove"
] | 622,898 | 622,899 | u348805958 | python |
p02818 | A,B,K = map(int, input().split())
if A <= K:
K = K - A
else:
print(0, B)
exit()
if B <= K:
print(0, 0)
else:
print(0, B - K)
| A,B,K = map(int, input().split())
if A < K:
K = K - A
else:
print(A - K, B)
exit()
if B < K:
print(0, 0)
else:
print(0, B - K)
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"io.output.change"
] | 622,909 | 622,910 | u643797323 | python |
p02818 | a,b,k=map(int,input())
if a+b<=k:print(0,0)
elif a<=k:print(0,a+b-k)
else:print(a-k,b) | a,b,k=map(int,input().split())
if a+b<=k:print(0,0)
elif a<=k:print(0,a+b-k)
else:print(a-k,b) | [
"call.add"
] | 622,913 | 622,914 | u170765582 | python |
p02818 | A, B, K = map(int, input().split())
if A > K:
print(A-K, B)
elif A < K and (A + B) > K:
print(0, A + B - K)
else:
print(0, 0)
| A, B, K = map(int, input().split())
if A >= K:
print(A-K, B)
elif A < K and (A + B) > K:
print(0, A + B - K)
else:
print(0, 0)
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 622,915 | 622,916 | u861141787 | python |
p02818 | a,b,c=map(int,input().split())
tmp=a-c
if (tmp<=0):
a=0
b=0 if b<-tmp else b+tmp
else:
a=a-tmp
print (a, b) | a,b,c=map(int,input().split())
tmp=a-c
if (tmp<=0):
a=0
b=0 if b<-tmp else b+tmp
else:
a=tmp
print (a, b) | [
"expression.operation.binary.remove"
] | 622,919 | 622,920 | u875028418 | python |
p02818 | a,b,k=map(int,input().split())
if k>a+b:
print('0 0')
if k>a:
print('0 {}'.format(b-k+a))
else:
print('{} {}'.format(a-k,b)) | a,b,k=map(int,input().split())
if k>a+b:
print('0 0')
elif k>a:
print('0 {}'.format(b-k+a))
else:
print('{} {}'.format(a-k,b))
| [
"control_flow.branch.if.replace.remove",
"control_flow.branch.else_if.replace.add"
] | 622,923 | 622,924 | u007808656 | python |
p02818 | A,B,K=map(int,input().split())
if A>=K:
print(str(A-k)+" "+str(B))
else:
if A+B>=K:
print("0 "+str(A+B-K))
else:
print("0 0") | A,B,K=map(int,input().split())
if A>=K:
print(str(A-K)+" "+str(B))
else:
if A+B>=K:
print("0 "+str(A+B-K))
else:
print("0 0") | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 622,927 | 622,928 | u051684204 | python |
p02818 | a, b, k = map(int, input().split())
if a < k:
k = k - a
a = 0
else:
k = k - a
a = a - k
if k < 0:
k = 0
b = b - k
if b < 0:
b = 0
print("{}".format(a) + " {}".format(b))
| a, b, k = map(int, input().split())
p = k
if a < k:
k = k - a
a = 0
else:
k = k - a
a = a - p
if k < 0:
k = 0
b = b - k
if b < 0:
b = 0
print("{}".format(a) + " {}".format(b))
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 622,935 | 622,936 | u700705777 | python |
p02818 | a,b,k = [int(i) for i in input().split()]
if a-k>0:
print(a-k,b)
else:
print(0,min(0,b-(k-a))) | a,b,k = [int(i) for i in input().split()]
if a-k>0:
print(a-k,b)
else:
print(0,max(0,b-(k-a))) | [
"misc.opposites",
"identifier.change",
"call.function.change",
"call.arguments.change",
"io.output.change"
] | 622,947 | 622,948 | u211706121 | python |
p02818 | a,b,k = [int(i) for i in input().split()]
if a-k>0:
print(a-k,b)
else:
print(0,b-(k-a)) | a,b,k = [int(i) for i in input().split()]
if a-k>0:
print(a-k,b)
else:
print(0,max(0,b-(k-a))) | [
"call.arguments.add",
"call.arguments.change"
] | 622,949 | 622,948 | u211706121 | python |
p02818 | cookies = [int(x) for x in input().split()]
leftOver = cookies[0] - cookies[2]
takahashi = max(0,leftOver)
print(str(takahashi)+''+(str(cookies[1])
if takahashi > 0
else str(max(0,cookies[1] - abs(leftOver)))))
| cookies = [int(x) for x in input().split()]
leftOver = cookies[0] - cookies[2]
takahashi = max(0, leftOver)
print(str(takahashi)+ ' ' + (str(cookies[1]) if takahashi > 0 else str(max(0,cookies[1] - abs(leftOver)))))
| [
"literal.string.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 622,952 | 622,953 | u213314609 | python |
p02818 | cookies = [int(x) for x in input().split()]
leftOver = cookies[0] - cookies[2]
takahashi = max(0,leftOver)
print(str(takahashi)+''+(str(cookies[1])
if takahashi > 0
else str(max(0,cookies[1] - abs(leftOver)))))
| cookies = [int(x) for x in input().split()]
leftOver = cookies[0] - cookies[2]
takahashi = max(0, leftOver)
print(str(takahashi)+ ' ' + (str(cookies[1]) if takahashi > 0 else str(max(0,cookies[1] - abs(leftOver))))) | [
"literal.string.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 622,952 | 622,954 | u213314609 | python |
p02818 | A,B,K=list(map(int,input().split()))
if A>=K:
print(A-K,B)
else:
K-=A
print(0,B-K) | A,B,K=list(map(int,input().split()))
if A>=K:
print(A-K,B)
else:
K-=A
print(0,max(B-K,0)) | [
"call.add",
"call.arguments.add",
"call.arguments.change"
] | 622,955 | 622,956 | u079022693 | python |
p02818 | a,b,k = map(int, input().split())
if a>=k:
print(a-k,b)
elif k>=a+b:
print(0,0)
else:
print(0,str(b-a+k)) | a,b,k = map(int, input().split())
if a>=k:
print(a-k,b)
elif k>=a+b:
print(0,0)
else:
print(0,str(b-k+a)) | [
"expression.operation.binary.remove"
] | 622,959 | 622,960 | u717265305 | python |
p02818 | a,b,k = (int(x) for x in input().split())
if k >= a :
if k >= b :
if a + b >= k :
a1 = 0
b1 = b - k + a
else :
a1 = 0
b1 = 0
else :
a1 = 0
b1 = b - k + a
else :
a1 = a - k
print(a1,b1) | a,b,k = (int(x) for x in input().split())
if k >= a :
if k >= b :
if a + b >= k :
a1 = 0
b1 = b - k + a
else :
a1 = 0
b1 = 0
else :
a1 = 0
b1 = b - k + a
else :
a1 = a - k
b1 = b
print(a1,b1) | [
"assignment.add"
] | 622,963 | 622,964 | u000840710 | python |
p02818 | a, b, k = map(int, input().split())
m = min(a, k)
a -= m
k -= m
m = min(b, k)
b -= k
print(a, b) | a, b, k = map(int, input().split())
m = min(a, k)
a -= m
k -= m
m = min(b, k)
b -= m
print(a, b) | [
"identifier.change"
] | 622,978 | 622,979 | u830390742 | python |
p02818 | a,b,k = list(map(int, input().split()))
if a >= k:
print(a-k,b)
if b >= k-a:
print(0,b + (a - k))
print(0, 0)
| a,b,k = list(map(int, input().split()))
if a >= k:
print(a-k,b)
elif b >= k-a:
print(0,b + (a - k))
else:
print(0,0)
| [
"control_flow.branch.if.replace.remove",
"control_flow.branch.else_if.replace.add"
] | 622,985 | 622,986 | u545221414 | python |
p02818 | a,b,k = map(int,input().split())
if a >= k:
print(a-k,b)
else:
if a + b < k:
print("0,0")
else:
print(0,b-(k-a))
| a,b,k = map(int,input().split())
if a >= k:
print(a-k,b)
else:
if a + b < k:
print("0 0")
else:
print(0,b-(k-a)) | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 622,989 | 622,990 | u806392288 | python |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.