node_ids
sequencelengths 4
1.4k
| edge_index
sequencelengths 1
2.22k
| text
sequencelengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
14,
2,
4,
13,
13,
4,
13,
13,
4,
13,
17,
4,
13,
0,
13,
2,
2,
4,
13,
13,
4,
13,
13,
13,
28,
13,
4,
13,
4,
13,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
2,
18,
13,
13,
13,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13,
10,
2,
13
] | [
[
87,
2
],
[
90,
8
],
[
91,
23
],
[
91,
26
],
[
93,
33
],
[
91,
38
],
[
91,
41
],
[
88,
42
],
[
45,
44
],
[
91,
49
],
[
91,
53
],
[
99,
56
],
[
60,
59
],
[
88,
62
],
[
102,
64
],
[
91,
68
],
[
59,
69
],
[
44,
70
],
[
91,
73
],
[
59,
74
],
[
44,
75
],
[
103,
78
],
[
100,
78
],
[
94,
79
],
[
97,
79
],
[
96,
81
],
[
103,
82
],
[
100,
82
],
[
97,
85
],
[
94,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
103,
96
],
[
100,
96
],
[
96,
97
],
[
99,
100
],
[
102,
103
]
] | [
"n = int(input())\n# n, k = list(map(int, input().split()))\na = list(map(int, input().split()))\n# abc = [int(input()) for i in range(5)]\nif min(a) == max(a):\n print(0)\n exit()\n\nans = (max(a)*max(a))*n\nfor i in range(min(a), max(a)+1):\n total = 0\n for j in range(n):\n total += (a[j]-i)*(a[j]-i)\n if total < ans:\n ans = total\n\n\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"if min(a) == max(a):\n print(0)\n exit()",
"min(a) == max(a)",
"min(a)",
"min",
"a",
"max(a)",
"max",
"a",
"print(0)",
"print",
"0",
"exit()",
"exit",
"ans = (max(a)*max(a))*n",
"ans",
"(max(a)*max(a))*n",
"max(a)*max(a)",
"max(a)",
"max",
"a",
"max(a)",
"max",
"a",
"n",
"for i in range(min(a), max(a)+1):\n total = 0\n for j in range(n):\n total += (a[j]-i)*(a[j]-i)\n if total < ans:\n ans = total",
"i",
"range(min(a), max(a)+1)",
"range",
"min(a)",
"min",
"a",
"max(a)+1",
"max(a)",
"max",
"a",
"1",
"total = 0",
"total",
"0",
"for j in range(n):\n total += (a[j]-i)*(a[j]-i)\n ",
"j",
"range(n)",
"range",
"n",
"total += (a[j]-i)*(a[j]-i)",
"total",
"(a[j]-i)*(a[j]-i)",
"a[j]-i",
"a[j]",
"a",
"j",
"i",
"a[j]-i",
"a[j]",
"a",
"j",
"i",
"if total < ans:\n ans = total",
"total < ans",
"total",
"ans",
"ans = total",
"ans",
"total",
"print(ans)",
"print",
"ans",
"n = int(input())",
"int(input())",
"n",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"ans = (max(a)*max(a))*n",
"(max(a)*max(a))*n",
"ans",
"ans = total",
"total",
"ans",
"total = 0",
"0",
"total",
"total += (a[j]-i)*(a[j]-i)",
"(a[j]-i)*(a[j]-i)",
"total"
] | n = int(input())
# n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
# abc = [int(input()) for i in range(5)]
if min(a) == max(a):
print(0)
exit()
ans = (max(a)*max(a))*n
for i in range(min(a), max(a)+1):
total = 0
for j in range(n):
total += (a[j]-i)*(a[j]-i)
if total < ans:
ans = total
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
2,
13,
17,
0,
13,
2,
2,
2,
13,
2,
13,
17,
2,
2,
17,
13,
13,
13,
0,
13,
2,
2,
2,
13,
2,
13,
17,
2,
2,
17,
13,
13,
13,
4,
13,
4,
13,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] | [
[
91,
2
],
[
100,
8
],
[
85,
20
],
[
101,
23
],
[
103,
25
],
[
29,
28
],
[
101,
28
],
[
94,
31
],
[
28,
33
],
[
106,
36
],
[
86,
38
],
[
92,
39
],
[
82,
41
],
[
107,
43
],
[
97,
46
],
[
92,
50
],
[
107,
52
],
[
86,
57
],
[
107,
58
],
[
95,
59
],
[
104,
59
],
[
88,
61
],
[
92,
65
],
[
83,
67
],
[
86,
72
],
[
83,
73
],
[
95,
74
],
[
104,
74
],
[
98,
79
],
[
89,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
],
[
106,
107
]
] | [
"n = int(input())\na = list(map(int,input().split()))\nasum = sum(a)\na2sum = 0\nfor m in a:\n a2sum += m**2\nx1 = asum//n\nx2 = x1+1\nz1 = n*x1**2-2*asum*x1+a2sum\nz2 = n*x2**2-2*asum*x2+a2sum\nprint(min(z1,z2))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"asum = sum(a)",
"asum",
"sum(a)",
"sum",
"a",
"a2sum = 0",
"a2sum",
"0",
"for m in a:\n a2sum += m**2",
"m",
"a",
"a2sum += m**2",
"a2sum",
"m**2",
"m",
"2",
"x1 = asum//n",
"x1",
"asum//n",
"asum",
"n",
"x2 = x1+1",
"x2",
"x1+1",
"x1",
"1",
"z1 = n*x1**2-2*asum*x1+a2sum",
"z1",
"n*x1**2-2*asum*x1+a2sum",
"n*x1**2-2*asum*x1",
"n*x1**2",
"n",
"x1**2",
"x1",
"2",
"2*asum*x1",
"2*asum",
"2",
"asum",
"x1",
"a2sum",
"z2 = n*x2**2-2*asum*x2+a2sum",
"z2",
"n*x2**2-2*asum*x2+a2sum",
"n*x2**2-2*asum*x2",
"n*x2**2",
"n",
"x2**2",
"x2",
"2",
"2*asum*x2",
"2*asum",
"2",
"asum",
"x2",
"a2sum",
"print(min(z1,z2))",
"print",
"min(z1,z2)",
"min",
"z1",
"z2",
"x2 = x1+1",
"x1+1",
"x2",
"asum = sum(a)",
"sum(a)",
"asum",
"z2 = n*x2**2-2*asum*x2+a2sum",
"n*x2**2-2*asum*x2+a2sum",
"z2",
"n = int(input())",
"int(input())",
"n",
"a2sum += m**2",
"m**2",
"a2sum",
"z1 = n*x1**2-2*asum*x1+a2sum",
"n*x1**2-2*asum*x1+a2sum",
"z1",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"a2sum = 0",
"0",
"a2sum",
"x1 = asum//n",
"asum//n",
"x1"
] | n = int(input())
a = list(map(int,input().split()))
asum = sum(a)
a2sum = 0
for m in a:
a2sum += m**2
x1 = asum//n
x2 = x1+1
z1 = n*x1**2-2*asum*x1+a2sum
z2 = n*x2**2-2*asum*x2+a2sum
print(min(z1,z2)) |
[
7,
15,
13,
15,
13,
15,
13,
15,
12,
13,
0,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
17,
29,
13,
23,
13,
12,
13,
0,
13,
4,
18,
4,
13,
2,
4,
13,
13,
13,
13,
4,
13,
17,
0,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
4,
13,
2,
13,
13,
17,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
4,
13,
13,
29,
13,
0,
13,
17,
0,
13,
17,
0,
13,
17,
12,
13,
17,
14,
13,
23,
13,
14,
2,
13,
17,
14,
13,
0,
18,
13,
13,
4,
18,
13,
13,
13,
4,
13,
17,
0,
13,
4,
13,
14,
13,
4,
13,
14,
2,
4,
18,
13,
13,
4,
18,
13,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13,
10,
12,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] | [
[
12,
11
],
[
15,
14
],
[
18,
17
],
[
25,
17
],
[
21,
20
],
[
20,
23
],
[
14,
23
],
[
11,
23
],
[
25,
25
],
[
30,
29
],
[
65,
37
],
[
63,
38
],
[
45,
44
],
[
48,
47
],
[
51,
50
],
[
65,
50
],
[
54,
53
],
[
50,
57
],
[
29,
58
],
[
53,
61
],
[
47,
61
],
[
63,
63
],
[
65,
65
],
[
70,
69
],
[
76,
75
],
[
88,
87
],
[
165,
91
],
[
69,
92
],
[
75,
93
],
[
87,
96
],
[
87,
98
],
[
161,
100
],
[
167,
103
],
[
170,
106
],
[
114,
114
],
[
125,
122
],
[
168,
129
],
[
173,
134
],
[
159,
136
],
[
171,
145
],
[
174,
149
],
[
161,
162
],
[
167,
168
],
[
170,
171
],
[
173,
174
]
] | [
"# -*- coding: utf-8 -*-\n\nimport io\nimport sys\nimport math\nfrom decimal import Decimal, ROUND_HALF_UP\n\n\ndef format_multi_line_answer(lst):\n ans = \"\"\n ans += f\"{len(lst)}\\n\" # Line count\n for y in lst:\n ans += f\"{y}\\n\"\n return ans\n\ndef solve(n,n_lst):\n # implement process\n \n #中央値を取り、四捨五入する\n target = Decimal(sum(n_lst)/n).quantize(Decimal('0'), rounding=ROUND_HALF_UP)\n cost = 0\n for a in n_lst:\n cost += pow(a-target,2)\n return cost\n\ndef main():\n # input\n n = int(input())\n n_lst = list(map(int, input().split()))\n\n # process\n ans = str( solve(n,n_lst ) )\n \n # output\n print(ans)\n return ans\n \n### DEBUG I/O ###\n_DEB = 0 # 1:ON / 0:OFF\n\n_INPUT = \"\"\"\\\n4\n-100 -100 -100 -100\n\n\"\"\"\n_EXPECTED = \"\"\"\\\n8\n\n\"\"\"\n\ndef logd(str):\n \"\"\"usage:\n if _DEB: logd(f\"{str}\")\n \"\"\"\n if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###\nif __name__ == \"__main__\":\n if _DEB:\n sys.stdin = io.StringIO(_INPUT)\n print(\"!! Debug Mode !!\")\n\n ans = main()\n\n if _DEB:\n print()\n if _EXPECTED.strip() == ans.strip(): print(\"!! Success !!\")\n else: print(f\"!! Failed... !!\\nANSWER: {ans}\\nExpected: {_EXPECTED}\")",
"import io",
"io",
"import sys",
"sys",
"import math",
"math",
"from decimal import Decimal, ROUND_HALF_UP",
"def format_multi_line_answer(lst):\n ans = \"\"\n ans += f\"{len(lst)}\\n\" # Line count\n for y in lst:\n ans += f\"{y}\\n\"\n return ans",
"format_multi_line_answer",
"ans = \"\"",
"ans",
"\"\"",
"ans += f\"{len(lst)}\\n\"",
"ans",
"f\"{len(lst)}\\n\"",
"for y in lst:\n ans += f\"{y}\\n\"\n ",
"y",
"lst",
"ans += f\"{y}\\n\"",
"ans",
"f\"{y}\\n\"",
"return ans",
"ans",
"lst",
"lst",
"def solve(n,n_lst):\n # implement process\n \n #中央値を取り、四捨五入する\n target = Decimal(sum(n_lst)/n).quantize(Decimal('0'), rounding=ROUND_HALF_UP)\n cost = 0\n for a in n_lst:\n cost += pow(a-target,2)\n return cost",
"solve",
"target = Decimal(sum(n_lst)/n).quantize(Decimal('0'), rounding=ROUND_HALF_UP)",
"target",
"Decimal(sum(n_lst)/n).quantize(Decimal('0'), rounding=ROUND_HALF_UP)",
"(sum(n_lst)/n).quantize",
"(sum(n_lst)/n)",
"Decimal",
"sum(n_lst)/n",
"sum(n_lst)",
"sum",
"n_lst",
"n",
"quantize",
"Decimal('0')",
"Decimal",
"'0'",
"rounding=ROUND_HALF_UP",
"rounding",
"ROUND_HALF_UP",
"cost = 0",
"cost",
"0",
"for a in n_lst:\n cost += pow(a-target,2)\n ",
"a",
"n_lst",
"cost += pow(a-target,2)",
"cost",
"pow(a-target,2)",
"pow",
"a-target",
"a",
"target",
"2",
"return cost",
"cost",
"n",
"n",
"n_lst",
"n_lst",
"def main():\n # input\n n = int(input())\n n_lst = list(map(int, input().split()))\n\n # process\n ans = str( solve(n,n_lst ) )\n \n # output\n print(ans)\n return ans\n \n### DEBUG I/O ###",
"main",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"n_lst = list(map(int, input().split()))",
"n_lst",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = str( solve(n,n_lst ) )",
"ans",
"str( solve(n,n_lst ) )",
"str",
"solve(n,n_lst )",
"solve",
"n",
"n_lst",
"print(ans)",
"print",
"ans",
"return ans",
"ans",
"_DEB = 0",
"_DEB",
"0",
"_INPUT = \"\"\"\\\n4\n-100 -100 -100 -100\n\n\"\"\"",
"_INPUT",
"\"\"\"\\\n4\n-100 -100 -100 -100\n\n\"\"\"",
"_EXPECTED = \"\"\"\\\n8\n\n\"\"\"",
"_EXPECTED",
"\"\"\"\\\n8\n\n\"\"\"",
"def logd(str):\n \"\"\"usage:\n if _DEB: logd(f\"{str}\")\n \"\"\"\n if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###",
"logd",
"\"\"\"usage:\n if _DEB: logd(f\"{str}\")\n \"\"\"",
"if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###",
"_DEB",
"str",
"str",
"if __name__ == \"__main__\":\n if _DEB:\n sys.stdin = io.StringIO(_INPUT)\n print(\"!! Debug Mode !!\")\n\n ans = main()\n\n if _DEB:\n print()\n if _EXPECTED.strip() == ans.strip(): print(\"!! Success !!\")\n else: print(f\"!! Failed... !!\\nANSWER: {ans}\\nExpected: {_EXPECTED}\")",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"if _DEB:\n sys.stdin = io.StringIO(_INPUT)\n print(\"!! Debug Mode !!\")\n\n ",
"_DEB",
"sys.stdin = io.StringIO(_INPUT)",
"sys.stdin",
"sys",
"stdin",
"io.StringIO(_INPUT)",
"io.StringIO",
"io",
"StringIO",
"_INPUT",
"print(\"!! Debug Mode !!\")",
"print",
"\"!! Debug Mode !!\"",
"ans = main()",
"ans",
"main()",
"main",
"if _DEB:\n print()\n if _EXPECTED.strip() == ans.strip(): print(\"!! Success !!\")\n else: print(f\"!! Failed... !!\\nANSWER: {ans}\\nExpected: {_EXPECTED}\")",
"_DEB",
"print()",
"print",
"if _EXPECTED.strip() == ans.strip(): print(\"!! Success !!\")\n else: print(f\"!! Failed... !!\\nANSWER: {ans}\\nExpected: {_EXPECTED}\")",
"_EXPECTED.strip() == ans.strip()",
"_EXPECTED.strip()",
"_EXPECTED.strip",
"_EXPECTED",
"strip",
"ans.strip()",
"ans.strip",
"ans",
"strip",
"def logd(str):\n \"\"\"usage:\n if _DEB: logd(f\"{str}\")\n \"\"\"\n if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###",
"def logd(str):\n \"\"\"usage:\n if _DEB: logd(f\"{str}\")\n \"\"\"\n if _DEB: print(f\"[deb] {str}\")\n\n### MAIN ###",
"logd",
"def format_multi_line_answer(lst):\n ans = \"\"\n ans += f\"{len(lst)}\\n\" # Line count\n for y in lst:\n ans += f\"{y}\\n\"\n return ans",
"def format_multi_line_answer(lst):\n ans = \"\"\n ans += f\"{len(lst)}\\n\" # Line count\n for y in lst:\n ans += f\"{y}\\n\"\n return ans",
"format_multi_line_answer",
"def main():\n # input\n n = int(input())\n n_lst = list(map(int, input().split()))\n\n # process\n ans = str( solve(n,n_lst ) )\n \n # output\n print(ans)\n return ans\n \n### DEBUG I/O ###",
"def main():\n # input\n n = int(input())\n n_lst = list(map(int, input().split()))\n\n # process\n ans = str( solve(n,n_lst ) )\n \n # output\n print(ans)\n return ans\n \n### DEBUG I/O ###",
"main",
"_DEB = 0",
"0",
"_DEB",
"def solve(n,n_lst):\n # implement process\n \n #中央値を取り、四捨五入する\n target = Decimal(sum(n_lst)/n).quantize(Decimal('0'), rounding=ROUND_HALF_UP)\n cost = 0\n for a in n_lst:\n cost += pow(a-target,2)\n return cost",
"def solve(n,n_lst):\n # implement process\n \n #中央値を取り、四捨五入する\n target = Decimal(sum(n_lst)/n).quantize(Decimal('0'), rounding=ROUND_HALF_UP)\n cost = 0\n for a in n_lst:\n cost += pow(a-target,2)\n return cost",
"solve",
"_INPUT = \"\"\"\\\n4\n-100 -100 -100 -100\n\n\"\"\"",
"\"\"\"\\\n4\n-100 -100 -100 -100\n\n\"\"\"",
"_INPUT",
"_EXPECTED = \"\"\"\\\n8\n\n\"\"\"",
"\"\"\"\\\n8\n\n\"\"\"",
"_EXPECTED",
"ans = main()",
"main()",
"ans"
] | # -*- coding: utf-8 -*-
import io
import sys
import math
from decimal import Decimal, ROUND_HALF_UP
def format_multi_line_answer(lst):
ans = ""
ans += f"{len(lst)}\n" # Line count
for y in lst:
ans += f"{y}\n"
return ans
def solve(n,n_lst):
# implement process
#中央値を取り、四捨五入する
target = Decimal(sum(n_lst)/n).quantize(Decimal('0'), rounding=ROUND_HALF_UP)
cost = 0
for a in n_lst:
cost += pow(a-target,2)
return cost
def main():
# input
n = int(input())
n_lst = list(map(int, input().split()))
# process
ans = str( solve(n,n_lst ) )
# output
print(ans)
return ans
### DEBUG I/O ###
_DEB = 0 # 1:ON / 0:OFF
_INPUT = """\
4
-100 -100 -100 -100
"""
_EXPECTED = """\
8
"""
def logd(str):
"""usage:
if _DEB: logd(f"{str}")
"""
if _DEB: print(f"[deb] {str}")
### MAIN ###
if __name__ == "__main__":
if _DEB:
sys.stdin = io.StringIO(_INPUT)
print("!! Debug Mode !!")
ans = main()
if _DEB:
print()
if _EXPECTED.strip() == ans.strip(): print("!! Success !!")
else: print(f"!! Failed... !!\nANSWER: {ans}\nExpected: {_EXPECTED}") |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
39,
13
] | [
[
52,
2
],
[
55,
8
],
[
64,
20
],
[
24,
23
],
[
61,
29
],
[
33,
32
],
[
56,
32
],
[
58,
35
],
[
32,
38
],
[
23,
39
],
[
65,
43
],
[
59,
45
],
[
62,
45
],
[
65,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
]
] | [
"N = int(input())\na = list(map(int, input().split()))\nb = []\nfor i in range(-100, 101):\n\tt = 0\n\tfor j in a:\n\t\tt += (j - i) ** 2\n\tb.append(t)\nprint(min(b))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"b = []",
"b",
"[]",
"for i in range(-100, 101):\n\tt = 0\n\tfor j in a:\n\t\tt += (j - i) ** 2\n\tb.append(t)",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"t = 0",
"t",
"0",
"for j in a:\n\t\tt += (j - i) ** 2\n\t",
"j",
"a",
"t += (j - i) ** 2",
"t",
"(j - i) ** 2",
"j - i",
"j",
"i",
"2",
"b.append(t)",
"b.append",
"b",
"append",
"t",
"print(min(b))",
"print",
"min(b)",
"min",
"b",
"N = int(input())",
"int(input())",
"N",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"t += (j - i) ** 2",
"(j - i) ** 2",
"t",
"t = 0",
"0",
"t",
"b = []",
"[]",
"b"
] | N = int(input())
a = list(map(int, input().split()))
b = []
for i in range(-100, 101):
t = 0
for j in a:
t += (j - i) ** 2
b.append(t)
print(min(b)) |
[
7,
0,
13,
4,
13,
17,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
13,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
71,
2
],
[
62,
7
],
[
59,
13
],
[
68,
25
],
[
72,
26
],
[
29,
28
],
[
65,
34
],
[
38,
37
],
[
60,
37
],
[
56,
40
],
[
37,
43
],
[
28,
44
],
[
74,
47
],
[
69,
50
],
[
75,
50
],
[
57,
51
],
[
66,
51
],
[
75,
54
],
[
69,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
72,
68
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] | [
"inf = float('inf')\nn = int(input())\narr = list(map(int, input().split()))\n\nmin_cost = inf\nfor i in range(-100, 101):\n cost = 0\n for j in arr:\n cost += (j - i)**2\n min_cost = min(min_cost, cost)\nprint(min_cost)",
"inf = float('inf')",
"inf",
"float('inf')",
"float",
"'inf'",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"arr = list(map(int, input().split()))",
"arr",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_cost = inf",
"min_cost",
"inf",
"for i in range(-100, 101):\n cost = 0\n for j in arr:\n cost += (j - i)**2\n min_cost = min(min_cost, cost)",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"cost = 0",
"cost",
"0",
"for j in arr:\n cost += (j - i)**2\n ",
"j",
"arr",
"cost += (j - i)**2",
"cost",
"(j - i)**2",
"j - i",
"j",
"i",
"2",
"min_cost = min(min_cost, cost)",
"min_cost",
"min(min_cost, cost)",
"min",
"min_cost",
"cost",
"print(min_cost)",
"print",
"min_cost",
"cost += (j - i)**2",
"(j - i)**2",
"cost",
"arr = list(map(int, input().split()))",
"list(map(int, input().split()))",
"arr",
"n = int(input())",
"int(input())",
"n",
"cost = 0",
"0",
"cost",
"min_cost = inf",
"inf",
"min_cost",
"inf = float('inf')",
"float('inf')",
"inf",
"min_cost = min(min_cost, cost)",
"min(min_cost, cost)",
"min_cost"
] | inf = float('inf')
n = int(input())
arr = list(map(int, input().split()))
min_cost = inf
for i in range(-100, 101):
cost = 0
for j in arr:
cost += (j - i)**2
min_cost = min(min_cost, cost)
print(min_cost) |
[
7,
0,
13,
2,
17,
17,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13
] | [
[
53,
2
],
[
56,
7
],
[
59,
13
],
[
26,
25
],
[
68,
31
],
[
35,
34
],
[
60,
34
],
[
62,
37
],
[
34,
40
],
[
25,
41
],
[
65,
44
],
[
54,
47
],
[
66,
47
],
[
63,
48
],
[
69,
48
],
[
66,
51
],
[
54,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] | [
"ans = 10 ** 9\nn = int(input())\nA = list(map(int,input().split()))\nfor i in range(-100,101):\n X = 0\n for j in A:\n X += (j - i) ** 2\n ans = min(ans,X)\nprint(ans)",
"ans = 10 ** 9",
"ans",
"10 ** 9",
"10",
"9",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(-100,101):\n X = 0\n for j in A:\n X += (j - i) ** 2\n ans = min(ans,X)",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"X = 0",
"X",
"0",
"for j in A:\n X += (j - i) ** 2\n ",
"j",
"A",
"X += (j - i) ** 2",
"X",
"(j - i) ** 2",
"j - i",
"j",
"i",
"2",
"ans = min(ans,X)",
"ans",
"min(ans,X)",
"min",
"ans",
"X",
"print(ans)",
"print",
"ans",
"ans = 10 ** 9",
"10 ** 9",
"ans",
"n = int(input())",
"int(input())",
"n",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"X += (j - i) ** 2",
"(j - i) ** 2",
"X",
"ans = min(ans,X)",
"min(ans,X)",
"ans",
"X = 0",
"0",
"X"
] | ans = 10 ** 9
n = int(input())
A = list(map(int,input().split()))
for i in range(-100,101):
X = 0
for j in A:
X += (j - i) ** 2
ans = min(ans,X)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
69,
2
],
[
75,
8
],
[
87,
20
],
[
76,
23
],
[
84,
25
],
[
76,
28
],
[
90,
30
],
[
34,
33
],
[
78,
41
],
[
45,
44
],
[
70,
47
],
[
72,
49
],
[
79,
51
],
[
73,
51
],
[
76,
55
],
[
44,
56
],
[
33,
57
],
[
81,
60
],
[
91,
63
],
[
82,
63
],
[
73,
64
],
[
79,
64
],
[
82,
67
],
[
91,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
]
] | [
"n = int(input())\narr = list(map(int, input().split()))\n\nmini = min(arr)\nmaxi = max(arr)\ncost = 10000000000\n\nfor i in range(-100, 101+1):\n add = 0\n for j in range(n):\n add = add + (arr[j] - i)**2\n cost = min(cost, add)\nprint(cost)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"arr = list(map(int, input().split()))",
"arr",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mini = min(arr)",
"mini",
"min(arr)",
"min",
"arr",
"maxi = max(arr)",
"maxi",
"max(arr)",
"max",
"arr",
"cost = 10000000000",
"cost",
"10000000000",
"for i in range(-100, 101+1):\n add = 0\n for j in range(n):\n add = add + (arr[j] - i)**2\n cost = min(cost, add)",
"i",
"range(-100, 101+1)",
"range",
"-100",
"101+1",
"101",
"1",
"add = 0",
"add",
"0",
"for j in range(n):\n add = add + (arr[j] - i)**2\n ",
"j",
"range(n)",
"range",
"n",
"add = add + (arr[j] - i)**2",
"add",
"add + (arr[j] - i)**2",
"add",
"(arr[j] - i)**2",
"arr[j] - i",
"arr[j]",
"arr",
"j",
"i",
"2",
"cost = min(cost, add)",
"cost",
"min(cost, add)",
"min",
"cost",
"add",
"print(cost)",
"print",
"cost",
"n = int(input())",
"int(input())",
"n",
"add = add + (arr[j] - i)**2",
"add + (arr[j] - i)**2",
"add",
"arr = list(map(int, input().split()))",
"list(map(int, input().split()))",
"arr",
"add = 0",
"0",
"add",
"cost = min(cost, add)",
"min(cost, add)",
"cost",
"maxi = max(arr)",
"max(arr)",
"maxi",
"mini = min(arr)",
"min(arr)",
"mini",
"cost = 10000000000",
"10000000000",
"cost"
] | n = int(input())
arr = list(map(int, input().split()))
mini = min(arr)
maxi = max(arr)
cost = 10000000000
for i in range(-100, 101+1):
add = 0
for j in range(n):
add = add + (arr[j] - i)**2
cost = min(cost, add)
print(cost) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] | [
[
66,
2
],
[
57,
8
],
[
60,
20
],
[
24,
23
],
[
63,
29
],
[
33,
32
],
[
58,
32
],
[
51,
35
],
[
23,
38
],
[
32,
39
],
[
54,
42
],
[
61,
45
],
[
55,
45
],
[
52,
46
],
[
64,
46
],
[
55,
49
],
[
61,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
]
] | [
"N = int(input())\na = list(map(int,input().split()))\n\n\nans = 1e10\nfor i in range(-100,101):\n tmp = 0\n for j in a:\n tmp += (i-j)**2\n ans = min(ans,tmp)\n\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = 1e10",
"ans",
"1e10",
"for i in range(-100,101):\n tmp = 0\n for j in a:\n tmp += (i-j)**2\n ans = min(ans,tmp)",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"tmp = 0",
"tmp",
"0",
"for j in a:\n tmp += (i-j)**2\n ",
"j",
"a",
"tmp += (i-j)**2",
"tmp",
"(i-j)**2",
"i-j",
"i",
"j",
"2",
"ans = min(ans,tmp)",
"ans",
"min(ans,tmp)",
"min",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"tmp += (i-j)**2",
"(i-j)**2",
"tmp",
"ans = min(ans,tmp)",
"min(ans,tmp)",
"ans",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"ans = 1e10",
"1e10",
"ans",
"tmp = 0",
"0",
"tmp",
"N = int(input())",
"int(input())",
"N"
] | N = int(input())
a = list(map(int,input().split()))
ans = 1e10
for i in range(-100,101):
tmp = 0
for j in a:
tmp += (i-j)**2
ans = min(ans,tmp)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
53,
2
],
[
56,
8
],
[
47,
20
],
[
57,
26
],
[
54,
27
],
[
50,
29
],
[
33,
32
],
[
57,
32
],
[
59,
35
],
[
51,
37
],
[
60,
37
],
[
32,
40
],
[
48,
41
],
[
60,
45
],
[
51,
45
],
[
47,
48
],
[
50,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
]
] | [
"n = int(input())\na = list(map(int, input().split()))\nmean = round(sum(a) / n)\nans = 0\nfor i in a:\n ans = ans + (i-mean)**2\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mean = round(sum(a) / n)",
"mean",
"round(sum(a) / n)",
"round",
"sum(a) / n",
"sum(a)",
"sum",
"a",
"n",
"ans = 0",
"ans",
"0",
"for i in a:\n ans = ans + (i-mean)**2",
"i",
"a",
"ans = ans + (i-mean)**2",
"ans",
"ans + (i-mean)**2",
"ans",
"(i-mean)**2",
"i-mean",
"i",
"mean",
"2",
"print(ans)",
"print",
"ans",
"mean = round(sum(a) / n)",
"round(sum(a) / n)",
"mean",
"ans = 0",
"0",
"ans",
"n = int(input())",
"int(input())",
"n",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"ans = ans + (i-mean)**2",
"ans + (i-mean)**2",
"ans"
] | n = int(input())
a = list(map(int, input().split()))
mean = round(sum(a) / n)
ans = 0
for i in a:
ans = ans + (i-mean)**2
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
4,
13,
12,
4,
13,
13,
23,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
13,
2,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
4,
13,
13,
17,
14,
40,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
76,
2
],
[
82,
8
],
[
79,
15
],
[
83,
25
],
[
94,
27
],
[
80,
30
],
[
100,
32
],
[
80,
35
],
[
88,
37
],
[
77,
40
],
[
43,
42
],
[
101,
45
],
[
95,
47
],
[
85,
51
],
[
55,
54
],
[
80,
54
],
[
91,
57
],
[
42,
60
],
[
54,
63
],
[
92,
67
],
[
86,
67
],
[
89,
68
],
[
98,
68
],
[
97,
70
],
[
92,
71
],
[
86,
71
],
[
98,
74
],
[
89,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
92,
97
],
[
86,
97
],
[
97,
98
],
[
100,
101
]
] | [
"N = int(input())\nb = input().split()\na = list(map((lambda x: int(x)), b))\n\n_max = max(a)\n_min = min(a)\nresult = 20000 * N\n\nfor i in range(_min,_max+1,1):\n _result = 0\n for j in a:\n _result += (i - int(j))**2\n if _result <= result:\n result = _result\nprint(result)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"b = input().split()",
"b",
"input().split()",
"().split",
"()",
"input",
"split",
"a = list(map((lambda x: int(x)), b))",
"a",
"list(map((lambda x: int(x)), b))",
"list",
"map((lambda x: int(x)), b)",
"map",
"lambda x: int(x)",
"int(x)",
"int",
"x",
"x",
"b",
"_max = max(a)",
"_max",
"max(a)",
"max",
"a",
"_min = min(a)",
"_min",
"min(a)",
"min",
"a",
"result = 20000 * N",
"result",
"20000 * N",
"20000",
"N",
"for i in range(_min,_max+1,1):\n _result = 0\n for j in a:\n _result += (i - int(j))**2\n if _result <= result:\n result = _result",
"i",
"range(_min,_max+1,1)",
"range",
"_min",
"_max+1",
"_max",
"1",
"1",
"_result = 0",
"_result",
"0",
"for j in a:\n _result += (i - int(j))**2\n ",
"j",
"a",
"_result += (i - int(j))**2",
"_result",
"(i - int(j))**2",
"i - int(j)",
"i",
"int(j)",
"int",
"j",
"2",
"if _result <= result:\n result = _result",
"_result <= result",
"_result",
"result",
"result = _result",
"result",
"_result",
"print(result)",
"print",
"result",
"N = int(input())",
"int(input())",
"N",
"a = list(map((lambda x: int(x)), b))",
"list(map((lambda x: int(x)), b))",
"a",
"b = input().split()",
"input().split()",
"b",
"_result = 0",
"0",
"_result",
"result = 20000 * N",
"20000 * N",
"result",
"_result += (i - int(j))**2",
"(i - int(j))**2",
"_result",
"_max = max(a)",
"max(a)",
"_max",
"result = _result",
"_result",
"result",
"_min = min(a)",
"min(a)",
"_min"
] | N = int(input())
b = input().split()
a = list(map((lambda x: int(x)), b))
_max = max(a)
_min = min(a)
result = 20000 * N
for i in range(_min,_max+1,1):
_result = 0
for j in a:
_result += (i - int(j))**2
if _result <= result:
result = _result
print(result) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
14,
2,
2,
4,
13,
13,
13,
17,
0,
13,
2,
4,
13,
13,
13,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
4,
13,
13,
0,
13,
2,
4,
13,
13,
13,
0,
13,
2,
2,
4,
13,
13,
13,
17,
14,
2,
2,
2,
4,
13,
13,
13,
13,
2,
13,
2,
4,
13,
13,
13,
0,
13,
13,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13
] | [
[
113,
2
],
[
110,
8
],
[
128,
20
],
[
111,
27
],
[
114,
28
],
[
122,
31
],
[
111,
35
],
[
114,
36
],
[
39,
38
],
[
114,
41
],
[
131,
43
],
[
123,
46
],
[
111,
48
],
[
38,
49
],
[
132,
53
],
[
129,
53
],
[
125,
55
],
[
111,
59
],
[
114,
60
],
[
119,
62
],
[
111,
67
],
[
114,
68
],
[
111,
76
],
[
114,
77
],
[
126,
78
],
[
120,
80
],
[
111,
84
],
[
114,
85
],
[
107,
87
],
[
120,
88
],
[
91,
90
],
[
114,
93
],
[
116,
95
],
[
108,
98
],
[
123,
98
],
[
126,
98
],
[
111,
100
],
[
90,
101
],
[
117,
105
],
[
132,
105
],
[
129,
105
],
[
120,
107
],
[
107,
108
],
[
110,
111
],
[
113,
114
],
[
116,
117
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
],
[
131,
132
]
] | [
"N = int(input())\nA = list(map(int, input().split()))\nans = 0\n\nif sum(A)%N == 0:\n x = sum(A)//N\n for i in range(N):\n ans += (x-A[i])**2\n print(ans)\nelse:\n x = sum(A)//N\n b = sum(A)//N+1\n if sum(A)/N - x > b - sum(A)/N:\n x = b\n for i in range(N):\n ans += (x-A[i])**2\n \n print(ans)\n",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = 0",
"ans",
"0",
"if sum(A)%N == 0:\n x = sum(A)//N\n for i in range(N):\n ans += (x-A[i])**2\n print(ans)\nelse:\n x = sum(A)//N\n b = sum(A)//N+1\n if sum(A)/N - x > b - sum(A)/N:\n x = b\n for i in range(N):\n ans += (x-A[i])**2\n \n print(ans)",
"sum(A)%N == 0",
"sum(A)%N",
"sum(A)",
"sum",
"A",
"N",
"0",
"x = sum(A)//N",
"x",
"sum(A)//N",
"sum(A)",
"sum",
"A",
"N",
"for i in range(N):\n ans += (x-A[i])**2\n ",
"i",
"range(N)",
"range",
"N",
"ans += (x-A[i])**2",
"ans",
"(x-A[i])**2",
"x-A[i]",
"x",
"A[i]",
"A",
"i",
"2",
"print(ans)",
"print",
"ans",
"x = sum(A)//N",
"x",
"sum(A)//N",
"sum(A)",
"sum",
"A",
"N",
"b = sum(A)//N+1",
"b",
"sum(A)//N+1",
"sum(A)//N",
"sum(A)",
"sum",
"A",
"N",
"1",
"if sum(A)/N - x > b - sum(A)/N:\n x = b\n ",
"sum(A)/N - x > b - sum(A)/N",
"sum(A)/N - x",
"sum(A)/N",
"sum(A)",
"sum",
"A",
"N",
"x",
"b - sum(A)/N",
"b",
"sum(A)/N",
"sum(A)",
"sum",
"A",
"N",
"x = b",
"x",
"b",
"for i in range(N):\n ans += (x-A[i])**2\n \n ",
"i",
"range(N)",
"range",
"N",
"ans += (x-A[i])**2",
"ans",
"(x-A[i])**2",
"x-A[i]",
"x",
"A[i]",
"A",
"i",
"2",
"print(ans)",
"print",
"ans",
"x = b",
"b",
"x",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"N = int(input())",
"int(input())",
"N",
"ans += (x-A[i])**2",
"(x-A[i])**2",
"ans",
"b = sum(A)//N+1",
"sum(A)//N+1",
"b",
"x = sum(A)//N",
"sum(A)//N",
"x",
"x = sum(A)//N",
"sum(A)//N",
"x",
"ans = 0",
"0",
"ans",
"ans += (x-A[i])**2",
"(x-A[i])**2",
"ans"
] | N = int(input())
A = list(map(int, input().split()))
ans = 0
if sum(A)%N == 0:
x = sum(A)//N
for i in range(N):
ans += (x-A[i])**2
print(ans)
else:
x = sum(A)//N
b = sum(A)//N+1
if sum(A)/N - x > b - sum(A)/N:
x = b
for i in range(N):
ans += (x-A[i])**2
print(ans)
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
2,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
2,
4,
13,
13,
13,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
4,
13,
4,
13,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
87,
4
],
[
102,
10
],
[
90,
22
],
[
103,
25
],
[
99,
27
],
[
103,
35
],
[
91,
36
],
[
88,
36
],
[
93,
38
],
[
103,
46
],
[
91,
47
],
[
88,
47
],
[
51,
50
],
[
103,
50
],
[
50,
55
],
[
100,
56
],
[
96,
59
],
[
66,
65
],
[
103,
65
],
[
65,
70
],
[
94,
71
],
[
105,
74
],
[
97,
84
],
[
106,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
]
] | [
"import numpy as np\nn = int(input())\na = list(map(int, input().split()))\nn = len(a)\nMean1 = np.floor(sum(a) / n)\nMean2 = np.ceil(sum(a) / n)\nsum1 = sum([(x-Mean1)**2 for x in a])\nsum2 = sum([(x-Mean2)**2 for x in a])\nprint(int(min(sum1, sum2)))",
"import numpy as np",
"numpy",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"n = len(a)",
"n",
"len(a)",
"len",
"a",
"Mean1 = np.floor(sum(a) / n)",
"Mean1",
"np.floor(sum(a) / n)",
"np.floor",
"np",
"floor",
"sum(a) / n",
"sum(a)",
"sum",
"a",
"n",
"Mean2 = np.ceil(sum(a) / n)",
"Mean2",
"np.ceil(sum(a) / n)",
"np.ceil",
"np",
"ceil",
"sum(a) / n",
"sum(a)",
"sum",
"a",
"n",
"(x-Mean1)**2 for x in a",
"for x in a",
"x",
"a",
"for x in a",
"(x-Mean1)**2",
"x-Mean1",
"x",
"Mean1",
"2",
"sum1 = sum([(x-Mean1)**2 for x in a])",
"sum1",
"sum([(x-Mean1)**2 for x in a])",
"sum",
"[(x-Mean1)**2 for x in a]",
"(x-Mean2)**2 for x in a",
"for x in a",
"x",
"a",
"for x in a",
"(x-Mean2)**2",
"x-Mean2",
"x",
"Mean2",
"2",
"sum2 = sum([(x-Mean2)**2 for x in a])",
"sum2",
"sum([(x-Mean2)**2 for x in a])",
"sum",
"[(x-Mean2)**2 for x in a]",
"print(int(min(sum1, sum2)))",
"print",
"int(min(sum1, sum2))",
"int",
"min(sum1, sum2)",
"min",
"sum1",
"sum2",
"n = int(input())",
"int(input())",
"n",
"n = len(a)",
"len(a)",
"n",
"Mean2 = np.ceil(sum(a) / n)",
"np.ceil(sum(a) / n)",
"Mean2",
"sum1 = sum([(x-Mean1)**2 for x in a])",
"sum([(x-Mean1)**2 for x in a])",
"sum1",
"Mean1 = np.floor(sum(a) / n)",
"np.floor(sum(a) / n)",
"Mean1",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"sum2 = sum([(x-Mean2)**2 for x in a])",
"sum([(x-Mean2)**2 for x in a])",
"sum2"
] | import numpy as np
n = int(input())
a = list(map(int, input().split()))
n = len(a)
Mean1 = np.floor(sum(a) / n)
Mean2 = np.ceil(sum(a) / n)
sum1 = sum([(x-Mean1)**2 for x in a])
sum2 = sum([(x-Mean2)**2 for x in a])
print(int(min(sum1, sum2)))
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
2,
2,
4,
13,
13,
13,
2,
4,
18,
13,
13,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
73,
4
],
[
67,
10
],
[
70,
22
],
[
68,
29
],
[
74,
30
],
[
68,
38
],
[
61,
41
],
[
45,
44
],
[
74,
47
],
[
64,
49
],
[
68,
53
],
[
44,
54
],
[
71,
55
],
[
65,
59
],
[
62,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
]
] | [
"import numpy as np\nn = int(input())\na = list(map(int, input().split()))\nmean = int(sum(a) / n + np.sign(sum(a)) * 0.5)\n#print(mean)\nans = 0\nfor i in range(n):\n ans += (a[i] - mean) ** 2\n\nprint(ans)",
"import numpy as np",
"numpy",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mean = int(sum(a) / n + np.sign(sum(a)) * 0.5)",
"mean",
"int(sum(a) / n + np.sign(sum(a)) * 0.5)",
"int",
"sum(a) / n + np.sign(sum(a)) * 0.5",
"sum(a) / n",
"sum(a)",
"sum",
"a",
"n",
"np.sign(sum(a)) * 0.5",
"np.sign(sum(a))",
"np.sign",
"np",
"sign",
"sum(a)",
"sum",
"a",
"0.5",
"ans = 0",
"ans",
"0",
"for i in range(n):\n ans += (a[i] - mean) ** 2",
"i",
"range(n)",
"range",
"n",
"ans += (a[i] - mean) ** 2",
"ans",
"(a[i] - mean) ** 2",
"a[i] - mean",
"a[i]",
"a",
"i",
"mean",
"2",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"ans += (a[i] - mean) ** 2",
"(a[i] - mean) ** 2",
"ans",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"mean = int(sum(a) / n + np.sign(sum(a)) * 0.5)",
"int(sum(a) / n + np.sign(sum(a)) * 0.5)",
"mean",
"n = int(input())",
"int(input())",
"n"
] | import numpy as np
n = int(input())
a = list(map(int, input().split()))
mean = int(sum(a) / n + np.sign(sum(a)) * 0.5)
#print(mean)
ans = 0
for i in range(n):
ans += (a[i] - mean) ** 2
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
39,
17,
17,
28,
13,
13,
28,
13,
4,
13,
17,
17,
0,
18,
13,
2,
13,
17,
2,
2,
13,
13,
17,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
51,
2
],
[
54,
8
],
[
57,
20
],
[
27,
26
],
[
55,
26
],
[
30,
29
],
[
40,
35
],
[
58,
36
],
[
29,
38
],
[
26,
42
],
[
29,
43
],
[
58,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
]
] | [
"n=int(input())\nA=list(map(int,input().split()))\nans = [0]*201\nfor a in A:\n for i in range(-100,101):\n ans[i+100] += (a-i)**2\nprint(min(ans))",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"A=list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = [0]*201",
"ans",
"[0]*201",
"[0]",
"0",
"201",
"for a in A:\n for i in range(-100,101):\n ans[i+100] += (a-i)**2",
"a",
"A",
"for i in range(-100,101):\n ans[i+100] += (a-i)**2",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"ans[i+100] += (a-i)**2",
"ans[i+100]",
"ans",
"i+100",
"i",
"100",
"(a-i)**2",
"a-i",
"a",
"i",
"2",
"print(min(ans))",
"print",
"min(ans)",
"min",
"ans",
"n=int(input())",
"int(input())",
"n",
"A=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"ans = [0]*201",
"[0]*201",
"ans"
] | n=int(input())
A=list(map(int,input().split()))
ans = [0]*201
for a in A:
for i in range(-100,101):
ans[i+100] += (a-i)**2
print(min(ans)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
17,
17,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
55,
2
],
[
67,
8
],
[
61,
20
],
[
26,
25
],
[
33,
32
],
[
68,
32
],
[
25,
37
],
[
32,
38
],
[
64,
41
],
[
58,
46
],
[
62,
49
],
[
59,
49
],
[
65,
50
],
[
59,
53
],
[
62,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
]
] | [
"N=int(input())\na = list(map(int,input().split()))\nres = 10**18\nfor val in range(-100,101):\n tmp = sum([(val-val2)**2 for val2 in a])\n res = min(res,tmp)\nprint(res)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"res = 10**18",
"res",
"10**18",
"10",
"18",
"for val in range(-100,101):\n tmp = sum([(val-val2)**2 for val2 in a])\n res = min(res,tmp)",
"val",
"range(-100,101)",
"range",
"-100",
"101",
"(val-val2)**2 for val2 in a",
"for val2 in a",
"val2",
"a",
"for val2 in a",
"(val-val2)**2",
"val-val2",
"val",
"val2",
"2",
"tmp = sum([(val-val2)**2 for val2 in a])",
"tmp",
"sum([(val-val2)**2 for val2 in a])",
"sum",
"[(val-val2)**2 for val2 in a]",
"res = min(res,tmp)",
"res",
"min(res,tmp)",
"min",
"res",
"tmp",
"print(res)",
"print",
"res",
"N=int(input())",
"int(input())",
"N",
"res = min(res,tmp)",
"min(res,tmp)",
"res",
"res = 10**18",
"10**18",
"res",
"tmp = sum([(val-val2)**2 for val2 in a])",
"sum([(val-val2)**2 for val2 in a])",
"tmp",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a"
] | N=int(input())
a = list(map(int,input().split()))
res = 10**18
for val in range(-100,101):
tmp = sum([(val-val2)**2 for val2 in a])
res = min(res,tmp)
print(res) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13
] | [
[
48,
2
],
[
57,
8
],
[
51,
20
],
[
58,
26
],
[
49,
27
],
[
60,
28
],
[
32,
31
],
[
49,
34
],
[
54,
36
],
[
58,
40
],
[
31,
41
],
[
52,
42
],
[
55,
46
],
[
61,
46
],
[
48,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
]
] | [
"N = int(input())\nA = list(map(int,input().split()))\nX,out = round(sum(A)/N),0\nfor i in range(N):\n out += (A[i]-X)**2\nprint(out)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"X,out = round(sum(A)/N),0",
"X",
"round(sum(A)/N)",
"round",
"sum(A)/N",
"sum(A)",
"sum",
"A",
"N",
"out",
"0",
"for i in range(N):\n out += (A[i]-X)**2",
"i",
"range(N)",
"range",
"N",
"out += (A[i]-X)**2",
"out",
"(A[i]-X)**2",
"A[i]-X",
"A[i]",
"A",
"i",
"X",
"2",
"print(out)",
"print",
"out",
"N = int(input())",
"int(input())",
"N",
"X,out = round(sum(A)/N),0",
"round(sum(A)/N)",
"X",
"out += (A[i]-X)**2",
"(A[i]-X)**2",
"out",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"out = round(sum(A)/N),0",
"0",
"out"
] | N = int(input())
A = list(map(int,input().split()))
X,out = round(sum(A)/N),0
for i in range(N):
out += (A[i]-X)**2
print(out)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
77,
2
],
[
71,
8
],
[
80,
20
],
[
72,
23
],
[
83,
25
],
[
72,
28
],
[
65,
30
],
[
36,
35
],
[
81,
38
],
[
84,
40
],
[
74,
43
],
[
47,
46
],
[
72,
46
],
[
86,
49
],
[
35,
52
],
[
46,
53
],
[
68,
56
],
[
66,
59
],
[
69,
59
],
[
87,
60
],
[
75,
60
],
[
69,
63
],
[
66,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
]
] | [
"N = int(input())\nA = list(map(int,input().split()))\n\nmin_a = min(A)\nmax_a = max(A)\n\nans = float(\"inf\")\nfor i in range(min_a, max_a+1):\n tmp = 0\n for j in A:\n tmp += (i - j) ** 2\n ans = min(ans, tmp)\n \nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_a = min(A)",
"min_a",
"min(A)",
"min",
"A",
"max_a = max(A)",
"max_a",
"max(A)",
"max",
"A",
"ans = float(\"inf\")",
"ans",
"float(\"inf\")",
"float",
"\"inf\"",
"for i in range(min_a, max_a+1):\n tmp = 0\n for j in A:\n tmp += (i - j) ** 2\n ans = min(ans, tmp)\n ",
"i",
"range(min_a, max_a+1)",
"range",
"min_a",
"max_a+1",
"max_a",
"1",
"tmp = 0",
"tmp",
"0",
"for j in A:\n tmp += (i - j) ** 2\n ",
"j",
"A",
"tmp += (i - j) ** 2",
"tmp",
"(i - j) ** 2",
"i - j",
"i",
"j",
"2",
"ans = min(ans, tmp)",
"ans",
"min(ans, tmp)",
"min",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"ans = float(\"inf\")",
"float(\"inf\")",
"ans",
"ans = min(ans, tmp)",
"min(ans, tmp)",
"ans",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"tmp = 0",
"0",
"tmp",
"N = int(input())",
"int(input())",
"N",
"min_a = min(A)",
"min(A)",
"min_a",
"max_a = max(A)",
"max(A)",
"max_a",
"tmp += (i - j) ** 2",
"(i - j) ** 2",
"tmp"
] | N = int(input())
A = list(map(int,input().split()))
min_a = min(A)
max_a = max(A)
ans = float("inf")
for i in range(min_a, max_a+1):
tmp = 0
for j in A:
tmp += (i - j) ** 2
ans = min(ans, tmp)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13
] | [
[
93,
2
],
[
78,
8
],
[
84,
20
],
[
24,
23
],
[
94,
26
],
[
102,
28
],
[
79,
30
],
[
23,
31
],
[
105,
33
],
[
103,
35
],
[
85,
35
],
[
94,
36
],
[
87,
38
],
[
96,
41
],
[
45,
44
],
[
94,
47
],
[
81,
49
],
[
44,
50
],
[
108,
52
],
[
56,
55
],
[
94,
58
],
[
90,
60
],
[
82,
63
],
[
106,
63
],
[
79,
65
],
[
55,
66
],
[
99,
69
],
[
97,
72
],
[
100,
72
],
[
91,
73
],
[
109,
73
],
[
88,
73
],
[
100,
76
],
[
97,
76
],
[
78,
79
],
[
44,
81
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
]
] | [
"N=int(input())\nList = list(map(int, input().split()))\nsumS = 0\nfor i in range(N):\n sumS +=List[i]\ntrial = sumS // N\nmid = 0\nres = 10000000\nfor i in range(N):\n trial += i\n mid = 0 \n for j in range(N):\n mid += (trial - List[j])**2\n res = min(res, mid)\nprint(res)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"List = list(map(int, input().split()))",
"List",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"sumS = 0",
"sumS",
"0",
"for i in range(N):\n sumS +=List[i]",
"i",
"range(N)",
"range",
"N",
"sumS +=List[i]",
"sumS",
"List[i]",
"List",
"i",
"trial = sumS // N",
"trial",
"sumS // N",
"sumS",
"N",
"mid = 0",
"mid",
"0",
"res = 10000000",
"res",
"10000000",
"for i in range(N):\n trial += i\n mid = 0 \n for j in range(N):\n mid += (trial - List[j])**2\n res = min(res, mid)",
"i",
"range(N)",
"range",
"N",
"trial += i",
"trial",
"i",
"mid = 0",
"mid",
"0",
"for j in range(N):\n mid += (trial - List[j])**2\n ",
"j",
"range(N)",
"range",
"N",
"mid += (trial - List[j])**2",
"mid",
"(trial - List[j])**2",
"trial - List[j]",
"trial",
"List[j]",
"List",
"j",
"2",
"res = min(res, mid)",
"res",
"min(res, mid)",
"min",
"res",
"mid",
"print(res)",
"print",
"res",
"List = list(map(int, input().split()))",
"list(map(int, input().split()))",
"List",
"trial += i",
"i",
"trial",
"sumS = 0",
"0",
"sumS",
"mid = 0",
"0",
"mid",
"mid += (trial - List[j])**2",
"(trial - List[j])**2",
"mid",
"N=int(input())",
"int(input())",
"N",
"res = 10000000",
"10000000",
"res",
"res = min(res, mid)",
"min(res, mid)",
"res",
"sumS +=List[i]",
"List[i]",
"sumS",
"trial = sumS // N",
"sumS // N",
"trial",
"mid = 0",
"0",
"mid"
] | N=int(input())
List = list(map(int, input().split()))
sumS = 0
for i in range(N):
sumS +=List[i]
trial = sumS // N
mid = 0
res = 10000000
for i in range(N):
trial += i
mid = 0
for j in range(N):
mid += (trial - List[j])**2
res = min(res, mid)
print(res) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
2,
2,
18,
13,
13,
13,
17,
4,
13,
4,
13,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
94,
2
],
[
73,
8
],
[
76,
20
],
[
74,
26
],
[
95,
27
],
[
91,
29
],
[
74,
35
],
[
95,
36
],
[
79,
38
],
[
88,
41
],
[
45,
44
],
[
95,
47
],
[
85,
49
],
[
74,
53
],
[
44,
54
],
[
77,
55
],
[
82,
58
],
[
74,
62
],
[
44,
63
],
[
92,
64
],
[
86,
70
],
[
80,
70
],
[
83,
71
],
[
89,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
]
] | [
"n = int(input())\na = list(map(int,input().split()))\n\na_u = round(sum(a)/n)\na_d = int(sum(a)/n)\nans_u = 0\nans_d = 0\nfor i in range(n):\n ans_u += (a[i]-a_u)**2\n ans_d += (a[i]-a_d)**2\nprint(min(ans_u,ans_d))\n#print(round(-2.5),int(-2.5))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a_u = round(sum(a)/n)",
"a_u",
"round(sum(a)/n)",
"round",
"sum(a)/n",
"sum(a)",
"sum",
"a",
"n",
"a_d = int(sum(a)/n)",
"a_d",
"int(sum(a)/n)",
"int",
"sum(a)/n",
"sum(a)",
"sum",
"a",
"n",
"ans_u = 0",
"ans_u",
"0",
"ans_d = 0",
"ans_d",
"0",
"for i in range(n):\n ans_u += (a[i]-a_u)**2\n ans_d += (a[i]-a_d)**2",
"i",
"range(n)",
"range",
"n",
"ans_u += (a[i]-a_u)**2",
"ans_u",
"(a[i]-a_u)**2",
"a[i]-a_u",
"a[i]",
"a",
"i",
"a_u",
"2",
"ans_d += (a[i]-a_d)**2",
"ans_d",
"(a[i]-a_d)**2",
"a[i]-a_d",
"a[i]",
"a",
"i",
"a_d",
"2",
"print(min(ans_u,ans_d))",
"print",
"min(ans_u,ans_d)",
"min",
"ans_u",
"ans_d",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"a_u = round(sum(a)/n)",
"round(sum(a)/n)",
"a_u",
"ans_u = 0",
"0",
"ans_u",
"ans_d += (a[i]-a_d)**2",
"(a[i]-a_d)**2",
"ans_d",
"ans_u += (a[i]-a_u)**2",
"(a[i]-a_u)**2",
"ans_u",
"ans_d = 0",
"0",
"ans_d",
"a_d = int(sum(a)/n)",
"int(sum(a)/n)",
"a_d",
"n = int(input())",
"int(input())",
"n"
] | n = int(input())
a = list(map(int,input().split()))
a_u = round(sum(a)/n)
a_d = int(sum(a)/n)
ans_u = 0
ans_d = 0
for i in range(n):
ans_u += (a[i]-a_u)**2
ans_d += (a[i]-a_d)**2
print(min(ans_u,ans_d))
#print(round(-2.5),int(-2.5)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
29,
13,
23,
13,
23,
13,
12,
13,
14,
40,
2,
13,
13,
17,
29,
4,
13,
4,
13,
13,
13,
4,
13,
13,
13,
0,
13,
2,
13,
2,
2,
13,
13,
17,
14,
40,
4,
13,
13,
13,
4,
13,
13,
2,
13,
17,
29,
4,
13,
13,
13,
13,
29,
4,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
14,
40,
4,
13,
13,
17,
4,
13,
13,
17,
4,
13,
4,
13,
13,
17,
14,
40,
4,
13,
13,
17,
4,
13,
13,
17,
4,
13,
4,
13,
13,
17,
4,
13,
4,
13,
17,
17,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
141,
2
],
[
138,
8
],
[
23,
22
],
[
26,
25
],
[
37,
25
],
[
29,
28
],
[
39,
31
],
[
25,
32
],
[
28,
35
],
[
22,
35
],
[
37,
37
],
[
39,
39
],
[
95,
45
],
[
93,
46
],
[
148,
52
],
[
97,
53
],
[
93,
54
],
[
148,
56
],
[
97,
57
],
[
95,
58
],
[
61,
60
],
[
93,
62
],
[
95,
65
],
[
93,
66
],
[
148,
71
],
[
97,
72
],
[
60,
73
],
[
148,
75
],
[
97,
76
],
[
60,
78
],
[
93,
83
],
[
60,
84
],
[
97,
85
],
[
60,
89
],
[
95,
90
],
[
97,
91
],
[
93,
93
],
[
95,
95
],
[
97,
97
],
[
148,
101
],
[
139,
102
],
[
148,
105
],
[
139,
106
],
[
148,
111
],
[
139,
112
],
[
148,
117
],
[
139,
118
],
[
148,
121
],
[
139,
122
],
[
148,
127
],
[
139,
128
],
[
145,
133
],
[
139,
136
],
[
138,
139
],
[
141,
142
]
] | [
"N=int(input())\na=list(map(int,input().split()))\ndef change(a,x):\n sum=0\n for i in a:\n sum+=(x-i)**2\n return sum\n\ndef binarysearch(left,right,a):\n if right-left<=1:\n return min(change(a,left),change(a,right))\n else:\n center=left+(right-left)//2\n if change(a,center)<=change(a,center+1):\n return binarysearch(left,center,a)\n else:\n return binarysearch(center,right,a)\n\nif change(a,100)<=change(a,99):\n print(change(a,100))\nelif change(a,-100)<=change(a,-99):\n print(change(a,-100))\nelse:\n print(binarysearch(-100,100,a))",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def change(a,x):\n sum=0\n for i in a:\n sum+=(x-i)**2\n return sum",
"change",
"sum=0",
"sum",
"0",
"for i in a:\n sum+=(x-i)**2\n ",
"i",
"a",
"sum+=(x-i)**2",
"sum",
"(x-i)**2",
"x-i",
"x",
"i",
"2",
"return sum",
"sum",
"a",
"a",
"x",
"x",
"def binarysearch(left,right,a):\n if right-left<=1:\n return min(change(a,left),change(a,right))\n else:\n center=left+(right-left)//2\n if change(a,center)<=change(a,center+1):\n return binarysearch(left,center,a)\n else:\n return binarysearch(center,right,a)",
"binarysearch",
"if right-left<=1:\n return min(change(a,left),change(a,right))\n else:\n center=left+(right-left)//2\n if change(a,center)<=change(a,center+1):\n return binarysearch(left,center,a)\n else:\n return binarysearch(center,right,a)",
"right-left<=1",
"right-left",
"right",
"left",
"1",
"return min(change(a,left),change(a,right))",
"min(change(a,left),change(a,right))",
"min",
"change(a,left)",
"change",
"a",
"left",
"change(a,right)",
"change",
"a",
"right",
"center=left+(right-left)//2",
"center",
"left+(right-left)//2",
"left",
"(right-left)//2",
"right-left",
"right",
"left",
"2",
"if change(a,center)<=change(a,center+1):\n return binarysearch(left,center,a)\n else:\n return binarysearch(center,right,a)",
"change(a,center)<=change(a,center+1)",
"change(a,center)",
"change",
"a",
"center",
"change(a,center+1)",
"change",
"a",
"center+1",
"center",
"1",
"return binarysearch(left,center,a)",
"binarysearch(left,center,a)",
"binarysearch",
"left",
"center",
"a",
"return binarysearch(center,right,a)",
"binarysearch(center,right,a)",
"binarysearch",
"center",
"right",
"a",
"left",
"left",
"right",
"right",
"a",
"a",
"if change(a,100)<=change(a,99):\n print(change(a,100))\nelif change(a,-100)<=change(a,-99):\n print(change(a,-100))\nelse:\n print(binarysearch(-100,100,a))",
"change(a,100)<=change(a,99)",
"change(a,100)",
"change",
"a",
"100",
"change(a,99)",
"change",
"a",
"99",
"print(change(a,100))",
"print",
"change(a,100)",
"change",
"a",
"100",
"elif change(a,-100)<=change(a,-99):\n print(change(a,-100))",
"change(a,-100)<=change(a,-99)",
"change(a,-100)",
"change",
"a",
"-100",
"change(a,-99)",
"change",
"a",
"-99",
"print(change(a,-100))",
"print",
"change(a,-100)",
"change",
"a",
"-100",
"print(binarysearch(-100,100,a))",
"print",
"binarysearch(-100,100,a)",
"binarysearch",
"-100",
"100",
"a",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"N=int(input())",
"int(input())",
"N",
"def binarysearch(left,right,a):\n if right-left<=1:\n return min(change(a,left),change(a,right))\n else:\n center=left+(right-left)//2\n if change(a,center)<=change(a,center+1):\n return binarysearch(left,center,a)\n else:\n return binarysearch(center,right,a)",
"def binarysearch(left,right,a):\n if right-left<=1:\n return min(change(a,left),change(a,right))\n else:\n center=left+(right-left)//2\n if change(a,center)<=change(a,center+1):\n return binarysearch(left,center,a)\n else:\n return binarysearch(center,right,a)",
"binarysearch",
"def change(a,x):\n sum=0\n for i in a:\n sum+=(x-i)**2\n return sum",
"def change(a,x):\n sum=0\n for i in a:\n sum+=(x-i)**2\n return sum",
"change"
] | N=int(input())
a=list(map(int,input().split()))
def change(a,x):
sum=0
for i in a:
sum+=(x-i)**2
return sum
def binarysearch(left,right,a):
if right-left<=1:
return min(change(a,left),change(a,right))
else:
center=left+(right-left)//2
if change(a,center)<=change(a,center+1):
return binarysearch(left,center,a)
else:
return binarysearch(center,right,a)
if change(a,100)<=change(a,99):
print(change(a,100))
elif change(a,-100)<=change(a,-99):
print(change(a,-100))
else:
print(binarysearch(-100,100,a)) |
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
18,
13,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
4,
13,
4,
18,
13,
13,
2,
2,
13,
13,
17,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
60,
4
],
[
57,
10
],
[
63,
26
],
[
32,
31
],
[
54,
37
],
[
58,
46
],
[
31,
47
],
[
64,
49
],
[
55,
49
],
[
55,
52
],
[
64,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
]
] | [
"import numpy as np\nn = int(input())\na = np.asarray(list(map(int, input().split())))\nm = float('inf')\n\nfor i in range(-100, 101):\n m = min(np.sum((a-i)**2), m)\nprint(m)",
"import numpy as np",
"numpy",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = np.asarray(list(map(int, input().split())))",
"a",
"np.asarray(list(map(int, input().split())))",
"np.asarray",
"np",
"asarray",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"m = float('inf')",
"m",
"float('inf')",
"float",
"'inf'",
"for i in range(-100, 101):\n m = min(np.sum((a-i)**2), m)",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"m = min(np.sum((a-i)**2), m)",
"m",
"min(np.sum((a-i)**2), m)",
"min",
"np.sum((a-i)**2)",
"np.sum",
"np",
"sum",
"(a-i)**2",
"a-i",
"a",
"i",
"2",
"m",
"print(m)",
"print",
"m",
"m = min(np.sum((a-i)**2), m)",
"min(np.sum((a-i)**2), m)",
"m",
"a = np.asarray(list(map(int, input().split())))",
"np.asarray(list(map(int, input().split())))",
"a",
"n = int(input())",
"int(input())",
"n",
"m = float('inf')",
"float('inf')",
"m"
] | import numpy as np
n = int(input())
a = np.asarray(list(map(int, input().split())))
m = float('inf')
for i in range(-100, 101):
m = min(np.sum((a-i)**2), m)
print(m)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13
] | [
[
57,
2
],
[
63,
8
],
[
66,
20
],
[
26,
25
],
[
72,
31
],
[
35,
34
],
[
58,
37
],
[
69,
39
],
[
25,
42
],
[
64,
44
],
[
34,
45
],
[
60,
48
],
[
67,
51
],
[
61,
51
],
[
70,
52
],
[
73,
52
],
[
61,
55
],
[
67,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
]
] | [
"n = int(input())\na = list(map(int, input().split()))\n\nans = 10**9\nfor num in range(-100, 101):\n temp = 0\n for i in range(n):\n temp += (num - a[i])**2\n ans = min(ans, temp)\n\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = 10**9",
"ans",
"10**9",
"10",
"9",
"for num in range(-100, 101):\n temp = 0\n for i in range(n):\n temp += (num - a[i])**2\n ans = min(ans, temp)",
"num",
"range(-100, 101)",
"range",
"-100",
"101",
"temp = 0",
"temp",
"0",
"for i in range(n):\n temp += (num - a[i])**2\n ",
"i",
"range(n)",
"range",
"n",
"temp += (num - a[i])**2",
"temp",
"(num - a[i])**2",
"num - a[i]",
"num",
"a[i]",
"a",
"i",
"2",
"ans = min(ans, temp)",
"ans",
"min(ans, temp)",
"min",
"ans",
"temp",
"print(ans)",
"print",
"ans",
"n = int(input())",
"int(input())",
"n",
"ans = min(ans, temp)",
"min(ans, temp)",
"ans",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"ans = 10**9",
"10**9",
"ans",
"temp += (num - a[i])**2",
"(num - a[i])**2",
"temp",
"temp = 0",
"0",
"temp"
] | n = int(input())
a = list(map(int, input().split()))
ans = 10**9
for num in range(-100, 101):
temp = 0
for i in range(n):
temp += (num - a[i])**2
ans = min(ans, temp)
print(ans) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
4,
13,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
62,
2
],
[
68,
6
],
[
65,
18
],
[
22,
21
],
[
69,
26
],
[
69,
30
],
[
74,
33
],
[
37,
36
],
[
69,
41
],
[
71,
43
],
[
69,
47
],
[
36,
48
],
[
21,
49
],
[
66,
53
],
[
72,
55
],
[
75,
55
],
[
66,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] | [
"N = input()\nlist1 = list(map(int,input().split()))\nlist2 = []\nfor i in range(min(list1),max(list1)+1):\n a = 0\n for j in range(len(list1)):\n a += (list1[j] - i)**2\n list2.append(a)\nprint(min(list2))",
"N = input()",
"N",
"input()",
"input",
"list1 = list(map(int,input().split()))",
"list1",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"list2 = []",
"list2",
"[]",
"for i in range(min(list1),max(list1)+1):\n a = 0\n for j in range(len(list1)):\n a += (list1[j] - i)**2\n list2.append(a)",
"i",
"range(min(list1),max(list1)+1)",
"range",
"min(list1)",
"min",
"list1",
"max(list1)+1",
"max(list1)",
"max",
"list1",
"1",
"a = 0",
"a",
"0",
"for j in range(len(list1)):\n a += (list1[j] - i)**2\n ",
"j",
"range(len(list1))",
"range",
"len(list1)",
"len",
"list1",
"a += (list1[j] - i)**2",
"a",
"(list1[j] - i)**2",
"list1[j] - i",
"list1[j]",
"list1",
"j",
"i",
"2",
"list2.append(a)",
"list2.append",
"list2",
"append",
"a",
"print(min(list2))",
"print",
"min(list2)",
"min",
"list2",
"N = input()",
"input()",
"N",
"list2 = []",
"[]",
"list2",
"list1 = list(map(int,input().split()))",
"list(map(int,input().split()))",
"list1",
"a += (list1[j] - i)**2",
"(list1[j] - i)**2",
"a",
"a = 0",
"0",
"a"
] | N = input()
list1 = list(map(int,input().split()))
list2 = []
for i in range(min(list1),max(list1)+1):
a = 0
for j in range(len(list1)):
a += (list1[j] - i)**2
list2.append(a)
print(min(list2)) |
[
7,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
4,
13,
2,
4,
13,
13,
4,
13,
13,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13
] | [
[
54,
2
],
[
48,
6
],
[
60,
18
],
[
57,
21
],
[
49,
27
],
[
49,
30
],
[
33,
32
],
[
49,
32
],
[
51,
35
],
[
32,
38
],
[
58,
39
],
[
63,
42
],
[
52,
43
],
[
64,
46
],
[
61,
46
],
[
48,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
],
[
52,
63
],
[
63,
64
]
] | [
"s=input();a=list(map(int,input().split()));ans=0\nmean=round(sum(a)/len(a))\n\nfor i in a:\n p=(i-mean)**2\n ans+=p\n \nprint(ans)",
"s=input()",
"s",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans=0",
"ans",
"0",
"mean=round(sum(a)/len(a))",
"mean",
"round(sum(a)/len(a))",
"round",
"sum(a)/len(a)",
"sum(a)",
"sum",
"a",
"len(a)",
"len",
"a",
"for i in a:\n p=(i-mean)**2\n ans+=p\n ",
"i",
"a",
"p=(i-mean)**2",
"p",
"(i-mean)**2",
"i-mean",
"i",
"mean",
"2",
"ans+=p",
"ans",
"p",
"print(ans)",
"print",
"ans",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"p=(i-mean)**2",
"(i-mean)**2",
"p",
"s=input()",
"input()",
"s",
"mean=round(sum(a)/len(a))",
"round(sum(a)/len(a))",
"mean",
"ans=0",
"0",
"ans",
"ans+=p",
"p",
"ans"
] | s=input();a=list(map(int,input().split()));ans=0
mean=round(sum(a)/len(a))
for i in a:
p=(i-mean)**2
ans+=p
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
17,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
63,
2
],
[
69,
8
],
[
66,
20
],
[
26,
25
],
[
57,
32
],
[
36,
35
],
[
70,
35
],
[
60,
38
],
[
35,
41
],
[
25,
42
],
[
54,
45
],
[
61,
48
],
[
58,
48
],
[
67,
49
],
[
55,
49
],
[
55,
52
],
[
67,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
]
] | [
"n = int(input())\nA = list(map(int, input().split()))\n\nans = float('inf')\nfor x in range(-100, 101, 1):\n c = 0\n for a in A:\n c += (a - x) ** 2\n ans = min(c, ans)\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = float('inf')",
"ans",
"float('inf')",
"float",
"'inf'",
"for x in range(-100, 101, 1):\n c = 0\n for a in A:\n c += (a - x) ** 2\n ans = min(c, ans)",
"x",
"range(-100, 101, 1)",
"range",
"-100",
"101",
"1",
"c = 0",
"c",
"0",
"for a in A:\n c += (a - x) ** 2\n ",
"a",
"A",
"c += (a - x) ** 2",
"c",
"(a - x) ** 2",
"a - x",
"a",
"x",
"2",
"ans = min(c, ans)",
"ans",
"min(c, ans)",
"min",
"c",
"ans",
"print(ans)",
"print",
"ans",
"ans = min(c, ans)",
"min(c, ans)",
"ans",
"c = 0",
"0",
"c",
"c += (a - x) ** 2",
"(a - x) ** 2",
"c",
"n = int(input())",
"int(input())",
"n",
"ans = float('inf')",
"float('inf')",
"ans",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A"
] | n = int(input())
A = list(map(int, input().split()))
ans = float('inf')
for x in range(-100, 101, 1):
c = 0
for a in A:
c += (a - x) ** 2
ans = min(c, ans)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
57,
2
],
[
51,
8
],
[
48,
20
],
[
52,
26
],
[
58,
27
],
[
54,
29
],
[
33,
32
],
[
52,
32
],
[
45,
35
],
[
32,
38
],
[
49,
39
],
[
46,
43
],
[
55,
43
],
[
45,
46
],
[
48,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
]
] | [
"N = int(input())\nlst = list(map(int, input().split()))\navg = round(sum(lst) / N)\n\nresult = 0\nfor i in lst:\n result += (i - avg)**2\n\nprint(result)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"lst = list(map(int, input().split()))",
"lst",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"avg = round(sum(lst) / N)",
"avg",
"round(sum(lst) / N)",
"round",
"sum(lst) / N",
"sum(lst)",
"sum",
"lst",
"N",
"result = 0",
"result",
"0",
"for i in lst:\n result += (i - avg)**2",
"i",
"lst",
"result += (i - avg)**2",
"result",
"(i - avg)**2",
"i - avg",
"i",
"avg",
"2",
"print(result)",
"print",
"result",
"result += (i - avg)**2",
"(i - avg)**2",
"result",
"avg = round(sum(lst) / N)",
"round(sum(lst) / N)",
"avg",
"lst = list(map(int, input().split()))",
"list(map(int, input().split()))",
"lst",
"result = 0",
"0",
"result",
"N = int(input())",
"int(input())",
"N"
] | N = int(input())
lst = list(map(int, input().split()))
avg = round(sum(lst) / N)
result = 0
for i in lst:
result += (i - avg)**2
print(result)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
53,
2
],
[
65,
8
],
[
56,
20
],
[
26,
25
],
[
68,
31
],
[
35,
34
],
[
66,
34
],
[
59,
37
],
[
34,
40
],
[
25,
41
],
[
62,
44
],
[
57,
47
],
[
63,
47
],
[
60,
48
],
[
69,
48
],
[
63,
51
],
[
57,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] | [
"n = int(input())\nA = list(map(int, input().split()))\nmin_cost = float(\"inf\")\nfor num in range(-100, 101):\n cost = 0\n for a in A:\n cost += (a - num) ** 2\n min_cost = min(min_cost, cost)\nprint(min_cost)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min_cost = float(\"inf\")",
"min_cost",
"float(\"inf\")",
"float",
"\"inf\"",
"for num in range(-100, 101):\n cost = 0\n for a in A:\n cost += (a - num) ** 2\n min_cost = min(min_cost, cost)",
"num",
"range(-100, 101)",
"range",
"-100",
"101",
"cost = 0",
"cost",
"0",
"for a in A:\n cost += (a - num) ** 2\n ",
"a",
"A",
"cost += (a - num) ** 2",
"cost",
"(a - num) ** 2",
"a - num",
"a",
"num",
"2",
"min_cost = min(min_cost, cost)",
"min_cost",
"min(min_cost, cost)",
"min",
"min_cost",
"cost",
"print(min_cost)",
"print",
"min_cost",
"n = int(input())",
"int(input())",
"n",
"min_cost = float(\"inf\")",
"float(\"inf\")",
"min_cost",
"cost += (a - num) ** 2",
"(a - num) ** 2",
"cost",
"min_cost = min(min_cost, cost)",
"min(min_cost, cost)",
"min_cost",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"cost = 0",
"0",
"cost"
] | n = int(input())
A = list(map(int, input().split()))
min_cost = float("inf")
for num in range(-100, 101):
cost = 0
for a in A:
cost += (a - num) ** 2
min_cost = min(min_cost, cost)
print(min_cost) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
4,
13,
13,
13,
0,
13,
2,
13,
17,
0,
13,
4,
13,
17,
28,
13,
39,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
67,
2
],
[
82,
8
],
[
73,
20
],
[
83,
24
],
[
68,
25
],
[
85,
27
],
[
74,
29
],
[
76,
32
],
[
38,
37
],
[
70,
42
],
[
46,
45
],
[
83,
45
],
[
64,
48
],
[
37,
51
],
[
45,
52
],
[
79,
55
],
[
77,
58
],
[
80,
58
],
[
65,
59
],
[
71,
59
],
[
80,
62
],
[
77,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
]
] | [
"n = int(input())\na_ls = list(map(int, input().split()))\nsmall = sum(a_ls)//n\nbig = small + 1\nans = float('inf')\nfor goal in [big, small]:\n Sum = 0\n for a in a_ls:\n Sum += (goal - a) ** 2\n ans = min(ans, Sum)\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a_ls = list(map(int, input().split()))",
"a_ls",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"small = sum(a_ls)//n",
"small",
"sum(a_ls)//n",
"sum(a_ls)",
"sum",
"a_ls",
"n",
"big = small + 1",
"big",
"small + 1",
"small",
"1",
"ans = float('inf')",
"ans",
"float('inf')",
"float",
"'inf'",
"for goal in [big, small]:\n Sum = 0\n for a in a_ls:\n Sum += (goal - a) ** 2\n ans = min(ans, Sum)",
"goal",
"[big, small]",
"big",
"small",
"Sum = 0",
"Sum",
"0",
"for a in a_ls:\n Sum += (goal - a) ** 2\n ",
"a",
"a_ls",
"Sum += (goal - a) ** 2",
"Sum",
"(goal - a) ** 2",
"goal - a",
"goal",
"a",
"2",
"ans = min(ans, Sum)",
"ans",
"min(ans, Sum)",
"min",
"ans",
"Sum",
"print(ans)",
"print",
"ans",
"Sum += (goal - a) ** 2",
"(goal - a) ** 2",
"Sum",
"n = int(input())",
"int(input())",
"n",
"Sum = 0",
"0",
"Sum",
"small = sum(a_ls)//n",
"sum(a_ls)//n",
"small",
"ans = float('inf')",
"float('inf')",
"ans",
"ans = min(ans, Sum)",
"min(ans, Sum)",
"ans",
"a_ls = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a_ls",
"big = small + 1",
"small + 1",
"big"
] | n = int(input())
a_ls = list(map(int, input().split()))
small = sum(a_ls)//n
big = small + 1
ans = float('inf')
for goal in [big, small]:
Sum = 0
for a in a_ls:
Sum += (goal - a) ** 2
ans = min(ans, Sum)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
41,
28,
13,
4,
13,
17,
4,
39,
0,
13,
13,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
13,
2,
2,
13,
18,
13,
13,
17,
0,
18,
13,
2,
13,
17,
13,
4,
13,
4,
13,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
77,
2
],
[
80,
8
],
[
22,
21
],
[
68,
28
],
[
32,
31
],
[
74,
37
],
[
41,
40
],
[
78,
43
],
[
71,
45
],
[
75,
47
],
[
72,
47
],
[
31,
50
],
[
81,
52
],
[
40,
53
],
[
61,
56
],
[
69,
57
],
[
31,
59
],
[
72,
61
],
[
75,
61
],
[
69,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
]
] | [
"N = int(input())\nl = list(map(int,input().split()))\nl_ans = [[] for _ in range(201)]\n\nfor i in range(-100,101):\n sum = 0\n\n for j in range(N):\n sum = sum + (i-l[j])**2\n\n l_ans[i+100] = sum\n\nprint(min(l_ans))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"l = list(map(int,input().split()))",
"l",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"[] for _ in range(201)",
"for _ in range(201)",
"_",
"range(201)",
"range",
"201",
"for _ in range(201)",
"[]",
"l_ans = [[] for _ in range(201)]",
"l_ans",
"[[] for _ in range(201)]",
"for i in range(-100,101):\n sum = 0\n\n for j in range(N):\n sum = sum + (i-l[j])**2\n\n l_ans[i+100] = sum",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"sum = 0",
"sum",
"0",
"for j in range(N):\n sum = sum + (i-l[j])**2\n\n ",
"j",
"range(N)",
"range",
"N",
"sum = sum + (i-l[j])**2",
"sum",
"sum + (i-l[j])**2",
"sum",
"(i-l[j])**2",
"i-l[j]",
"i",
"l[j]",
"l",
"j",
"2",
"l_ans[i+100] = sum",
"l_ans[i+100]",
"l_ans",
"i+100",
"i",
"100",
"sum",
"print(min(l_ans))",
"print",
"min(l_ans)",
"min",
"l_ans",
"l_ans = [[] for _ in range(201)]",
"[[] for _ in range(201)]",
"l_ans",
"sum = sum + (i-l[j])**2",
"sum + (i-l[j])**2",
"sum",
"sum = 0",
"0",
"sum",
"N = int(input())",
"int(input())",
"N",
"l = list(map(int,input().split()))",
"list(map(int,input().split()))",
"l"
] | N = int(input())
l = list(map(int,input().split()))
l_ans = [[] for _ in range(201)]
for i in range(-100,101):
sum = 0
for j in range(N):
sum = sum + (i-l[j])**2
l_ans[i+100] = sum
print(min(l_ans)) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
12,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
13,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
4,
13,
13,
2,
4,
13,
13,
17,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
18,
13,
10,
12,
13
] | [
[
81,
4
],
[
14,
13
],
[
82,
17
],
[
20,
19
],
[
82,
30
],
[
35,
34
],
[
40,
39
],
[
19,
44
],
[
19,
48
],
[
53,
52
],
[
19,
52
],
[
52,
57
],
[
39,
58
],
[
62,
61
],
[
67,
66
],
[
34,
69
],
[
66,
69
],
[
61,
70
],
[
66,
73
],
[
34,
73
],
[
85,
79
],
[
81,
82
]
] | [
"import sys\nreadline = sys.stdin.readline\n\ndef main():\n N = int(readline())\n A = list(map(int, readline().rstrip().split()))\n ans = 10 ** 7\n for i in range(min(A), max(A)+1):\n c = sum([(a-i)**2 for a in A])\n ans = min(ans, c)\n \n print(ans)\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"readline = sys.stdin.readline",
"readline",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"def main():\n N = int(readline())\n A = list(map(int, readline().rstrip().split()))\n ans = 10 ** 7\n for i in range(min(A), max(A)+1):\n c = sum([(a-i)**2 for a in A])\n ans = min(ans, c)\n \n print(ans)",
"main",
"N = int(readline())",
"N",
"int(readline())",
"int",
"readline()",
"readline",
"A = list(map(int, readline().rstrip().split()))",
"A",
"list(map(int, readline().rstrip().split()))",
"list",
"map(int, readline().rstrip().split())",
"map",
"int",
"readline().rstrip().split()",
"().rstrip().split",
"().rstrip()",
"().rstrip",
"()",
"readline",
"rstrip",
"split",
"ans = 10 ** 7",
"ans",
"10 ** 7",
"10",
"7",
"for i in range(min(A), max(A)+1):\n c = sum([(a-i)**2 for a in A])\n ans = min(ans, c)\n \n ",
"i",
"range(min(A), max(A)+1)",
"range",
"min(A)",
"min",
"A",
"max(A)+1",
"max(A)",
"max",
"A",
"1",
"(a-i)**2 for a in A",
"for a in A",
"a",
"A",
"for a in A",
"(a-i)**2",
"a-i",
"a",
"i",
"2",
"c = sum([(a-i)**2 for a in A])",
"c",
"sum([(a-i)**2 for a in A])",
"sum",
"[(a-i)**2 for a in A]",
"ans = min(ans, c)",
"ans",
"min(ans, c)",
"min",
"ans",
"c",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"readline = sys.stdin.readline",
"sys.stdin.readline",
"readline",
"def main():\n N = int(readline())\n A = list(map(int, readline().rstrip().split()))\n ans = 10 ** 7\n for i in range(min(A), max(A)+1):\n c = sum([(a-i)**2 for a in A])\n ans = min(ans, c)\n \n print(ans)",
"def main():\n N = int(readline())\n A = list(map(int, readline().rstrip().split()))\n ans = 10 ** 7\n for i in range(min(A), max(A)+1):\n c = sum([(a-i)**2 for a in A])\n ans = min(ans, c)\n \n print(ans)",
"main"
] | import sys
readline = sys.stdin.readline
def main():
N = int(readline())
A = list(map(int, readline().rstrip().split()))
ans = 10 ** 7
for i in range(min(A), max(A)+1):
c = sum([(a-i)**2 for a in A])
ans = min(ans, c)
print(ans)
if __name__ == '__main__':
main() |
[
7,
0,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
31,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
0,
13,
39,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
2,
13,
17,
0,
13,
13,
14,
2,
13,
2,
13,
17,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
94,
2
],
[
94,
12
],
[
76,
15
],
[
95,
18
],
[
85,
20
],
[
82,
28
],
[
32,
31
],
[
88,
37
],
[
41,
40
],
[
77,
43
],
[
95,
43
],
[
97,
45
],
[
86,
48
],
[
40,
49
],
[
31,
50
],
[
91,
52
],
[
98,
54
],
[
79,
57
],
[
92,
58
],
[
40,
61
],
[
77,
63
],
[
95,
63
],
[
83,
67
],
[
80,
69
],
[
89,
69
],
[
83,
74
],
[
76,
77
],
[
92,
79
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
]
] | [
"N,*a = open(0).read().split()\n\nN=int(N)\n\nlist1=list(map(int,a))\n\n#print(N)\n\n#print(list1)\n\na=[]\n\nfor i in range(-100,101):\n int1=0\n for n in range(N):\n x = (list1[n]-i)\n y = x**2\n int1+=y\n if n==N-1:\n a.append(int1)\n \n#print(a)\n\n#print(max(a))\n\nprint(min(a))",
"N,*a = open(0).read().split()",
"N",
"open(0).read().split()",
"(0).read().split",
"(0).read()",
"(0).read",
"(0)",
"open",
"0",
"read",
"split",
"*a",
"a",
"N=int(N)",
"N",
"int(N)",
"int",
"N",
"list1=list(map(int,a))",
"list1",
"list(map(int,a))",
"list",
"map(int,a)",
"map",
"int",
"a",
"a=[]",
"a",
"[]",
"for i in range(-100,101):\n int1=0\n for n in range(N):\n x = (list1[n]-i)\n y = x**2\n int1+=y\n if n==N-1:\n a.append(int1)\n \n#print(a)\n\n#print(max(a))",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"int1=0",
"int1",
"0",
"for n in range(N):\n x = (list1[n]-i)\n y = x**2\n int1+=y\n if n==N-1:\n a.append(int1)\n \n#print(a)\n\n#print(max(a))",
"n",
"range(N)",
"range",
"N",
"x = (list1[n]-i)",
"x",
"list1[n]-i",
"list1[n]",
"list1",
"n",
"i",
"y = x**2",
"y",
"x**2",
"x",
"2",
"int1+=y",
"int1",
"y",
"if n==N-1:\n a.append(int1)\n \n#print(a)\n\n#print(max(a))",
"n==N-1",
"n",
"N-1",
"N",
"1",
"a.append(int1)",
"a.append",
"a",
"append",
"int1",
"print(min(a))",
"print",
"min(a)",
"min",
"a",
"N=int(N)",
"int(N)",
"N",
"int1+=y",
"y",
"int1",
"a=[]",
"[]",
"a",
"list1=list(map(int,a))",
"list(map(int,a))",
"list1",
"int1=0",
"0",
"int1",
"y = x**2",
"x**2",
"y",
"N,*a = open(0).read().split()",
"open(0).read().split()",
"N",
"x = (list1[n]-i)",
"list1[n]-i",
"x"
] | N,*a = open(0).read().split()
N=int(N)
list1=list(map(int,a))
#print(N)
#print(list1)
a=[]
for i in range(-100,101):
int1=0
for n in range(N):
x = (list1[n]-i)
y = x**2
int1+=y
if n==N-1:
a.append(int1)
#print(a)
#print(max(a))
print(min(a)) |
[
7,
15,
13,
13,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
18,
13,
13,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
4,
18,
13,
13,
13,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
4,
13,
13,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
98,
6
],
[
110,
13
],
[
99,
17
],
[
21,
20
],
[
99,
24
],
[
20,
29
],
[
92,
31
],
[
101,
34
],
[
93,
43
],
[
95,
45
],
[
93,
54
],
[
58,
57
],
[
93,
57
],
[
57,
62
],
[
102,
63
],
[
104,
66
],
[
73,
72
],
[
93,
72
],
[
72,
77
],
[
96,
78
],
[
107,
81
],
[
105,
89
],
[
108,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
]
] | [
"# -*- coding:utf-8 -*-\nimport sys,math,statistics\ninput = sys.stdin.readline\nn = int(input())\na = [int(_) for _ in input().split()]\nc1 = math.floor(statistics.mean(a))\nc2 = math.ceil(statistics.mean(a))\na1 = sum([(i-c1)**2 for i in a])\na2 = sum([(i-c2)**2 for i in a])\nprint(min(a1,a2))",
"import sys,math,statistics",
"sys",
"math",
"statistics",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"a = [int(_) for _ in input().split()]",
"a",
"[int(_) for _ in input().split()]",
"c1 = math.floor(statistics.mean(a))",
"c1",
"math.floor(statistics.mean(a))",
"math.floor",
"math",
"floor",
"statistics.mean(a)",
"statistics.mean",
"statistics",
"mean",
"a",
"c2 = math.ceil(statistics.mean(a))",
"c2",
"math.ceil(statistics.mean(a))",
"math.ceil",
"math",
"ceil",
"statistics.mean(a)",
"statistics.mean",
"statistics",
"mean",
"a",
"(i-c1)**2 for i in a",
"for i in a",
"i",
"a",
"for i in a",
"(i-c1)**2",
"i-c1",
"i",
"c1",
"2",
"a1 = sum([(i-c1)**2 for i in a])",
"a1",
"sum([(i-c1)**2 for i in a])",
"sum",
"[(i-c1)**2 for i in a]",
"(i-c2)**2 for i in a",
"for i in a",
"i",
"a",
"for i in a",
"(i-c2)**2",
"i-c2",
"i",
"c2",
"2",
"a2 = sum([(i-c2)**2 for i in a])",
"a2",
"sum([(i-c2)**2 for i in a])",
"sum",
"[(i-c2)**2 for i in a]",
"print(min(a1,a2))",
"print",
"min(a1,a2)",
"min",
"a1",
"a2",
"a = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"a",
"c2 = math.ceil(statistics.mean(a))",
"math.ceil(statistics.mean(a))",
"c2",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"c1 = math.floor(statistics.mean(a))",
"math.floor(statistics.mean(a))",
"c1",
"a1 = sum([(i-c1)**2 for i in a])",
"sum([(i-c1)**2 for i in a])",
"a1",
"a2 = sum([(i-c2)**2 for i in a])",
"sum([(i-c2)**2 for i in a])",
"a2",
"n = int(input())",
"int(input())",
"n"
] | # -*- coding:utf-8 -*-
import sys,math,statistics
input = sys.stdin.readline
n = int(input())
a = [int(_) for _ in input().split()]
c1 = math.floor(statistics.mean(a))
c2 = math.ceil(statistics.mean(a))
a1 = sum([(i-c1)**2 for i in a])
a2 = sum([(i-c2)**2 for i in a])
print(min(a1,a2)) |
[
7,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
2,
2,
13,
13,
17,
13,
0,
13,
8,
2,
4,
13,
2,
13,
2,
13,
13,
4,
13,
2,
13,
2,
13,
13,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
8,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13
] | [
[
87,
2
],
[
10,
9
],
[
9,
18
],
[
84,
20
],
[
96,
23
],
[
85,
26
],
[
99,
28
],
[
97,
30
],
[
88,
31
],
[
78,
33
],
[
97,
37
],
[
88,
38
],
[
88,
40
],
[
90,
42
],
[
97,
48
],
[
100,
50
],
[
88,
51
],
[
97,
55
],
[
79,
57
],
[
88,
58
],
[
100,
59
],
[
79,
60
],
[
93,
62
],
[
66,
65
],
[
85,
65
],
[
81,
68
],
[
65,
71
],
[
91,
72
],
[
82,
76
],
[
94,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
]
] | [
"n = int(input())\na_list = [int(x) for x in input().split()]\n\na_sum = sum(a_list)\nf = a_sum // n\nc = (a_sum + n - 1) // n\nb = f if abs(a_sum - f * n) < abs(a_sum - c * n) else c\n\nans = 0\nfor a in a_list:\n ans += (a - b) ** 2\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"int(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)",
"int",
"x",
"a_list = [int(x) for x in input().split()]",
"a_list",
"[int(x) for x in input().split()]",
"a_sum = sum(a_list)",
"a_sum",
"sum(a_list)",
"sum",
"a_list",
"f = a_sum // n",
"f",
"a_sum // n",
"a_sum",
"n",
"c = (a_sum + n - 1) // n",
"c",
"(a_sum + n - 1) // n",
"a_sum + n - 1",
"a_sum + n",
"a_sum",
"n",
"1",
"n",
"b = f if abs(a_sum - f * n) < abs(a_sum - c * n) else c",
"b",
"f if abs(a_sum - f * n) < abs(a_sum - c * n) else c",
"abs(a_sum - f * n) < abs(a_sum - c * n)",
"abs(a_sum - f * n)",
"abs",
"a_sum - f * n",
"a_sum",
"f * n",
"f",
"n",
"abs(a_sum - c * n)",
"abs",
"a_sum - c * n",
"a_sum",
"c * n",
"c",
"n",
"f",
"c",
"ans = 0",
"ans",
"0",
"for a in a_list:\n ans += (a - b) ** 2",
"a",
"a_list",
"ans += (a - b) ** 2",
"ans",
"(a - b) ** 2",
"a - b",
"a",
"b",
"2",
"print(ans)",
"print",
"ans",
"c = (a_sum + n - 1) // n",
"(a_sum + n - 1) // n",
"c",
"ans += (a - b) ** 2",
"(a - b) ** 2",
"ans",
"a_list = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"a_list",
"n = int(input())",
"int(input())",
"n",
"b = f if abs(a_sum - f * n) < abs(a_sum - c * n) else c",
"f if abs(a_sum - f * n) < abs(a_sum - c * n) else c",
"b",
"ans = 0",
"0",
"ans",
"a_sum = sum(a_list)",
"sum(a_list)",
"a_sum",
"f = a_sum // n",
"a_sum // n",
"f"
] | n = int(input())
a_list = [int(x) for x in input().split()]
a_sum = sum(a_list)
f = a_sum // n
c = (a_sum + n - 1) // n
b = f if abs(a_sum - f * n) < abs(a_sum - c * n) else c
ans = 0
for a in a_list:
ans += (a - b) ** 2
print(ans) |
[
7,
15,
0,
13,
17,
13,
17,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
4,
13,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
17,
4,
13,
4,
13,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
77,
3
],
[
83,
5
],
[
71,
8
],
[
89,
14
],
[
68,
26
],
[
90,
30
],
[
90,
33
],
[
86,
35
],
[
69,
38
],
[
92,
40
],
[
69,
43
],
[
46,
45
],
[
90,
45
],
[
74,
48
],
[
45,
51
],
[
87,
52
],
[
80,
55
],
[
45,
58
],
[
93,
59
],
[
75,
65
],
[
78,
65
],
[
81,
66
],
[
84,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
]
] | [
"from math import ceil,floor\nansc,ansf = 0,0\nn = int(input())\na = list(map(int,input().split()))\n \ngp = sum(a)/len(a)\nc = ceil(gp)\nf = floor(gp)\n\nfor i in a:\n ansc += (i-c)**2\n ansf += (i-f)**2\n \nprint(min(ansc,ansf))",
"from math import ceil,floor",
"ansc,ansf = 0,0",
"ansc",
"0",
"ansf",
"0",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"gp = sum(a)/len(a)",
"gp",
"sum(a)/len(a)",
"sum(a)",
"sum",
"a",
"len(a)",
"len",
"a",
"c = ceil(gp)",
"c",
"ceil(gp)",
"ceil",
"gp",
"f = floor(gp)",
"f",
"floor(gp)",
"floor",
"gp",
"for i in a:\n ansc += (i-c)**2\n ansf += (i-f)**2\n ",
"i",
"a",
"ansc += (i-c)**2",
"ansc",
"(i-c)**2",
"i-c",
"i",
"c",
"2",
"ansf += (i-f)**2",
"ansf",
"(i-f)**2",
"i-f",
"i",
"f",
"2",
"print(min(ansc,ansf))",
"print",
"min(ansc,ansf)",
"min",
"ansc",
"ansf",
"gp = sum(a)/len(a)",
"sum(a)/len(a)",
"gp",
"n = int(input())",
"int(input())",
"n",
"ansc += (i-c)**2",
"(i-c)**2",
"ansc",
"ansc,ansf = 0,0",
"0",
"ansc",
"ansf += (i-f)**2",
"(i-f)**2",
"ansf",
"ansf = 0,0",
"0",
"ansf",
"c = ceil(gp)",
"ceil(gp)",
"c",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"f = floor(gp)",
"floor(gp)",
"f"
] | from math import ceil,floor
ansc,ansf = 0,0
n = int(input())
a = list(map(int,input().split()))
gp = sum(a)/len(a)
c = ceil(gp)
f = floor(gp)
for i in a:
ansc += (i-c)**2
ansf += (i-f)**2
print(min(ansc,ansf)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
12,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
29,
13,
23,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
17,
17,
0,
13,
4,
13,
13,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
12,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
74,
2
],
[
77,
8
],
[
23,
22
],
[
26,
25
],
[
78,
25
],
[
29,
28
],
[
25,
31
],
[
37,
32
],
[
28,
35
],
[
22,
35
],
[
37,
37
],
[
68,
39
],
[
45,
44
],
[
80,
50
],
[
66,
52
],
[
44,
53
],
[
81,
56
],
[
69,
57
],
[
72,
57
],
[
71,
59
],
[
81,
60
],
[
72,
63
],
[
69,
63
],
[
68,
69
],
[
81,
71
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
]
] | [
"N = int(input())\nA = list(map(int,input().split()))\n\ndef ans_one(i):\n ans=0\n for a in A:\n ans += (a-i)**2\n return ans\n\nans=10**20\nfor i in range(-102,103):\n ans_ = ans_one(i)\n if ans_ < ans:\n ans =ans_\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"def ans_one(i):\n ans=0\n for a in A:\n ans += (a-i)**2\n return ans",
"ans_one",
"ans=0",
"ans",
"0",
"for a in A:\n ans += (a-i)**2\n ",
"a",
"A",
"ans += (a-i)**2",
"ans",
"(a-i)**2",
"a-i",
"a",
"i",
"2",
"return ans",
"ans",
"i",
"i",
"ans=10**20",
"ans",
"10**20",
"10",
"20",
"for i in range(-102,103):\n ans_ = ans_one(i)\n if ans_ < ans:\n ans =ans_",
"i",
"range(-102,103)",
"range",
"-102",
"103",
"ans_ = ans_one(i)",
"ans_",
"ans_one(i)",
"ans_one",
"i",
"if ans_ < ans:\n ans =ans_",
"ans_ < ans",
"ans_",
"ans",
"ans =ans_",
"ans",
"ans_",
"print(ans)",
"print",
"ans",
"def ans_one(i):\n ans=0\n for a in A:\n ans += (a-i)**2\n return ans",
"def ans_one(i):\n ans=0\n for a in A:\n ans += (a-i)**2\n return ans",
"ans_one",
"ans=10**20",
"10**20",
"ans",
"ans =ans_",
"ans_",
"ans",
"N = int(input())",
"int(input())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"ans_ = ans_one(i)",
"ans_one(i)",
"ans_"
] | N = int(input())
A = list(map(int,input().split()))
def ans_one(i):
ans=0
for a in A:
ans += (a-i)**2
return ans
ans=10**20
for i in range(-102,103):
ans_ = ans_one(i)
if ans_ < ans:
ans =ans_
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
65,
2
],
[
59,
8
],
[
56,
20
],
[
26,
25
],
[
68,
31
],
[
35,
34
],
[
60,
34
],
[
53,
37
],
[
34,
40
],
[
25,
41
],
[
62,
44
],
[
57,
47
],
[
63,
47
],
[
54,
48
],
[
69,
48
],
[
63,
51
],
[
57,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] | [
"n = int(input())\na = list(map(int, input().split()))\n\nres = float('inf')\nfor i in range(-100, 101):\n s = 0\n for v in a:\n s += (v - i) ** 2\n res = min(res, s)\n\nprint(res)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"res = float('inf')",
"res",
"float('inf')",
"float",
"'inf'",
"for i in range(-100, 101):\n s = 0\n for v in a:\n s += (v - i) ** 2\n res = min(res, s)",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"s = 0",
"s",
"0",
"for v in a:\n s += (v - i) ** 2\n ",
"v",
"a",
"s += (v - i) ** 2",
"s",
"(v - i) ** 2",
"v - i",
"v",
"i",
"2",
"res = min(res, s)",
"res",
"min(res, s)",
"min",
"res",
"s",
"print(res)",
"print",
"res",
"s += (v - i) ** 2",
"(v - i) ** 2",
"s",
"res = float('inf')",
"float('inf')",
"res",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"res = min(res, s)",
"min(res, s)",
"res",
"n = int(input())",
"int(input())",
"n",
"s = 0",
"0",
"s"
] | n = int(input())
a = list(map(int, input().split()))
res = float('inf')
for i in range(-100, 101):
s = 0
for v in a:
s += (v - i) ** 2
res = min(res, s)
print(res) |
[
7,
15,
13,
13,
15,
15,
15,
15,
15,
15,
15,
15,
15,
15,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
0,
13,
4,
13,
0,
13,
13,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
12,
13
] | [
[
25,
24
],
[
107,
30
],
[
34,
34
],
[
118,
43
],
[
121,
48
],
[
112,
55
],
[
116,
57
],
[
97,
59
],
[
95,
61
],
[
124,
63
],
[
119,
64
],
[
67,
66
],
[
109,
72
],
[
76,
75
],
[
98,
75
],
[
103,
78
],
[
75,
81
],
[
66,
82
],
[
127,
85
],
[
125,
88
],
[
128,
88
],
[
104,
89
],
[
110,
89
],
[
128,
92
],
[
125,
92
],
[
97,
98
],
[
103,
104
],
[
109,
110
],
[
112,
113
],
[
118,
119
],
[
121,
122
],
[
119,
124
],
[
124,
125
],
[
127,
128
]
] | [
"import sys, re\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2\nfrom collections import deque, defaultdict, Counter\nfrom itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left\nfrom fractions import gcd\nfrom heapq import heappush, heappop, heapify\nfrom functools import reduce\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10 ** 9 + 7\n\nN = INT()\na = LIST()\n\nans = INF\nfor y in range(-100, 101):\n\ttmp = 0\n\tfor x in a:\n\t\ttmp += (x-y)**2\n\tans = min(ans, tmp)\nprint(ans)",
"import sys, re",
"sys",
"re",
"from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2",
"from collections import deque, defaultdict, Counter",
"from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby",
"from operator import itemgetter, mul",
"from copy import deepcopy",
"from string import ascii_lowercase, ascii_uppercase, digits",
"from bisect import bisect, bisect_left",
"from fractions import gcd",
"from heapq import heappush, heappop, heapify",
"from functools import reduce",
"def input(): return sys.stdin.readline().strip()",
"input",
"def INT(): return int(input())",
"INT",
"def MAP(): return map(int, input().split())",
"MAP",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"MAP() for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"MAP()",
"MAP",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"n",
"n",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"INF = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N = INT()",
"N",
"INT()",
"INT",
"a = LIST()",
"a",
"LIST()",
"LIST",
"ans = INF",
"ans",
"INF",
"for y in range(-100, 101):\n\ttmp = 0\n\tfor x in a:\n\t\ttmp += (x-y)**2\n\tans = min(ans, tmp)",
"y",
"range(-100, 101)",
"range",
"-100",
"101",
"tmp = 0",
"tmp",
"0",
"for x in a:\n\t\ttmp += (x-y)**2\n\t",
"x",
"a",
"tmp += (x-y)**2",
"tmp",
"(x-y)**2",
"x-y",
"x",
"y",
"2",
"ans = min(ans, tmp)",
"ans",
"min(ans, tmp)",
"min",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"def LIST(): return list(map(int, input().split()))",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"a = LIST()",
"LIST()",
"a",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"tmp += (x-y)**2",
"(x-y)**2",
"tmp",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"tmp = 0",
"0",
"tmp",
"N = INT()",
"INT()",
"N",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT",
"INF = float('inf')",
"float('inf')",
"INF",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"ans = INF",
"INF",
"ans",
"ans = min(ans, tmp)",
"min(ans, tmp)",
"ans",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input"
] | import sys, re
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2
from collections import deque, defaultdict, Counter
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop, heapify
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N = INT()
a = LIST()
ans = INF
for y in range(-100, 101):
tmp = 0
for x in a:
tmp += (x-y)**2
ans = min(ans, tmp)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
14,
40,
13,
13,
0,
13,
2,
2,
13,
13,
2,
13,
13,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13
] | [
[
67,
2
],
[
64,
8
],
[
58,
20
],
[
24,
23
],
[
70,
29
],
[
33,
32
],
[
65,
32
],
[
23,
36
],
[
32,
37
],
[
61,
39
],
[
32,
42
],
[
23,
43
],
[
32,
45
],
[
23,
46
],
[
59,
49
],
[
74,
49
],
[
62,
50
],
[
71,
50
],
[
73,
52
],
[
62,
53
],
[
71,
53
],
[
74,
56
],
[
59,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
62,
73
],
[
71,
73
],
[
73,
74
]
] | [
"num = int(input())\nl = list(map(int,input().split()))\nmin = 1000000\nfor n in range(-100,101):\n sum = 0\n for i in l:\n if n !=i:\n sum += (i-n)*(i-n)\n \n if min > sum:\n min = sum\n\nprint(min)",
"num = int(input())",
"num",
"int(input())",
"int",
"input()",
"input",
"l = list(map(int,input().split()))",
"l",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"min = 1000000",
"min",
"1000000",
"for n in range(-100,101):\n sum = 0\n for i in l:\n if n !=i:\n sum += (i-n)*(i-n)\n \n if min > sum:\n min = sum",
"n",
"range(-100,101)",
"range",
"-100",
"101",
"sum = 0",
"sum",
"0",
"for i in l:\n if n !=i:\n sum += (i-n)*(i-n)\n \n ",
"i",
"l",
"if n !=i:\n sum += (i-n)*(i-n)\n \n ",
"n !=i",
"n",
"i",
"sum += (i-n)*(i-n)",
"sum",
"(i-n)*(i-n)",
"i-n",
"i",
"n",
"i-n",
"i",
"n",
"if min > sum:\n min = sum",
"min > sum",
"min",
"sum",
"min = sum",
"min",
"sum",
"print(min)",
"print",
"min",
"min = 1000000",
"1000000",
"min",
"sum += (i-n)*(i-n)",
"(i-n)*(i-n)",
"sum",
"l = list(map(int,input().split()))",
"list(map(int,input().split()))",
"l",
"num = int(input())",
"int(input())",
"num",
"sum = 0",
"0",
"sum",
"min = sum",
"sum",
"min"
] | num = int(input())
l = list(map(int,input().split()))
min = 1000000
for n in range(-100,101):
sum = 0
for i in l:
if n !=i:
sum += (i-n)*(i-n)
if min > sum:
min = sum
print(min) |
[
7,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
2,
4,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
13,
2,
2,
18,
13,
13,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
13,
2,
2,
18,
13,
13,
13,
17,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13
] | [
[
87,
2
],
[
10,
9
],
[
9,
18
],
[
84,
20
],
[
96,
23
],
[
85,
27
],
[
88,
28
],
[
105,
30
],
[
34,
33
],
[
88,
36
],
[
93,
38
],
[
106,
40
],
[
94,
40
],
[
85,
44
],
[
33,
45
],
[
97,
46
],
[
50,
49
],
[
99,
55
],
[
59,
58
],
[
88,
61
],
[
102,
63
],
[
100,
65
],
[
103,
65
],
[
85,
69
],
[
58,
70
],
[
49,
71
],
[
94,
75
],
[
106,
75
],
[
91,
75
],
[
103,
76
],
[
100,
76
],
[
90,
78
],
[
103,
79
],
[
100,
79
],
[
91,
82
],
[
94,
82
],
[
106,
82
],
[
84,
85
],
[
87,
88
],
[
103,
90
],
[
100,
90
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
],
[
105,
106
]
] | [
"\nN = int(input())\nlist = [int(a) for a in input().split()]\n\nA = sum(list)//N\nans = 0\n\nfor k in range(N):\n ans = ans + (list[k] - A) ** 2\n\nfor i in range(-100,100):\n sum_new = 0\n for j in range(N):\n sum_new = sum_new + (list[j] - i) ** 2\n if(ans > sum_new):\n ans = sum_new\n\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"int(a) for a in input().split()",
"for a in input().split()",
"a",
"input().split()",
"().split",
"()",
"input",
"split",
"for a in input().split()",
"int(a)",
"int",
"a",
"list = [int(a) for a in input().split()]",
"list",
"[int(a) for a in input().split()]",
"A = sum(list)//N",
"A",
"sum(list)//N",
"sum(list)",
"sum",
"list",
"N",
"ans = 0",
"ans",
"0",
"for k in range(N):\n ans = ans + (list[k] - A) ** 2",
"k",
"range(N)",
"range",
"N",
"ans = ans + (list[k] - A) ** 2",
"ans",
"ans + (list[k] - A) ** 2",
"ans",
"(list[k] - A) ** 2",
"list[k] - A",
"list[k]",
"list",
"k",
"A",
"2",
"for i in range(-100,100):\n sum_new = 0\n for j in range(N):\n sum_new = sum_new + (list[j] - i) ** 2\n if(ans > sum_new):\n ans = sum_new",
"i",
"range(-100,100)",
"range",
"-100",
"100",
"sum_new = 0",
"sum_new",
"0",
"for j in range(N):\n sum_new = sum_new + (list[j] - i) ** 2\n ",
"j",
"range(N)",
"range",
"N",
"sum_new = sum_new + (list[j] - i) ** 2",
"sum_new",
"sum_new + (list[j] - i) ** 2",
"sum_new",
"(list[j] - i) ** 2",
"list[j] - i",
"list[j]",
"list",
"j",
"i",
"2",
"if(ans > sum_new):\n ans = sum_new",
"ans > sum_new",
"ans",
"sum_new",
"ans = sum_new",
"ans",
"sum_new",
"print(ans)",
"print",
"ans",
"list = [int(a) for a in input().split()]",
"[int(a) for a in input().split()]",
"list",
"N = int(input())",
"int(input())",
"N",
"ans = sum_new",
"sum_new",
"ans",
"ans = ans + (list[k] - A) ** 2",
"ans + (list[k] - A) ** 2",
"ans",
"A = sum(list)//N",
"sum(list)//N",
"A",
"sum_new = 0",
"0",
"sum_new",
"sum_new = sum_new + (list[j] - i) ** 2",
"sum_new + (list[j] - i) ** 2",
"sum_new",
"ans = 0",
"0",
"ans"
] |
N = int(input())
list = [int(a) for a in input().split()]
A = sum(list)//N
ans = 0
for k in range(N):
ans = ans + (list[k] - A) ** 2
for i in range(-100,100):
sum_new = 0
for j in range(N):
sum_new = sum_new + (list[j] - i) ** 2
if(ans > sum_new):
ans = sum_new
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
2,
13,
18,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] | [
[
62,
2
],
[
59,
8
],
[
65,
20
],
[
24,
23
],
[
68,
29
],
[
33,
32
],
[
63,
35
],
[
71,
37
],
[
23,
40
],
[
60,
42
],
[
32,
43
],
[
23,
45
],
[
60,
47
],
[
32,
48
],
[
74,
50
],
[
66,
53
],
[
75,
53
],
[
72,
54
],
[
69,
54
],
[
75,
57
],
[
66,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] | [
"n = int(input())\nA = list(map(int, input().split()))\n\nans = 1000000000\n\nfor i in range(-101, 101):\n tmp = 0\n for j in range (n):\n tmp += (i - A[j]) * (i - A[j])\n ans = min(ans, tmp)\n\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = 1000000000",
"ans",
"1000000000",
"for i in range(-101, 101):\n tmp = 0\n for j in range (n):\n tmp += (i - A[j]) * (i - A[j])\n ans = min(ans, tmp)",
"i",
"range(-101, 101)",
"range",
"-101",
"101",
"tmp = 0",
"tmp",
"0",
"for j in range (n):\n tmp += (i - A[j]) * (i - A[j])\n ",
"j",
"range (n)",
"range",
"n",
"tmp += (i - A[j]) * (i - A[j])",
"tmp",
"(i - A[j]) * (i - A[j])",
"i - A[j]",
"i",
"A[j]",
"A",
"j",
"i - A[j]",
"i",
"A[j]",
"A",
"j",
"ans = min(ans, tmp)",
"ans",
"min(ans, tmp)",
"min",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"n = int(input())",
"int(input())",
"n",
"ans = 1000000000",
"1000000000",
"ans",
"tmp = 0",
"0",
"tmp",
"tmp += (i - A[j]) * (i - A[j])",
"(i - A[j]) * (i - A[j])",
"tmp",
"ans = min(ans, tmp)",
"min(ans, tmp)",
"ans"
] | n = int(input())
A = list(map(int, input().split()))
ans = 1000000000
for i in range(-101, 101):
tmp = 0
for j in range (n):
tmp += (i - A[j]) * (i - A[j])
ans = min(ans, tmp)
print(ans)
|
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
17,
4,
4,
13,
13,
0,
13,
13,
0,
13,
2,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
4,
13,
4,
13,
39,
13,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
96,
4
],
[
12,
11
],
[
11,
21
],
[
84,
23
],
[
87,
26
],
[
85,
30
],
[
97,
31
],
[
99,
33
],
[
88,
38
],
[
93,
40
],
[
88,
45
],
[
49,
48
],
[
85,
48
],
[
48,
53
],
[
100,
54
],
[
102,
57
],
[
64,
63
],
[
85,
63
],
[
63,
68
],
[
94,
69
],
[
90,
72
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
],
[
99,
100
],
[
102,
103
]
] | [
"import math\n \nN = int(input())\nA = [int(a) for a in input().split(\" \")]\nave = sum(A) / N\ncan1 = math.floor(ave)\ncan2 = math.ceil(ave)\n \ncost1 = sum([(a - can1) ** 2 for a in A])\ncost2 = sum([(a - can2) ** 2 for a in A])\nprint(min([cost1, cost2]))",
"import math",
"math",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"int(a) for a in input().split(\" \")",
"for a in input().split(\" \")",
"a",
"input().split(\" \")",
"().split",
"()",
"input",
"split",
"\" \"",
"for a in input().split(\" \")",
"int(a)",
"int",
"a",
"A = [int(a) for a in input().split(\" \")]",
"A",
"[int(a) for a in input().split(\" \")]",
"ave = sum(A) / N",
"ave",
"sum(A) / N",
"sum(A)",
"sum",
"A",
"N",
"can1 = math.floor(ave)",
"can1",
"math.floor(ave)",
"math.floor",
"math",
"floor",
"ave",
"can2 = math.ceil(ave)",
"can2",
"math.ceil(ave)",
"math.ceil",
"math",
"ceil",
"ave",
"(a - can1) ** 2 for a in A",
"for a in A",
"a",
"A",
"for a in A",
"(a - can1) ** 2",
"a - can1",
"a",
"can1",
"2",
"cost1 = sum([(a - can1) ** 2 for a in A])",
"cost1",
"sum([(a - can1) ** 2 for a in A])",
"sum",
"[(a - can1) ** 2 for a in A]",
"(a - can2) ** 2 for a in A",
"for a in A",
"a",
"A",
"for a in A",
"(a - can2) ** 2",
"a - can2",
"a",
"can2",
"2",
"cost2 = sum([(a - can2) ** 2 for a in A])",
"cost2",
"sum([(a - can2) ** 2 for a in A])",
"sum",
"[(a - can2) ** 2 for a in A]",
"print(min([cost1, cost2]))",
"print",
"min([cost1, cost2])",
"min",
"[cost1, cost2]",
"cost1",
"cost2",
"A = [int(a) for a in input().split(\" \")]",
"[int(a) for a in input().split(\" \")]",
"A",
"ave = sum(A) / N",
"sum(A) / N",
"ave",
"cost2 = sum([(a - can2) ** 2 for a in A])",
"sum([(a - can2) ** 2 for a in A])",
"cost2",
"can2 = math.ceil(ave)",
"math.ceil(ave)",
"can2",
"N = int(input())",
"int(input())",
"N",
"can1 = math.floor(ave)",
"math.floor(ave)",
"can1",
"cost1 = sum([(a - can1) ** 2 for a in A])",
"sum([(a - can1) ** 2 for a in A])",
"cost1"
] | import math
N = int(input())
A = [int(a) for a in input().split(" ")]
ave = sum(A) / N
can1 = math.floor(ave)
can2 = math.ceil(ave)
cost1 = sum([(a - can1) ** 2 for a in A])
cost2 = sum([(a - can2) ** 2 for a in A])
print(min([cost1, cost2])) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
17,
0,
13,
39,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
28,
13,
4,
13,
4,
13,
13,
2,
4,
13,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
18,
13,
13,
13,
0,
13,
17,
4,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
65,
2
],
[
74,
8
],
[
68,
11
],
[
77,
14
],
[
28,
27
],
[
78,
32
],
[
78,
36
],
[
40,
39
],
[
78,
39
],
[
71,
42
],
[
27,
45
],
[
39,
46
],
[
69,
50
],
[
72,
52
],
[
75,
52
],
[
63,
52
],
[
62,
54
],
[
69,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
]
] | [
"count = int(input())\nsum_n = 0\nsum_list = []\n\nli = list(map(int, input().split(\" \")))\n\nfor i in range(min(li),max(li) + 1):\n for j in li:\n sum_n += (i - j)**2\n sum_list.append(sum_n)\n sum_n = 0\n \nprint(min(sum_list))",
"count = int(input())",
"count",
"int(input())",
"int",
"input()",
"input",
"sum_n = 0",
"sum_n",
"0",
"sum_list = []",
"sum_list",
"[]",
"li = list(map(int, input().split(\" \")))",
"li",
"list(map(int, input().split(\" \")))",
"list",
"map(int, input().split(\" \"))",
"map",
"int",
"input().split(\" \")",
"().split",
"()",
"input",
"split",
"\" \"",
"for i in range(min(li),max(li) + 1):\n for j in li:\n sum_n += (i - j)**2\n sum_list.append(sum_n)\n sum_n = 0\n ",
"i",
"range(min(li),max(li) + 1)",
"range",
"min(li)",
"min",
"li",
"max(li) + 1",
"max(li)",
"max",
"li",
"1",
"for j in li:\n sum_n += (i - j)**2\n ",
"j",
"li",
"sum_n += (i - j)**2",
"sum_n",
"(i - j)**2",
"i - j",
"i",
"j",
"2",
"sum_list.append(sum_n)",
"sum_list.append",
"sum_list",
"append",
"sum_n",
"sum_n = 0",
"sum_n",
"0",
"print(min(sum_list))",
"print",
"min(sum_list)",
"min",
"sum_list",
"sum_n = 0",
"0",
"sum_n",
"count = int(input())",
"int(input())",
"count",
"sum_list = []",
"[]",
"sum_list",
"sum_n += (i - j)**2",
"(i - j)**2",
"sum_n",
"sum_n = 0",
"0",
"sum_n",
"li = list(map(int, input().split(\" \")))",
"list(map(int, input().split(\" \")))",
"li"
] | count = int(input())
sum_n = 0
sum_list = []
li = list(map(int, input().split(" ")))
for i in range(min(li),max(li) + 1):
for j in li:
sum_n += (i - j)**2
sum_list.append(sum_n)
sum_n = 0
print(min(sum_list)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
2,
17,
17,
0,
13,
17,
28,
13,
4,
13,
17,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
2,
4,
13,
18,
13,
13,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
17,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13
] | [
[
80,
2
],
[
71,
8
],
[
74,
17
],
[
83,
20
],
[
77,
25
],
[
29,
28
],
[
35,
34
],
[
72,
39
],
[
92,
41
],
[
72,
47
],
[
34,
48
],
[
28,
49
],
[
84,
53
],
[
90,
53
],
[
93,
54
],
[
75,
54
],
[
87,
54
],
[
89,
56
],
[
93,
57
],
[
75,
57
],
[
87,
57
],
[
68,
59
],
[
28,
60
],
[
86,
62
],
[
90,
66
],
[
84,
66
],
[
28,
68
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
93,
89
],
[
75,
89
],
[
87,
89
],
[
89,
90
],
[
92,
93
]
] | [
"n = int(input())\nl = list(input().split())\nsum = 0\nmin_sum = 10**10\nnum = 0\nfor i in range(-100,101):\n for j in range(len(l)):\n sum += (int(l[j]) - i)**2\n if min_sum > sum:\n min_sum = sum\n num = i\n sum = 0\n\nprint(min_sum)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"l = list(input().split())",
"l",
"list(input().split())",
"list",
"input().split()",
"().split",
"()",
"input",
"split",
"sum = 0",
"sum",
"0",
"min_sum = 10**10",
"min_sum",
"10**10",
"10",
"10",
"num = 0",
"num",
"0",
"for i in range(-100,101):\n for j in range(len(l)):\n sum += (int(l[j]) - i)**2\n if min_sum > sum:\n min_sum = sum\n num = i\n sum = 0",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"for j in range(len(l)):\n sum += (int(l[j]) - i)**2\n ",
"j",
"range(len(l))",
"range",
"len(l)",
"len",
"l",
"sum += (int(l[j]) - i)**2",
"sum",
"(int(l[j]) - i)**2",
"int(l[j]) - i",
"int(l[j])",
"int",
"l[j]",
"l",
"j",
"i",
"2",
"if min_sum > sum:\n min_sum = sum\n num = i\n ",
"min_sum > sum",
"min_sum",
"sum",
"min_sum = sum",
"min_sum",
"sum",
"num = i",
"num",
"i",
"sum = 0",
"sum",
"0",
"print(min_sum)",
"print",
"min_sum",
"num = i",
"i",
"num",
"l = list(input().split())",
"list(input().split())",
"l",
"sum = 0",
"0",
"sum",
"num = 0",
"0",
"num",
"n = int(input())",
"int(input())",
"n",
"min_sum = 10**10",
"10**10",
"min_sum",
"sum = 0",
"0",
"sum",
"min_sum = sum",
"sum",
"min_sum",
"sum += (int(l[j]) - i)**2",
"(int(l[j]) - i)**2",
"sum"
] | n = int(input())
l = list(input().split())
sum = 0
min_sum = 10**10
num = 0
for i in range(-100,101):
for j in range(len(l)):
sum += (int(l[j]) - i)**2
if min_sum > sum:
min_sum = sum
num = i
sum = 0
print(min_sum) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
13,
13,
14,
40,
13,
4,
13,
13,
14,
40,
13,
2,
4,
13,
13,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
4,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
18,
13,
10,
4,
13,
10,
2,
13
] | [
[
107,
2
],
[
95,
8
],
[
98,
20
],
[
24,
23
],
[
108,
26
],
[
104,
28
],
[
96,
30
],
[
23,
31
],
[
92,
33
],
[
105,
35
],
[
99,
35
],
[
108,
36
],
[
93,
39
],
[
93,
42
],
[
93,
45
],
[
93,
49
],
[
86,
52
],
[
93,
56
],
[
101,
59
],
[
93,
62
],
[
89,
64
],
[
68,
67
],
[
108,
70
],
[
110,
72
],
[
102,
75
],
[
87,
75
],
[
93,
75
],
[
96,
77
],
[
67,
78
],
[
111,
84
],
[
90,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
]
] | [
"n = int(input())\nAs = list(map(int, input().split()))\n\ntotal = 0\nfor i in range(n):\n total += As[i]\n\n# detect optimal number\nave = total / n\n\nif ave != int(ave):\n if ave >= int(ave)+0.5:\n ave = int(ave)+1\n else:\n ave = int(ave)\n\nans = 0\nfor i in range(n):\n ans += (ave-As[i])**2\n\nprint(int(ans))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"As = list(map(int, input().split()))",
"As",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"total = 0",
"total",
"0",
"for i in range(n):\n total += As[i]\n\n# detect optimal number",
"i",
"range(n)",
"range",
"n",
"total += As[i]",
"total",
"As[i]",
"As",
"i",
"ave = total / n",
"ave",
"total / n",
"total",
"n",
"if ave != int(ave):\n if ave >= int(ave)+0.5:\n ave = int(ave)+1\n else:\n ave = int(ave)",
"ave != int(ave)",
"ave",
"int(ave)",
"int",
"ave",
"if ave >= int(ave)+0.5:\n ave = int(ave)+1\n else:\n ave = int(ave)",
"ave >= int(ave)+0.5",
"ave",
"int(ave)+0.5",
"int(ave)",
"int",
"ave",
"0.5",
"ave = int(ave)+1",
"ave",
"int(ave)+1",
"int(ave)",
"int",
"ave",
"1",
"ave = int(ave)",
"ave",
"int(ave)",
"int",
"ave",
"ans = 0",
"ans",
"0",
"for i in range(n):\n ans += (ave-As[i])**2",
"i",
"range(n)",
"range",
"n",
"ans += (ave-As[i])**2",
"ans",
"(ave-As[i])**2",
"ave-As[i]",
"ave",
"As[i]",
"As",
"i",
"2",
"print(int(ans))",
"print",
"int(ans)",
"int",
"ans",
"ave = int(ave)+1",
"int(ave)+1",
"ave",
"ans = 0",
"0",
"ans",
"ave = total / n",
"total / n",
"ave",
"As = list(map(int, input().split()))",
"list(map(int, input().split()))",
"As",
"total = 0",
"0",
"total",
"ave = int(ave)",
"int(ave)",
"ave",
"total += As[i]",
"As[i]",
"total",
"n = int(input())",
"int(input())",
"n",
"ans += (ave-As[i])**2",
"(ave-As[i])**2",
"ans"
] | n = int(input())
As = list(map(int, input().split()))
total = 0
for i in range(n):
total += As[i]
# detect optimal number
ave = total / n
if ave != int(ave):
if ave >= int(ave)+0.5:
ave = int(ave)+1
else:
ave = int(ave)
ans = 0
for i in range(n):
ans += (ave-As[i])**2
print(int(ans)) |
[
7,
0,
13,
2,
17,
17,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
69,
2
],
[
66,
7
],
[
60,
13
],
[
26,
25
],
[
72,
31
],
[
35,
34
],
[
67,
37
],
[
63,
39
],
[
61,
43
],
[
34,
44
],
[
25,
45
],
[
57,
48
],
[
70,
51
],
[
58,
51
],
[
64,
52
],
[
73,
52
],
[
58,
55
],
[
70,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
]
] | [
"ans = 10 ** 9\nn = int(input())\nA = list(map(int,input().split()))\nfor i in range(-100,101):\n X = 0\n for j in range(n):\n X += (A[j] - i) ** 2\n ans = min(ans,X)\nprint(ans)",
"ans = 10 ** 9",
"ans",
"10 ** 9",
"10",
"9",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in range(-100,101):\n X = 0\n for j in range(n):\n X += (A[j] - i) ** 2\n ans = min(ans,X)",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"X = 0",
"X",
"0",
"for j in range(n):\n X += (A[j] - i) ** 2\n ",
"j",
"range(n)",
"range",
"n",
"X += (A[j] - i) ** 2",
"X",
"(A[j] - i) ** 2",
"A[j] - i",
"A[j]",
"A",
"j",
"i",
"2",
"ans = min(ans,X)",
"ans",
"min(ans,X)",
"min",
"ans",
"X",
"print(ans)",
"print",
"ans",
"ans = min(ans,X)",
"min(ans,X)",
"ans",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"X += (A[j] - i) ** 2",
"(A[j] - i) ** 2",
"X",
"n = int(input())",
"int(input())",
"n",
"ans = 10 ** 9",
"10 ** 9",
"ans",
"X = 0",
"0",
"X"
] | ans = 10 ** 9
n = int(input())
A = list(map(int,input().split()))
for i in range(-100,101):
X = 0
for j in range(n):
X += (A[j] - i) ** 2
ans = min(ans,X)
print(ans) |
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
4,
18,
13,
13,
0,
13,
18,
13,
13,
28,
13,
4,
13,
18,
13,
17,
2,
18,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
14,
40,
13,
13,
0,
13,
13,
3,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] | [
[
74,
4
],
[
86,
10
],
[
87,
23
],
[
77,
26
],
[
32,
31
],
[
87,
35
],
[
87,
39
],
[
80,
43
],
[
47,
46
],
[
75,
49
],
[
83,
51
],
[
87,
55
],
[
46,
56
],
[
31,
57
],
[
78,
61
],
[
72,
61
],
[
84,
62
],
[
81,
62
],
[
71,
64
],
[
84,
65
],
[
81,
65
],
[
72,
69
],
[
78,
69
],
[
84,
71
],
[
81,
71
],
[
71,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
]
] | [
"import math\nN = int(input())\na = list(map(int, input().split()))\na.sort()\n\nans = math.inf\nfor i in range(a[0], a[-1]+1):\n tmp = 0\n for j in range(N):\n tmp += (a[j]-i) ** 2\n if ans >= tmp:\n ans = tmp\n else:\n break\nprint(ans)",
"import math",
"math",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a.sort()",
"a.sort",
"a",
"sort",
"ans = math.inf",
"ans",
"math.inf",
"math",
"inf",
"for i in range(a[0], a[-1]+1):\n tmp = 0\n for j in range(N):\n tmp += (a[j]-i) ** 2\n if ans >= tmp:\n ans = tmp\n else:\n break",
"i",
"range(a[0], a[-1]+1)",
"range",
"a[0]",
"a",
"0",
"a[-1]+1",
"a[-1]",
"a",
"-1",
"1",
"tmp = 0",
"tmp",
"0",
"for j in range(N):\n tmp += (a[j]-i) ** 2\n ",
"j",
"range(N)",
"range",
"N",
"tmp += (a[j]-i) ** 2",
"tmp",
"(a[j]-i) ** 2",
"a[j]-i",
"a[j]",
"a",
"j",
"i",
"2",
"if ans >= tmp:\n ans = tmp\n else:\n break",
"ans >= tmp",
"ans",
"tmp",
"ans = tmp",
"ans",
"tmp",
"break",
"print(ans)",
"print",
"ans",
"ans = tmp",
"tmp",
"ans",
"N = int(input())",
"int(input())",
"N",
"ans = math.inf",
"math.inf",
"ans",
"tmp = 0",
"0",
"tmp",
"tmp += (a[j]-i) ** 2",
"(a[j]-i) ** 2",
"tmp",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] | import math
N = int(input())
a = list(map(int, input().split()))
a.sort()
ans = math.inf
for i in range(a[0], a[-1]+1):
tmp = 0
for j in range(N):
tmp += (a[j]-i) ** 2
if ans >= tmp:
ans = tmp
else:
break
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
2,
2,
13,
17,
13,
28,
13,
4,
13,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
4,
13,
2,
13,
13,
17,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13
] | [
[
88,
2
],
[
73,
8
],
[
82,
20
],
[
74,
23
],
[
76,
25
],
[
74,
28
],
[
91,
30
],
[
83,
33
],
[
89,
35
],
[
38,
37
],
[
77,
40
],
[
83,
42
],
[
79,
45
],
[
49,
48
],
[
74,
48
],
[
70,
51
],
[
48,
56
],
[
37,
57
],
[
71,
61
],
[
80,
61
],
[
92,
62
],
[
86,
62
],
[
85,
64
],
[
71,
65
],
[
80,
65
],
[
86,
68
],
[
92,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
71,
85
],
[
80,
85
],
[
85,
86
],
[
88,
89
],
[
91,
92
]
] | [
"N=int(input())\na=list(map(int,input().split()))\nmaxi=max(a)\nmini=min(a)\nans1=(maxi**2)*N\nfor i in range(mini,maxi+1):\n ans=0\n for j in a:\n ans+=abs(j-i)**2\n if ans<ans1:\n ans1=ans\nprint(ans1)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"maxi=max(a)",
"maxi",
"max(a)",
"max",
"a",
"mini=min(a)",
"mini",
"min(a)",
"min",
"a",
"ans1=(maxi**2)*N",
"ans1",
"(maxi**2)*N",
"maxi**2",
"maxi",
"2",
"N",
"for i in range(mini,maxi+1):\n ans=0\n for j in a:\n ans+=abs(j-i)**2\n if ans<ans1:\n ans1=ans",
"i",
"range(mini,maxi+1)",
"range",
"mini",
"maxi+1",
"maxi",
"1",
"ans=0",
"ans",
"0",
"for j in a:\n ans+=abs(j-i)**2\n ",
"j",
"a",
"ans+=abs(j-i)**2",
"ans",
"abs(j-i)**2",
"abs(j-i)",
"abs",
"j-i",
"j",
"i",
"2",
"if ans<ans1:\n ans1=ans",
"ans<ans1",
"ans",
"ans1",
"ans1=ans",
"ans1",
"ans",
"print(ans1)",
"print",
"ans1",
"ans+=abs(j-i)**2",
"abs(j-i)**2",
"ans",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"mini=min(a)",
"min(a)",
"mini",
"ans=0",
"0",
"ans",
"maxi=max(a)",
"max(a)",
"maxi",
"ans1=ans",
"ans",
"ans1",
"N=int(input())",
"int(input())",
"N",
"ans1=(maxi**2)*N",
"(maxi**2)*N",
"ans1"
] | N=int(input())
a=list(map(int,input().split()))
maxi=max(a)
mini=min(a)
ans1=(maxi**2)*N
for i in range(mini,maxi+1):
ans=0
for j in a:
ans+=abs(j-i)**2
if ans<ans1:
ans1=ans
print(ans1)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
4,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
92,
2
],
[
89,
8
],
[
83,
20
],
[
24,
23
],
[
77,
28
],
[
32,
31
],
[
93,
34
],
[
95,
36
],
[
90,
40
],
[
31,
41
],
[
23,
42
],
[
84,
46
],
[
96,
48
],
[
78,
48
],
[
87,
48
],
[
81,
48
],
[
80,
50
],
[
54,
53
],
[
93,
56
],
[
86,
58
],
[
90,
62
],
[
53,
63
],
[
23,
64
],
[
84,
68
],
[
87,
70
],
[
81,
70
],
[
96,
70
],
[
78,
70
],
[
84,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
]
] | [
"N = int(input())\nA = list(map(int,input().split()))\ncosts = []\n\nfor i in range(101):\n cost = 0\n for j in range(N):\n cost += (A[j]-i)**2\n costs.append(cost)\n cost = 0\n for j in range(N):\n cost += (A[j]+i)**2\n costs.append(cost)\n\nprint(min(costs))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"costs = []",
"costs",
"[]",
"for i in range(101):\n cost = 0\n for j in range(N):\n cost += (A[j]-i)**2\n costs.append(cost)\n cost = 0\n for j in range(N):\n cost += (A[j]+i)**2\n costs.append(cost)",
"i",
"range(101)",
"range",
"101",
"cost = 0",
"cost",
"0",
"for j in range(N):\n cost += (A[j]-i)**2\n ",
"j",
"range(N)",
"range",
"N",
"cost += (A[j]-i)**2",
"cost",
"(A[j]-i)**2",
"A[j]-i",
"A[j]",
"A",
"j",
"i",
"2",
"costs.append(cost)",
"costs.append",
"costs",
"append",
"cost",
"cost = 0",
"cost",
"0",
"for j in range(N):\n cost += (A[j]+i)**2\n ",
"j",
"range(N)",
"range",
"N",
"cost += (A[j]+i)**2",
"cost",
"(A[j]+i)**2",
"A[j]+i",
"A[j]",
"A",
"j",
"i",
"2",
"costs.append(cost)",
"costs.append",
"costs",
"append",
"cost",
"print(min(costs))",
"print",
"min(costs)",
"min",
"costs",
"cost = 0",
"0",
"cost",
"cost = 0",
"0",
"cost",
"costs = []",
"[]",
"costs",
"cost += (A[j]+i)**2",
"(A[j]+i)**2",
"cost",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"N = int(input())",
"int(input())",
"N",
"cost += (A[j]-i)**2",
"(A[j]-i)**2",
"cost"
] | N = int(input())
A = list(map(int,input().split()))
costs = []
for i in range(101):
cost = 0
for j in range(N):
cost += (A[j]-i)**2
costs.append(cost)
cost = 0
for j in range(N):
cost += (A[j]+i)**2
costs.append(cost)
print(min(costs)) |
[
7,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
54,
2
],
[
10,
9
],
[
9,
18
],
[
51,
20
],
[
57,
23
],
[
52,
29
],
[
55,
30
],
[
60,
32
],
[
36,
35
],
[
52,
35
],
[
48,
38
],
[
35,
41
],
[
58,
42
],
[
49,
46
],
[
61,
46
],
[
48,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
]
] | [
"n = int(input())\nA = [int(i) for i in input().split()]\nave = round(sum(A) / n)\nans = 0\nfor x in A:\n ans += (x-ave)**2\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"A = [int(i) for i in input().split()]",
"A",
"[int(i) for i in input().split()]",
"ave = round(sum(A) / n)",
"ave",
"round(sum(A) / n)",
"round",
"sum(A) / n",
"sum(A)",
"sum",
"A",
"n",
"ans = 0",
"ans",
"0",
"for x in A:\n ans += (x-ave)**2",
"x",
"A",
"ans += (x-ave)**2",
"ans",
"(x-ave)**2",
"x-ave",
"x",
"ave",
"2",
"print(ans)",
"print",
"ans",
"ans += (x-ave)**2",
"(x-ave)**2",
"ans",
"A = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"A",
"n = int(input())",
"int(input())",
"n",
"ave = round(sum(A) / n)",
"round(sum(A) / n)",
"ave",
"ans = 0",
"0",
"ans"
] | n = int(input())
A = [int(i) for i in input().split()]
ave = round(sum(A) / n)
ans = 0
for x in A:
ans += (x-ave)**2
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
4,
13,
13,
2,
4,
13,
13,
17,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
4,
18,
13,
13,
4,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
57,
2
],
[
60,
8
],
[
63,
20
],
[
24,
23
],
[
61,
28
],
[
61,
32
],
[
37,
36
],
[
61,
36
],
[
36,
41
],
[
23,
42
],
[
64,
46
],
[
64,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
]
] | [
"N = int(input())\nA = list(map(int,input().split()))\ncost = []\n\nfor n in range(min(A),max(A)+1):\n cost.append(sum([(a-n)**2 for a in A]))\n\nprint(min(cost))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"cost = []",
"cost",
"[]",
"for n in range(min(A),max(A)+1):\n cost.append(sum([(a-n)**2 for a in A]))",
"n",
"range(min(A),max(A)+1)",
"range",
"min(A)",
"min",
"A",
"max(A)+1",
"max(A)",
"max",
"A",
"1",
"(a-n)**2 for a in A",
"for a in A",
"a",
"A",
"for a in A",
"(a-n)**2",
"a-n",
"a",
"n",
"2",
"cost.append(sum([(a-n)**2 for a in A]))",
"cost.append",
"cost",
"append",
"sum([(a-n)**2 for a in A])",
"sum",
"[(a-n)**2 for a in A]",
"print(min(cost))",
"print",
"min(cost)",
"min",
"cost",
"N = int(input())",
"int(input())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"cost = []",
"[]",
"cost"
] | N = int(input())
A = list(map(int,input().split()))
cost = []
for n in range(min(A),max(A)+1):
cost.append(sum([(a-n)**2 for a in A]))
print(min(cost)) |
[
7,
15,
13,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
13,
4,
18,
13,
13,
13,
0,
13,
2,
13,
17,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
4,
13,
4,
13,
4,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13
] | [
[
59,
4
],
[
12,
11
],
[
11,
20
],
[
68,
22
],
[
62,
25
],
[
69,
32
],
[
65,
34
],
[
63,
36
],
[
41,
40
],
[
69,
40
],
[
40,
45
],
[
63,
46
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] | [
"import numpy as np\nn = int(input())\nxs = [int(x) for x in input().split()]\na = int(np.average(xs))\nb = a + 1\nprint(min(sum([(x - a) ** 2 for x in xs]), sum([(x - b) ** 2 for x in xs])))",
"import numpy as np",
"numpy",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"int(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)",
"int",
"x",
"xs = [int(x) for x in input().split()]",
"xs",
"[int(x) for x in input().split()]",
"a = int(np.average(xs))",
"a",
"int(np.average(xs))",
"int",
"np.average(xs)",
"np.average",
"np",
"average",
"xs",
"b = a + 1",
"b",
"a + 1",
"a",
"1",
"(x - a) ** 2 for x in xs",
"for x in xs",
"x",
"xs",
"for x in xs",
"(x - a) ** 2",
"x - a",
"x",
"a",
"2",
"print(min(sum([(x - a) ** 2 for x in xs]), sum([(x - b) ** 2 for x in xs])))",
"print",
"min(sum([(x - a) ** 2 for x in xs]), sum([(x - b) ** 2 for x in xs]))",
"min",
"sum([(x - a) ** 2 for x in xs])",
"sum",
"[(x - a) ** 2 for x in xs]",
"sum([(x - b) ** 2 for x in xs])",
"sum",
"[(x - b) ** 2 for x in xs]",
"n = int(input())",
"int(input())",
"n",
"a = int(np.average(xs))",
"int(np.average(xs))",
"a",
"b = a + 1",
"a + 1",
"b",
"xs = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"xs"
] | import numpy as np
n = int(input())
xs = [int(x) for x in input().split()]
a = int(np.average(xs))
b = a + 1
print(min(sum([(x - a) ** 2 for x in xs]), sum([(x - b) ** 2 for x in xs])))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
69,
2
],
[
72,
8
],
[
66,
20
],
[
24,
23
],
[
57,
29
],
[
33,
32
],
[
73,
37
],
[
60,
39
],
[
73,
43
],
[
32,
44
],
[
23,
45
],
[
63,
48
],
[
67,
51
],
[
64,
51
],
[
61,
52
],
[
58,
52
],
[
64,
55
],
[
67,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
]
] | [
"N = int(input())\nA = list(map(int,input().split()))\nans=10000000\nfor i in range(-100, 101):\n sum=0\n for a in range(len(A)):\n sum+=(A[a]-i)**2\n ans=min(ans,sum)\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans=10000000",
"ans",
"10000000",
"for i in range(-100, 101):\n sum=0\n for a in range(len(A)):\n sum+=(A[a]-i)**2\n ans=min(ans,sum)",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"sum=0",
"sum",
"0",
"for a in range(len(A)):\n sum+=(A[a]-i)**2\n ",
"a",
"range(len(A))",
"range",
"len(A)",
"len",
"A",
"sum+=(A[a]-i)**2",
"sum",
"(A[a]-i)**2",
"A[a]-i",
"A[a]",
"A",
"a",
"i",
"2",
"ans=min(ans,sum)",
"ans",
"min(ans,sum)",
"min",
"ans",
"sum",
"print(ans)",
"print",
"ans",
"sum=0",
"0",
"sum",
"sum+=(A[a]-i)**2",
"(A[a]-i)**2",
"sum",
"ans=min(ans,sum)",
"min(ans,sum)",
"ans",
"ans=10000000",
"10000000",
"ans",
"N = int(input())",
"int(input())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A"
] | N = int(input())
A = list(map(int,input().split()))
ans=10000000
for i in range(-100, 101):
sum=0
for a in range(len(A)):
sum+=(A[a]-i)**2
ans=min(ans,sum)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13
] | [
[
56,
2
],
[
65,
8
],
[
59,
20
],
[
24,
23
],
[
68,
29
],
[
33,
32
],
[
57,
35
],
[
62,
37
],
[
66,
41
],
[
32,
42
],
[
23,
43
],
[
63,
47
],
[
69,
47
],
[
60,
48
],
[
72,
48
],
[
71,
50
],
[
63,
51
],
[
69,
51
],
[
72,
54
],
[
60,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
63,
71
],
[
69,
71
],
[
71,
72
]
] | [
"n=int(input())\na=list(map(int,input().split()))\nans=10000000\nfor i in range(-100,101):\n tmp=0\n for j in range(n):\n tmp+=(a[j]-i)**2\n if tmp<ans:\n ans=tmp\nprint(ans)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans=10000000",
"ans",
"10000000",
"for i in range(-100,101):\n tmp=0\n for j in range(n):\n tmp+=(a[j]-i)**2\n if tmp<ans:\n ans=tmp",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"tmp=0",
"tmp",
"0",
"for j in range(n):\n tmp+=(a[j]-i)**2\n ",
"j",
"range(n)",
"range",
"n",
"tmp+=(a[j]-i)**2",
"tmp",
"(a[j]-i)**2",
"a[j]-i",
"a[j]",
"a",
"j",
"i",
"2",
"if tmp<ans:\n ans=tmp",
"tmp<ans",
"tmp",
"ans",
"ans=tmp",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"n=int(input())",
"int(input())",
"n",
"ans=10000000",
"10000000",
"ans",
"tmp+=(a[j]-i)**2",
"(a[j]-i)**2",
"tmp",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"tmp=0",
"0",
"tmp",
"ans=tmp",
"tmp",
"ans"
] | n=int(input())
a=list(map(int,input().split()))
ans=10000000
for i in range(-100,101):
tmp=0
for j in range(n):
tmp+=(a[j]-i)**2
if tmp<ans:
ans=tmp
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
2,
17,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
63,
2
],
[
81,
8
],
[
78,
20
],
[
69,
23
],
[
29,
28
],
[
72,
34
],
[
38,
37
],
[
82,
37
],
[
75,
40
],
[
37,
43
],
[
28,
44
],
[
76,
48
],
[
73,
48
],
[
70,
49
],
[
67,
49
],
[
60,
51
],
[
28,
52
],
[
66,
54
],
[
76,
55
],
[
73,
55
],
[
67,
58
],
[
70,
58
],
[
28,
60
],
[
60,
61
],
[
63,
64
],
[
76,
66
],
[
73,
66
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
]
] | [
"n = int(input())\na = list(map(int,input().split()))\n\nans = -100\ntmp = 10**10\n\nfor i in range(-100, 101):\n t = 0\n for j in a:\n t += (j - i) ** 2\n if t < tmp:\n ans = i\n tmp = t\n\nprint(tmp)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = -100",
"ans",
"-100",
"tmp = 10**10",
"tmp",
"10**10",
"10",
"10",
"for i in range(-100, 101):\n t = 0\n for j in a:\n t += (j - i) ** 2\n if t < tmp:\n ans = i\n tmp = t",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"t = 0",
"t",
"0",
"for j in a:\n t += (j - i) ** 2\n ",
"j",
"a",
"t += (j - i) ** 2",
"t",
"(j - i) ** 2",
"j - i",
"j",
"i",
"2",
"if t < tmp:\n ans = i\n tmp = t",
"t < tmp",
"t",
"tmp",
"ans = i",
"ans",
"i",
"tmp = t",
"tmp",
"t",
"print(tmp)",
"print",
"tmp",
"ans = i",
"i",
"ans",
"n = int(input())",
"int(input())",
"n",
"tmp = t",
"t",
"tmp",
"tmp = 10**10",
"10**10",
"tmp",
"t = 0",
"0",
"t",
"t += (j - i) ** 2",
"(j - i) ** 2",
"t",
"ans = -100",
"-100",
"ans",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a"
] | n = int(input())
a = list(map(int,input().split()))
ans = -100
tmp = 10**10
for i in range(-100, 101):
t = 0
for j in a:
t += (j - i) ** 2
if t < tmp:
ans = i
tmp = t
print(tmp)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
4,
13,
13,
13,
14,
2,
40,
13,
17,
40,
2,
13,
17,
17,
0,
13,
2,
4,
13,
13,
17,
14,
2,
2,
13,
17,
40,
2,
40,
13,
17,
17,
0,
13,
2,
4,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13
] | [
[
92,
2
],
[
98,
8
],
[
101,
20
],
[
99,
24
],
[
93,
25
],
[
102,
29
],
[
102,
33
],
[
95,
37
],
[
102,
41
],
[
102,
46
],
[
102,
51
],
[
86,
55
],
[
102,
59
],
[
83,
62
],
[
102,
65
],
[
89,
67
],
[
71,
70
],
[
99,
70
],
[
104,
73
],
[
70,
76
],
[
84,
77
],
[
87,
77
],
[
96,
77
],
[
102,
77
],
[
105,
81
],
[
90,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
]
] | [
"N=int(input())\na=list(map(int,input().split()))\nave=sum(a)/N\nif ave>=0 and ave%1>=0.5:\n ave=int(ave)+1\nelif ave<0 and -ave%1>=0.5:\n ave=int(ave)-1\nelse:\n ave=int(ave)\nans=0\nfor i in a:\n ans+=(i-ave)**2\nprint(ans)",
"N=int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ave=sum(a)/N",
"ave",
"sum(a)/N",
"sum(a)",
"sum",
"a",
"N",
"if ave>=0 and ave%1>=0.5:\n ave=int(ave)+1\nelif ave<0 and -ave%1>=0.5:\n ave=int(ave)-1\nelse:\n ave=int(ave)",
"ave>=0 and ave%1>=0.5",
"ave>=0",
"ave",
"0",
"ave%1>=0.5",
"ave%1",
"ave",
"1",
"0.5",
"ave=int(ave)+1",
"ave",
"int(ave)+1",
"int(ave)",
"int",
"ave",
"1",
"elif ave<0 and -ave%1>=0.5:\n ave=int(ave)-1",
"ave<0 and -ave%1>=0.5",
"ave<0",
"ave",
"0",
"-ave%1>=0.5",
"-ave%1",
"-ave",
"ave",
"1",
"0.5",
"ave=int(ave)-1",
"ave",
"int(ave)-1",
"int(ave)",
"int",
"ave",
"1",
"ave=int(ave)",
"ave",
"int(ave)",
"int",
"ave",
"ans=0",
"ans",
"0",
"for i in a:\n ans+=(i-ave)**2",
"i",
"a",
"ans+=(i-ave)**2",
"ans",
"(i-ave)**2",
"i-ave",
"i",
"ave",
"2",
"print(ans)",
"print",
"ans",
"ave=int(ave)",
"int(ave)",
"ave",
"ave=int(ave)-1",
"int(ave)-1",
"ave",
"ans=0",
"0",
"ans",
"N=int(input())",
"int(input())",
"N",
"ave=int(ave)+1",
"int(ave)+1",
"ave",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"ave=sum(a)/N",
"sum(a)/N",
"ave",
"ans+=(i-ave)**2",
"(i-ave)**2",
"ans"
] | N=int(input())
a=list(map(int,input().split()))
ave=sum(a)/N
if ave>=0 and ave%1>=0.5:
ave=int(ave)+1
elif ave<0 and -ave%1>=0.5:
ave=int(ave)-1
else:
ave=int(ave)
ans=0
for i in a:
ans+=(i-ave)**2
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
59,
2
],
[
62,
8
],
[
68,
20
],
[
26,
25
],
[
65,
31
],
[
35,
34
],
[
63,
34
],
[
53,
37
],
[
34,
40
],
[
25,
41
],
[
56,
44
],
[
69,
47
],
[
57,
47
],
[
54,
48
],
[
66,
48
],
[
57,
51
],
[
69,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] | [
"N = int(input())\nA = list(map(int,input().split()))\nans = float('inf')\nfor i in range(-100, 101):\n cnt = 0\n for a in A:\n cnt += (a - i) ** 2\n ans = min(ans, cnt)\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int,input().split()))",
"A",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = float('inf')",
"ans",
"float('inf')",
"float",
"'inf'",
"for i in range(-100, 101):\n cnt = 0\n for a in A:\n cnt += (a - i) ** 2\n ans = min(ans, cnt)",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"cnt = 0",
"cnt",
"0",
"for a in A:\n cnt += (a - i) ** 2\n ",
"a",
"A",
"cnt += (a - i) ** 2",
"cnt",
"(a - i) ** 2",
"a - i",
"a",
"i",
"2",
"ans = min(ans, cnt)",
"ans",
"min(ans, cnt)",
"min",
"ans",
"cnt",
"print(ans)",
"print",
"ans",
"cnt += (a - i) ** 2",
"(a - i) ** 2",
"cnt",
"ans = min(ans, cnt)",
"min(ans, cnt)",
"ans",
"N = int(input())",
"int(input())",
"N",
"A = list(map(int,input().split()))",
"list(map(int,input().split()))",
"A",
"cnt = 0",
"0",
"cnt",
"ans = float('inf')",
"float('inf')",
"ans"
] | N = int(input())
A = list(map(int,input().split()))
ans = float('inf')
for i in range(-100, 101):
cnt = 0
for a in A:
cnt += (a - i) ** 2
ans = min(ans, cnt)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
68,
2
],
[
59,
8
],
[
53,
20
],
[
26,
25
],
[
62,
31
],
[
35,
34
],
[
60,
34
],
[
56,
37
],
[
34,
40
],
[
25,
41
],
[
65,
44
],
[
54,
47
],
[
66,
47
],
[
57,
48
],
[
63,
48
],
[
66,
51
],
[
54,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] | [
"n = int(input())\na = list(map(int, input().split()))\n\nans = float(\"inf\")\nfor y in range(-100, 101):\n res = 0\n for x in a:\n res += (x - y)**2\n ans = min(ans, res)\n\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = float(\"inf\")",
"ans",
"float(\"inf\")",
"float",
"\"inf\"",
"for y in range(-100, 101):\n res = 0\n for x in a:\n res += (x - y)**2\n ans = min(ans, res)",
"y",
"range(-100, 101)",
"range",
"-100",
"101",
"res = 0",
"res",
"0",
"for x in a:\n res += (x - y)**2\n ",
"x",
"a",
"res += (x - y)**2",
"res",
"(x - y)**2",
"x - y",
"x",
"y",
"2",
"ans = min(ans, res)",
"ans",
"min(ans, res)",
"min",
"ans",
"res",
"print(ans)",
"print",
"ans",
"ans = float(\"inf\")",
"float(\"inf\")",
"ans",
"res += (x - y)**2",
"(x - y)**2",
"res",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"res = 0",
"0",
"res",
"ans = min(ans, res)",
"min(ans, res)",
"ans",
"n = int(input())",
"int(input())",
"n"
] | n = int(input())
a = list(map(int, input().split()))
ans = float("inf")
for y in range(-100, 101):
res = 0
for x in a:
res += (x - y)**2
ans = min(ans, res)
print(ans)
|
[
7,
15,
13,
4,
13,
0,
13,
4,
18,
13,
13,
4,
18,
4,
13,
13,
0,
13,
18,
13,
13,
4,
13,
4,
13,
4,
18,
2,
13,
13,
13,
2,
13,
13,
10,
4,
13
] | [
[
35,
6
],
[
18,
17
],
[
36,
28
],
[
36,
32
],
[
35,
36
]
] | [
"import numpy as np\ninput()\nA = np.array(input().split(), dtype=np.int32)\nprint(min((A - i).dot(A - i) for i in range(-100, 101)))",
"import numpy as np",
"numpy",
"input()",
"input",
"A = np.array(input().split(), dtype=np.int32)",
"A",
"np.array(input().split(), dtype=np.int32)",
"np.array",
"np",
"array",
"input().split()",
"().split",
"()",
"input",
"split",
"dtype=np.int32",
"dtype",
"np.int32",
"np",
"int32",
"print(min((A - i).dot(A - i) for i in range(-100, 101)))",
"print",
"min((A - i).dot(A - i) for i in range(-100, 101))",
"min",
"(A - i).dot(A - i)",
"A - i).dot",
"A - i",
"A",
"i",
"dot",
"A - i",
"A",
"i",
"A = np.array(input().split(), dtype=np.int32)",
"np.array(input().split(), dtype=np.int32)",
"A"
] | import numpy as np
input()
A = np.array(input().split(), dtype=np.int32)
print(min((A - i).dot(A - i) for i in range(-100, 101))) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
65,
2
],
[
68,
8
],
[
62,
20
],
[
24,
23
],
[
53,
29
],
[
33,
32
],
[
69,
32
],
[
56,
35
],
[
23,
38
],
[
32,
39
],
[
23,
41
],
[
32,
42
],
[
59,
44
],
[
63,
47
],
[
60,
47
],
[
57,
48
],
[
54,
48
],
[
60,
51
],
[
63,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] | [
"n=int(input())\na=list(map(int,input().split()))\nans=100000000\nfor i in range(-100,101):\n now=0\n for k in a:\n now+=(i-k)*(i-k)\n ans=min(ans,now)\nprint(ans)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans=100000000",
"ans",
"100000000",
"for i in range(-100,101):\n now=0\n for k in a:\n now+=(i-k)*(i-k)\n ans=min(ans,now)",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"now=0",
"now",
"0",
"for k in a:\n now+=(i-k)*(i-k)\n ",
"k",
"a",
"now+=(i-k)*(i-k)",
"now",
"(i-k)*(i-k)",
"i-k",
"i",
"k",
"i-k",
"i",
"k",
"ans=min(ans,now)",
"ans",
"min(ans,now)",
"min",
"ans",
"now",
"print(ans)",
"print",
"ans",
"now=0",
"0",
"now",
"now+=(i-k)*(i-k)",
"(i-k)*(i-k)",
"now",
"ans=min(ans,now)",
"min(ans,now)",
"ans",
"ans=100000000",
"100000000",
"ans",
"n=int(input())",
"int(input())",
"n",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a"
] | n=int(input())
a=list(map(int,input().split()))
ans=100000000
for i in range(-100,101):
now=0
for k in a:
now+=(i-k)*(i-k)
ans=min(ans,now)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
0,
13,
39,
14,
2,
4,
18,
13,
13,
18,
13,
17,
4,
13,
13,
4,
13,
17,
4,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
13,
9,
0,
13,
2,
2,
18,
13,
13,
13,
17,
4,
18,
13,
13,
13,
15,
13,
4,
18,
13,
13,
13,
4,
13,
4,
18,
13,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
97,
2
],
[
100,
8
],
[
103,
21
],
[
101,
27
],
[
101,
30
],
[
101,
34
],
[
43,
42
],
[
94,
48
],
[
52,
51
],
[
98,
54
],
[
101,
58
],
[
51,
59
],
[
42,
60
],
[
91,
63
],
[
101,
67
],
[
51,
68
],
[
42,
69
],
[
104,
73
],
[
92,
75
],
[
95,
75
],
[
104,
82
],
[
104,
89
],
[
91,
92
],
[
94,
95
],
[
97,
98
],
[
100,
101
],
[
103,
104
]
] | [
"N = int(input())\nA = list(map(int, input().split(' ')))\nans = []\nif A.count(A[0]) == len(A):\n print(0)\n exit(0)\nfor i in range(-100,101):\n cost = 0\n for j in range(N):\n if A[j] == i:\n continue\n else:\n cost += (A[j] - i)**2\n ans.append(cost)\nimport heapq\nheapq.heapify(ans)\nprint(heapq.heappop(ans))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split(' ')))",
"A",
"list(map(int, input().split(' ')))",
"list",
"map(int, input().split(' '))",
"map",
"int",
"input().split(' ')",
"().split",
"()",
"input",
"split",
"' '",
"ans = []",
"ans",
"[]",
"if A.count(A[0]) == len(A):\n print(0)\n exit(0)",
"A.count(A[0]) == len(A)",
"A.count(A[0])",
"A.count",
"A",
"count",
"A[0]",
"A",
"0",
"len(A)",
"len",
"A",
"print(0)",
"print",
"0",
"exit(0)",
"exit",
"0",
"for i in range(-100,101):\n cost = 0\n for j in range(N):\n if A[j] == i:\n continue\n else:\n cost += (A[j] - i)**2\n ans.append(cost)",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"cost = 0",
"cost",
"0",
"for j in range(N):\n if A[j] == i:\n continue\n else:\n cost += (A[j] - i)**2\n ",
"j",
"range(N)",
"range",
"N",
"if A[j] == i:\n continue\n else:\n cost += (A[j] - i)**2\n ",
"A[j] == i",
"A[j]",
"A",
"j",
"i",
"continue",
"cost += (A[j] - i)**2",
"cost",
"(A[j] - i)**2",
"A[j] - i",
"A[j]",
"A",
"j",
"i",
"2",
"ans.append(cost)",
"ans.append",
"ans",
"append",
"cost",
"import heapq",
"heapq",
"heapq.heapify(ans)",
"heapq.heapify",
"heapq",
"heapify",
"ans",
"print(heapq.heappop(ans))",
"print",
"heapq.heappop(ans)",
"heapq.heappop",
"heapq",
"heappop",
"ans",
"cost += (A[j] - i)**2",
"(A[j] - i)**2",
"cost",
"cost = 0",
"0",
"cost",
"N = int(input())",
"int(input())",
"N",
"A = list(map(int, input().split(' ')))",
"list(map(int, input().split(' ')))",
"A",
"ans = []",
"[]",
"ans"
] | N = int(input())
A = list(map(int, input().split(' ')))
ans = []
if A.count(A[0]) == len(A):
print(0)
exit(0)
for i in range(-100,101):
cost = 0
for j in range(N):
if A[j] == i:
continue
else:
cost += (A[j] - i)**2
ans.append(cost)
import heapq
heapq.heapify(ans)
print(heapq.heappop(ans)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
4,
13,
13,
13,
0,
13,
2,
2,
4,
13,
13,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
4,
13,
2,
18,
13,
13,
13,
17,
0,
13,
2,
4,
13,
2,
18,
13,
13,
13,
17,
4,
13,
4,
13,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13
] | [
[
81,
2
],
[
93,
8
],
[
75,
20
],
[
94,
24
],
[
82,
25
],
[
84,
27
],
[
94,
32
],
[
82,
33
],
[
87,
36
],
[
96,
39
],
[
43,
42
],
[
82,
45
],
[
90,
47
],
[
94,
53
],
[
42,
54
],
[
76,
55
],
[
78,
58
],
[
94,
64
],
[
42,
65
],
[
85,
66
],
[
91,
72
],
[
88,
72
],
[
79,
73
],
[
97,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
]
] | [
"n = int(input())\na = list(map(int,input().split()))\n\navg1 = sum(a) // n\navg2 = (sum(a) // n) + 1\nans1 = 0\nans2 = 0\nfor i in range(n):\n ans1 += abs(a[i] - avg1) ** 2\n ans2 += abs(a[i] - avg2) ** 2\n\nprint(min(ans1,ans2))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"avg1 = sum(a) // n",
"avg1",
"sum(a) // n",
"sum(a)",
"sum",
"a",
"n",
"avg2 = (sum(a) // n) + 1",
"avg2",
"(sum(a) // n) + 1",
"sum(a) // n",
"sum(a)",
"sum",
"a",
"n",
"1",
"ans1 = 0",
"ans1",
"0",
"ans2 = 0",
"ans2",
"0",
"for i in range(n):\n ans1 += abs(a[i] - avg1) ** 2\n ans2 += abs(a[i] - avg2) ** 2",
"i",
"range(n)",
"range",
"n",
"ans1 += abs(a[i] - avg1) ** 2",
"ans1",
"abs(a[i] - avg1) ** 2",
"abs(a[i] - avg1)",
"abs",
"a[i] - avg1",
"a[i]",
"a",
"i",
"avg1",
"2",
"ans2 += abs(a[i] - avg2) ** 2",
"ans2",
"abs(a[i] - avg2) ** 2",
"abs(a[i] - avg2)",
"abs",
"a[i] - avg2",
"a[i]",
"a",
"i",
"avg2",
"2",
"print(min(ans1,ans2))",
"print",
"min(ans1,ans2)",
"min",
"ans1",
"ans2",
"avg1 = sum(a) // n",
"sum(a) // n",
"avg1",
"ans2 += abs(a[i] - avg2) ** 2",
"abs(a[i] - avg2) ** 2",
"ans2",
"n = int(input())",
"int(input())",
"n",
"avg2 = (sum(a) // n) + 1",
"(sum(a) // n) + 1",
"avg2",
"ans1 = 0",
"0",
"ans1",
"ans1 += abs(a[i] - avg1) ** 2",
"abs(a[i] - avg1) ** 2",
"ans1",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"ans2 = 0",
"0",
"ans2"
] | n = int(input())
a = list(map(int,input().split()))
avg1 = sum(a) // n
avg2 = (sum(a) // n) + 1
ans1 = 0
ans2 = 0
for i in range(n):
ans1 += abs(a[i] - avg1) ** 2
ans2 += abs(a[i] - avg2) ** 2
print(min(ans1,ans2)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
4,
13,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
61,
2
],
[
73,
8
],
[
58,
20
],
[
74,
24
],
[
62,
25
],
[
64,
27
],
[
59,
30
],
[
70,
32
],
[
36,
35
],
[
62,
38
],
[
67,
40
],
[
74,
44
],
[
35,
45
],
[
65,
46
],
[
55,
49
],
[
68,
50
],
[
56,
53
],
[
71,
53
],
[
68,
55
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
]
] | [
"n=int(input())\na = list(map(int,input().split()))\n_sum =sum(a) / n\ns = round(_sum)\nans = 0\n#print(s)\nfor i in range(n):\n v =(a[i]-s)**2\n ans += v\nprint(ans)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"_sum =sum(a) / n",
"_sum",
"sum(a) / n",
"sum(a)",
"sum",
"a",
"n",
"s = round(_sum)",
"s",
"round(_sum)",
"round",
"_sum",
"ans = 0",
"ans",
"0",
"for i in range(n):\n v =(a[i]-s)**2\n ans += v",
"i",
"range(n)",
"range",
"n",
"v =(a[i]-s)**2",
"v",
"(a[i]-s)**2",
"a[i]-s",
"a[i]",
"a",
"i",
"s",
"2",
"ans += v",
"ans",
"v",
"print(ans)",
"print",
"ans",
"ans += v",
"v",
"ans",
"_sum =sum(a) / n",
"sum(a) / n",
"_sum",
"n=int(input())",
"int(input())",
"n",
"s = round(_sum)",
"round(_sum)",
"s",
"v =(a[i]-s)**2",
"(a[i]-s)**2",
"v",
"ans = 0",
"0",
"ans",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a"
] | n=int(input())
a = list(map(int,input().split()))
_sum =sum(a) / n
s = round(_sum)
ans = 0
#print(s)
for i in range(n):
v =(a[i]-s)**2
ans += v
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
14,
2,
13,
13,
0,
13,
17,
41,
28,
13,
13,
4,
2,
2,
13,
13,
2,
13,
13,
28,
13,
4,
13,
13,
2,
13,
17,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
68,
2
],
[
71,
8
],
[
65,
20
],
[
72,
23
],
[
62,
24
],
[
72,
27
],
[
66,
30
],
[
63,
31
],
[
59,
33
],
[
38,
37
],
[
72,
37
],
[
37,
43
],
[
37,
46
],
[
49,
48
],
[
63,
51
],
[
66,
53
],
[
60,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
]
] | [
"n= int(input())\na= list(map(int,input().split()))\nmaxa,mina=max(a),min(a)\nif maxa==mina:print(0)\nelse:\n gmin=9999999\n for c in range(mina,maxa+1):gmin=min(gmin,sum([(c-b)*(c-b) for b in a]))\n print(gmin)",
"n= int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a= list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"maxa,mina=max(a),min(a)",
"maxa",
"max(a)",
"max",
"a",
"mina",
"min(a)",
"min",
"a",
"if maxa==mina:print(0)\nelse:\n gmin=9999999\n for c in range(mina,maxa+1):gmin=min(gmin,sum([(c-b)*(c-b) for b in a]))\n print(gmin)",
"maxa==mina",
"maxa",
"mina",
"gmin=9999999",
"gmin",
"9999999",
"(c-b)*(c-b) for b in a",
"for b in a",
"b",
"a",
"for b in a",
"(c-b)*(c-b)",
"c-b",
"c",
"b",
"c-b",
"c",
"b",
"for c in range(mina,maxa+1):gmin=min(gmin,sum([(c-b)*(c-b) for b in a]))\n ",
"c",
"range(mina,maxa+1)",
"range",
"mina",
"maxa+1",
"maxa",
"1",
"print(gmin)",
"print",
"gmin",
"gmin=9999999",
"9999999",
"gmin",
"mina=max(a),min(a)",
"min(a)",
"mina",
"maxa,mina=max(a),min(a)",
"max(a)",
"maxa",
"n= int(input())",
"int(input())",
"n",
"a= list(map(int,input().split()))",
"list(map(int,input().split()))",
"a"
] | n= int(input())
a= list(map(int,input().split()))
maxa,mina=max(a),min(a)
if maxa==mina:print(0)
else:
gmin=9999999
for c in range(mina,maxa+1):gmin=min(gmin,sum([(c-b)*(c-b) for b in a]))
print(gmin) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
13,
0,
13,
2,
17,
13,
28,
13,
4,
13,
17,
2,
17,
17,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] | [
[
65,
2
],
[
71,
8
],
[
74,
20
],
[
66,
23
],
[
62,
25
],
[
66,
28
],
[
31,
30
],
[
40,
39
],
[
72,
39
],
[
39,
44
],
[
30,
45
],
[
68,
48
],
[
77,
53
],
[
63,
56
],
[
78,
56
],
[
69,
57
],
[
75,
57
],
[
78,
60
],
[
63,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
],
[
77,
78
]
] | [
"N = int(input())\nan = list(map(int, input().split()))\n\ncost = 10000*N\nans = 10000*N\nfor i in range(-100,100+1):\n cost = sum([(j - i)**2 for j in an])\n ans = min(ans, cost)\n\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"an = list(map(int, input().split()))",
"an",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"cost = 10000*N",
"cost",
"10000*N",
"10000",
"N",
"ans = 10000*N",
"ans",
"10000*N",
"10000",
"N",
"for i in range(-100,100+1):\n cost = sum([(j - i)**2 for j in an])\n ans = min(ans, cost)",
"i",
"range(-100,100+1)",
"range",
"-100",
"100+1",
"100",
"1",
"(j - i)**2 for j in an",
"for j in an",
"j",
"an",
"for j in an",
"(j - i)**2",
"j - i",
"j",
"i",
"2",
"cost = sum([(j - i)**2 for j in an])",
"cost",
"sum([(j - i)**2 for j in an])",
"sum",
"[(j - i)**2 for j in an]",
"ans = min(ans, cost)",
"ans",
"min(ans, cost)",
"min",
"ans",
"cost",
"print(ans)",
"print",
"ans",
"ans = 10000*N",
"10000*N",
"ans",
"N = int(input())",
"int(input())",
"N",
"cost = sum([(j - i)**2 for j in an])",
"sum([(j - i)**2 for j in an])",
"cost",
"an = list(map(int, input().split()))",
"list(map(int, input().split()))",
"an",
"cost = 10000*N",
"10000*N",
"cost",
"ans = min(ans, cost)",
"min(ans, cost)",
"ans"
] | N = int(input())
an = list(map(int, input().split()))
cost = 10000*N
ans = 10000*N
for i in range(-100,100+1):
cost = sum([(j - i)**2 for j in an])
ans = min(ans, cost)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
42,
2,
13,
13,
0,
13,
18,
13,
13,
0,
13,
17,
0,
13,
2,
13,
13,
0,
13,
2,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
42,
2,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
0,
13,
2,
2,
13,
18,
13,
13,
17,
0,
13,
17,
14,
2,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] | [
[
125,
2
],
[
152,
8
],
[
149,
20
],
[
122,
23
],
[
143,
26
],
[
128,
29
],
[
150,
33
],
[
147,
33
],
[
126,
34
],
[
134,
36
],
[
153,
38
],
[
150,
39
],
[
147,
39
],
[
146,
41
],
[
116,
44
],
[
135,
46
],
[
129,
46
],
[
126,
47
],
[
137,
49
],
[
117,
51
],
[
131,
54
],
[
104,
57
],
[
110,
60
],
[
132,
64
],
[
147,
64
],
[
150,
64
],
[
141,
64
],
[
126,
65
],
[
107,
67
],
[
117,
70
],
[
153,
72
],
[
132,
73
],
[
147,
73
],
[
150,
73
],
[
141,
73
],
[
101,
76
],
[
138,
79
],
[
153,
81
],
[
132,
82
],
[
147,
82
],
[
150,
82
],
[
141,
82
],
[
140,
85
],
[
108,
89
],
[
105,
89
],
[
102,
90
],
[
111,
90
],
[
113,
92
],
[
108,
93
],
[
105,
93
],
[
119,
95
],
[
102,
96
],
[
111,
96
],
[
120,
99
],
[
114,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
108,
113
],
[
105,
113
],
[
113,
114
],
[
116,
117
],
[
102,
119
],
[
111,
119
],
[
119,
120
],
[
122,
123
],
[
125,
126
],
[
128,
129
],
[
131,
132
],
[
134,
135
],
[
137,
138
],
[
140,
141
],
[
143,
144
],
[
146,
147
],
[
149,
150
],
[
152,
153
]
] | [
"n = int(input())\na = list(map(int, input().split()))\n\ni = 0\nm = 100\nM = -100\n\ns = 0\nwhile i < n:\n s += a[i]\n i+=1\n\ns1 = s//n\ns2 = s1 + 1\n\ni = 0\nx1 = 0\nx2 = 0\nwhile i < n:\n x1 += (s1-a[i])**2\n x2 += (s2-a[i])**2\n i+=1\n\nif x1<x2:\n ans = x1\nelse:\n ans = x2\nprint(ans)\n",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"i = 0",
"i",
"0",
"m = 100",
"m",
"100",
"M = -100",
"M",
"-100",
"s = 0",
"s",
"0",
"while i < n:\n s += a[i]\n i+=1",
"i < n",
"i",
"n",
"s += a[i]",
"s",
"a[i]",
"a",
"i",
"i+=1",
"i",
"1",
"s1 = s//n",
"s1",
"s//n",
"s",
"n",
"s2 = s1 + 1",
"s2",
"s1 + 1",
"s1",
"1",
"i = 0",
"i",
"0",
"x1 = 0",
"x1",
"0",
"x2 = 0",
"x2",
"0",
"while i < n:\n x1 += (s1-a[i])**2\n x2 += (s2-a[i])**2\n i+=1",
"i < n",
"i",
"n",
"x1 += (s1-a[i])**2",
"x1",
"(s1-a[i])**2",
"s1-a[i]",
"s1",
"a[i]",
"a",
"i",
"2",
"x2 += (s2-a[i])**2",
"x2",
"(s2-a[i])**2",
"s2-a[i]",
"s2",
"a[i]",
"a",
"i",
"2",
"i+=1",
"i",
"1",
"if x1<x2:\n ans = x1\nelse:\n ans = x2",
"x1<x2",
"x1",
"x2",
"ans = x1",
"ans",
"x1",
"ans = x2",
"ans",
"x2",
"print(ans)",
"print",
"ans",
"x2 += (s2-a[i])**2",
"(s2-a[i])**2",
"x2",
"x1 = 0",
"0",
"x1",
"x1 += (s1-a[i])**2",
"(s1-a[i])**2",
"x1",
"x2 = 0",
"0",
"x2",
"ans = x1",
"x1",
"ans",
"s1 = s//n",
"s//n",
"s1",
"ans = x2",
"x2",
"ans",
"m = 100",
"100",
"m",
"n = int(input())",
"int(input())",
"n",
"s = 0",
"0",
"s",
"i = 0",
"0",
"i",
"s += a[i]",
"a[i]",
"s",
"s2 = s1 + 1",
"s1 + 1",
"s2",
"i+=1",
"1",
"i",
"M = -100",
"-100",
"M",
"i+=1",
"1",
"i",
"i = 0",
"0",
"i",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] | n = int(input())
a = list(map(int, input().split()))
i = 0
m = 100
M = -100
s = 0
while i < n:
s += a[i]
i+=1
s1 = s//n
s2 = s1 + 1
i = 0
x1 = 0
x2 = 0
while i < n:
x1 += (s1-a[i])**2
x2 += (s2-a[i])**2
i+=1
if x1<x2:
ans = x1
else:
ans = x2
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
13,
0,
13,
2,
13,
13,
0,
13,
40,
2,
40,
13,
13,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
13,
4,
13,
13,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
40,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13
] | [
[
88,
2
],
[
82,
8
],
[
73,
20
],
[
76,
23
],
[
91,
26
],
[
30,
29
],
[
83,
29
],
[
97,
32
],
[
29,
33
],
[
79,
35
],
[
98,
37
],
[
74,
37
],
[
89,
38
],
[
85,
40
],
[
98,
44
],
[
74,
44
],
[
89,
45
],
[
48,
47
],
[
83,
47
],
[
100,
50
],
[
47,
53
],
[
80,
54
],
[
58,
57
],
[
83,
57
],
[
94,
60
],
[
57,
63
],
[
86,
64
],
[
101,
70
],
[
77,
70
],
[
95,
71
],
[
92,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
],
[
91,
92
],
[
94,
95
],
[
29,
97
],
[
97,
98
],
[
100,
101
]
] | [
"n=int(input())\na=list(map(int,input().split()))\ntotal=0\nans1=0\nans2=0\nfor i in a:\n total+=i\ntmp1=total//n\ntmp2=-(-total//n)\nfor i in a:\n ans1+=(i-tmp1)**2\nfor i in a:\n ans2+=(i-tmp2)**2\nprint(min(ans1,ans2))",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"total=0",
"total",
"0",
"ans1=0",
"ans1",
"0",
"ans2=0",
"ans2",
"0",
"for i in a:\n total+=i",
"i",
"a",
"total+=i",
"total",
"i",
"tmp1=total//n",
"tmp1",
"total//n",
"total",
"n",
"tmp2=-(-total//n)",
"tmp2",
"-(-total//n)",
"-total//n",
"-total",
"total",
"n",
"for i in a:\n ans1+=(i-tmp1)**2",
"i",
"a",
"ans1+=(i-tmp1)**2",
"ans1",
"(i-tmp1)**2",
"i-tmp1",
"i",
"tmp1",
"2",
"for i in a:\n ans2+=(i-tmp2)**2",
"i",
"a",
"ans2+=(i-tmp2)**2",
"ans2",
"(i-tmp2)**2",
"i-tmp2",
"i",
"tmp2",
"2",
"print(min(ans1,ans2))",
"print",
"min(ans1,ans2)",
"min",
"ans1",
"ans2",
"total=0",
"0",
"total",
"ans1=0",
"0",
"ans1",
"tmp1=total//n",
"total//n",
"tmp1",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"tmp2=-(-total//n)",
"-(-total//n)",
"tmp2",
"n=int(input())",
"int(input())",
"n",
"ans2=0",
"0",
"ans2",
"ans2+=(i-tmp2)**2",
"(i-tmp2)**2",
"ans2",
"total+=i",
"i",
"total",
"ans1+=(i-tmp1)**2",
"(i-tmp1)**2",
"ans1"
] | n=int(input())
a=list(map(int,input().split()))
total=0
ans1=0
ans2=0
for i in a:
total+=i
tmp1=total//n
tmp2=-(-total//n)
for i in a:
ans1+=(i-tmp1)**2
for i in a:
ans2+=(i-tmp2)**2
print(min(ans1,ans2)) |
[
7,
14,
2,
13,
17,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
2,
17,
17,
2,
17,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
69,
6
],
[
75,
12
],
[
72,
24
],
[
34,
33
],
[
66,
39
],
[
43,
42
],
[
76,
42
],
[
63,
45
],
[
33,
48
],
[
42,
49
],
[
33,
51
],
[
42,
52
],
[
78,
54
],
[
73,
57
],
[
79,
57
],
[
64,
58
],
[
67,
58
],
[
79,
61
],
[
73,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
]
] | [
"if __name__ == '__main__':\n n = int(input())\n lst = list(map(int, input().split()))\n\n ans = (50*100)*(50*100)\n for i in range(-100,101):\n mn = 0\n for c in lst:\n mn += (i-c)*(i-c)\n ans = min(ans,mn)\n\n print(ans)",
"if __name__ == '__main__':\n n = int(input())\n lst = list(map(int, input().split()))\n\n ans = (50*100)*(50*100)\n for i in range(-100,101):\n mn = 0\n for c in lst:\n mn += (i-c)*(i-c)\n ans = min(ans,mn)\n\n print(ans)",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"lst = list(map(int, input().split()))",
"lst",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = (50*100)*(50*100)",
"ans",
"(50*100)*(50*100)",
"50*100",
"50",
"100",
"50*100",
"50",
"100",
"for i in range(-100,101):\n mn = 0\n for c in lst:\n mn += (i-c)*(i-c)\n ans = min(ans,mn)\n\n ",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"mn = 0",
"mn",
"0",
"for c in lst:\n mn += (i-c)*(i-c)\n ",
"c",
"lst",
"mn += (i-c)*(i-c)",
"mn",
"(i-c)*(i-c)",
"i-c",
"i",
"c",
"i-c",
"i",
"c",
"ans = min(ans,mn)",
"ans",
"min(ans,mn)",
"min",
"ans",
"mn",
"print(ans)",
"print",
"ans",
"mn += (i-c)*(i-c)",
"(i-c)*(i-c)",
"mn",
"mn = 0",
"0",
"mn",
"n = int(input())",
"int(input())",
"n",
"ans = (50*100)*(50*100)",
"(50*100)*(50*100)",
"ans",
"lst = list(map(int, input().split()))",
"list(map(int, input().split()))",
"lst",
"ans = min(ans,mn)",
"min(ans,mn)",
"ans"
] | if __name__ == '__main__':
n = int(input())
lst = list(map(int, input().split()))
ans = (50*100)*(50*100)
for i in range(-100,101):
mn = 0
for c in lst:
mn += (i-c)*(i-c)
ans = min(ans,mn)
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13
] | [
[
64,
2
],
[
67,
8
],
[
58,
20
],
[
26,
25
],
[
73,
31
],
[
35,
34
],
[
65,
37
],
[
61,
39
],
[
68,
43
],
[
34,
44
],
[
25,
45
],
[
59,
49
],
[
71,
49
],
[
62,
50
],
[
74,
50
],
[
70,
52
],
[
62,
53
],
[
74,
53
],
[
71,
56
],
[
59,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
62,
70
],
[
74,
70
],
[
70,
71
],
[
73,
74
]
] | [
"N = int(input())\nA = list(map(int, input().split()))\n\nans = float('inf')\nfor i in range(-100, 101):\n tmp = 0\n for j in range(N):\n tmp += (A[j] - i)**2\n if ans > tmp:\n ans = tmp\n\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = float('inf')",
"ans",
"float('inf')",
"float",
"'inf'",
"for i in range(-100, 101):\n tmp = 0\n for j in range(N):\n tmp += (A[j] - i)**2\n if ans > tmp:\n ans = tmp",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"tmp = 0",
"tmp",
"0",
"for j in range(N):\n tmp += (A[j] - i)**2\n ",
"j",
"range(N)",
"range",
"N",
"tmp += (A[j] - i)**2",
"tmp",
"(A[j] - i)**2",
"A[j] - i",
"A[j]",
"A",
"j",
"i",
"2",
"if ans > tmp:\n ans = tmp",
"ans > tmp",
"ans",
"tmp",
"ans = tmp",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"ans = float('inf')",
"float('inf')",
"ans",
"tmp += (A[j] - i)**2",
"(A[j] - i)**2",
"tmp",
"N = int(input())",
"int(input())",
"N",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"ans = tmp",
"tmp",
"ans",
"tmp = 0",
"0",
"tmp"
] | N = int(input())
A = list(map(int, input().split()))
ans = float('inf')
for i in range(-100, 101):
tmp = 0
for j in range(N):
tmp += (A[j] - i)**2
if ans > tmp:
ans = tmp
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
17,
28,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13
] | [
[
41,
2
],
[
10,
9
],
[
9,
18
],
[
50,
20
],
[
47,
23
],
[
51,
29
],
[
42,
30
],
[
44,
32
],
[
36,
35
],
[
51,
35
],
[
45,
39
],
[
41,
42
],
[
44,
45
],
[
47,
48
],
[
50,
51
]
] | [
"N = int(input())\nA = [int(x) for x in input().split()]\naverage = round(sum(A) / N)\nans = 0\nfor x in A: ans += (average-x)**2\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"int(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)",
"int",
"x",
"A = [int(x) for x in input().split()]",
"A",
"[int(x) for x in input().split()]",
"average = round(sum(A) / N)",
"average",
"round(sum(A) / N)",
"round",
"sum(A) / N",
"sum(A)",
"sum",
"A",
"N",
"ans = 0",
"ans",
"0",
"for x in A: ans += (average-x)**2",
"x",
"A",
"print(ans)",
"print",
"ans",
"N = int(input())",
"int(input())",
"N",
"ans = 0",
"0",
"ans",
"average = round(sum(A) / N)",
"round(sum(A) / N)",
"average",
"A = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"A"
] | N = int(input())
A = [int(x) for x in input().split()]
average = round(sum(A) / N)
ans = 0
for x in A: ans += (average-x)**2
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
0,
13,
39,
0,
13,
39,
0,
13,
2,
2,
18,
13,
17,
18,
13,
17,
17,
28,
13,
4,
13,
13,
4,
18,
13,
13,
2,
18,
13,
17,
13,
14,
2,
18,
13,
17,
18,
13,
17,
3,
14,
2,
4,
13,
4,
13,
13,
17,
4,
13,
17,
28,
13,
13,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
18,
13,
13,
13,
0,
13,
17,
4,
13,
4,
13,
13,
10,
39,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13
] | [
[
111,
2
],
[
120,
8
],
[
108,
22
],
[
102,
25
],
[
123,
28
],
[
114,
31
],
[
121,
35
],
[
121,
38
],
[
43,
42
],
[
115,
45
],
[
124,
48
],
[
121,
52
],
[
42,
54
],
[
124,
58
],
[
121,
61
],
[
121,
70
],
[
77,
76
],
[
124,
76
],
[
80,
79
],
[
121,
79
],
[
105,
82
],
[
76,
85
],
[
79,
86
],
[
103,
90
],
[
106,
92
],
[
109,
92
],
[
118,
92
],
[
117,
94
],
[
103,
100
],
[
102,
103
],
[
105,
106
],
[
108,
109
],
[
111,
112
],
[
114,
115
],
[
117,
118
],
[
120,
121
],
[
123,
124
]
] | [
"n = int(input())\na = sorted(list(map(int,input().split())))\nsum = 0\nList_sum = []\nCounter = []\nCount_num = (a[-1] - a[0])+1\nfor i in range(Count_num):\n Counter.append(a[0]+i)\n if Counter[-1] == a[-1]:\n break\nif len(set(a)) == 1:\n print(0)\nelse:\n for i in Counter:\n for j in a:\n sum += (i-j)**2\n else:\n List_sum.append(sum)\n sum = 0\n else:\n print(min(List_sum))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = sorted(list(map(int,input().split())))",
"a",
"sorted(list(map(int,input().split())))",
"sorted",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"sum = 0",
"sum",
"0",
"List_sum = []",
"List_sum",
"[]",
"Counter = []",
"Counter",
"[]",
"Count_num = (a[-1] - a[0])+1",
"Count_num",
"(a[-1] - a[0])+1",
"a[-1] - a[0]",
"a[-1]",
"a",
"-1",
"a[0]",
"a",
"0",
"1",
"for i in range(Count_num):\n Counter.append(a[0]+i)\n if Counter[-1] == a[-1]:\n break",
"i",
"range(Count_num)",
"range",
"Count_num",
"Counter.append(a[0]+i)",
"Counter.append",
"Counter",
"append",
"a[0]+i",
"a[0]",
"a",
"0",
"i",
"if Counter[-1] == a[-1]:\n break",
"Counter[-1] == a[-1]",
"Counter[-1]",
"Counter",
"-1",
"a[-1]",
"a",
"-1",
"break",
"if len(set(a)) == 1:\n print(0)\nelse:\n for i in Counter:\n for j in a:\n sum += (i-j)**2\n else:\n List_sum.append(sum)\n sum = 0\n else:\n print(min(List_sum))",
"len(set(a)) == 1",
"len(set(a))",
"len",
"set(a)",
"set",
"a",
"1",
"print(0)",
"print",
"0",
"for i in Counter:\n for j in a:\n sum += (i-j)**2\n else:\n List_sum.append(sum)\n sum = 0\n else:\n print(min(List_sum))",
"i",
"Counter",
"for j in a:\n sum += (i-j)**2\n else:\n List_sum.append(sum)\n sum = 0\n ",
"j",
"a",
"sum += (i-j)**2",
"sum",
"(i-j)**2",
"i-j",
"i",
"j",
"2",
"List_sum.append(sum)",
"List_sum.append",
"List_sum",
"append",
"sum",
"sum = 0",
"sum",
"0",
"print(min(List_sum))",
"print",
"min(List_sum)",
"min",
"List_sum",
"List_sum = []",
"[]",
"List_sum",
"sum += (i-j)**2",
"(i-j)**2",
"sum",
"sum = 0",
"0",
"sum",
"n = int(input())",
"int(input())",
"n",
"Count_num = (a[-1] - a[0])+1",
"(a[-1] - a[0])+1",
"Count_num",
"sum = 0",
"0",
"sum",
"a = sorted(list(map(int,input().split())))",
"sorted(list(map(int,input().split())))",
"a",
"Counter = []",
"[]",
"Counter"
] | n = int(input())
a = sorted(list(map(int,input().split())))
sum = 0
List_sum = []
Counter = []
Count_num = (a[-1] - a[0])+1
for i in range(Count_num):
Counter.append(a[0]+i)
if Counter[-1] == a[-1]:
break
if len(set(a)) == 1:
print(0)
else:
for i in Counter:
for j in a:
sum += (i-j)**2
else:
List_sum.append(sum)
sum = 0
else:
print(min(List_sum)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
4,
18,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
2,
13,
13,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
82,
2
],
[
70,
8
],
[
71,
21
],
[
73,
24
],
[
71,
27
],
[
88,
29
],
[
71,
32
],
[
76,
34
],
[
38,
37
],
[
74,
40
],
[
89,
42
],
[
85,
45
],
[
49,
48
],
[
71,
48
],
[
79,
51
],
[
48,
54
],
[
37,
55
],
[
48,
57
],
[
37,
58
],
[
77,
61
],
[
80,
63
],
[
86,
63
],
[
77,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
]
] | [
"# -*- coding : utf-8 -*-\n\nN = int(input())\nL = list(map(int, input().split()))\n\nL.sort()\nm = min(L)\nM = max(L)\n\nA = []\nfor i in range(m,M+1):\n k=0\n for j in L:\n k += (j-i)*(j-i)\n A.append(k)\n \nprint(min(A))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"L = list(map(int, input().split()))",
"L",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"L.sort()",
"L.sort",
"L",
"sort",
"m = min(L)",
"m",
"min(L)",
"min",
"L",
"M = max(L)",
"M",
"max(L)",
"max",
"L",
"A = []",
"A",
"[]",
"for i in range(m,M+1):\n k=0\n for j in L:\n k += (j-i)*(j-i)\n A.append(k)\n ",
"i",
"range(m,M+1)",
"range",
"m",
"M+1",
"M",
"1",
"k=0",
"k",
"0",
"for j in L:\n k += (j-i)*(j-i)\n ",
"j",
"L",
"k += (j-i)*(j-i)",
"k",
"(j-i)*(j-i)",
"j-i",
"j",
"i",
"j-i",
"j",
"i",
"A.append(k)",
"A.append",
"A",
"append",
"k",
"print(min(A))",
"print",
"min(A)",
"min",
"A",
"L = list(map(int, input().split()))",
"list(map(int, input().split()))",
"L",
"m = min(L)",
"min(L)",
"m",
"A = []",
"[]",
"A",
"k += (j-i)*(j-i)",
"(j-i)*(j-i)",
"k",
"N = int(input())",
"int(input())",
"N",
"k=0",
"0",
"k",
"M = max(L)",
"max(L)",
"M"
] | # -*- coding : utf-8 -*-
N = int(input())
L = list(map(int, input().split()))
L.sort()
m = min(L)
M = max(L)
A = []
for i in range(m,M+1):
k=0
for j in L:
k += (j-i)*(j-i)
A.append(k)
print(min(A)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
70,
2
],
[
67,
8
],
[
55,
20
],
[
24,
23
],
[
61,
29
],
[
33,
32
],
[
71,
35
],
[
64,
37
],
[
68,
41
],
[
32,
42
],
[
23,
43
],
[
58,
46
],
[
56,
49
],
[
59,
49
],
[
65,
50
],
[
62,
50
],
[
59,
53
],
[
56,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
]
] | [
"n=int(input())\na=list(map(int,input().split()))\nans=1000000\n\nfor i in range(-100,101):\n cou=0\n for j in range(n):\n cou+=(a[j]-i)**2\n ans=min(ans,cou)\n \nprint(ans)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans=1000000",
"ans",
"1000000",
"for i in range(-100,101):\n cou=0\n for j in range(n):\n cou+=(a[j]-i)**2\n ans=min(ans,cou)\n ",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"cou=0",
"cou",
"0",
"for j in range(n):\n cou+=(a[j]-i)**2\n ",
"j",
"range(n)",
"range",
"n",
"cou+=(a[j]-i)**2",
"cou",
"(a[j]-i)**2",
"a[j]-i",
"a[j]",
"a",
"j",
"i",
"2",
"ans=min(ans,cou)",
"ans",
"min(ans,cou)",
"min",
"ans",
"cou",
"print(ans)",
"print",
"ans",
"ans=1000000",
"1000000",
"ans",
"ans=min(ans,cou)",
"min(ans,cou)",
"ans",
"cou=0",
"0",
"cou",
"cou+=(a[j]-i)**2",
"(a[j]-i)**2",
"cou",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"n=int(input())",
"int(input())",
"n"
] | n=int(input())
a=list(map(int,input().split()))
ans=1000000
for i in range(-100,101):
cou=0
for j in range(n):
cou+=(a[j]-i)**2
ans=min(ans,cou)
print(ans) |
[
7,
15,
13,
15,
13,
12,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
4,
13,
2,
13,
13,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
11,
10
],
[
23,
22
],
[
10,
28
],
[
10,
31
],
[
34,
33
],
[
37,
36
],
[
10,
36
],
[
40,
39
],
[
36,
43
],
[
22,
44
],
[
39,
48
],
[
33,
48
],
[
57,
54
]
] | [
"import sys\nimport math\n\ndef main():\n\n input()\n a = list(map(int, input().split()))\n\n y = round(sum(a)/len(a))\n\n ans = 0\n for i in a:\n ans += pow((i - y), 2)\n\n print(ans)\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"import math",
"math",
"def main():\n\n input()\n a = list(map(int, input().split()))\n\n y = round(sum(a)/len(a))\n\n ans = 0\n for i in a:\n ans += pow((i - y), 2)\n\n print(ans)",
"main",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"y = round(sum(a)/len(a))",
"y",
"round(sum(a)/len(a))",
"round",
"sum(a)/len(a)",
"sum(a)",
"sum",
"a",
"len(a)",
"len",
"a",
"ans = 0",
"ans",
"0",
"for i in a:\n ans += pow((i - y), 2)\n\n ",
"i",
"a",
"ans += pow((i - y), 2)",
"ans",
"pow((i - y), 2)",
"pow",
"i - y",
"i",
"y",
"2",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n\n input()\n a = list(map(int, input().split()))\n\n y = round(sum(a)/len(a))\n\n ans = 0\n for i in a:\n ans += pow((i - y), 2)\n\n print(ans)",
"def main():\n\n input()\n a = list(map(int, input().split()))\n\n y = round(sum(a)/len(a))\n\n ans = 0\n for i in a:\n ans += pow((i - y), 2)\n\n print(ans)",
"main"
] | import sys
import math
def main():
input()
a = list(map(int, input().split()))
y = round(sum(a)/len(a))
ans = 0
for i in a:
ans += pow((i - y), 2)
print(ans)
if __name__ == '__main__':
main() |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
13,
2,
2,
13,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
60,
2
],
[
63,
8
],
[
72,
20
],
[
26,
25
],
[
57,
31
],
[
35,
34
],
[
64,
34
],
[
66,
37
],
[
58,
39
],
[
67,
39
],
[
25,
42
],
[
34,
43
],
[
25,
45
],
[
34,
46
],
[
69,
48
],
[
73,
51
],
[
70,
51
],
[
67,
52
],
[
58,
52
],
[
70,
55
],
[
73,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
]
] | [
"n = int(input())\narr =list(map(int , input().split()))\nans = 10001*10001\nfor i in range(-100 ,101):\n\ttot =0\n\tfor j in arr:\n\t\ttot = tot+(i-j)*(i-j)\n\tans = min(ans, tot)\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"arr =list(map(int , input().split()))",
"arr",
"list(map(int , input().split()))",
"list",
"map(int , input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = 10001*10001",
"ans",
"10001*10001",
"10001",
"10001",
"for i in range(-100 ,101):\n\ttot =0\n\tfor j in arr:\n\t\ttot = tot+(i-j)*(i-j)\n\tans = min(ans, tot)",
"i",
"range(-100 ,101)",
"range",
"-100",
"101",
"tot =0",
"tot",
"0",
"for j in arr:\n\t\ttot = tot+(i-j)*(i-j)\n\t",
"j",
"arr",
"tot = tot+(i-j)*(i-j)",
"tot",
"tot+(i-j)*(i-j)",
"tot",
"(i-j)*(i-j)",
"i-j",
"i",
"j",
"i-j",
"i",
"j",
"ans = min(ans, tot)",
"ans",
"min(ans, tot)",
"min",
"ans",
"tot",
"print(ans)",
"print",
"ans",
"tot =0",
"0",
"tot",
"n = int(input())",
"int(input())",
"n",
"arr =list(map(int , input().split()))",
"list(map(int , input().split()))",
"arr",
"tot = tot+(i-j)*(i-j)",
"tot+(i-j)*(i-j)",
"tot",
"ans = min(ans, tot)",
"min(ans, tot)",
"ans",
"ans = 10001*10001",
"10001*10001",
"ans"
] | n = int(input())
arr =list(map(int , input().split()))
ans = 10001*10001
for i in range(-100 ,101):
tot =0
for j in arr:
tot = tot+(i-j)*(i-j)
ans = min(ans, tot)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
2,
13,
4,
13,
13,
14,
2,
2,
2,
13,
17,
2,
13,
4,
13,
13,
2,
2,
13,
4,
13,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
4,
13,
2,
13,
13,
17,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
90,
2
],
[
81,
8
],
[
78,
20
],
[
82,
23
],
[
84,
25
],
[
79,
29
],
[
82,
32
],
[
85,
37
],
[
79,
40
],
[
82,
43
],
[
79,
46
],
[
82,
49
],
[
85,
50
],
[
72,
52
],
[
75,
55
],
[
59,
58
],
[
82,
58
],
[
87,
61
],
[
58,
65
],
[
73,
66
],
[
85,
66
],
[
88,
70
],
[
76,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
]
] | [
"N = int(input())\na = list(map(int, input().split()))\ns = sum(a)\nx = int(s / len(a))\n\nif (x + 1) - (s / len(a)) < (s / len(a)) - x:\n x += 1\ncost = 0\nfor y in a:\n cost += pow(y - x, 2)\n\nprint(cost)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"s = sum(a)",
"s",
"sum(a)",
"sum",
"a",
"x = int(s / len(a))",
"x",
"int(s / len(a))",
"int",
"s / len(a)",
"s",
"len(a)",
"len",
"a",
"if (x + 1) - (s / len(a)) < (s / len(a)) - x:\n x += 1",
"(x + 1) - (s / len(a)) < (s / len(a)) - x",
"(x + 1) - (s / len(a))",
"x + 1",
"x",
"1",
"s / len(a)",
"s",
"len(a)",
"len",
"a",
"(s / len(a)) - x",
"s / len(a)",
"s",
"len(a)",
"len",
"a",
"x",
"x += 1",
"x",
"1",
"cost = 0",
"cost",
"0",
"for y in a:\n cost += pow(y - x, 2)",
"y",
"a",
"cost += pow(y - x, 2)",
"cost",
"pow(y - x, 2)",
"pow",
"y - x",
"y",
"x",
"2",
"print(cost)",
"print",
"cost",
"x += 1",
"1",
"x",
"cost = 0",
"0",
"cost",
"s = sum(a)",
"sum(a)",
"s",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"x = int(s / len(a))",
"int(s / len(a))",
"x",
"cost += pow(y - x, 2)",
"pow(y - x, 2)",
"cost",
"N = int(input())",
"int(input())",
"N"
] | N = int(input())
a = list(map(int, input().split()))
s = sum(a)
x = int(s / len(a))
if (x + 1) - (s / len(a)) < (s / len(a)) - x:
x += 1
cost = 0
for y in a:
cost += pow(y - x, 2)
print(cost) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
39,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
18,
13,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13
] | [
[
52,
2
],
[
61,
8
],
[
58,
20
],
[
24,
23
],
[
55,
29
],
[
33,
32
],
[
62,
32
],
[
64,
35
],
[
32,
38
],
[
23,
39
],
[
59,
43
],
[
65,
45
],
[
56,
45
],
[
59,
50
],
[
52,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
]
] | [
"n=int(input())\nl=list(map(int,input().split()))\ncost=[]\nfor i in range(-100,101):\n count=0\n for j in l:\n count+=(j-i)**2\n cost.append(count)\nprint(min(cost))",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"l=list(map(int,input().split()))",
"l",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"cost=[]",
"cost",
"[]",
"for i in range(-100,101):\n count=0\n for j in l:\n count+=(j-i)**2\n cost.append(count)",
"i",
"range(-100,101)",
"range",
"-100",
"101",
"count=0",
"count",
"0",
"for j in l:\n count+=(j-i)**2\n ",
"j",
"l",
"count+=(j-i)**2",
"count",
"(j-i)**2",
"j-i",
"j",
"i",
"2",
"cost.append(count)",
"cost.append",
"cost",
"append",
"count",
"print(min(cost))",
"print",
"min(cost)",
"min",
"cost",
"n=int(input())",
"int(input())",
"n",
"count=0",
"0",
"count",
"cost=[]",
"[]",
"cost",
"l=list(map(int,input().split()))",
"list(map(int,input().split()))",
"l",
"count+=(j-i)**2",
"(j-i)**2",
"count"
] | n=int(input())
l=list(map(int,input().split()))
cost=[]
for i in range(-100,101):
count=0
for j in l:
count+=(j-i)**2
cost.append(count)
print(min(cost)) |
[
7,
12,
13,
0,
13,
17,
18,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
13,
42,
40,
13,
13,
0,
13,
17,
0,
13,
17,
42,
2,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
17,
14,
2,
40,
13,
13,
2,
13,
13,
0,
13,
13,
0,
13,
17,
29,
13,
23,
13,
23,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
4,
13,
4,
13,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
5,
4
],
[
63,
7
],
[
11,
10
],
[
14,
13
],
[
17,
16
],
[
10,
17
],
[
16,
20
],
[
56,
20
],
[
13,
21
],
[
24,
23
],
[
27,
26
],
[
26,
30
],
[
42,
30
],
[
61,
31
],
[
34,
33
],
[
63,
37
],
[
26,
38
],
[
42,
38
],
[
16,
39
],
[
56,
39
],
[
43,
42
],
[
33,
47
],
[
23,
47
],
[
4,
48
],
[
53,
48
],
[
16,
50
],
[
56,
50
],
[
10,
51
],
[
54,
53
],
[
33,
54
],
[
23,
54
],
[
57,
56
],
[
53,
59
],
[
4,
59
],
[
61,
61
],
[
63,
63
],
[
101,
65
],
[
95,
71
],
[
92,
78
],
[
96,
84
],
[
99,
88
],
[
102,
89
],
[
93,
90
],
[
92,
93
],
[
95,
96
],
[
101,
102
]
] | [
"def keisan(N,A):\n \n KAI = 0\n A.sort\n \n min = -100\n max = 101\n \n i = min\n \n while i <= max:\n kari = 0\n j = 0\n while j < N:\n kari += (A[j]-i)**2\n j += 1\n \n \n if kari <= KAI or i == min:\n KAI = kari\n i += 1\n \n \n return KAI\n \n \nN = int(input())\n \nA = input().split()\nint_list = list(map(int,A))\n \nprint(keisan(N,int_list))",
"def keisan(N,A):\n \n KAI = 0\n A.sort\n \n min = -100\n max = 101\n \n i = min\n \n while i <= max:\n kari = 0\n j = 0\n while j < N:\n kari += (A[j]-i)**2\n j += 1\n \n \n if kari <= KAI or i == min:\n KAI = kari\n i += 1\n \n \n return KAI\n \n ",
"keisan",
"KAI = 0",
"KAI",
"0",
"A.sort",
"A",
"sort",
"min = -100",
"min",
"-100",
"max = 101",
"max",
"101",
"i = min",
"i",
"min",
"while i <= max:\n kari = 0\n j = 0\n while j < N:\n kari += (A[j]-i)**2\n j += 1\n \n \n if kari <= KAI or i == min:\n KAI = kari\n i += 1\n \n \n ",
"i <= max",
"i",
"max",
"kari = 0",
"kari",
"0",
"j = 0",
"j",
"0",
"while j < N:\n kari += (A[j]-i)**2\n j += 1\n \n \n ",
"j < N",
"j",
"N",
"kari += (A[j]-i)**2",
"kari",
"(A[j]-i)**2",
"A[j]-i",
"A[j]",
"A",
"j",
"i",
"2",
"j += 1",
"j",
"1",
"if kari <= KAI or i == min:\n KAI = kari\n ",
"kari <= KAI or i == min",
"kari <= KAI",
"kari",
"KAI",
"i == min",
"i",
"min",
"KAI = kari",
"KAI",
"kari",
"i += 1",
"i",
"1",
"return KAI",
"KAI",
"N",
"N",
"A",
"A",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = input().split()",
"A",
"input().split()",
"().split",
"()",
"input",
"split",
"int_list = list(map(int,A))",
"int_list",
"list(map(int,A))",
"list",
"map(int,A)",
"map",
"int",
"A",
"print(keisan(N,int_list))",
"print",
"keisan(N,int_list)",
"keisan",
"N",
"int_list",
"int_list = list(map(int,A))",
"list(map(int,A))",
"int_list",
"A = input().split()",
"input().split()",
"A",
"def keisan(N,A):\n \n KAI = 0\n A.sort\n \n min = -100\n max = 101\n \n i = min\n \n while i <= max:\n kari = 0\n j = 0\n while j < N:\n kari += (A[j]-i)**2\n j += 1\n \n \n if kari <= KAI or i == min:\n KAI = kari\n i += 1\n \n \n return KAI\n \n ",
"def keisan(N,A):\n \n KAI = 0\n A.sort\n \n min = -100\n max = 101\n \n i = min\n \n while i <= max:\n kari = 0\n j = 0\n while j < N:\n kari += (A[j]-i)**2\n j += 1\n \n \n if kari <= KAI or i == min:\n KAI = kari\n i += 1\n \n \n return KAI\n \n ",
"keisan",
"N = int(input())",
"int(input())",
"N"
] | def keisan(N,A):
KAI = 0
A.sort
min = -100
max = 101
i = min
while i <= max:
kari = 0
j = 0
while j < N:
kari += (A[j]-i)**2
j += 1
if kari <= KAI or i == min:
KAI = kari
i += 1
return KAI
N = int(input())
A = input().split()
int_list = list(map(int,A))
print(keisan(N,int_list)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
63,
2
],
[
60,
8
],
[
57,
20
],
[
26,
25
],
[
69,
31
],
[
35,
34
],
[
64,
37
],
[
66,
39
],
[
25,
42
],
[
61,
44
],
[
34,
45
],
[
72,
48
],
[
58,
51
],
[
73,
51
],
[
67,
52
],
[
70,
52
],
[
73,
55
],
[
58,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
]
] | [
"N = int(input())\nA = list(map(int, input().split()))\nans = 10**9\nfor i in range(-100, 101):\n tmp = 0\n for j in range(N):\n tmp += (i-A[j])**2\n ans = min(ans, tmp)\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = 10**9",
"ans",
"10**9",
"10",
"9",
"for i in range(-100, 101):\n tmp = 0\n for j in range(N):\n tmp += (i-A[j])**2\n ans = min(ans, tmp)",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"tmp = 0",
"tmp",
"0",
"for j in range(N):\n tmp += (i-A[j])**2\n ",
"j",
"range(N)",
"range",
"N",
"tmp += (i-A[j])**2",
"tmp",
"(i-A[j])**2",
"i-A[j]",
"i",
"A[j]",
"A",
"j",
"2",
"ans = min(ans, tmp)",
"ans",
"min(ans, tmp)",
"min",
"ans",
"tmp",
"print(ans)",
"print",
"ans",
"ans = 10**9",
"10**9",
"ans",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"N = int(input())",
"int(input())",
"N",
"tmp += (i-A[j])**2",
"(i-A[j])**2",
"tmp",
"tmp = 0",
"0",
"tmp",
"ans = min(ans, tmp)",
"min(ans, tmp)",
"ans"
] | N = int(input())
A = list(map(int, input().split()))
ans = 10**9
for i in range(-100, 101):
tmp = 0
for j in range(N):
tmp += (i-A[j])**2
ans = min(ans, tmp)
print(ans) |
[
7,
15,
13,
15,
13,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
18,
13,
13,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
2,
2,
2,
18,
13,
13,
13,
17,
17,
4,
13,
4,
13,
13,
13,
10,
13,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
95,
6
],
[
14,
13
],
[
13,
22
],
[
77,
24
],
[
89,
27
],
[
78,
36
],
[
92,
38
],
[
80,
41
],
[
45,
44
],
[
78,
49
],
[
83,
51
],
[
78,
55
],
[
44,
56
],
[
90,
57
],
[
86,
60
],
[
78,
65
],
[
44,
66
],
[
90,
67
],
[
84,
74
],
[
93,
74
],
[
87,
75
],
[
81,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
]
] | [
"import math\nimport statistics\nN = int(input())\nA = [int(x) for x in input().split()]\navg = math.floor(statistics.mean(A))\na = 0\nb = 0\nfor i in range(len(A)):\n a += (A[i] - avg)**2\n b += (A[i] - avg - 1)**2\nprint(min(a,b))",
"import math",
"math",
"import statistics",
"statistics",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"int(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)",
"int",
"x",
"A = [int(x) for x in input().split()]",
"A",
"[int(x) for x in input().split()]",
"avg = math.floor(statistics.mean(A))",
"avg",
"math.floor(statistics.mean(A))",
"math.floor",
"math",
"floor",
"statistics.mean(A)",
"statistics.mean",
"statistics",
"mean",
"A",
"a = 0",
"a",
"0",
"b = 0",
"b",
"0",
"for i in range(len(A)):\n a += (A[i] - avg)**2\n b += (A[i] - avg - 1)**2",
"i",
"range(len(A))",
"range",
"len(A)",
"len",
"A",
"a += (A[i] - avg)**2",
"a",
"(A[i] - avg)**2",
"A[i] - avg",
"A[i]",
"A",
"i",
"avg",
"2",
"b += (A[i] - avg - 1)**2",
"b",
"(A[i] - avg - 1)**2",
"A[i] - avg - 1",
"A[i] - avg",
"A[i]",
"A",
"i",
"avg",
"1",
"2",
"print(min(a,b))",
"print",
"min(a,b)",
"min",
"a",
"b",
"A = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"A",
"b = 0",
"0",
"b",
"a += (A[i] - avg)**2",
"(A[i] - avg)**2",
"a",
"b += (A[i] - avg - 1)**2",
"(A[i] - avg - 1)**2",
"b",
"avg = math.floor(statistics.mean(A))",
"math.floor(statistics.mean(A))",
"avg",
"a = 0",
"0",
"a",
"N = int(input())",
"int(input())",
"N"
] | import math
import statistics
N = int(input())
A = [int(x) for x in input().split()]
avg = math.floor(statistics.mean(A))
a = 0
b = 0
for i in range(len(A)):
a += (A[i] - avg)**2
b += (A[i] - avg - 1)**2
print(min(a,b)) |
[
7,
12,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
13,
4,
13,
13,
0,
13,
39,
14,
2,
13,
13,
29,
17,
28,
13,
4,
13,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
18,
13,
13,
13,
29,
4,
13,
13,
14,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13
] | [
[
5,
4
],
[
11,
10
],
[
23,
22
],
[
10,
25
],
[
27,
26
],
[
10,
29
],
[
32,
31
],
[
22,
35
],
[
26,
36
],
[
41,
40
],
[
22,
43
],
[
26,
45
],
[
49,
48
],
[
52,
51
],
[
10,
51
],
[
55,
54
],
[
51,
57
],
[
40,
58
],
[
31,
62
],
[
54,
64
],
[
48,
64
],
[
31,
68
],
[
84,
74
],
[
82,
76
],
[
85,
79
],
[
84,
85
]
] | [
"def main():\n n = int(input())\n a = list(map(int, input().split()))\n n_min, n_max = min(a), max(a)\n ans = []\n\n if n_min == n_max:\n return 0\n\n for y in range(n_min, n_max+1):\n cost = 0\n for x in a:\n cost += (x-y)**2\n ans.append(cost)\n\n return min(ans)\n\n\nif __name__ == '__main__':\n ans = main()\n print(ans)",
"def main():\n n = int(input())\n a = list(map(int, input().split()))\n n_min, n_max = min(a), max(a)\n ans = []\n\n if n_min == n_max:\n return 0\n\n for y in range(n_min, n_max+1):\n cost = 0\n for x in a:\n cost += (x-y)**2\n ans.append(cost)\n\n return min(ans)",
"main",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"n_min, n_max = min(a), max(a)",
"n_min",
"min(a)",
"min",
"a",
"n_max",
"max(a)",
"max",
"a",
"ans = []",
"ans",
"[]",
"if n_min == n_max:\n return 0\n\n ",
"n_min == n_max",
"n_min",
"n_max",
"return 0",
"0",
"for y in range(n_min, n_max+1):\n cost = 0\n for x in a:\n cost += (x-y)**2\n ans.append(cost)\n\n ",
"y",
"range(n_min, n_max+1)",
"range",
"n_min",
"n_max+1",
"n_max",
"1",
"cost = 0",
"cost",
"0",
"for x in a:\n cost += (x-y)**2\n ",
"x",
"a",
"cost += (x-y)**2",
"cost",
"(x-y)**2",
"x-y",
"x",
"y",
"2",
"ans.append(cost)",
"ans.append",
"ans",
"append",
"cost",
"return min(ans)",
"min(ans)",
"min",
"ans",
"if __name__ == '__main__':\n ans = main()\n print(ans)",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"ans = main()",
"ans",
"main()",
"main",
"print(ans)",
"print",
"ans",
"def main():\n n = int(input())\n a = list(map(int, input().split()))\n n_min, n_max = min(a), max(a)\n ans = []\n\n if n_min == n_max:\n return 0\n\n for y in range(n_min, n_max+1):\n cost = 0\n for x in a:\n cost += (x-y)**2\n ans.append(cost)\n\n return min(ans)",
"def main():\n n = int(input())\n a = list(map(int, input().split()))\n n_min, n_max = min(a), max(a)\n ans = []\n\n if n_min == n_max:\n return 0\n\n for y in range(n_min, n_max+1):\n cost = 0\n for x in a:\n cost += (x-y)**2\n ans.append(cost)\n\n return min(ans)",
"main",
"ans = main()",
"main()",
"ans"
] | def main():
n = int(input())
a = list(map(int, input().split()))
n_min, n_max = min(a), max(a)
ans = []
if n_min == n_max:
return 0
for y in range(n_min, n_max+1):
cost = 0
for x in a:
cost += (x-y)**2
ans.append(cost)
return min(ans)
if __name__ == '__main__':
ans = main()
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
2,
13,
17,
0,
13,
2,
13,
17,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
13,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
13,
41,
28,
13,
13,
4,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
4,
13,
39,
4,
13,
13,
4,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13
] | [
[
110,
2
],
[
95,
8
],
[
113,
20
],
[
96,
26
],
[
111,
27
],
[
92,
29
],
[
114,
31
],
[
98,
34
],
[
114,
36
],
[
41,
40
],
[
96,
40
],
[
40,
45
],
[
114,
46
],
[
104,
49
],
[
54,
53
],
[
96,
53
],
[
53,
58
],
[
93,
59
],
[
107,
62
],
[
67,
66
],
[
96,
66
],
[
66,
71
],
[
99,
72
],
[
101,
75
],
[
105,
84
],
[
108,
87
],
[
102,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
],
[
113,
114
]
] | [
"n = int(input())\nlist_int = list(map(int, input().split()))\nave0 = int(sum(list_int)/n)\nave1 = ave0 + 1\nave2 = ave0 - 1\n\nlist_cost0 = [(i-ave0)**2 for i in list_int]\nlist_cost1 = [(i-ave1)**2 for i in list_int]\nlist_cost2 = [(i-ave2)**2 for i in list_int]\nprint(min([sum(list_cost0), sum(list_cost1), sum(list_cost2)]))",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"list_int = list(map(int, input().split()))",
"list_int",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ave0 = int(sum(list_int)/n)",
"ave0",
"int(sum(list_int)/n)",
"int",
"sum(list_int)/n",
"sum(list_int)",
"sum",
"list_int",
"n",
"ave1 = ave0 + 1",
"ave1",
"ave0 + 1",
"ave0",
"1",
"ave2 = ave0 - 1",
"ave2",
"ave0 - 1",
"ave0",
"1",
"(i-ave0)**2 for i in list_int",
"for i in list_int",
"i",
"list_int",
"for i in list_int",
"(i-ave0)**2",
"i-ave0",
"i",
"ave0",
"2",
"list_cost0 = [(i-ave0)**2 for i in list_int]",
"list_cost0",
"[(i-ave0)**2 for i in list_int]",
"(i-ave1)**2 for i in list_int",
"for i in list_int",
"i",
"list_int",
"for i in list_int",
"(i-ave1)**2",
"i-ave1",
"i",
"ave1",
"2",
"list_cost1 = [(i-ave1)**2 for i in list_int]",
"list_cost1",
"[(i-ave1)**2 for i in list_int]",
"(i-ave2)**2 for i in list_int",
"for i in list_int",
"i",
"list_int",
"for i in list_int",
"(i-ave2)**2",
"i-ave2",
"i",
"ave2",
"2",
"list_cost2 = [(i-ave2)**2 for i in list_int]",
"list_cost2",
"[(i-ave2)**2 for i in list_int]",
"print(min([sum(list_cost0), sum(list_cost1), sum(list_cost2)]))",
"print",
"min([sum(list_cost0), sum(list_cost1), sum(list_cost2)])",
"min",
"[sum(list_cost0), sum(list_cost1), sum(list_cost2)]",
"sum(list_cost0)",
"sum",
"list_cost0",
"sum(list_cost1)",
"sum",
"list_cost1",
"sum(list_cost2)",
"sum",
"list_cost2",
"ave1 = ave0 + 1",
"ave0 + 1",
"ave1",
"list_int = list(map(int, input().split()))",
"list(map(int, input().split()))",
"list_int",
"ave2 = ave0 - 1",
"ave0 - 1",
"ave2",
"list_cost2 = [(i-ave2)**2 for i in list_int]",
"[(i-ave2)**2 for i in list_int]",
"list_cost2",
"list_cost0 = [(i-ave0)**2 for i in list_int]",
"[(i-ave0)**2 for i in list_int]",
"list_cost0",
"list_cost1 = [(i-ave1)**2 for i in list_int]",
"[(i-ave1)**2 for i in list_int]",
"list_cost1",
"n = int(input())",
"int(input())",
"n",
"ave0 = int(sum(list_int)/n)",
"int(sum(list_int)/n)",
"ave0"
] | n = int(input())
list_int = list(map(int, input().split()))
ave0 = int(sum(list_int)/n)
ave1 = ave0 + 1
ave2 = ave0 - 1
list_cost0 = [(i-ave0)**2 for i in list_int]
list_cost1 = [(i-ave1)**2 for i in list_int]
list_cost2 = [(i-ave2)**2 for i in list_int]
print(min([sum(list_cost0), sum(list_cost1), sum(list_cost2)])) |
[
7,
15,
13,
12,
13,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
0,
13,
17,
0,
13,
2,
4,
13,
13,
13,
14,
2,
2,
4,
13,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
0,
13,
2,
2,
18,
13,
13,
13,
17,
14,
40,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
4,
13,
13,
4,
13,
10,
12,
13
] | [
[
7,
6
],
[
14,
13
],
[
13,
22
],
[
25,
24
],
[
28,
27
],
[
31,
30
],
[
34,
33
],
[
24,
37
],
[
6,
38
],
[
24,
44
],
[
6,
45
],
[
49,
48
],
[
52,
51
],
[
6,
54
],
[
57,
56
],
[
24,
60
],
[
51,
61
],
[
33,
62
],
[
66,
65
],
[
33,
70
],
[
73,
72
],
[
33,
77
],
[
80,
79
],
[
6,
82
],
[
85,
84
],
[
24,
88
],
[
79,
89
],
[
65,
90
],
[
94,
93
],
[
24,
97
],
[
79,
98
],
[
72,
99
],
[
84,
103
],
[
27,
103
],
[
93,
104
],
[
30,
104
],
[
107,
106
],
[
84,
107
],
[
27,
107
],
[
110,
109
],
[
93,
110
],
[
30,
110
],
[
109,
115
],
[
106,
115
],
[
56,
115
],
[
48,
115
],
[
120,
117
]
] | [
"#! python3\nimport math\n\ndef main():\n N = int(input())\n alist = [int(num) for num in input().split()]\n ans1 = 0\n ans2 = 0\n m = sum(alist) / N\n\n if sum(alist) % N == 0:\n ans = 0\n for i in range(N):\n ans += (alist[i] - m)**2\n else:\n mu = math.floor(m)\n mo = math.ceil(m)\n for i in range(N):\n ans1 += (alist[i] - mu)**2\n ans2 += (alist[i] - mo)**2\n\n if ans1 <= ans2:\n ans = ans1\n else:\n ans = ans2\n\n print(int(ans))\n\n\nmain()",
"import math",
"math",
"def main():\n N = int(input())\n alist = [int(num) for num in input().split()]\n ans1 = 0\n ans2 = 0\n m = sum(alist) / N\n\n if sum(alist) % N == 0:\n ans = 0\n for i in range(N):\n ans += (alist[i] - m)**2\n else:\n mu = math.floor(m)\n mo = math.ceil(m)\n for i in range(N):\n ans1 += (alist[i] - mu)**2\n ans2 += (alist[i] - mo)**2\n\n if ans1 <= ans2:\n ans = ans1\n else:\n ans = ans2\n\n print(int(ans))",
"main",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"int(num) for num in input().split()",
"for num in input().split()",
"num",
"input().split()",
"().split",
"()",
"input",
"split",
"for num in input().split()",
"int(num)",
"int",
"num",
"alist = [int(num) for num in input().split()]",
"alist",
"[int(num) for num in input().split()]",
"ans1 = 0",
"ans1",
"0",
"ans2 = 0",
"ans2",
"0",
"m = sum(alist) / N",
"m",
"sum(alist) / N",
"sum(alist)",
"sum",
"alist",
"N",
"if sum(alist) % N == 0:\n ans = 0\n for i in range(N):\n ans += (alist[i] - m)**2\n else:\n mu = math.floor(m)\n mo = math.ceil(m)\n for i in range(N):\n ans1 += (alist[i] - mu)**2\n ans2 += (alist[i] - mo)**2\n\n if ans1 <= ans2:\n ans = ans1\n else:\n ans = ans2\n\n ",
"sum(alist) % N == 0",
"sum(alist) % N",
"sum(alist)",
"sum",
"alist",
"N",
"0",
"ans = 0",
"ans",
"0",
"for i in range(N):\n ans += (alist[i] - m)**2\n ",
"i",
"range(N)",
"range",
"N",
"ans += (alist[i] - m)**2",
"ans",
"(alist[i] - m)**2",
"alist[i] - m",
"alist[i]",
"alist",
"i",
"m",
"2",
"mu = math.floor(m)",
"mu",
"math.floor(m)",
"math.floor",
"math",
"floor",
"m",
"mo = math.ceil(m)",
"mo",
"math.ceil(m)",
"math.ceil",
"math",
"ceil",
"m",
"for i in range(N):\n ans1 += (alist[i] - mu)**2\n ans2 += (alist[i] - mo)**2\n\n ",
"i",
"range(N)",
"range",
"N",
"ans1 += (alist[i] - mu)**2",
"ans1",
"(alist[i] - mu)**2",
"alist[i] - mu",
"alist[i]",
"alist",
"i",
"mu",
"2",
"ans2 += (alist[i] - mo)**2",
"ans2",
"(alist[i] - mo)**2",
"alist[i] - mo",
"alist[i]",
"alist",
"i",
"mo",
"2",
"if ans1 <= ans2:\n ans = ans1\n else:\n ans = ans2\n\n ",
"ans1 <= ans2",
"ans1",
"ans2",
"ans = ans1",
"ans",
"ans1",
"ans = ans2",
"ans",
"ans2",
"print(int(ans))",
"print",
"int(ans)",
"int",
"ans",
"main()",
"main",
"def main():\n N = int(input())\n alist = [int(num) for num in input().split()]\n ans1 = 0\n ans2 = 0\n m = sum(alist) / N\n\n if sum(alist) % N == 0:\n ans = 0\n for i in range(N):\n ans += (alist[i] - m)**2\n else:\n mu = math.floor(m)\n mo = math.ceil(m)\n for i in range(N):\n ans1 += (alist[i] - mu)**2\n ans2 += (alist[i] - mo)**2\n\n if ans1 <= ans2:\n ans = ans1\n else:\n ans = ans2\n\n print(int(ans))",
"def main():\n N = int(input())\n alist = [int(num) for num in input().split()]\n ans1 = 0\n ans2 = 0\n m = sum(alist) / N\n\n if sum(alist) % N == 0:\n ans = 0\n for i in range(N):\n ans += (alist[i] - m)**2\n else:\n mu = math.floor(m)\n mo = math.ceil(m)\n for i in range(N):\n ans1 += (alist[i] - mu)**2\n ans2 += (alist[i] - mo)**2\n\n if ans1 <= ans2:\n ans = ans1\n else:\n ans = ans2\n\n print(int(ans))",
"main"
] | #! python3
import math
def main():
N = int(input())
alist = [int(num) for num in input().split()]
ans1 = 0
ans2 = 0
m = sum(alist) / N
if sum(alist) % N == 0:
ans = 0
for i in range(N):
ans += (alist[i] - m)**2
else:
mu = math.floor(m)
mo = math.ceil(m)
for i in range(N):
ans1 += (alist[i] - mu)**2
ans2 += (alist[i] - mo)**2
if ans1 <= ans2:
ans = ans1
else:
ans = ans2
print(int(ans))
main() |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
4,
13,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
65,
2
],
[
62,
8
],
[
68,
20
],
[
26,
25
],
[
63,
30
],
[
63,
34
],
[
71,
37
],
[
41,
40
],
[
63,
40
],
[
59,
43
],
[
25,
46
],
[
40,
47
],
[
74,
50
],
[
60,
53
],
[
72,
53
],
[
69,
54
],
[
75,
54
],
[
75,
57
],
[
69,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
],
[
74,
75
]
] | [
"n = int(input())\nA = list(map(int, input().split()))\n\nans = float(\"INF\")\nfor i in range(min(A), max(A)+1):\n tmp = 0\n for a in A:\n tmp += (i - a) ** 2\n ans = min(tmp, ans)\n\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = float(\"INF\")",
"ans",
"float(\"INF\")",
"float",
"\"INF\"",
"for i in range(min(A), max(A)+1):\n tmp = 0\n for a in A:\n tmp += (i - a) ** 2\n ans = min(tmp, ans)",
"i",
"range(min(A), max(A)+1)",
"range",
"min(A)",
"min",
"A",
"max(A)+1",
"max(A)",
"max",
"A",
"1",
"tmp = 0",
"tmp",
"0",
"for a in A:\n tmp += (i - a) ** 2\n ",
"a",
"A",
"tmp += (i - a) ** 2",
"tmp",
"(i - a) ** 2",
"i - a",
"i",
"a",
"2",
"ans = min(tmp, ans)",
"ans",
"min(tmp, ans)",
"min",
"tmp",
"ans",
"print(ans)",
"print",
"ans",
"tmp += (i - a) ** 2",
"(i - a) ** 2",
"tmp",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"n = int(input())",
"int(input())",
"n",
"ans = float(\"INF\")",
"float(\"INF\")",
"ans",
"tmp = 0",
"0",
"tmp",
"ans = min(tmp, ans)",
"min(tmp, ans)",
"ans"
] | n = int(input())
A = list(map(int, input().split()))
ans = float("INF")
for i in range(min(A), max(A)+1):
tmp = 0
for a in A:
tmp += (i - a) ** 2
ans = min(tmp, ans)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
4,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
56,
2
],
[
59,
8
],
[
71,
20
],
[
26,
25
],
[
68,
31
],
[
60,
38
],
[
62,
40
],
[
25,
43
],
[
65,
47
],
[
72,
50
],
[
66,
50
],
[
63,
51
],
[
69,
51
],
[
66,
54
],
[
72,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
],
[
71,
72
]
] | [
"N = int(input())\nA = list(map(int, input().split()))\nans = float('inf')\n\nfor target in range(-100, 101):\n cost = 0\n for j, a in enumerate(A):\n cost += (target - a)**2\n ans = min(ans, cost)\n\nprint(ans)",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = float('inf')",
"ans",
"float('inf')",
"float",
"'inf'",
"for target in range(-100, 101):\n cost = 0\n for j, a in enumerate(A):\n cost += (target - a)**2\n ans = min(ans, cost)",
"target",
"range(-100, 101)",
"range",
"-100",
"101",
"cost = 0",
"cost",
"0",
"for j, a in enumerate(A):\n cost += (target - a)**2\n ",
"j",
"a",
"enumerate(A)",
"enumerate",
"A",
"cost += (target - a)**2",
"cost",
"(target - a)**2",
"target - a",
"target",
"a",
"2",
"ans = min(ans, cost)",
"ans",
"min(ans, cost)",
"min",
"ans",
"cost",
"print(ans)",
"print",
"ans",
"N = int(input())",
"int(input())",
"N",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"cost += (target - a)**2",
"(target - a)**2",
"cost",
"ans = min(ans, cost)",
"min(ans, cost)",
"ans",
"cost = 0",
"0",
"cost",
"ans = float('inf')",
"float('inf')",
"ans"
] | N = int(input())
A = list(map(int, input().split()))
ans = float('inf')
for target in range(-100, 101):
cost = 0
for j, a in enumerate(A):
cost += (target - a)**2
ans = min(ans, cost)
print(ans) |
[
7,
15,
13,
15,
13,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
17,
4,
13,
4,
13,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
89,
6
],
[
74,
12
],
[
92,
24
],
[
75,
29
],
[
80,
31
],
[
93,
36
],
[
86,
38
],
[
93,
43
],
[
83,
45
],
[
98,
48
],
[
52,
51
],
[
75,
51
],
[
95,
54
],
[
51,
57
],
[
81,
58
],
[
77,
61
],
[
51,
64
],
[
87,
65
],
[
96,
71
],
[
84,
71
],
[
78,
72
],
[
99,
72
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
],
[
86,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
]
] | [
"import numpy as np\nimport math\n\nN = int(input())\n\na = list(map(int, input().split()))\n\navr = np.average(a)\n\nav1 = math.floor(avr)\nav2 = math.ceil(avr)\n\nres1 = 0\nres2 = 0\n\nfor num in a:\n res1 += (num - av1) ** 2\n res2 += (num - av2) ** 2\n\nprint(min(res1, res2))",
"import numpy as np",
"numpy",
"import math",
"math",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"avr = np.average(a)",
"avr",
"np.average(a)",
"np.average",
"np",
"average",
"a",
"av1 = math.floor(avr)",
"av1",
"math.floor(avr)",
"math.floor",
"math",
"floor",
"avr",
"av2 = math.ceil(avr)",
"av2",
"math.ceil(avr)",
"math.ceil",
"math",
"ceil",
"avr",
"res1 = 0",
"res1",
"0",
"res2 = 0",
"res2",
"0",
"for num in a:\n res1 += (num - av1) ** 2\n res2 += (num - av2) ** 2",
"num",
"a",
"res1 += (num - av1) ** 2",
"res1",
"(num - av1) ** 2",
"num - av1",
"num",
"av1",
"2",
"res2 += (num - av2) ** 2",
"res2",
"(num - av2) ** 2",
"num - av2",
"num",
"av2",
"2",
"print(min(res1, res2))",
"print",
"min(res1, res2)",
"min",
"res1",
"res2",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"res2 += (num - av2) ** 2",
"(num - av2) ** 2",
"res2",
"av1 = math.floor(avr)",
"math.floor(avr)",
"av1",
"res1 = 0",
"0",
"res1",
"av2 = math.ceil(avr)",
"math.ceil(avr)",
"av2",
"N = int(input())",
"int(input())",
"N",
"avr = np.average(a)",
"np.average(a)",
"avr",
"res1 += (num - av1) ** 2",
"(num - av1) ** 2",
"res1",
"res2 = 0",
"0",
"res2"
] | import numpy as np
import math
N = int(input())
a = list(map(int, input().split()))
avr = np.average(a)
av1 = math.floor(avr)
av2 = math.ceil(avr)
res1 = 0
res2 = 0
for num in a:
res1 += (num - av1) ** 2
res2 += (num - av2) ** 2
print(min(res1, res2)) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
4,
13,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
4,
13,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
64,
2
],
[
79,
8
],
[
70,
20
],
[
80,
24
],
[
65,
25
],
[
67,
27
],
[
33,
32
],
[
71,
35
],
[
71,
37
],
[
73,
40
],
[
44,
43
],
[
80,
43
],
[
82,
46
],
[
43,
51
],
[
32,
52
],
[
76,
55
],
[
83,
58
],
[
74,
58
],
[
68,
59
],
[
77,
59
],
[
77,
62
],
[
68,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
]
] | [
"n = int(input())\na = list(map(int, input().split()))\n\nm = sum(a)//n\nans = float(\"inf\")\nfor i in range(m, m+2):\n t = 0\n for j in a:\n t += abs(j-i)**2\n ans = min(t,ans)\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"m = sum(a)//n",
"m",
"sum(a)//n",
"sum(a)",
"sum",
"a",
"n",
"ans = float(\"inf\")",
"ans",
"float(\"inf\")",
"float",
"\"inf\"",
"for i in range(m, m+2):\n t = 0\n for j in a:\n t += abs(j-i)**2\n ans = min(t,ans)",
"i",
"range(m, m+2)",
"range",
"m",
"m+2",
"m",
"2",
"t = 0",
"t",
"0",
"for j in a:\n t += abs(j-i)**2\n ",
"j",
"a",
"t += abs(j-i)**2",
"t",
"abs(j-i)**2",
"abs(j-i)",
"abs",
"j-i",
"j",
"i",
"2",
"ans = min(t,ans)",
"ans",
"min(t,ans)",
"min",
"t",
"ans",
"print(ans)",
"print",
"ans",
"n = int(input())",
"int(input())",
"n",
"ans = float(\"inf\")",
"float(\"inf\")",
"ans",
"m = sum(a)//n",
"sum(a)//n",
"m",
"t = 0",
"0",
"t",
"ans = min(t,ans)",
"min(t,ans)",
"ans",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"t += abs(j-i)**2",
"abs(j-i)**2",
"t"
] | n = int(input())
a = list(map(int, input().split()))
m = sum(a)//n
ans = float("inf")
for i in range(m, m+2):
t = 0
for j in a:
t += abs(j-i)**2
ans = min(t,ans)
print(ans) |
[
7,
15,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
4,
13,
13,
13,
14,
2,
4,
13,
2,
4,
13,
13,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
88,
3
],
[
85,
9
],
[
73,
21
],
[
86,
25
],
[
89,
26
],
[
74,
34
],
[
74,
35
],
[
74,
41
],
[
74,
42
],
[
82,
44
],
[
74,
47
],
[
79,
49
],
[
74,
52
],
[
70,
54
],
[
58,
57
],
[
86,
57
],
[
76,
60
],
[
57,
63
],
[
80,
64
],
[
83,
64
],
[
74,
64
],
[
77,
68
],
[
71,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
79,
80
],
[
82,
83
],
[
85,
86
],
[
88,
89
]
] | [
"from math import floor, ceil\n\n\nn = int(input())\nA = list(map(int, input().split()))\n\nx = sum(A) / n\nif abs(floor(x) - x) < abs(ceil(x) - x):\n x = floor(x)\nelse:\n x = ceil(x)\n\nanswer = 0\nfor a in A:\n answer += (a - x)**2\n\nprint(answer)",
"from math import floor, ceil",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"A = list(map(int, input().split()))",
"A",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"x = sum(A) / n",
"x",
"sum(A) / n",
"sum(A)",
"sum",
"A",
"n",
"if abs(floor(x) - x) < abs(ceil(x) - x):\n x = floor(x)\nelse:\n x = ceil(x)",
"abs(floor(x) - x) < abs(ceil(x) - x)",
"abs(floor(x) - x)",
"abs",
"floor(x) - x",
"floor(x)",
"floor",
"x",
"x",
"abs(ceil(x) - x)",
"abs",
"ceil(x) - x",
"ceil(x)",
"ceil",
"x",
"x",
"x = floor(x)",
"x",
"floor(x)",
"floor",
"x",
"x = ceil(x)",
"x",
"ceil(x)",
"ceil",
"x",
"answer = 0",
"answer",
"0",
"for a in A:\n answer += (a - x)**2",
"a",
"A",
"answer += (a - x)**2",
"answer",
"(a - x)**2",
"a - x",
"a",
"x",
"2",
"print(answer)",
"print",
"answer",
"answer = 0",
"0",
"answer",
"x = sum(A) / n",
"sum(A) / n",
"x",
"answer += (a - x)**2",
"(a - x)**2",
"answer",
"x = ceil(x)",
"ceil(x)",
"x",
"x = floor(x)",
"floor(x)",
"x",
"A = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A",
"n = int(input())",
"int(input())",
"n"
] | from math import floor, ceil
n = int(input())
A = list(map(int, input().split()))
x = sum(A) / n
if abs(floor(x) - x) < abs(ceil(x) - x):
x = floor(x)
else:
x = ceil(x)
answer = 0
for a in A:
answer += (a - x)**2
print(answer)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
2,
17,
17,
13,
28,
13,
4,
13,
4,
13,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
4,
13,
2,
18,
13,
13,
13,
17,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
77,
2
],
[
80,
8
],
[
83,
20
],
[
78,
25
],
[
28,
27
],
[
81,
32
],
[
81,
36
],
[
71,
39
],
[
43,
42
],
[
78,
45
],
[
68,
47
],
[
81,
53
],
[
42,
54
],
[
27,
55
],
[
69,
59
],
[
72,
59
],
[
84,
60
],
[
75,
60
],
[
74,
62
],
[
69,
63
],
[
72,
63
],
[
75,
66
],
[
84,
66
],
[
68,
69
],
[
71,
72
],
[
69,
74
],
[
72,
74
],
[
74,
75
],
[
77,
78
],
[
80,
81
],
[
83,
84
]
] | [
"n=int(input())\na=list(map(int,input().split()))\nmins=100**2*n\nfor i in range(min(a),max(a)+1):\n sum=0\n for j in range(n):\n sum+=abs(a[j]-i)**2\n if sum<mins:\n mins=sum\nprint(mins)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mins=100**2*n",
"mins",
"100**2*n",
"100**2",
"100",
"2",
"n",
"for i in range(min(a),max(a)+1):\n sum=0\n for j in range(n):\n sum+=abs(a[j]-i)**2\n if sum<mins:\n mins=sum",
"i",
"range(min(a),max(a)+1)",
"range",
"min(a)",
"min",
"a",
"max(a)+1",
"max(a)",
"max",
"a",
"1",
"sum=0",
"sum",
"0",
"for j in range(n):\n sum+=abs(a[j]-i)**2\n ",
"j",
"range(n)",
"range",
"n",
"sum+=abs(a[j]-i)**2",
"sum",
"abs(a[j]-i)**2",
"abs(a[j]-i)",
"abs",
"a[j]-i",
"a[j]",
"a",
"j",
"i",
"2",
"if sum<mins:\n mins=sum",
"sum<mins",
"sum",
"mins",
"mins=sum",
"mins",
"sum",
"print(mins)",
"print",
"mins",
"sum+=abs(a[j]-i)**2",
"abs(a[j]-i)**2",
"sum",
"sum=0",
"0",
"sum",
"mins=sum",
"sum",
"mins",
"n=int(input())",
"int(input())",
"n",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"mins=100**2*n",
"100**2*n",
"mins"
] | n=int(input())
a=list(map(int,input().split()))
mins=100**2*n
for i in range(min(a),max(a)+1):
sum=0
for j in range(n):
sum+=abs(a[j]-i)**2
if sum<mins:
mins=sum
print(mins) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
2,
13,
17,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13
] | [
[
61,
2
],
[
58,
8
],
[
73,
20
],
[
26,
25
],
[
64,
30
],
[
34,
33
],
[
62,
36
],
[
70,
38
],
[
59,
42
],
[
33,
43
],
[
25,
45
],
[
67,
49
],
[
74,
52
],
[
68,
52
],
[
71,
53
],
[
65,
53
],
[
68,
56
],
[
74,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
]
] | [
"n=int(input())\na=list(map(int,input().split()))\nans=10**10\nfor i in range(201):\n cnt=0\n for j in range(n):\n cnt+=(a[j]-(i-100))**2\n ans=min(ans,cnt)\nprint(ans)",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans=10**10",
"ans",
"10**10",
"10",
"10",
"for i in range(201):\n cnt=0\n for j in range(n):\n cnt+=(a[j]-(i-100))**2\n ans=min(ans,cnt)",
"i",
"range(201)",
"range",
"201",
"cnt=0",
"cnt",
"0",
"for j in range(n):\n cnt+=(a[j]-(i-100))**2\n ",
"j",
"range(n)",
"range",
"n",
"cnt+=(a[j]-(i-100))**2",
"cnt",
"(a[j]-(i-100))**2",
"a[j]-(i-100)",
"a[j]",
"a",
"j",
"i-100",
"i",
"100",
"2",
"ans=min(ans,cnt)",
"ans",
"min(ans,cnt)",
"min",
"ans",
"cnt",
"print(ans)",
"print",
"ans",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"n=int(input())",
"int(input())",
"n",
"cnt=0",
"0",
"cnt",
"ans=min(ans,cnt)",
"min(ans,cnt)",
"ans",
"cnt+=(a[j]-(i-100))**2",
"(a[j]-(i-100))**2",
"cnt",
"ans=10**10",
"10**10",
"ans"
] | n=int(input())
a=list(map(int,input().split()))
ans=10**10
for i in range(201):
cnt=0
for j in range(n):
cnt+=(a[j]-(i-100))**2
ans=min(ans,cnt)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
4,
13,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
17,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13
] | [
[
76,
2
],
[
64,
8
],
[
67,
20
],
[
26,
25
],
[
65,
30
],
[
65,
34
],
[
70,
37
],
[
41,
40
],
[
77,
43
],
[
73,
45
],
[
65,
49
],
[
40,
50
],
[
25,
51
],
[
74,
55
],
[
71,
55
],
[
68,
56
],
[
80,
56
],
[
79,
58
],
[
74,
59
],
[
71,
59
],
[
80,
62
],
[
68,
62
],
[
64,
65
],
[
67,
68
],
[
70,
71
],
[
73,
74
],
[
76,
77
],
[
74,
79
],
[
71,
79
],
[
79,
80
]
] | [
"N =int(input())\na = list(map(int,input().split()))\nans = (10**9)\nfor av in range(min(a),max(a)+1):\n Sum = 0\n for i in range(N):\n Sum += (a[i]-av)**2\n if Sum < ans:\n ans = Sum\nprint(ans)",
"N =int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = (10**9)",
"ans",
"10**9",
"10",
"9",
"for av in range(min(a),max(a)+1):\n Sum = 0\n for i in range(N):\n Sum += (a[i]-av)**2\n if Sum < ans:\n ans = Sum",
"av",
"range(min(a),max(a)+1)",
"range",
"min(a)",
"min",
"a",
"max(a)+1",
"max(a)",
"max",
"a",
"1",
"Sum = 0",
"Sum",
"0",
"for i in range(N):\n Sum += (a[i]-av)**2\n ",
"i",
"range(N)",
"range",
"N",
"Sum += (a[i]-av)**2",
"Sum",
"(a[i]-av)**2",
"a[i]-av",
"a[i]",
"a",
"i",
"av",
"2",
"if Sum < ans:\n ans = Sum",
"Sum < ans",
"Sum",
"ans",
"ans = Sum",
"ans",
"Sum",
"print(ans)",
"print",
"ans",
"a = list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"ans = (10**9)",
"10**9",
"ans",
"Sum = 0",
"0",
"Sum",
"Sum += (a[i]-av)**2",
"(a[i]-av)**2",
"Sum",
"N =int(input())",
"int(input())",
"N",
"ans = Sum",
"Sum",
"ans"
] | N =int(input())
a = list(map(int,input().split()))
ans = (10**9)
for av in range(min(a),max(a)+1):
Sum = 0
for i in range(N):
Sum += (a[i]-av)**2
if Sum < ans:
ans = Sum
print(ans) |
[
7,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
4,
13,
13,
2,
4,
13,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
61,
4
],
[
58,
16
],
[
22,
21
],
[
62,
26
],
[
62,
30
],
[
67,
33
],
[
37,
36
],
[
62,
36
],
[
64,
39
],
[
36,
42
],
[
21,
43
],
[
55,
46
],
[
65,
49
],
[
68,
49
],
[
59,
50
],
[
56,
50
],
[
56,
53
],
[
59,
53
],
[
55,
56
],
[
58,
59
],
[
61,
62
],
[
64,
65
],
[
67,
68
]
] | [
"input();a=list(map(int,input().split()));r=float('inf')\nfor i in range(min(a),max(a)+1):\n n=0\n for j in a:\n n+=(j-i)**2\n r=min(n,r)\nprint(r)",
"input()",
"input",
"a=list(map(int,input().split()))",
"a",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"r=float('inf')",
"r",
"float('inf')",
"float",
"'inf'",
"for i in range(min(a),max(a)+1):\n n=0\n for j in a:\n n+=(j-i)**2\n r=min(n,r)",
"i",
"range(min(a),max(a)+1)",
"range",
"min(a)",
"min",
"a",
"max(a)+1",
"max(a)",
"max",
"a",
"1",
"n=0",
"n",
"0",
"for j in a:\n n+=(j-i)**2\n ",
"j",
"a",
"n+=(j-i)**2",
"n",
"(j-i)**2",
"j-i",
"j",
"i",
"2",
"r=min(n,r)",
"r",
"min(n,r)",
"min",
"n",
"r",
"print(r)",
"print",
"r",
"r=min(n,r)",
"min(n,r)",
"r",
"r=float('inf')",
"float('inf')",
"r",
"a=list(map(int,input().split()))",
"list(map(int,input().split()))",
"a",
"n+=(j-i)**2",
"(j-i)**2",
"n",
"n=0",
"0",
"n"
] | input();a=list(map(int,input().split()));r=float('inf')
for i in range(min(a),max(a)+1):
n=0
for j in a:
n+=(j-i)**2
r=min(n,r)
print(r) |
[
7,
15,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
50,
3
],
[
59,
9
],
[
47,
21
],
[
60,
24
],
[
62,
26
],
[
48,
29
],
[
53,
31
],
[
35,
34
],
[
60,
34
],
[
56,
37
],
[
34,
40
],
[
63,
41
],
[
48,
41
],
[
57,
45
],
[
54,
45
],
[
47,
48
],
[
50,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
]
] | [
"from statistics import mean\n\nn = int(input())\n\nnum_list = list(map(int, input().split()))\n\nm = mean(num_list)\n\nm = round(m)\n\ncost = 0\nfor num in num_list:\n cost += (num - m)**2\n\nprint(cost)",
"from statistics import mean",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"num_list = list(map(int, input().split()))",
"num_list",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"m = mean(num_list)",
"m",
"mean(num_list)",
"mean",
"num_list",
"m = round(m)",
"m",
"round(m)",
"round",
"m",
"cost = 0",
"cost",
"0",
"for num in num_list:\n cost += (num - m)**2",
"num",
"num_list",
"cost += (num - m)**2",
"cost",
"(num - m)**2",
"num - m",
"num",
"m",
"2",
"print(cost)",
"print",
"cost",
"m = mean(num_list)",
"mean(num_list)",
"m",
"n = int(input())",
"int(input())",
"n",
"cost = 0",
"0",
"cost",
"cost += (num - m)**2",
"(num - m)**2",
"cost",
"num_list = list(map(int, input().split()))",
"list(map(int, input().split()))",
"num_list",
"m = round(m)",
"round(m)",
"m"
] | from statistics import mean
n = int(input())
num_list = list(map(int, input().split()))
m = mean(num_list)
m = round(m)
cost = 0
for num in num_list:
cost += (num - m)**2
print(cost)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
17,
28,
13,
13,
0,
13,
4,
13,
2,
13,
13,
17,
0,
13,
4,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
60,
2
],
[
69,
8
],
[
54,
20
],
[
26,
25
],
[
57,
31
],
[
35,
34
],
[
70,
34
],
[
63,
37
],
[
34,
41
],
[
25,
42
],
[
66,
45
],
[
55,
48
],
[
67,
48
],
[
64,
49
],
[
58,
49
],
[
67,
52
],
[
55,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
],
[
63,
64
],
[
66,
67
],
[
69,
70
]
] | [
"n = int(input())\na = list(map(int, input().split()))\nans = float('inf')\nfor i in range(-100, 101):\n dummy = 0\n for a_i in a:\n dummy += pow((a_i-i), 2)\n ans = min(ans, dummy)\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"ans = float('inf')",
"ans",
"float('inf')",
"float",
"'inf'",
"for i in range(-100, 101):\n dummy = 0\n for a_i in a:\n dummy += pow((a_i-i), 2)\n ans = min(ans, dummy)",
"i",
"range(-100, 101)",
"range",
"-100",
"101",
"dummy = 0",
"dummy",
"0",
"for a_i in a:\n dummy += pow((a_i-i), 2)\n ",
"a_i",
"a",
"dummy += pow((a_i-i), 2)",
"dummy",
"pow((a_i-i), 2)",
"pow",
"a_i-i",
"a_i",
"i",
"2",
"ans = min(ans, dummy)",
"ans",
"min(ans, dummy)",
"min",
"ans",
"dummy",
"print(ans)",
"print",
"ans",
"ans = float('inf')",
"float('inf')",
"ans",
"dummy = 0",
"0",
"dummy",
"n = int(input())",
"int(input())",
"n",
"dummy += pow((a_i-i), 2)",
"pow((a_i-i), 2)",
"dummy",
"ans = min(ans, dummy)",
"min(ans, dummy)",
"ans",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a"
] | n = int(input())
a = list(map(int, input().split()))
ans = float('inf')
for i in range(-100, 101):
dummy = 0
for a_i in a:
dummy += pow((a_i-i), 2)
ans = min(ans, dummy)
print(ans) |
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
4,
18,
13,
13,
12,
13,
29,
39,
2,
4,
13,
13,
4,
13,
13,
2,
2,
4,
13,
13,
4,
13,
13,
17,
2,
2,
4,
13,
13,
4,
13,
13,
17,
14,
2,
4,
13,
13,
17,
29,
39,
18,
13,
2,
4,
13,
13,
17,
0,
13,
2,
18,
13,
2,
2,
4,
13,
13,
17,
17,
18,
13,
2,
4,
13,
13,
17,
29,
39,
2,
13,
17,
2,
2,
13,
17,
17,
2,
2,
13,
17,
17,
23,
13,
12,
13,
0,
13,
17,
28,
13,
13,
29,
13,
23,
13,
23,
13,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
13,
13,
4,
13,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13
] | [
[
140,
2
],
[
137,
8
],
[
138,
19
],
[
100,
28
],
[
100,
31
],
[
100,
36
],
[
100,
39
],
[
100,
45
],
[
100,
48
],
[
100,
54
],
[
100,
59
],
[
100,
63
],
[
67,
66
],
[
100,
69
],
[
100,
74
],
[
100,
78
],
[
100,
82
],
[
66,
87
],
[
66,
91
],
[
66,
96
],
[
100,
100
],
[
105,
104
],
[
108,
107
],
[
112,
107
],
[
104,
110
],
[
112,
112
],
[
114,
114
],
[
119,
118
],
[
135,
120
],
[
138,
121
],
[
132,
124
],
[
138,
125
],
[
118,
126
],
[
137,
138
],
[
140,
141
]
] | [
"\nn = int(raw_input())\nais = map(int, raw_input().split())\nais.sort()\n\ndef f(ais):\n\treturn [sum(ais)/len(ais),sum(ais)/len(ais)+1,sum(ais)/len(ais)-1]\n\tif len(ais) % 2:\n\t\treturn [ais[len(ais)/2]]\n\t\n\tv = ais[len(ais)/2 -1] + ais[len(ais)/2]\n\treturn [v/2,v/2-1,v/2+1]\ndef g(ais,m):\n\ts= 0\n\tfor ai in ais: s+=abs(ai - m) **2\n\treturn s\nprint min([g(ais,m) for m in f(ais)])",
"n = int(raw_input())",
"n",
"int(raw_input())",
"int",
"raw_input()",
"raw_input",
"ais = map(int, raw_input().split())",
"ais",
"map(int, raw_input().split())",
"map",
"int",
"raw_input().split()",
"().split",
"()",
"raw_input",
"split",
"ais.sort()",
"ais.sort",
"ais",
"sort",
"def f(ais):\n\treturn [sum(ais)/len(ais),sum(ais)/len(ais)+1,sum(ais)/len(ais)-1]\n\tif len(ais) % 2:\n\t\treturn [ais[len(ais)/2]]\n\t\n\tv = ais[len(ais)/2 -1] + ais[len(ais)/2]\n\treturn [v/2,v/2-1,v/2+1]",
"f",
"return [sum(ais)/len(ais),sum(ais)/len(ais)+1,sum(ais)/len(ais)-1]",
"[sum(ais)/len(ais),sum(ais)/len(ais)+1,sum(ais)/len(ais)-1]",
"sum(ais)/len(ais)",
"sum(ais)",
"sum",
"ais",
"len(ais)",
"len",
"ais",
"sum(ais)/len(ais)+1",
"sum(ais)/len(ais)",
"sum(ais)",
"sum",
"ais",
"len(ais)",
"len",
"ais",
"1",
"sum(ais)/len(ais)-1",
"sum(ais)/len(ais)",
"sum(ais)",
"sum",
"ais",
"len(ais)",
"len",
"ais",
"1",
"if len(ais) % 2:\n\t\treturn [ais[len(ais)/2]]\n\t\n\t",
"len(ais) % 2",
"len(ais)",
"len",
"ais",
"2",
"return [ais[len(ais)/2]]",
"[ais[len(ais)/2]]",
"ais[len(ais)/2]",
"ais",
"len(ais)/2",
"len(ais)",
"len",
"ais",
"2",
"v = ais[len(ais)/2 -1] + ais[len(ais)/2]",
"v",
"ais[len(ais)/2 -1] + ais[len(ais)/2]",
"ais[len(ais)/2 -1]",
"ais",
"len(ais)/2 -1",
"len(ais)/2",
"len(ais)",
"len",
"ais",
"2",
"1",
"ais[len(ais)/2]",
"ais",
"len(ais)/2",
"len(ais)",
"len",
"ais",
"2",
"return [v/2,v/2-1,v/2+1]",
"[v/2,v/2-1,v/2+1]",
"v/2",
"v",
"2",
"v/2-1",
"v/2",
"v",
"2",
"1",
"v/2+1",
"v/2",
"v",
"2",
"1",
"ais",
"ais",
"def g(ais,m):\n\ts= 0\n\tfor ai in ais: s+=abs(ai - m) **2\n\treturn s",
"g",
"s= 0",
"s",
"0",
"for ai in ais: s+=abs(ai - m) **2\n\t",
"ai",
"ais",
"return s",
"s",
"ais",
"ais",
"m",
"m",
"print",
"g(ais,m) for m in f(ais)",
"for m in f(ais)",
"m",
"f(ais)",
"f",
"ais",
"for m in f(ais)",
"g(ais,m)",
"g",
"ais",
"m",
"min([g(ais,m) for m in f(ais)])",
"min",
"[g(ais,m) for m in f(ais)]",
"def g(ais,m):\n\ts= 0\n\tfor ai in ais: s+=abs(ai - m) **2\n\treturn s",
"def g(ais,m):\n\ts= 0\n\tfor ai in ais: s+=abs(ai - m) **2\n\treturn s",
"g",
"def f(ais):\n\treturn [sum(ais)/len(ais),sum(ais)/len(ais)+1,sum(ais)/len(ais)-1]\n\tif len(ais) % 2:\n\t\treturn [ais[len(ais)/2]]\n\t\n\tv = ais[len(ais)/2 -1] + ais[len(ais)/2]\n\treturn [v/2,v/2-1,v/2+1]",
"def f(ais):\n\treturn [sum(ais)/len(ais),sum(ais)/len(ais)+1,sum(ais)/len(ais)-1]\n\tif len(ais) % 2:\n\t\treturn [ais[len(ais)/2]]\n\t\n\tv = ais[len(ais)/2 -1] + ais[len(ais)/2]\n\treturn [v/2,v/2-1,v/2+1]",
"f",
"ais = map(int, raw_input().split())",
"map(int, raw_input().split())",
"ais",
"n = int(raw_input())",
"int(raw_input())",
"n"
] |
n = int(raw_input())
ais = map(int, raw_input().split())
ais.sort()
def f(ais):
return [sum(ais)/len(ais),sum(ais)/len(ais)+1,sum(ais)/len(ais)-1]
if len(ais) % 2:
return [ais[len(ais)/2]]
v = ais[len(ais)/2 -1] + ais[len(ais)/2]
return [v/2,v/2-1,v/2+1]
def g(ais,m):
s= 0
for ai in ais: s+=abs(ai - m) **2
return s
print min([g(ais,m) for m in f(ais)]) |
[
7,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
2,
4,
13,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13
] | [
[
56,
2
],
[
10,
9
],
[
9,
18
],
[
68,
20
],
[
65,
23
],
[
69,
27
],
[
69,
30
],
[
59,
32
],
[
66,
35
],
[
62,
37
],
[
41,
40
],
[
69,
40
],
[
53,
43
],
[
40,
46
],
[
60,
47
],
[
54,
51
],
[
63,
51
],
[
53,
54
],
[
56,
57
],
[
59,
60
],
[
62,
63
],
[
65,
66
],
[
68,
69
]
] | [
"n = int(input())\na = [int(i) for i in input().split()]\n\nm = sum(a) / len(a)\nnum = round(m)\n\nloss = 0\nfor n in a:\n\tloss += (n - num)**2\n\nprint(loss)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"a = [int(i) for i in input().split()]",
"a",
"[int(i) for i in input().split()]",
"m = sum(a) / len(a)",
"m",
"sum(a) / len(a)",
"sum(a)",
"sum",
"a",
"len(a)",
"len",
"a",
"num = round(m)",
"num",
"round(m)",
"round",
"m",
"loss = 0",
"loss",
"0",
"for n in a:\n\tloss += (n - num)**2",
"n",
"a",
"loss += (n - num)**2",
"loss",
"(n - num)**2",
"n - num",
"n",
"num",
"2",
"print(loss)",
"print",
"loss",
"loss += (n - num)**2",
"(n - num)**2",
"loss",
"n = int(input())",
"int(input())",
"n",
"num = round(m)",
"round(m)",
"num",
"loss = 0",
"0",
"loss",
"m = sum(a) / len(a)",
"sum(a) / len(a)",
"m",
"a = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"a"
] | n = int(input())
a = [int(i) for i in input().split()]
m = sum(a) / len(a)
num = round(m)
loss = 0
for n in a:
loss += (n - num)**2
print(loss)
|
[
7,
15,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
2,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
4,
13,
4,
13,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13
] | [
[
78,
3
],
[
75,
9
],
[
87,
21
],
[
76,
27
],
[
79,
28
],
[
90,
30
],
[
88,
32
],
[
84,
35
],
[
93,
38
],
[
42,
41
],
[
79,
44
],
[
81,
46
],
[
88,
49
],
[
76,
51
],
[
41,
52
],
[
56,
55
],
[
79,
58
],
[
96,
60
],
[
91,
63
],
[
76,
65
],
[
55,
66
],
[
82,
72
],
[
85,
72
],
[
97,
73
],
[
94,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
87,
88
],
[
90,
91
],
[
93,
94
],
[
96,
97
]
] | [
"from math import *\nn=int(input())\nl=list(map(int,input().split()))\ns=ceil(sum(l)/n)\nss=s-1\nc=0\nx=0\nfor i in range(n):\n c+=(s-l[i])**2\nfor i in range(n):\n x+=(ss-l[i])**2\nprint(min(c,x))",
"from math import *",
"n=int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"l=list(map(int,input().split()))",
"l",
"list(map(int,input().split()))",
"list",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"s=ceil(sum(l)/n)",
"s",
"ceil(sum(l)/n)",
"ceil",
"sum(l)/n",
"sum(l)",
"sum",
"l",
"n",
"ss=s-1",
"ss",
"s-1",
"s",
"1",
"c=0",
"c",
"0",
"x=0",
"x",
"0",
"for i in range(n):\n c+=(s-l[i])**2",
"i",
"range(n)",
"range",
"n",
"c+=(s-l[i])**2",
"c",
"(s-l[i])**2",
"s-l[i]",
"s",
"l[i]",
"l",
"i",
"2",
"for i in range(n):\n x+=(ss-l[i])**2",
"i",
"range(n)",
"range",
"n",
"x+=(ss-l[i])**2",
"x",
"(ss-l[i])**2",
"ss-l[i]",
"ss",
"l[i]",
"l",
"i",
"2",
"print(min(c,x))",
"print",
"min(c,x)",
"min",
"c",
"x",
"l=list(map(int,input().split()))",
"list(map(int,input().split()))",
"l",
"n=int(input())",
"int(input())",
"n",
"c+=(s-l[i])**2",
"(s-l[i])**2",
"c",
"c=0",
"0",
"c",
"s=ceil(sum(l)/n)",
"ceil(sum(l)/n)",
"s",
"ss=s-1",
"s-1",
"ss",
"x=0",
"0",
"x",
"x+=(ss-l[i])**2",
"(ss-l[i])**2",
"x"
] | from math import *
n=int(input())
l=list(map(int,input().split()))
s=ceil(sum(l)/n)
ss=s-1
c=0
x=0
for i in range(n):
c+=(s-l[i])**2
for i in range(n):
x+=(ss-l[i])**2
print(min(c,x))
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
14,
2,
13,
17,
0,
13,
4,
13,
2,
2,
13,
13,
17,
0,
13,
4,
13,
2,
2,
13,
13,
17,
0,
13,
17,
14,
2,
2,
18,
13,
17,
13,
2,
18,
13,
17,
13,
4,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
17,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
110,
2
],
[
98,
8
],
[
89,
20
],
[
99,
23
],
[
92,
25
],
[
90,
28
],
[
99,
28
],
[
93,
31
],
[
104,
34
],
[
93,
39
],
[
111,
40
],
[
101,
43
],
[
93,
48
],
[
111,
49
],
[
107,
52
],
[
90,
58
],
[
99,
58
],
[
102,
60
],
[
105,
60
],
[
93,
60
],
[
90,
63
],
[
99,
63
],
[
102,
65
],
[
105,
65
],
[
93,
65
],
[
71,
70
],
[
111,
73
],
[
95,
75
],
[
102,
78
],
[
105,
78
],
[
93,
78
],
[
90,
80
],
[
99,
80
],
[
70,
81
],
[
96,
87
],
[
108,
87
],
[
89,
90
],
[
92,
93
],
[
95,
96
],
[
98,
99
],
[
101,
102
],
[
104,
105
],
[
107,
108
],
[
110,
111
]
] | [
"N = int(input())\na = list(map(int, input().split()))\na = sorted(a)\n\nx = sum(a)\nif x > 0:\n x = int(x/N+0.5)\nelse:\n x = int(x/N-0.5)\n\ntotal = 0\nif a[0] == x and a[-1] == x:\n print(0)\nelse: \n for i in range(N):\n total += (x-a[i])**2\n print(int(total))",
"N = int(input())",
"N",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"a = sorted(a)",
"a",
"sorted(a)",
"sorted",
"a",
"x = sum(a)",
"x",
"sum(a)",
"sum",
"a",
"if x > 0:\n x = int(x/N+0.5)\nelse:\n x = int(x/N-0.5)",
"x > 0",
"x",
"0",
"x = int(x/N+0.5)",
"x",
"int(x/N+0.5)",
"int",
"x/N+0.5",
"x/N",
"x",
"N",
"0.5",
"x = int(x/N-0.5)",
"x",
"int(x/N-0.5)",
"int",
"x/N-0.5",
"x/N",
"x",
"N",
"0.5",
"total = 0",
"total",
"0",
"if a[0] == x and a[-1] == x:\n print(0)\nelse: \n for i in range(N):\n total += (x-a[i])**2\n print(int(total))",
"a[0] == x and a[-1] == x",
"a[0] == x",
"a[0]",
"a",
"0",
"x",
"a[-1] == x",
"a[-1]",
"a",
"-1",
"x",
"print(0)",
"print",
"0",
"for i in range(N):\n total += (x-a[i])**2\n ",
"i",
"range(N)",
"range",
"N",
"total += (x-a[i])**2",
"total",
"(x-a[i])**2",
"x-a[i]",
"x",
"a[i]",
"a",
"i",
"2",
"print(int(total))",
"print",
"int(total)",
"int",
"total",
"a = sorted(a)",
"sorted(a)",
"a",
"x = sum(a)",
"sum(a)",
"x",
"total += (x-a[i])**2",
"(x-a[i])**2",
"total",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"x = int(x/N-0.5)",
"int(x/N-0.5)",
"x",
"x = int(x/N+0.5)",
"int(x/N+0.5)",
"x",
"total = 0",
"0",
"total",
"N = int(input())",
"int(input())",
"N"
] | N = int(input())
a = list(map(int, input().split()))
a = sorted(a)
x = sum(a)
if x > 0:
x = int(x/N+0.5)
else:
x = int(x/N-0.5)
total = 0
if a[0] == x and a[-1] == x:
print(0)
else:
for i in range(N):
total += (x-a[i])**2
print(int(total)) |
[
7,
15,
13,
15,
12,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
17,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
4,
13,
13,
4,
13,
13,
13,
4,
13,
13,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
8,
7
],
[
11,
10
],
[
24,
10
],
[
14,
13
],
[
22,
16
],
[
10,
17
],
[
13,
20
],
[
7,
20
],
[
22,
22
],
[
24,
24
],
[
29,
28
],
[
36,
35
],
[
35,
44
],
[
47,
46
],
[
50,
49
],
[
53,
52
],
[
46,
52
],
[
56,
55
],
[
52,
56
],
[
59,
58
],
[
55,
60
],
[
49,
60
],
[
28,
61
],
[
64,
63
],
[
69,
68
],
[
58,
72
],
[
55,
72
],
[
49,
72
],
[
58,
75
],
[
55,
75
],
[
49,
75
],
[
79,
78
],
[
63,
81
],
[
78,
81
],
[
96,
83
],
[
68,
84
],
[
46,
85
],
[
78,
88
],
[
63,
88
],
[
93,
90
]
] | [
"import math\nfrom datetime import date\n\ndef f(x, a):\n\tans = 0\n\tfor y in a:\n\t\tans += (x - y) ** 2\n\n\treturn ans\n\ndef main():\n\t\n\tn = int(input())\n\ta = [int(x) for x in input().split()]\n\ts = 0\n\tfor x in a:\n\t\ts += x\n\n\ts = s // n\n\tans = 10**17\n\n\tfor x in range(s - 2, s + 3):\n\t\tans = min(ans, f(x, a))\n\n\tprint(ans)\n\t\nmain()",
"import math",
"math",
"from datetime import date",
"def f(x, a):\n\tans = 0\n\tfor y in a:\n\t\tans += (x - y) ** 2\n\n\treturn ans",
"f",
"ans = 0",
"ans",
"0",
"for y in a:\n\t\tans += (x - y) ** 2\n\n\t",
"y",
"a",
"ans += (x - y) ** 2",
"ans",
"(x - y) ** 2",
"x - y",
"x",
"y",
"2",
"return ans",
"ans",
"x",
"x",
"a",
"a",
"def main():\n\t\n\tn = int(input())\n\ta = [int(x) for x in input().split()]\n\ts = 0\n\tfor x in a:\n\t\ts += x\n\n\ts = s // n\n\tans = 10**17\n\n\tfor x in range(s - 2, s + 3):\n\t\tans = min(ans, f(x, a))\n\n\tprint(ans)\n\t",
"main",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"int(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)",
"int",
"x",
"a = [int(x) for x in input().split()]",
"a",
"[int(x) for x in input().split()]",
"s = 0",
"s",
"0",
"for x in a:\n\t\ts += x\n\n\t",
"x",
"a",
"s += x",
"s",
"x",
"s = s // n",
"s",
"s // n",
"s",
"n",
"ans = 10**17",
"ans",
"10**17",
"10",
"17",
"for x in range(s - 2, s + 3):\n\t\tans = min(ans, f(x, a))\n\n\t",
"x",
"range(s - 2, s + 3)",
"range",
"s - 2",
"s",
"2",
"s + 3",
"s",
"3",
"ans = min(ans, f(x, a))",
"ans",
"min(ans, f(x, a))",
"min",
"ans",
"f(x, a)",
"f",
"x",
"a",
"print(ans)",
"print",
"ans",
"main()",
"main",
"def main():\n\t\n\tn = int(input())\n\ta = [int(x) for x in input().split()]\n\ts = 0\n\tfor x in a:\n\t\ts += x\n\n\ts = s // n\n\tans = 10**17\n\n\tfor x in range(s - 2, s + 3):\n\t\tans = min(ans, f(x, a))\n\n\tprint(ans)\n\t",
"def main():\n\t\n\tn = int(input())\n\ta = [int(x) for x in input().split()]\n\ts = 0\n\tfor x in a:\n\t\ts += x\n\n\ts = s // n\n\tans = 10**17\n\n\tfor x in range(s - 2, s + 3):\n\t\tans = min(ans, f(x, a))\n\n\tprint(ans)\n\t",
"main",
"def f(x, a):\n\tans = 0\n\tfor y in a:\n\t\tans += (x - y) ** 2\n\n\treturn ans",
"def f(x, a):\n\tans = 0\n\tfor y in a:\n\t\tans += (x - y) ** 2\n\n\treturn ans",
"f"
] | import math
from datetime import date
def f(x, a):
ans = 0
for y in a:
ans += (x - y) ** 2
return ans
def main():
n = int(input())
a = [int(x) for x in input().split()]
s = 0
for x in a:
s += x
s = s // n
ans = 10**17
for x in range(s - 2, s + 3):
ans = min(ans, f(x, a))
print(ans)
main()
|
[
7,
0,
13,
4,
13,
4,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
4,
13,
2,
4,
13,
13,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13
] | [
[
57,
2
],
[
10,
9
],
[
9,
18
],
[
60,
20
],
[
48,
23
],
[
61,
29
],
[
58,
30
],
[
51,
32
],
[
36,
35
],
[
61,
35
],
[
54,
38
],
[
35,
41
],
[
49,
42
],
[
55,
46
],
[
52,
46
],
[
48,
49
],
[
51,
52
],
[
54,
55
],
[
57,
58
],
[
60,
61
]
] | [
"n = int(input())\na = [ int(x) for x in input().split() ]\n\navg = round(sum(a) / n)\n\ncost = 0\n\nfor e in a:\n cost += (e-avg)**2\n\nprint(cost)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"int(x) for x in input().split()",
"for x in input().split()",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"for x in input().split()",
"int(x)",
"int",
"x",
"a = [ int(x) for x in input().split() ]",
"a",
"[ int(x) for x in input().split() ]",
"avg = round(sum(a) / n)",
"avg",
"round(sum(a) / n)",
"round",
"sum(a) / n",
"sum(a)",
"sum",
"a",
"n",
"cost = 0",
"cost",
"0",
"for e in a:\n cost += (e-avg)**2",
"e",
"a",
"cost += (e-avg)**2",
"cost",
"(e-avg)**2",
"e-avg",
"e",
"avg",
"2",
"print(cost)",
"print",
"cost",
"avg = round(sum(a) / n)",
"round(sum(a) / n)",
"avg",
"cost = 0",
"0",
"cost",
"cost += (e-avg)**2",
"(e-avg)**2",
"cost",
"n = int(input())",
"int(input())",
"n",
"a = [ int(x) for x in input().split() ]",
"[ int(x) for x in input().split() ]",
"a"
] | n = int(input())
a = [ int(x) for x in input().split() ]
avg = round(sum(a) / n)
cost = 0
for e in a:
cost += (e-avg)**2
print(cost)
|
[
7,
0,
13,
4,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
2,
13,
13,
14,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13
] | [
[
69,
2
],
[
84,
8
],
[
66,
20
],
[
85,
23
],
[
72,
25
],
[
85,
28
],
[
75,
30
],
[
34,
33
],
[
67,
36
],
[
73,
38
],
[
81,
41
],
[
45,
44
],
[
85,
44
],
[
78,
47
],
[
44,
50
],
[
33,
51
],
[
44,
53
],
[
33,
54
],
[
76,
57
],
[
88,
57
],
[
79,
58
],
[
82,
58
],
[
87,
60
],
[
79,
61
],
[
82,
61
],
[
88,
64
],
[
76,
64
],
[
66,
67
],
[
69,
70
],
[
72,
73
],
[
75,
76
],
[
78,
79
],
[
81,
82
],
[
84,
85
],
[
79,
87
],
[
82,
87
],
[
87,
88
]
] | [
"n = int(input())\na = list(map(int, input().split()))\n\nmn = min(a)\nmx = max(a)\n\nans = 10000000\nfor i in range(mn, mx+1):\n p = 0\n for j in a:\n p += (j-i) * (j-i)\n if ans > p:\n ans = p\nprint(ans)",
"n = int(input())",
"n",
"int(input())",
"int",
"input()",
"input",
"a = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"mn = min(a)",
"mn",
"min(a)",
"min",
"a",
"mx = max(a)",
"mx",
"max(a)",
"max",
"a",
"ans = 10000000",
"ans",
"10000000",
"for i in range(mn, mx+1):\n p = 0\n for j in a:\n p += (j-i) * (j-i)\n if ans > p:\n ans = p",
"i",
"range(mn, mx+1)",
"range",
"mn",
"mx+1",
"mx",
"1",
"p = 0",
"p",
"0",
"for j in a:\n p += (j-i) * (j-i)\n ",
"j",
"a",
"p += (j-i) * (j-i)",
"p",
"(j-i) * (j-i)",
"j-i",
"j",
"i",
"j-i",
"j",
"i",
"if ans > p:\n ans = p",
"ans > p",
"ans",
"p",
"ans = p",
"ans",
"p",
"print(ans)",
"print",
"ans",
"mn = min(a)",
"min(a)",
"mn",
"n = int(input())",
"int(input())",
"n",
"mx = max(a)",
"max(a)",
"mx",
"ans = 10000000",
"10000000",
"ans",
"p += (j-i) * (j-i)",
"(j-i) * (j-i)",
"p",
"p = 0",
"0",
"p",
"a = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"ans = p",
"p",
"ans"
] | n = int(input())
a = list(map(int, input().split()))
mn = min(a)
mx = max(a)
ans = 10000000
for i in range(mn, mx+1):
p = 0
for j in a:
p += (j-i) * (j-i)
if ans > p:
ans = p
print(ans)
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.