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 9
values |
|---|---|---|---|---|---|---|---|
p02767
|
N = int(input())
X = list(map(int,input().split()))
avex = round(sum(X)/N)
sumX = 0
for x in X:
sumX = sumX + (x - 20) ** 2
print(sumX)
|
N = int(input())
X = list(map(int,input().split()))
avex = round(sum(X)/N)
sumX = 0
for x in X:
sumX = sumX + (x - avex) ** 2
print(sumX)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 563,370
| 563,371
|
u486251525
|
python
|
p02767
|
N = int(input())
X = list(map(int,input().split()))
avex = round(sum(X)/N)
print(avex)
sumX = 0
for x in X:
sumX = sumX + (x - 20) ** 2
print(sumX)
|
N = int(input())
X = list(map(int,input().split()))
avex = round(sum(X)/N)
sumX = 0
for x in X:
sumX = sumX + (x - avex) ** 2
print(sumX)
|
[
"call.remove",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 563,372
| 563,371
|
u486251525
|
python
|
p02767
|
N = int(input())
X = list(map(int, input().split(' ')))
distlist = [10000] * 101
for P in range(1, 101):
dist = 0
for Xi in X:
dist += (Xi - P) ** 2
distlist[P] = dist
print(min(distlist))
|
N = int(input())
X = list(map(int, input().split(' ')))
distlist = [1000000] * 101
for P in range(1, 101):
dist = 0
for Xi in X:
dist += (Xi - P) ** 2
distlist[P] = dist
print(min(distlist))
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 563,375
| 563,376
|
u211203739
|
python
|
p02767
|
n = int(input())
za = list(map(int,input().split()))
print(za)
za_max = max(za)
za_min = min(za)
kouho = 0
kouho_sum = 0
ans = 9999999999999999999999999999999999999999999999999999999999999999999999999999
for zahyou in range(za_min,za_max+1):
for i in za:
kouho = (i - zahyou)*(i - zahyou)
kouho_sum = kouho_sum + kouho
if(ans > kouho_sum):
ans = kouho_sum
kouho_sum = 0
print(ans)
|
n = int(input())
za = list(map(int,input().split()))
za_max = max(za)
za_min = min(za)
kouho = 0
kouho_sum = 0
ans = 9999999999999999999999999999999999999999999999999999999999999999999999999999
for zahyou in range(za_min,za_max+1):
for i in za:
kouho = (i - zahyou)*(i - zahyou)
kouho_sum = kouho_sum + kouho
if(ans > kouho_sum):
ans = kouho_sum
kouho_sum = 0
print(ans)
|
[
"call.remove"
] | 563,379
| 563,380
|
u178304274
|
python
|
p02767
|
N = int(input())
x_list = list(map(int, input().split()))
max_x = max(x_list)
min_x = min(x_list)
each_value_list = []
min_value = 10e1000
for i in range(min_x, max_x + 1):
print(i)
tmp_sum = 0
for x in x_list:
tmp_sum += (x - i)**2
if min_value > tmp_sum:
min_value = tmp_sum
print(min_value)
|
N = int(input())
x_list = list(map(int, input().split()))
max_x = max(x_list)
min_x = min(x_list)
each_value_list = []
min_value = 10e1000
for i in range(min_x, max_x + 1):
tmp_sum = 0
for x in x_list:
tmp_sum += (x - i)**2
if min_value > tmp_sum:
min_value = tmp_sum
print(min_value)
|
[
"call.remove"
] | 563,384
| 563,385
|
u381574135
|
python
|
p02767
|
N = int(input())
x_list = list(map(int, input().split()))
max_x = max(x_list)
min_x = min(x_list)
each_value_list = []
min_value = 10e1000
for i in range(min_x, max_x):
tmp_sum = 0
for x in x_list:
tmp_sum += (x - i)**2
if min_value > tmp_sum:
min_value = tmp_sum
print(min_value)
|
N = int(input())
x_list = list(map(int, input().split()))
max_x = max(x_list)
min_x = min(x_list)
each_value_list = []
min_value = 10e1000
for i in range(min_x, max_x + 1):
tmp_sum = 0
for x in x_list:
tmp_sum += (x - i)**2
if min_value > tmp_sum:
min_value = tmp_sum
print(min_value)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,386
| 563,385
|
u381574135
|
python
|
p02767
|
import math
def main():
n = int(input())
array = [int(s) for s in input().split(" ")]
total = 0
min_v = min(array)
max_v = max(array)
min_ans = float("inf")
for i in range(min_v, max_v):
total = 0
for a in array:
total += (a - i) ** 2
if min_ans > total:
min_ans = total
print(min_ans)
if __name__ == '__main__':
main()
|
import math
def main():
n = int(input())
array = [int(s) for s in input().split(" ")]
min_v = min(array)
max_v = max(array)
min_ans = float("inf")
for i in range(min_v, max_v + 1):
total = 0
for a in array:
total += (a - i) ** 2
if min_ans > total:
min_ans = total
print(min_ans)
if __name__ == '__main__':
main()
|
[
"assignment.remove",
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,392
| 563,393
|
u628907033
|
python
|
p02767
|
N = int(input())
X = list(map(int,input().rstrip().split(" ")))
ans = 0
ansb = 0
for i in range(100):
ansb = 0
for i2 in range(N):
ansb += (X[i2] - i)**2
if ans == 0 or ans > ansb:
ans = ansb
print(ans)
|
N = int(input())
X = list(map(int,input().rstrip().split(" ")))
ans = 0
ansb = 0
for i in range(100):
ansb = 0
for i2 in range(N):
ansb += (X[i2] - i)**2
if i == 0 or ans > ansb:
ans = ansb
print(ans)
|
[
"identifier.change",
"control_flow.branch.if.condition.change"
] | 563,396
| 563,397
|
u017050982
|
python
|
p02767
|
n=int(input())
xl=list(map(int,input().split()))
ans=[]
for p in range(xl[-1]-xl[0]+1):
sum1=0
for xi in xl:
sum1+=(xi-xl[0]-p)**2
ans.append(sum1)
print(min(ans))
|
n=int(input())
xl=list(map(int,input().split()))
xl.sort()
ans=[]
for p in range(xl[-1]-xl[0]+1):
sum1=0
for xi in xl:
sum1+=(xi-xl[0]-p)**2
ans.append(sum1)
print(min(ans))
|
[
"call.add"
] | 563,400
| 563,401
|
u755801379
|
python
|
p02767
|
# coding:utf-8
import sys
import math
import time
#import numpy as np
import collections
from collections import deque
import queue
import copy
#X = str(input()).split()
#a = [int(x) for x in input().split()]
N = int(input())
X = [int(x) for x in input().split()]
ans = 9999999999
su = 0
X.sort()
xm = max(X)
for i in range(xm):
for j in range(N):
su += (X[j]-i)**2
ans = min(ans, su)
su = 0
print(ans)
|
# coding:utf-8
import sys
import math
import time
#import numpy as np
import collections
from collections import deque
import queue
import copy
#X = str(input()).split()
#a = [int(x) for x in input().split()]
N = int(input())
X = [int(x) for x in input().split()]
ans = 9999999999
su = 0
X.sort()
xm = max(X)
for i in range(xm+1):
for j in range(N):
su += (X[j]-i)**2
ans = min(ans, su)
su = 0
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,408
| 563,409
|
u395117343
|
python
|
p02767
|
def resolve():
import math
n = int(input())
x = list(map(int,input().split()))
b = math.ceil(sum(x)/n)
m = 0
for i in x:
m += (i-b) * (i-b)
print(m)
resolve()
|
def resolve():
n = int(input())
x = list(map(int,input().split()))
b = round(sum(x)/n)
m = 0
for i in x:
m += (i-b) * (i-b)
print(m)
resolve()
|
[
"assignment.value.change"
] | 563,410
| 563,411
|
u777394984
|
python
|
p02767
|
N=int(input())
A=list(map(int, input().split()))
res=float("inf")
for i in range(max(A)):
res1=0
for j in range(len(A)):
res1=res1+(A[j]-i)**2
res=min(res,res1)
print(res)
|
N=int(input())
A=list(map(int, input().split()))
res=float("inf")
for i in range(max(A)+1):
res1=0
for j in range(len(A)):
res1=res1+(A[j]-i)**2
res=min(res,res1)
print(res)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,412
| 563,413
|
u830592648
|
python
|
p02767
|
N = int(input())
#x = map(int, input().split())
x = list(map(int, input().split()))
#s = float('Inf')
s = float('Inf')
for i in range(min(x), max(x)):
score = 0
for j in x:
score += (j - i)**2
s = min(s, score)
print(s)
|
N = int(input())
#x = map(int, input().split())
x = list(map(int, input().split()))
#s = float('Inf')
s = float('Inf')
for i in range(min(x), max(x) + 1):
score = 0
for j in x:
score += (j - i)**2
s = min(s, score)
print(s)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,414
| 563,415
|
u038408819
|
python
|
p02767
|
n=int(input())
x_list = list(map(int,input().split()))
min = min(x_list)
max = max(x_list)
sum_min = 10000000000
for target_i in range(min, max):
sum_tmp = 0
for i in range(n):
sum_tmp += (target_i - x_list[i]) ** 2
if sum_min >= sum_tmp:
sum_min = sum_tmp
print(sum_min)
|
n=int(input())
x_list = list(map(int,input().split()))
min = min(x_list)
max = max(x_list)
sum_min = 1000000000000000000
for target_i in range(1, 101):
sum_tmp = 0
for i in range(n):
sum_tmp += (target_i - x_list[i]) ** 2
if sum_min >= sum_tmp:
sum_min = sum_tmp
print(sum_min)
|
[
"literal.number.integer.change",
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"control_flow.loop.range.bounds.lower.change",
"control_flow.loop.range.bounds.upper.change"
] | 563,418
| 563,419
|
u024768467
|
python
|
p02767
|
n=int(input())
x=list(map(int,input().split()))
result=0
for p in range(1,max(x)):
s=0
for i in range(0,n):
s+=(x[i]-p)**2
if p==1:
result=s
else:
if s<result:
result=s
print(result)
|
n=int(input())
x=list(map(int,input().split()))
result=0
for p in range(0,max(x)+1):
s=0
for i in range(0,n):
s+=(x[i]-p)**2
if p==0:
result=s
else:
if s<result:
result=s
print(result)
|
[
"literal.number.integer.change",
"call.arguments.change",
"control_flow.loop.range.bounds.lower.change",
"control_flow.branch.if.condition.change"
] | 563,430
| 563,431
|
u404639509
|
python
|
p02767
|
#!/use/bin/env python3
from collections import defaultdict
n = int(input())
x_n = [int(s) for s in input().split()]
s = sorted(x_n)
ans = 1e18
for p in range(s[0], s[-1]):
l = sum([int(pow(x - p, 2)) for x in s])
if l < ans:
ans = l
print(ans)
|
#!/use/bin/env python3
from collections import defaultdict
n = int(input())
x_n = [int(s) for s in input().split()]
s = sorted(x_n)
ans = 1e18
for p in range(s[0], s[-1] + 1):
l = sum([pow(x - p, 2) for x in s])
if l < ans:
ans = l
print(ans)
|
[
"call.remove",
"call.arguments.change"
] | 563,439
| 563,440
|
u734936991
|
python
|
p02767
|
n=int(input())
x=[int(i) for i in input().split(" ")]
x=sorted(x)
mind=-1
for i in range(x[0],x[len(x)-1]):
sum=0
for j in x:
sum+=(j-i)**2
if mind>sum or mind==-1:
mind=sum
print(mind)
|
n=int(input())
x=[int(i) for i in input().split(" ")]
x=sorted(x)
mind=-1
for i in range(x[0],x[len(x)-1]+1):
sum=0
for j in x:
sum+=(j-i)**2
if mind>sum or mind==-1:
mind=sum
print(mind)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,445
| 563,446
|
u196297781
|
python
|
p02767
|
n=int(input())
x=[int(i) for i in input().split(" ")]
x=sorted(x)
mind=-1
for i in range(x[0],int(x[len(x)-1]/2+1)):
sum=0
for j in x:
sum+=(j-i)**2
if mind>sum or mind==-1:
mind=sum
print(mind)
|
n=int(input())
x=[int(i) for i in input().split(" ")]
x=sorted(x)
mind=-1
for i in range(x[0],x[len(x)-1]+1):
sum=0
for j in x:
sum+=(j-i)**2
if mind>sum or mind==-1:
mind=sum
print(mind)
|
[
"call.remove",
"expression.operation.binary.remove",
"call.arguments.change"
] | 563,447
| 563,446
|
u196297781
|
python
|
p02767
|
n = int(input())
x = list(map(int, input().split()))
av = int(sum(x)/n)
print(sum([(i-av)**2 for i in x]))
|
n = int(input())
x = list(map(int, input().split()))
av = round(sum(x)/n)
print(sum([(i-av)**2 for i in x]))
|
[
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 563,457
| 563,458
|
u550835660
|
python
|
p02767
|
n=int(input())
L=list(map(int,input().split()))
r=0
for i in range(max(L)):
b=0
for j in range(n):
b+=(L[j]-i)**2
if i==0 or b<r:
r=b
print(r)
|
n=int(input())
L=list(map(int,input().split()))
r=0
for i in range(2*max(L)):
b=0
for j in range(n):
b+=(L[j]-i)**2
if i==0 or b<r:
r=b
print(r)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,459
| 563,460
|
u014960543
|
python
|
p02767
|
N = int(input())
X = [int(x) for x in input().split()]
L = min(X)
R = max(X)
ans = 10000000
for P in range(L, R - L + 1):
tmp = 0
for Xi in X:
tmp += (Xi - P) ** 2
ans = min(ans, tmp)
print(ans)
|
N = int(input())
X = [int(x) for x in input().split()]
L = min(X)
R = max(X)
ans = 10000000
for P in range(L, R + 1):
tmp = 0
for Xi in X:
tmp += (Xi - P) ** 2
ans = min(ans, tmp)
print(ans)
|
[
"expression.operation.binary.remove"
] | 563,465
| 563,466
|
u795245552
|
python
|
p02767
|
N = int(input())
X = list(map(int,input().split()))
X.sort()
min_pw = 10**30
for i in range(min(X),max(X)):
sum_pw = 0
for x in X:
sum_pw += (i-x)**2
if sum_pw < min_pw:
min_pw = sum_pw
print(min_pw)
|
N = int(input())
X = list(map(int,input().split()))
X.sort()
min_pw = 10**30
for i in range(min(X),max(X)+1):
sum_pw = 0
for x in X:
sum_pw += (i-x)**2
if sum_pw < min_pw:
min_pw = sum_pw
print(min_pw)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,471
| 563,472
|
u825541307
|
python
|
p02767
|
N = int(input())
X = list(map(int,input().split()))
X.sort()
min_pw = 10**9
for i in range(min(X),max(X)):
sum_pw = 0
for x in X:
sum_pw += (i-x)**2
if sum_pw < min_pw:
min_pw = sum_pw
print(min_pw)
|
N = int(input())
X = list(map(int,input().split()))
X.sort()
min_pw = 10**30
for i in range(min(X),max(X)+1):
sum_pw = 0
for x in X:
sum_pw += (i-x)**2
if sum_pw < min_pw:
min_pw = sum_pw
print(min_pw)
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 563,473
| 563,472
|
u825541307
|
python
|
p02767
|
#!/usr/bin/env python3
import sys
import math
def solve(N: int, X: "List[int]"):
p = math.ceil(sum(X) / N)
print(sum([(x-p)**2 for x in X]))
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
X = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, X)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
def solve(N: int, X: "List[int]"):
p = round(sum(X) / N)
print(sum([(x-p)**2 for x in X]))
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
X = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, X)
if __name__ == '__main__':
main()
|
[
"assignment.value.change"
] | 563,474
| 563,475
|
u928254435
|
python
|
p02767
|
N = int(input())
X = list(map(int,input().split()))
ans = 10**9+7
for i in range(max(X)):
point = 0
for j in X:
point += ((j-i)**2)
if point < ans:
ans = point
print(ans)
|
N = int(input())
X = list(map(int,input().split()))
ans = 10**9+7
for i in range(100):
point = 0
for j in X:
point += ((j-i)**2)
if point <= ans:
ans = point
print(ans)
|
[
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"control_flow.loop.range.bounds.upper.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 563,482
| 563,483
|
u371132735
|
python
|
p02767
|
N = int(input())
X = list(map(int,input().split()))
INF = 10**7
def cost(x,p):
return (x-p)**2
X.sort()
ans = INF
for p in range(X[0],X[N-1]):
sum = 0
for i in range(N):
sum += cost(X[i],p)
ans = min(ans,sum)
print(ans)
|
N = int(input())
X = list(map(int,input().split()))
INF = 10**7
def cost(x,p):
return (x-p)**2
X.sort()
ans = INF
for p in range(X[0],X[N-1]+1):
sum = 0
for i in range(N):
sum += cost(X[i],p)
ans = min(ans,sum)
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,489
| 563,490
|
u571867512
|
python
|
p02767
|
import sys
# import math
# import decimal
# import queue
# import bisect
# import heapq
# import time
# import itertools
mod = int(1e9+7)
INF = 1<<29
def main():
n = int(input())
x = list(map(int,input().split()))
ans = [INF] * 101
for i in range(1,101):
p = 0
for j in range(n):
p += (x[j]-(i+1))**2
ans[i] = min(ans[i],p)
print(min(ans))
return
if __name__=='__main__':
main()
|
import sys
# import math
# import decimal
# import queue
# import bisect
# import heapq
# import time
# import itertools
mod = int(1e9+7)
INF = 1<<29
def main():
n = int(input())
x = list(map(int,input().split()))
ans = [INF] * 105
for i in range(105):
p = 0
for j in range(n):
p += (x[j]-(i+1))**2
ans[i] = min(ans[i],p)
print(min(ans))
return
if __name__=='__main__':
main()
|
[
"literal.number.integer.change",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change",
"control_flow.loop.range.bounds.lower.change"
] | 563,493
| 563,494
|
u807028974
|
python
|
p02767
|
N = int(input())
X = list(map(int,input().split()))
ans = 10**10
for i in range(min(X),max(X)):
cnt = 0
for j in X:
cnt += (j - i)**2
ans = min(ans,cnt)
print(ans)
|
N = int(input())
X = list(map(int,input().split()))
ans = 10**10
for i in range(min(X)-1,max(X)+1):
cnt = 0
for j in X:
cnt += (j - i)**2
ans = min(ans,cnt)
print(ans)
|
[
"control_flow.loop.range.bounds.lower.change",
"expression.operation.binary.add",
"control_flow.loop.range.bounds.upper.change"
] | 563,497
| 563,498
|
u355371431
|
python
|
p02767
|
import math
n = int(input())
x = list(map(int, input().split()))
s = sum(x)
ans = 0
a = round(s/n)
for i in x:
ans += (i - a) ** 2
print(a)
print(ans)
|
import math
n = int(input())
x = list(map(int, input().split()))
s = sum(x)
ans = 0
a = round(s/n)
for i in x:
ans += (i - a) ** 2
print(ans)
|
[
"call.remove"
] | 563,501
| 563,502
|
u952491523
|
python
|
p02767
|
N=int(input())
X=list(map(int,input().split()))
ans=float("inf")
for P in range(X[0],X[-1]+1):
a=0
for i in range(N):
a+=(X[i]-P)**2
ans=min(ans,a)
print(ans)
|
N=int(input())
X=sorted(map(int,input().split()))
ans=float("inf")
for P in range(X[0],X[-1]+1):
a=0
for i in range(N):
a+=(X[i]-P)**2
ans=min(ans,a)
print(ans)
|
[
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 563,503
| 563,504
|
u343454379
|
python
|
p02767
|
n = int(input())
x_list = list(map(int, input().split()))
min_x = min(x_list)
max_x = max(x_list)
min_power = 10000 * 1000
for i in range(min_x, max_x):
check_power = 0
for j in x_list:
check_power += (j - i) * (j - i)
if(check_power < min_power):
min_power = check_power
print(min_power)
|
n = int(input())
x_list = list(map(int, input().split()))
min_x = min(x_list)
max_x = max(x_list)
min_power = 10000 * 1000
for i in range(min_x, max_x + 1):
check_power = 0
for j in x_list:
check_power += (j - i) * (j - i)
if(check_power < min_power):
min_power = check_power
print(min_power)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,520
| 563,521
|
u363992934
|
python
|
p02767
|
import sys
input = sys.stdin.readline
N = int(input())
X = [int(x) for x in input().split()]
ans = 10 ** 10
for i in range(X[0], X[-1] + 1):
tmp = 0
for j in X:
tmp += (i - j) ** 2
ans = min(ans, tmp)
print(ans)
|
import sys
input = sys.stdin.readline
N = int(input())
X = [int(x) for x in input().split()]
X.sort()
ans = 10 ** 10
for i in range(X[0], X[-1] + 1):
tmp = 0
for j in X:
tmp += (i - j) ** 2
ans = min(ans, tmp)
print(ans)
|
[
"call.add"
] | 563,522
| 563,523
|
u609061751
|
python
|
p02767
|
N=int(input())
X=list(map(int, input().split()))
min_s=100000
for i in range(min(X),max(X)):
s = sum([(j-i)**2 for j in X])
min_s = min(min_s, s)
print(min_s)
|
N=int(input())
X=list(map(int, input().split()))
min_s=1000000
for i in range(min(X),max(X)+1):
s = sum([(j-i)**2 for j in X])
min_s = min(min_s, s)
print(min_s)
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 563,524
| 563,525
|
u933717615
|
python
|
p02767
|
# C
import numpy as np
N = int(input())
X = np.array(list(map(int, input().split())))
P_floor = math.floor(np.sum(X)/N)
P_ceil = math.ceil(np.sum(X)/N)
ans = min(np.sum((X-P_floor)**2), np.sum((X-P_ceil)**2))
print(ans)
|
import numpy as np
import math
N = int(input())
X = np.array(list(map(int, input().split())))
P_floor = math.floor(np.sum(X)/N)
P_ceil = math.ceil(np.sum(X)/N)
ans = min(np.sum((X-P_floor)**2), np.sum((X-P_ceil)**2))
print(ans)
|
[] | 563,528
| 563,529
|
u239528020
|
python
|
p02767
|
import math
import numpy as np
n= int(input())
l = list(map(int,input().split()))
ans = 0
me = int(round(np.mean(l)))
print(me)
for i in range(n):
ans += (l[i]-me)**2
print(ans)
|
import math
import numpy as np
n= int(input())
l = list(map(int,input().split()))
ans = 0
me = int(round(np.mean(l)))
#print(me)
for i in range(n):
ans += (l[i]-me)**2
print(ans)
|
[
"call.remove"
] | 563,530
| 563,531
|
u427984570
|
python
|
p02767
|
n = int(input())
x = list(map(int, input().split()))
ans = 10 ** 9
x_min = min(x)
x_max = max(x)
for i in range(x_min, x_max):
tmp = sum([(i-j)*(i-j) for j in x])
if ans > tmp:
ans = tmp
print(ans)
|
n = int(input())
x = list(map(int, input().split()))
ans = 10 ** 9
x_min = min(x)
x_max = max(x)
for i in range(x_min, x_max+1):
tmp = sum([(i-j)*(i-j) for j in x])
if ans > tmp:
ans = tmp
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,532
| 563,533
|
u329709276
|
python
|
p02767
|
# じょえチャンネル
# 高評価・チャンネル登録宜しくお願いします！
# https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
import sys
from math import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from itertools import combinations as comb
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
def y(f):
if f:
print('Yes')
else:
print('No')
def Y(f):
if f:
print('YES')
else:
print('NO')
def Z(f):
if f:
print('Yay!')
else:
print(':(')
def ispow(n):
if int(n**.5)**2==n:
return True
return False
n = int(input())
a = list(map(int,input().split()))
res = 10 ** 100
for i in range(-100, 200):
tmp = 0
for j in range(a):
tmp += (i - j) ** 2
res = min(res, tmp)
print(res)
|
# じょえチャンネル
# 高評価・チャンネル登録宜しくお願いします！
# https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
import sys
from math import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from itertools import combinations as comb
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
def y(f):
if f:
print('Yes')
else:
print('No')
def Y(f):
if f:
print('YES')
else:
print('NO')
def Z(f):
if f:
print('Yay!')
else:
print(':(')
def ispow(n):
if int(n**.5)**2==n:
return True
return False
n = int(input())
a = list(map(int,input().split()))
res = 10 ** 100
for i in range(-100, 200):
tmp = 0
for j in a:
tmp += (i - j) ** 2
res = min(res, tmp)
print(res)
|
[
"call.remove",
"call.arguments.change"
] | 563,536
| 563,537
|
u832039789
|
python
|
p02767
|
n = int(input())
arr = list(map(int, input().split()))
ans = 10 ** 18
for i in range(1, 101):
tmp = 0
for j in range(n):
tmp += (arr[j] - (i + 1)) ** 2
ans = min(tmp, ans)
print(ans)
|
n = int(input())
arr = list(map(int, input().split()))
ans = 10 ** 18
for i in range(100):
tmp = 0
for j in range(n):
tmp += (arr[j] - (i + 1)) ** 2
ans = min(tmp, ans)
print(ans)
|
[
"literal.number.integer.change",
"call.arguments.change",
"control_flow.loop.range.bounds.lower.change"
] | 563,538
| 563,539
|
u445624660
|
python
|
p02767
|
n = int(input())
arr = list(map(int, input().split()))
ans = 10 ** 18
for i in range(n):
tmp = 0
for j in range(n):
tmp += (arr[j] - (i + 1)) ** 2
ans = min(tmp, ans)
print(ans)
|
n = int(input())
arr = list(map(int, input().split()))
ans = 10 ** 18
for i in range(100):
tmp = 0
for j in range(n):
tmp += (arr[j] - (i + 1)) ** 2
ans = min(tmp, ans)
print(ans)
|
[
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"control_flow.loop.range.bounds.upper.change"
] | 563,540
| 563,539
|
u445624660
|
python
|
p02767
|
N=int(input())
X=list(map(int,input().split()))
max=max(X)
ans = 100*5*N
for i in range(max+1):
tmp=0
for x in X:
tmp+=(x-i)**2
ans=min(ans,tmp)
print(ans)
|
N=int(input())
X=list(map(int,input().split()))
max=max(X)
ans = (100**5)*N
for i in range(max+1):
tmp=0
for x in X:
tmp+=(x-i)**2
ans=min(ans,tmp)
print(ans)
|
[
"assignment.value.change",
"expression.operation.binary.change"
] | 563,541
| 563,542
|
u243699903
|
python
|
p02767
|
N=int(input())
X=list(map(int,input().split()))
max=max(X)
ans = 100*5*N
for i in range(max):
tmp=0
for x in X:
tmp+=(x-i)**2
ans=min(ans,tmp)
print(ans)
|
N=int(input())
X=list(map(int,input().split()))
max=max(X)
ans = (100**5)*N
for i in range(max+1):
tmp=0
for x in X:
tmp+=(x-i)**2
ans=min(ans,tmp)
print(ans)
|
[
"assignment.value.change",
"expression.operation.binary.change"
] | 563,543
| 563,542
|
u243699903
|
python
|
p02767
|
import numpy as np
def resolve():
input()
x = list(map(int, input().split()))
m = int(round(np.median(x)))
sum = 0
for val in x:
sum += (val - m) ** 2
print(sum)
if __name__ == '__main__':
resolve()
|
import numpy as np
def resolve():
input()
x = list(map(int, input().split()))
m = int(round(np.mean(x)))
sum = 0
for val in x:
sum += (val - m) ** 2
print(sum)
if __name__ == '__main__':
resolve()
|
[
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 563,574
| 563,575
|
u822961851
|
python
|
p02767
|
import numpy as np
def resolve():
input()
x = list(map(int, input().split()))
m = round(np.median(x))
sum = 0
for val in x:
sum += (val - m) ** 2
print(sum)
if __name__ == '__main__':
resolve()
|
import numpy as np
def resolve():
input()
x = list(map(int, input().split()))
m = int(round(np.mean(x)))
sum = 0
for val in x:
sum += (val - m) ** 2
print(sum)
if __name__ == '__main__':
resolve()
|
[
"call.add",
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 563,577
| 563,575
|
u822961851
|
python
|
p02767
|
N = int(input())
A = list(map(int,input().split()))
c = sum(A)//N + 1
ans = 0
for i in range(N):
ans += (A[i] - c) ** 2
print(ans)
|
N = int(input())
A = list(map(int,input().split()))
c = round(sum(A)/N)
ans = 0
for i in range(N):
ans += (A[i] - c) ** 2
print(ans)
|
[
"call.add",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 563,583
| 563,584
|
u291028869
|
python
|
p02767
|
N = int(input())
x_list = list(map(int, input().split()))
maxValue = max(x_list)
minValue = 1000000
for i in range(1,maxValue):
ans = 0
for j in range(N):
ans += ( x_list[j] - i ) **2
if(ans < minValue):
minValue = ans
print(minValue)
|
N = int(input())
x_list = list(map(int, input().split()))
maxValue = max(x_list)
minValue = 1000000
for i in range(1,100):
ans = 0
for j in range(N):
ans += ( x_list[j] - i ) **2
if(ans < minValue):
minValue = ans
print(minValue)
|
[
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"control_flow.loop.range.bounds.upper.change"
] | 563,585
| 563,586
|
u363995337
|
python
|
p02767
|
import sys
input = sys.stdin.readline
N = int(input())
X = [int(x) for x in input().split()]
P = int(sum(X) / N) + 1
total = 0
for x in X:
kyori = (x - P) * (x - P)
total += kyori
print(total)
|
import sys
input = sys.stdin.readline
N = int(input())
X = [int(x) for x in input().split()]
P = int(sum(X) / N + 0.5)
total = 0
for x in X:
kyori = (x - P) * (x - P)
total += kyori
print(total)
|
[
"expression.operation.binary.remove"
] | 563,591
| 563,592
|
u502649733
|
python
|
p02767
|
import sys
input = sys.stdin.readline
N = int(input())
X = [int(x) for x in input().split()]
P = int(sum(X)/N)
total = 0
for x in X:
kyori = (x - P) * (x - P)
total += kyori
print(total)
|
import sys
input = sys.stdin.readline
N = int(input())
X = [int(x) for x in input().split()]
P = int(sum(X) / N + 0.5)
total = 0
for x in X:
kyori = (x - P) * (x - P)
total += kyori
print(total)
|
[
"assignment.change"
] | 563,593
| 563,592
|
u502649733
|
python
|
p02767
|
import sys
input = sys.stdin.readline
N = int(input())
X = [int(x) for x in input().split()]
P = int(sum(X)/N)
total = 0
for x in X:
kyori = (x - P) * (x - P)
total += kyori
print(total)
|
import sys
input = sys.stdin.readline
N = int(input())
X = [int(x) for x in input().split()]
P = int(sum(X) / N + 0.5)
total = 0
for x in X:
kyori = (x - P) * (x - P)
total += kyori
print(total)
|
[
"assignment.change"
] | 563,593
| 563,594
|
u502649733
|
python
|
p02767
|
n = int(input())
index = list(map(int, input().split()))
energy = []
for p in range(min(index), max(index)):
sum = 0
for xi in index:
sum += (xi-p)**2
energy.append(sum)
print(min(energy))
|
n = int(input())
index = list(map(int, input().split()))
energy = []
for p in range(min(index), max(index)+1):
sum = 0
for xi in index:
sum += (xi-p)**2
energy.append(sum)
print(min(energy))
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,599
| 563,600
|
u734876600
|
python
|
p02767
|
n = int(input())
r = list(map(int, input().split()))
old = None
for x in range(min(r), max(r)):
t = sum([(i - x) ** 2 for i in r])
if not old:
old = t
continue
if t < old:
old = t
print(old)
|
n = int(input())
r = list(map(int, input().split()))
old = None
for x in range(min(r), max(r)+1):
t = sum([(i - x) ** 2 for i in r])
if not old:
old = t
continue
if t < old:
old = t
print(old)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,601
| 563,602
|
u511870776
|
python
|
p02767
|
n = int(input())
x = [int(i) for i in input().split()]
d = []
for i in range(min(x), max(x)):
a = 0
for j in x:
a += (j - i)**2
# print("({}-{})**2={}".format(j,i,(j - i)**2))
d.append(a)
print(min(d))
|
n = int(input())
x = [int(i) for i in input().split()]
d = []
for i in range(min(x), max(x)+1):
a = 0
for j in x:
a += (j - i)**2
# print("({}-{})**2={}".format(j,i,(j - i)**2))
d.append(a)
print(min(d))
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,609
| 563,610
|
u218487926
|
python
|
p02767
|
#!python3
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
X = list(iim())
av = 2 * (sum(X) + N) // N // 2
ans = 0
for x in X:
ans += (x - av)**2
print(ans)
if __name__ == "__main__":
resolve()
|
#!python3
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
X = list(iim())
av = (2 * sum(X) + N) // N // 2
ans = 0
for x in X:
ans += (x - av)**2
print(ans)
if __name__ == "__main__":
resolve()
|
[] | 563,611
| 563,612
|
u348805958
|
python
|
p02767
|
#!python3
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
X = list(iim())
av = 2 * (sum(X) + N) // N
ans = 0
for x in X:
ans += (x - av)**2
print(ans)
if __name__ == "__main__":
resolve()
|
#!python3
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = int(input())
X = list(iim())
av = (2 * sum(X) + N) // N // 2
ans = 0
for x in X:
ans += (x - av)**2
print(ans)
if __name__ == "__main__":
resolve()
|
[
"assignment.change"
] | 563,613
| 563,612
|
u348805958
|
python
|
p02767
|
N = int(input())
x = list(map(int, input().split()))
p = sum(x) / N
p0 = p - int(p)
if p <= 0.5:
p = int(p)
else:
p = int(p) + 1
ans = 0
for i in x:
ans += (p - i) ** 2
print(ans)
|
N = int(input())
x = list(map(int, input().split()))
p = sum(x) / N
p0 = p - int(p)
if p0 <= 0.5:
p = int(p)
else:
p = int(p) + 1
ans = 0
for i in x:
ans += (p - i) ** 2
print(ans)
|
[
"identifier.change",
"control_flow.branch.if.condition.change"
] | 563,614
| 563,615
|
u586368075
|
python
|
p02767
|
N=int(input())
people=[]
cost=[]
people=list(map(int,input().split()))
for p in range(len(people)):
cost.append(0)
for person in people:
cost[-1]+=(person-(p+1))**2
print(min(cost))
|
N=int(input())
people=[]
cost=[]
people=list(map(int,input().split()))
for p in range(101):
cost.append(0)
for person in people:
cost[-1]+=(person-(p+1))**2
print(min(cost))
|
[
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"control_flow.loop.range.bounds.upper.change"
] | 563,618
| 563,619
|
u034340853
|
python
|
p02767
|
N=int(input())
X=list(map(int,input().split()))
c=0
d=sum(X)/N
for i in X:
c+=(i-d)**2
print(c)
|
N=int(input())
X=list(map(int,input().split()))
c=0
d=round(sum(X)/N)
for i in X:
c+=(i-d)**2
print(c)
|
[
"call.add",
"call.arguments.change"
] | 563,630
| 563,631
|
u038819082
|
python
|
p02767
|
n = int(input())
x = list(map(int, input().split()))
a = []
for pp in 100:
sum = 0
for xx in x:
sum += abs((xx-pp) ** 2)
a.append(sum)
print(min(a))
|
n = int(input())
x = list(map(int, input().split()))
a = []
for pp in range(1,101):
sum = 0
for xx in x:
sum += abs((xx-pp) ** 2)
a.append(sum)
print(min(a))
|
[
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.add"
] | 563,636
| 563,637
|
u574590381
|
python
|
p02767
|
n = int(input())
x = list(map(int, input().split()))
a = []
for pp in range(max(x)):
sum = 0
for xx in x:
sum += abs((xx-pp) ** 2)
a.append(sum)
print(min(a))
|
n = int(input())
x = list(map(int, input().split()))
a = []
for pp in range(1,101):
sum = 0
for xx in x:
sum += abs((xx-pp) ** 2)
a.append(sum)
print(min(a))
|
[
"call.arguments.change"
] | 563,638
| 563,637
|
u574590381
|
python
|
p02767
|
n=int(input())
x=list(map(int,input().split()))
imax=int(max(x))
imin=int(min(x))
lis=[]
re=0
for k in range(imin,imax+1):
for i in x:
re=re+(x[i]-k)**2
lis.append(re)
re=0
print(min(lis))
|
n=int(input())
x=list(map(int,input().split()))
imax=int(max(x))
imin=int(min(x))
lis=[]
re=0
for k in range(imax+1):
for i in x:
re=re+(i-k)**2
lis.append(re)
re=0
print(min(lis))
|
[
"call.arguments.change"
] | 563,644
| 563,645
|
u395894569
|
python
|
p02767
|
n=int(input())
x=list(map(int,input().split()))
imax=int(max(x))
imin=int(min(x))
lis=[]
re=0
for k in range(imin,imax+1):
for i in x:
re=re+(x[i]-k)**2
lis.append(re)
re=0
print(min(lis))
|
n=int(input())
x=list(map(int,input().split()))
imax=int(max(x))
imin=int(min(x))
lis=[]
re=0
for k in range(imin,imax+1):
for i in x:
re=re+(i-k)**2
lis.append(re)
re=0
print(min(lis))
|
[] | 563,644
| 563,646
|
u395894569
|
python
|
p02767
|
n = int(input())
x = list(map(int,input().split()))
x.sort()
z = 10000
for p in range(x[0],x[-1]+1):
temp = 0
for xx in x:
temp += (xx-p)**2
z = min(temp,z)
print(z)
|
n = int(input())
x = list(map(int,input().split()))
x.sort()
z = 10**100
for p in range(x[0],x[-1]+1):
temp = 0
for xx in x:
temp += (xx-p)**2
z = min(temp,z)
print(z)
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 563,652
| 563,653
|
u181295070
|
python
|
p02767
|
n = int(input())
x = list(map(int,input().split()))
x.sort()
z = 10000
for p in range(x[0],x[-1]):
temp = 0
for xx in x:
temp += (xx-p)**2
z = min(temp,z)
print(z)
|
n = int(input())
x = list(map(int,input().split()))
x.sort()
z = 10**100
for p in range(x[0],x[-1]+1):
temp = 0
for xx in x:
temp += (xx-p)**2
z = min(temp,z)
print(z)
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 563,654
| 563,653
|
u181295070
|
python
|
p02767
|
N = int(input())
X = list(map(int, input().split()))
Xmax = max(X)
Xmin = min(X)
ans = 0
ans_sum = 0
for P in range(Xmin,Xmax+1):
for i in range(N):
cal = (X[i] - P)**2
ans_sum = ans_sum + cal
if P == Xmin:
ans = ans_sum
ans_sum = 0
elif ans >= ans_sum:
ans = ans_sum
else :
ans_sum = 0
print(ans)
|
N = int(input())
X = list(map(int, input().split()))
Xmax = max(X)
Xmin = min(X)
ans = 0
ans_sum = 0
for P in range(Xmin,Xmax+1):
for i in range(N):
cal = (X[i] - P)**2
ans_sum = ans_sum + cal
if P == Xmin:
ans = ans_sum
ans_sum = 0
elif ans >= ans_sum:
ans = ans_sum
ans_sum = 0
else :
ans_sum = 0
print(ans)
|
[
"assignment.add"
] | 563,655
| 563,656
|
u262244504
|
python
|
p02767
|
n = int(input())
x = list(map(int, input().split()))
l1 = min(x)
l2 = max(x)
ans = 0
for i in range(l1, l2+1):
for j in x:
sum += (i-j)**2
if sum > ans:
ans = sum
print(ans)
|
n = int(input())
x = list(map(int, input().split()))
l1 = min(x)
l2 = max(x)
ans = 100000000
for i in range(l1, l2+1):
sum = 0
for j in x:
sum += (i-j)**2
if sum < ans:
ans = sum
print(ans)
|
[
"literal.number.integer.change",
"assignment.value.change",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 563,672
| 563,673
|
u962309487
|
python
|
p02767
|
n = int(input())
a = list(map(int, input().split()))
av = round(sum(a)/n)
x=0
for i in a:
x = x + (av)**2
print(x)
|
n = int(input())
a = list(map(int, input().split()))
av = round(sum(a)/n)
x=0
for i in a:
x = x + (i-av)**2
print(x)
|
[
"assignment.change"
] | 563,683
| 563,684
|
u829778936
|
python
|
p02767
|
import statistics
def cal_hp(p, num_list):
total = 0
for num in num_list:
temp = (num - p) ** 2
total = total + temp
return total
line1 = input()
line2 = input()
num_list = line2.split(" ")
num_list = [int(n) for n in num_list]
ans_list = []
for i in range(0, max(num_list)):
ans_list.append(cal_hp(i, num_list))
print(min(ans_list))
|
import statistics
def cal_hp(p, num_list):
total = 0
for num in num_list:
temp = (num - p) ** 2
total = total + temp
return total
line1 = input()
line2 = input()
num_list = line2.split(" ")
num_list = [int(n) for n in num_list]
ans_list = []
for i in range(0, max(num_list)+1):
ans_list.append(cal_hp(i, num_list))
print(min(ans_list))
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,694
| 563,695
|
u844813573
|
python
|
p02767
|
import numpy as np
N=int(input())
X = list(map(int,input().split()))
X.sort()
a=list()
c=N-1
for i in range(X[0],X[c]):
b=0
for j in range(0,N):
if i-X[j]>10**5:
break
b+=(i-X[j])**2
a.append(b)
print(min(a))
|
import numpy as np
N=int(input())
X = list(map(int,input().split()))
X.sort()
a=list()
c=N-1
for i in range(X[0],X[c]+1):
b=0
for j in range(0,N):
if i-X[j]>10**5:
break
b+=(i-X[j])**2
a.append(b)
print(min(a))
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,704
| 563,705
|
u005317312
|
python
|
p02767
|
n = int(input())
xxx = list(map(int, input().split()))
ans = 0
for p in range(1, 101):
tmp = sum((x - p) ** 2 for x in xxx)
ans = min(ans, tmp)
print(ans)
|
n = int(input())
xxx = list(map(int, input().split()))
ans = 10**10
for p in range(1, 101):
tmp = sum((x - p) ** 2 for x in xxx)
ans = min(ans, tmp)
print(ans)
|
[
"literal.number.integer.change",
"assignment.value.change"
] | 563,725
| 563,726
|
u340781749
|
python
|
p02768
|
n,a,b=map(int,input().split())
mod=10**9+7
def cmb(n, r,mod):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
#X//Y
X=1
Y=1
for i in range(r):
X*=(n-r)
X%=mod
Y*=(r+1)
Y%=mod
Y=pow(Y,mod-2,mod)
return (X*Y)%mod
allp=pow(2,n,mod)-1
ans=(allp-cmb(n,a,mod)-cmb(n,b,mod))%mod
if n==2:
ans=0
print(ans)
|
n,a,b=map(int,input().split())
mod=10**9+7
def cmb(n, r,mod):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
#X//Y
X=1
Y=1
for i in range(r):
X*=(n-i)
X%=mod
Y*=(i+1)
Y%=mod
inv=pow(Y,mod-2,mod)
return (X*inv)%mod
allp=pow(2,n,mod)-1
ans=(allp-cmb(n,a,mod)-cmb(n,b,mod))%mod
if n==2:
ans=0
print(ans)
|
[
"identifier.change",
"expression.operation.binary.change",
"assignment.variable.change",
"function.return_value.change"
] | 563,738
| 563,739
|
u498487134
|
python
|
p02767
|
N = int(input())
X = list(map(int, input().split()))
ma = max(X)
mi = min(X)
ans = 10**9
for n in range(mi, ma):
count = 0
for x in X:
count += abs(x-n)**2
if ans > count:
ans = count
print(ans)
|
N = int(input())
X = list(map(int, input().split()))
ma = max(X)
mi = min(X)
ans = 10**9
for n in range(mi, ma+1):
count = 0
for x in X:
count += abs(x-n)**2
if ans > count:
ans = count
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,742
| 563,743
|
u431981421
|
python
|
p02767
|
n = int(input())
x = list(map(int, input().split()))
ans = int(1e10)
for i in range(max(x)):
cnt = 0
for j in range(n):
cnt += (x[j] - i) ** 2
if ans > cnt:
ans = cnt
print(ans)
|
n = int(input())
x = list(map(int, input().split()))
ans = int(1e10)
for i in range(max(x)+1):
cnt = 0
for j in range(n):
cnt += (x[j] - i) ** 2
if ans > cnt:
ans = cnt
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,744
| 563,745
|
u361381049
|
python
|
p02767
|
N = int(input())
X = list(map(int,input().split()))
X.sort()
Xmin = min(X)
Xmax = max(X)
#print(Xmin,Xmax)
T =[]
for i in range(Xmin+1,Xmax+1):
HP = 0
for j in X:
HP = HP + (i-j)**2
T.append(HP)
print(min(T))
|
N = int(input())
X = list(map(int,input().split()))
X.sort()
Xmin = min(X)
Xmax = max(X)
#print(Xmin,Xmax)
T =[]
for i in range(1,101):
HP = 0
for j in X:
HP = HP + (i-j)**2
T.append(HP)
print(min(T))
|
[
"expression.operation.binary.remove",
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.range.bounds.upper.change"
] | 563,746
| 563,747
|
u507826663
|
python
|
p02767
|
n = int(input())
data = list(map(int, input().split()))
p_min = min(data)
p_max = max(data)
ans_min = 100000000000000
for i in range(p_min, p_max):
ans = 0
for d in data:
ans += (i-d)**2
if ans < ans_min:
ans_min = ans
print(ans_min)
|
n = int(input())
data = list(map(int, input().split()))
p_min = min(data)
p_max = max(data)
ans_min = 100000000000000
for i in range(p_min, p_max+2):
ans = 0
for d in data:
ans += (i-d)**2
if ans < ans_min:
ans_min = ans
print(ans_min)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,748
| 563,749
|
u534308356
|
python
|
p02767
|
# N人住んでいる
N = int(input())
# Xiが住んでいる場所
X = list(map(int, input().split()))
# 体力計算
ans = 10**9
# 開催場所は0~一番遠い人のところまで
for p in range(max(X)):
tmp = 0
for x in X:
tmp += (x-p)**2
# 最小値を更新する
ans = min(ans, tmp)
print(ans)
|
# N人住んでいる
N = int(input())
# Xiが住んでいる場所
X = list(map(int, input().split()))
ans = 10**9
# 開催場所は0~一番遠い人のところまで
for p in range(max(X)+1):
tmp = 0
for x in X:
#print(x,p,(x-p)**2)
tmp += (x-p)**2
# 最小値を更新する
ans = min(ans, tmp)
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,750
| 563,751
|
u875600867
|
python
|
p02767
|
N = int(input())
X = list(map(int,input().split()))
tmp = 0
mi =100000000000
for i in range(1,101):
for k in range(N):
tmp = (X[k] - i)**2
if tmp < mi:
mi = tmp
print(mi)
|
N = int(input())
X = list(map(int,input().split()))
tmp = 0
mi =100000000000
for i in range(1,101):
for k in range(N):
tmp += (X[k] - i)**2
if tmp < mi:
mi = tmp
tmp = 0
print(mi)
|
[
"assignment.value.change"
] | 563,752
| 563,753
|
u944643608
|
python
|
p02767
|
#!/usr/bin/env python3
import sys
#sys.setrecursionlimit(150000)
def solve(N: int, X: "List[int]"):
st=min(X)
end=max(X)
costmin=1000000
for p in range(st,end-st+1):
cost=0
for i in range(N):
cost+=(p-X[i])**2
if cost<costmin: costmin=cost
print(costmin)
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
X = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, X)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
#sys.setrecursionlimit(150000)
def solve(N: int, X: "List[int]"):
st=min(X)
end=max(X)
costmin=1000000
for p in range(st,end+1):
cost=0
for i in range(N):
cost+=(p-X[i])**2
if cost<costmin: costmin=cost
print(costmin)
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
X = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, X)
if __name__ == '__main__':
main()
|
[
"expression.operation.binary.remove"
] | 563,754
| 563,755
|
u090649502
|
python
|
p02767
|
def main():
import sys
input = sys.stdin.readline
N = int(input())
X = list(map(int,input().split()))
min = float("inf")
s = X[0]
g = X[N-1]
for p in range(s,g+1):
s = 0
for x in X:
s += (x-p)**2
if min >= s:
min = s
print(min)
if __name__ == "__main__":
main()
|
def main():
import sys
input = sys.stdin.readline
N = int(input())
X = list(map(int,input().split()))
X.sort()
min = float("inf")
s = X[0]
g = X[N-1]
for p in range(s,g+1):
s = 0
for x in X:
s += (x-p)**2
if min >= s:
min = s
print(min)
if __name__ == "__main__":
main()
|
[
"call.add"
] | 563,760
| 563,761
|
u891504219
|
python
|
p02767
|
n = int(input())
ls = list(map(int,input().split()))
ls = sorted(ls)
ans = 10000000000000
x = 0
for i in range(ls[0],ls[-1]+1):
tmp = 0
for a in ls:
tmp += (a-i)**2
if ans > tmp:
x = i
ans = tmp
print(x)
|
n = int(input())
ls = list(map(int,input().split()))
ls = sorted(ls)
ans = 10000000000000
x = 0
for i in range(ls[0],ls[-1]+1):
tmp = 0
for a in ls:
tmp += (a-i)**2
if ans > tmp:
x = i
ans = tmp
print(ans)
|
[
"identifier.change",
"call.arguments.change",
"io.output.change"
] | 563,778
| 563,779
|
u115110170
|
python
|
p02767
|
n = int(input())
x = list(map(int, input().split()))
s = min(x)
e = max(x)
f_inf = float("inf")
ans = f_inf
for j in range(s, e):
res = 0
for i in range(n):
res += (x[i] - j) ** 2
ans = min(ans, res)
print(ans)
|
n = int(input())
x = list(map(int, input().split()))
s = min(x)
e = max(x)
f_inf = float("inf")
ans = f_inf
for j in range(s, e + 1):
res = 0
for i in range(n):
res += (x[i] - j) ** 2
ans = min(ans, res)
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,786
| 563,787
|
u489959379
|
python
|
p02767
|
n = int(input())
x = list(map(int, input().split()))
ans = 100 * 100
for i in range(100):
temp = 0
for j in x:
temp += pow(j - i, 2)
if temp < ans:
ans = temp
print(ans)
|
n = int(input())
x = list(map(int, input().split()))
ans = 100 * 100 * 100
for i in range(100):
temp = 0
for j in x:
temp += pow(j - i, 2)
if temp < ans:
ans = temp
print(ans)
|
[
"assignment.change"
] | 563,790
| 563,791
|
u639340617
|
python
|
p02767
|
n = int(input())
x = list(map(int, input().split()))
m = 10 ** 8
for i in range(min(x), max(x)):
c = 0
for j in range(n):
c += (x[j] - i) ** 2
if c < m:
m = c
print(m)
|
n = int(input())
x = list(map(int, input().split()))
m = 10 ** 8
for i in range(min(x), max(x) + 1):
c = 0
for j in range(n):
c += (x[j] - i) ** 2
if c < m:
m = c
print(m)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 563,799
| 563,800
|
u644972721
|
python
|
p02768
|
n,a,b = map(int,input().split())
mod = 10**9+7
def C(n, r, mod):
x=y=1
for i in range(r):
x *= n; y *= r
x %= mod; y %= mod
n -= 1; r -= 1
return x * pow(y, mod - 2, mod) % mod
res = pow(2,n,mod) - 1
comb_a = C(n,a,mod)
comb_b = C(n,b,mod)
print(res-(comb_a+comb_b)%mod)
|
n,a,b = map(int,input().split())
mod = 10**9+7
def C(n, r, mod):
x=y=1
for i in range(r):
x *= n; y *= r
x %= mod; y %= mod
n -= 1; r -= 1
return x * pow(y, mod - 2, mod) % mod
res = pow(2,n,mod) - 1
comb_a = C(n,a,mod)
comb_b = C(n,b,mod)
print((res-(comb_a+comb_b))%mod)
|
[
"call.arguments.change"
] | 563,894
| 563,895
|
u797550216
|
python
|
p02768
|
n,a,b = map(int,input().split())
mod = 10**9+7
def C(n, r, mod):
x=y=1
for i in range(r):
x *= n; y *= r
x %= mod; y %= mod
n -= 1; r -= 1
return x * pow(y, mod - 2, mod) % mod
res = pow(2,n,mod) - 1
comb_a = C(n,a,mod)
comb_b = C(n,b,mod)
print(res-(comb_a+comb_b)%mod)
|
n,a,b = map(int,input().split())
mod = 10**9+7
def C(n, r, mod):
x=y=1
for i in range(r):
x *= n; y *= r
x %= mod; y %= mod
n -= 1; r -= 1
return x * pow(y, mod - 2, mod) % mod
res = pow(2,n,mod) - 1
comb_a = C(n,a,mod)
comb_b = C(n,b,mod)
print((res-(comb_a+comb_b))%mod)
|
[
"call.arguments.change"
] | 563,896
| 563,895
|
u797550216
|
python
|
p02768
|
MOD = 10**9+7 # p=MOD
n, a, b = map(int, input().split())
whole = pow(2, n, MOD)-1 # 2^n-1(mod p)を計算。
# nCaの計算
comb1=1
for i in range(n-a+1,n+1): # n*(n-1)*(n-2)*...*(n-a+1)(mod p)を計算
comb1 *= i
comb1 %= mod
for i in range(1,a+1): # 1/a!(mod p)を計算 フェルマーの小定理:1/a = a^p-2(mod p)を利用
comb1 *= pow(i,mod-2,mod)
comb1 %= mod
comb2=1
for i in range(n-b+1,n+1): # n*(n-1)*(n-2)*...*(n-b+1)(mod p)を計算
comb2 *= i
comb2 %= mod
for i in range(1,b+1):
comb2 *= pow(i,mod-2,mod)
comb2 %= mod
whole -= (comb1+comb2)
whole %= mod
print(whole)
|
mod = 10**9+7
n, a, b = map(int, input().split())
whole = pow(2, n, mod)-1 # 2^n-1(mod p)を計算。
# nCaの計算
comb1=1
for i in range(n-a+1,n+1): # n*(n-1)*(n-2)*...*(n-a+1)(mod p)を計算
comb1 *= i
comb1 %= mod
for i in range(1,a+1): # 1/a!(mod p)を計算 フェルマーの小定理:1/a = a^p-2(mod p)を利用
comb1 *= pow(i,mod-2,mod)
comb1 %= mod
comb2=1
for i in range(n-b+1,n+1): # n*(n-1)*(n-2)*...*(n-b+1)(mod p)を計算
comb2 *= i
comb2 %= mod
for i in range(1,b+1):
comb2 *= pow(i,mod-2,mod)
comb2 %= mod
whole -= (comb1+comb2)
whole %= mod
print(whole)
|
[
"assignment.variable.change",
"identifier.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 563,936
| 563,938
|
u270144704
|
python
|
p02768
|
MOD = 10**9+7 # p=MOD
n, a, b = map(int, input().split())
whole = pow(2, n, MOD)-1 # 2^n-1(mod p)を計算。
# nCaの計算
comb1=1
for i in range(n-a+1,n+1): # n*(n-1)*(n-2)*...*(n-a+1)(mod p)を計算
comb1 *= i
comb1 %= mod
for i in range(1,a+1): # 1/a!(mod p)を計算 フェルマーの小定理:1/a = a^p-2(mod p)を利用
comb1 *= pow(i,mod-2,mod)
comb1 %= mod
comb2=1
for i in range(n-b+1,n+1): # n*(n-1)*(n-2)*...*(n-b+1)(mod p)を計算
comb2 *= i
comb2 %= mod
for i in range(1,b+1):
comb2 *= pow(i,mod-2,mod)
comb2 %= mod
ans -= (comb1+comb2)
ans %= mod
print(ans)
|
mod = 10**9+7
n, a, b = map(int, input().split())
whole = pow(2, n, mod)-1 # 2^n-1(mod p)を計算。
# nCaの計算
comb1=1
for i in range(n-a+1,n+1): # n*(n-1)*(n-2)*...*(n-a+1)(mod p)を計算
comb1 *= i
comb1 %= mod
for i in range(1,a+1): # 1/a!(mod p)を計算 フェルマーの小定理:1/a = a^p-2(mod p)を利用
comb1 *= pow(i,mod-2,mod)
comb1 %= mod
comb2=1
for i in range(n-b+1,n+1): # n*(n-1)*(n-2)*...*(n-b+1)(mod p)を計算
comb2 *= i
comb2 %= mod
for i in range(1,b+1):
comb2 *= pow(i,mod-2,mod)
comb2 %= mod
whole -= (comb1+comb2)
whole %= mod
print(whole)
|
[
"assignment.variable.change",
"identifier.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 563,939
| 563,938
|
u270144704
|
python
|
p02768
|
# 乗法のmod逆元 (mod-2乗)
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
# nCr mod p
def comb(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod # modinvが必要
return res
def binary(n):
return bin(n)[2:]
# バイナリ法
def pow_by_binary(a, x, n): # a^x mod n
x = [int(b) for b in binary(x)]
y = a
for i in range(1, len(x)):
y = (y**2) % n
if x[i] == 1:
y = (y * a) % n
return y
n,a,b = [int(i) for i in input().split()]
mod = 10**9+7
ans = pow_by_binary(2,n,mod)-1-comb(n,a,mod)-comb(n,b,mod)
if ans < 0:
ans += mod
print(ans)
|
# 乗法のmod逆元 (mod-2乗)
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
# nCr mod m
# modinvが必要
# rがn/2に近いと非常に重くなる
def comb(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
def binary(n):
return bin(n)[2:]
# バイナリ法
def pow_by_binary(a, x, n): # a^x mod n
x = [int(b) for b in binary(x)]
y = a
for i in range(1, len(x)):
y = (y**2) % n
if x[i] == 1:
y = (y * a) % n
return y
n,a,b = [int(i) for i in input().split()]
mod = 10**9+7
ans = pow_by_binary(2,n,mod)-1-comb(n,a,mod)-comb(n,b,mod)
if ans < 0:
ans += mod
print(ans%mod)
|
[
"expression.operation.binary.add"
] | 563,975
| 563,977
|
u075595666
|
python
|
p02768
|
N,A,B=map(int,input().split())
MOD=10**9+7
def calculate_combination(n,k):
x,y=1,1
for i in range(k):
x=x*(n-i)%MOD
y=y*(k-1)%MOD
return x*pow(y,MOD-2,MOD)%MOD
ans=pow(2,N,MOD)-1-calculate_combination(N,A)-calculate_combination(N,B)
while ans<0:
ans+=MOD
print(ans)
|
N,A,B=map(int,input().split())
MOD=10**9+7
def calculate_combination(n,k):
x,y=1,1
for i in range(k):
x=x*(n-i)%MOD
y=y*(k-i)%MOD
return x*pow(y,MOD-2,MOD)%MOD
ans=pow(2,N,MOD)-1-calculate_combination(N,A)-calculate_combination(N,B)
while ans<0:
ans+=MOD
print(ans)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 563,983
| 563,984
|
u265506056
|
python
|
p02768
|
from math import factorial
n,a,b = map(int,input().split())
mod = 10**9 + 7
def pow(x, n):
ans = 1
while(n > 0):
if(bin(n & 1) == bin(1)):
ans = ans*x % mod
x = x*x % mod
n = n >> 1 #ビットシフト
return ans
def ncr(n, r):
x = 1
y = 1
for i in range(r):
x *= (n-i)
y *= (i+1)
x %= mod
y %= mod
return (x * pow(y, 10**9+5)) % mod
ans = pow(2,n) - ncr(n,a) - ncr(n,b) - 1
print(ans if ans >= 0 else ans + mod)
|
from math import factorial
n,a,b = map(int,input().split())
mod = 10**9 + 7
def pow(x, n):
ans = 1
while(n > 0):
if(bin(n & 1) == bin(1)):
ans = ans*x % mod
x = x*x % mod
n = n >> 1 #ビットシフト
return ans
def ncr(n, r):
x = 1
y = 1
for i in range(r):
x *= (n-i)
y *= (i+1)
x %= mod
y %= mod
return (x * pow(y, 10**9+5)) % mod
ans = (pow(2,n) - ncr(n,a) - ncr(n,b) - 1) % mod
print(ans if ans >= 0 else ans + mod)
|
[
"assignment.change"
] | 563,994
| 563,996
|
u623231048
|
python
|
p02768
|
n,a,b = map(int,input().split())
mod=7+10**9
ans = pow(2 , n , mod)
def comb(n,c,mod):
s=1
t=1
for i in range(1,c+1):
s=s*i%mod
for j in range(n-c+1,n+1):
t=t*j%mod
return (t*pow(s,mod-2,mod))%mod
print(ans-1-comb(n,a,mod)-comb(n,b,mod))
|
n,a,b = map(int,input().split())
mod=7+10**9
ans = pow(2 , n , mod)
def comb(n,c,mod):
s=1
t=1
for i in range(1,c+1):
s=s*i%mod
for j in range(n-c+1,n+1):
t=t*j%mod
return (t*pow(s,mod-2,mod))%mod
print((ans-1-comb(n,a,mod)-comb(n,b,mod))%mod)
|
[
"call.arguments.change",
"call.arguments.add"
] | 563,997
| 563,998
|
u549383771
|
python
|
p02768
|
mod = 7+10**9
def ncr(n,c,mod):
x = 1
y = 1
for i in range(n-c+1,n+1):
x = x*i%mod
for j in range(1,c+1):
y = y*j%mod
return (x * pow(y, mod-2, mod)) % mod
n, a, b = map(int, input().split())
al = pow(2, n, mod) -1
acr = ncr(n, a, mod)
bcr = ncr(n, b, mod)
print(al-(acr+bcr)%mod)
|
mod = 7+10**9
def ncr(n,c,mod):
x = 1
y = 1
for i in range(n-c+1,n+1):
x = x*i%mod
for j in range(1,c+1):
y = y*j%mod
return (x * pow(y, mod-2, mod)) % mod
n, a, b = map(int, input().split())
al = pow(2, n, mod) -1
acr = ncr(n, a, mod)
bcr = ncr(n, b, mod)
print( (al-(acr+bcr))%mod )
|
[
"call.arguments.change"
] | 564,024
| 564,022
|
u452512115
|
python
|
p02768
|
mod = 10**9+7
def comb(n, r):
x = 1
y = 1
if n-r<r:
r = n-r
for i in range(r):
x *= n-i
y *= (i*1)
x %= mod
y %= mod
return x * pow(y, mod-2, mod) % mod
n, a, b = map(int, input().split())
print((pow(2, n, mod)-comb(n, a)-comb(n, b)-1)%mod)
|
mod = 10**9+7
def comb(n, r):
x = 1
y = 1
if n-r<r:
r = n-r
for i in range(r):
x *= n-i
y *= (i+1)
x %= mod
y %= mod
return x * pow(y, mod-2, mod) % mod
n, a, b = map(int, input().split())
print((pow(2, n, mod)-comb(n, a)-comb(n, b)-1)%mod)
|
[
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 564,029
| 564,030
|
u003644389
|
python
|
p02768
|
import math
l=10**9+7
n,a,b=map(int,input().split())
comb=[1]
for i in range(max(a,b)):
den=i+1
num=n-i
ans=comb[i]*num*pow(den,l-2,l)%l
comb.append(ans)
print(pow(2,n,l)-1-comb[a]-comb[b])
|
import math
l=10**9+7
n,a,b=map(int,input().split())
comb=[1]
for i in range(max(a,b)):
den=i+1
num=n-i
ans=comb[i]*num*pow(den,l-2,l)%l
comb.append(ans)
print((pow(2,n,l)-1-comb[a]-comb[b])%l)
|
[
"call.arguments.change",
"call.arguments.add"
] | 564,035
| 564,037
|
u556069480
|
python
|
p02768
|
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
def main():
n, a, b = map(int, input().split())
mod = 10 ** 9 + 7
all_case = pow(2, n, mod) - 1
nCa = conbination(n, a, mod)
nCb = conbination(n, b, mod)
result = all_case - nCa - nCb
if result < 0:
result = result + mod
print(result)
def conbination(n, r, mod):
a = 1
b = 1
for i in range(1, r + 1):
# print(a, b, i)
a = (a * (n - i + 1)) % mod
b = (b * i) % mod
b = pow(b, mod - 2, mod)
return (a * b) % mod
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
def main():
n, a, b = map(int, input().split())
mod = 10 ** 9 + 7
all_case = pow(2, n, mod) - 1
nCa = conbination(n, a, mod)
nCb = conbination(n, b, mod)
result = all_case - nCa - nCb
while (result < 0):
result = result + mod
print(result)
def conbination(n, r, mod):
a = 1
b = 1
for i in range(1, r + 1):
# print(a, b, i)
a = (a * (n - i + 1)) % mod
b = (b * i) % mod
b = pow(b, mod - 2, mod)
return (a * b) % mod
if __name__ == '__main__':
main()
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove",
"control_flow.loop.condition.change"
] | 564,046
| 564,047
|
u151037808
|
python
|
p02768
|
# -*- coding: utf-8 -*-
def comb(N, A):
x = 1
for i in range(A):
x *= N
N -= 1
x %= MOD
y = 1
for i in range(A):
y *= A
A -= 1
y %= MOD
return x*pow(y, MOD-2, MOD) % MOD
N, A, B = map(int, input().split())
MOD = 10**9+7
print(pow(2, N, MOD)-1-comb(N, A)-comb(N, B))
|
# -*- coding: utf-8 -*-
def comb(N, A):
x = 1
for i in range(A):
x *= N
N -= 1
x %= MOD
y = 1
for i in range(A):
y *= A
A -= 1
y %= MOD
return x*pow(y, MOD-2, MOD) % MOD
N, A, B = map(int, input().split())
MOD = 10**9+7
print((pow(2, N, MOD)-1-comb(N, A)-comb(N, B)+MOD) % MOD)
|
[
"call.arguments.change"
] | 564,049
| 564,051
|
u375616706
|
python
|
p02768
|
def com(n, r, mod):
num = 1
denom = 1
for i in range(r):
denom = (denom * (i+1)) % mod
num = (num * (n-i)) % mod
return num*pow(denom, 1, mod)
n, a, b = map(int,input().split())
mod = 10**9 + 7
sum = pow(2, n, mod) - 1
sum -= com(n, a, mod)
sum -= com(n, b, mod)
print(int(sum % mod))
|
def com(n, r, mod):
num = 1
denom = 1
for i in range(r):
denom = (denom * (i+1)) % mod
num = (num * (n-i)) % mod
return num*pow(denom, mod-2, mod)
n, a, b = map(int,input().split())
mod = 10**9 + 7
sum = pow(2, n, mod) - 1
sum -= com(n, a, mod)
sum -= com(n, b, mod)
print(int(sum % mod))
|
[
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 564,060
| 564,061
|
u106778233
|
python
|
p02768
|
mod = 10**9 + 7
n, a, b = map(int, input().split())
res = pow(2, n, mod)-1
c1 = 1
for i in range(n-a+1, n+1):
c1 *= i
c1 %= mod
for i in range(1, a+1):
c1 *= pow(i, mod-2, mod)
c1 %= mod
c2 = 1
for i in range(n-a+1, n+1):
c2 *= i
c2 %= mod
for i in range(1, a+1):
c2 *= pow(i, mod-2, mod)
c2 %= mod
res -= (c1+c2)
res %= mod
print(res)
|
mod = 10**9 + 7
n, a, b = map(int, input().split())
res = pow(2, n, mod)-1
c1 = 1
for i in range(n-a+1, n+1):
c1 *= i
c1 %= mod
for i in range(1, a+1):
c1 *= pow(i, mod-2, mod)
c1 %= mod
c2 = 1
for i in range(n-b+1, n+1):
c2 *= i
c2 %= mod
for i in range(1, b+1):
c2 *= pow(i, mod-2, mod)
c2 %= mod
res -= (c1+c2)
res %= mod
print(res)
|
[
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.range.bounds.upper.change"
] | 563,828
| 563,829
|
u075502030
|
python
|
p02768
|
mod = 10**9 + 7
n, a, b = map(int, input().split())
res = pow(2, n, mod)-1
# nCr = n*(n-1)*...(n-a+1)/ a!
# n*(n-1)*...(n-a+1)
c1 = 1
for i in range(n-a+1, n+1):
c1 *= i
c1 %= mod
#1/a!=1/(1*2*…*a)=1^(p-2)*2^(p-2)*…*a^(p-2) (p=10**9+7)を計算
for i in range(1, a+1):
c1 *= pow(i, mod-2, mod)
c1 %= mod
c2 = 1
for i in range(n-a+1, n+1):
c2 *= i
c2 %= mod
for i in range(1, a+1):
c2 *= pow(i, mod-2, mod)
c2 %= mod
res -= (c1+c2)
res %= mod
print(res)
|
mod = 10**9 + 7
n, a, b = map(int, input().split())
res = pow(2, n, mod)-1
c1 = 1
for i in range(n-a+1, n+1):
c1 *= i
c1 %= mod
for i in range(1, a+1):
c1 *= pow(i, mod-2, mod)
c1 %= mod
c2 = 1
for i in range(n-b+1, n+1):
c2 *= i
c2 %= mod
for i in range(1, b+1):
c2 *= pow(i, mod-2, mod)
c2 %= mod
res -= (c1+c2)
res %= mod
print(res)
|
[
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.range.bounds.upper.change"
] | 563,830
| 563,829
|
u075502030
|
python
|
p02768
|
MOD = 10**9 + 7
def nCr(n, r, MOD):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
result %= MOD
return result
n, a, b = map(int,input().split())
ans = pow(2,n,MOD)-1-nCr(n,a,MOD)-nCr(n,b,MOD)
if ans < 0:
ans += MOD
print(ans)
|
MOD = 10**9 + 7
def nCr(n, r, MOD):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
result %= MOD
return result
n, a, b = map(int,input().split())
ans = pow(2,n,MOD)-1-nCr(n,a,MOD)-nCr(n,b,MOD)
while ans < 0:
ans += MOD
print(ans)
|
[
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove"
] | 563,838
| 563,839
|
u620084012
|
python
|
p02768
|
n, a, b = map(int, input().split())
MOD = 10**9 + 7
N = pow(2,n,MOD)
def com(n,r):
s = 1
for i in range(n-r+1, n+1):
s *= i
s %= MOD
t = 1
for j in range(1,r+1):
t *= j
t %= MOD
return s * pow(t,MOD-2, MOD) % MOD
print((N - com(n, a) - com(n, b)) % (MOD))
|
n, a, b = map(int, input().split())
MOD = 10**9 + 7
N = pow(2,n,MOD)
def com(n,r):
s = 1
for i in range(n-r+1, n+1):
s *= i
s %= MOD
t = 1
for j in range(1,r+1):
t *= j
t %= MOD
return s * pow(t,MOD-2, MOD) % MOD
print((N - com(n, a) - com(n, b) - 1) % (MOD))
|
[
"expression.operation.binary.add"
] | 563,842
| 563,843
|
u277104886
|
python
|
p02768
|
n,a,b=map(int,input().split())
mod=10**9+7
def modpow(a,n):
if n<1:
return 1
ans=modpow(a,n//2)
ans=(ans*ans)%mod
if n%2==1:
ans*=a
return ans%mod
def cmb(n,i):#逆元
inv,ans=1,1
for j in range(1,i+1):
ans=ans*(n-j+1)%mod
inv=inv*j%mod
return (ans*modpow(inv,mod-2))%mod
ans_n=pow(2,n,mod)-1
ans_a=cmb(n,a)%mod
ans_b=cmb(n,b)%mod
print(ans_n-(ans_a+ans_b)%mod)
|
n,a,b=map(int,input().split())
mod=10**9+7
def modpow(a,n):
if n<1:
return 1
ans=modpow(a,n//2)
ans=(ans*ans)%mod
if n%2==1:
ans*=a
return ans%mod
def cmb(n,i):#逆元
inv,ans=1,1
for j in range(1,i+1):
ans=ans*(n-j+1)%mod
inv=inv*j%mod
return (ans*modpow(inv,mod-2))%mod
ans_n=pow(2,n,mod)-1
ans_a=cmb(n,a)%mod
ans_b=cmb(n,b)%mod
print((ans_n-ans_a-ans_b)%mod)
|
[
"call.arguments.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change",
"io.output.change"
] | 563,861
| 563,863
|
u347184682
|
python
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.