message stringlengths 2 22.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 145 109k | cluster float64 9 9 | __index_level_0__ int64 290 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
When Kefa came to the restaurant and sat at a table, the waiter immediately brought him the menu. There were n dishes. Kefa knows that he needs exactly m dishes. But at that, he doesn't want to order the same dish twice to taste as many dishes as possible.
Kefa knows that the i-th dish gives him ai units of satisfaction. But some dishes do not go well together and some dishes go very well together. Kefa set to himself k rules of eating food of the following type — if he eats dish x exactly before dish y (there should be no other dishes between x and y), then his satisfaction level raises by c.
Of course, our parrot wants to get some maximal possible satisfaction from going to the restaurant. Help him in this hard task!
Input
The first line of the input contains three space-separated numbers, n, m and k (1 ≤ m ≤ n ≤ 18, 0 ≤ k ≤ n * (n - 1)) — the number of dishes on the menu, the number of portions Kefa needs to eat to get full and the number of eating rules.
The second line contains n space-separated numbers ai, (0 ≤ ai ≤ 109) — the satisfaction he gets from the i-th dish.
Next k lines contain the rules. The i-th rule is described by the three numbers xi, yi and ci (1 ≤ xi, yi ≤ n, 0 ≤ ci ≤ 109). That means that if you eat dish xi right before dish yi, then the Kefa's satisfaction increases by ci. It is guaranteed that there are no such pairs of indexes i and j (1 ≤ i < j ≤ k), that xi = xj and yi = yj.
Output
In the single line of the output print the maximum satisfaction that Kefa can get from going to the restaurant.
Examples
Input
2 2 1
1 1
2 1 1
Output
3
Input
4 3 2
1 2 3 4
2 1 5
3 4 2
Output
12
Note
In the first sample it is best to first eat the second dish, then the first one. Then we get one unit of satisfaction for each dish and plus one more for the rule.
In the second test the fitting sequences of choice are 4 2 1 or 2 1 4. In both cases we get satisfaction 7 for dishes and also, if we fulfill rule 1, we get an additional satisfaction 5. | instruction | 0 | 45,764 | 9 | 91,528 |
Tags: bitmasks, dp
Correct Solution:
```
import os
import sys
from io import BytesIO,IOBase
def main():
n,m,k = map(int,input().split())
a = list(map(float,input().split()))
tree = [[0]*n for _ in range(n)]
for i in range(k):
x,y,z = map(int,input().split())
tree[x-1][y-1] = float(z)
po = [1]
while len(po) != n:
po.append(po[-1]*2)
dp = [[0]*(po[-1]*2) for _ in range(n)]
for i in range(n):
dp[i][po[i]] = a[i]
for i in range(po[-1]*2):
for j in range(n):
if i&po[j]:
for k in range(n):
if not (i&po[k]):
dp[k][i+po[k]] = max(dp[k][i+po[k]],dp[j][i]+a[k]+tree[j][k])
ma = 0
for i in range(po[-1]*2):
if bin(i)[2:].count("1") == m:
for j in range(n):
ma = max(ma,dp[j][i])
print(int(ma))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self,file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
self.newlines = b.count(b"\n")+(not b)
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd,self.buffer.getvalue())
self.buffer.truncate(0),self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self,file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s:self.buffer.write(s.encode("ascii"))
self.read = lambda:self.buffer.read().decode("ascii")
self.readline = lambda:self.buffer.readline().decode("ascii")
sys.stdin,sys.stdout = IOWrapper(sys.stdin),IOWrapper(sys.stdout)
input = lambda:sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 45,764 | 9 | 91,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When Kefa came to the restaurant and sat at a table, the waiter immediately brought him the menu. There were n dishes. Kefa knows that he needs exactly m dishes. But at that, he doesn't want to order the same dish twice to taste as many dishes as possible.
Kefa knows that the i-th dish gives him ai units of satisfaction. But some dishes do not go well together and some dishes go very well together. Kefa set to himself k rules of eating food of the following type — if he eats dish x exactly before dish y (there should be no other dishes between x and y), then his satisfaction level raises by c.
Of course, our parrot wants to get some maximal possible satisfaction from going to the restaurant. Help him in this hard task!
Input
The first line of the input contains three space-separated numbers, n, m and k (1 ≤ m ≤ n ≤ 18, 0 ≤ k ≤ n * (n - 1)) — the number of dishes on the menu, the number of portions Kefa needs to eat to get full and the number of eating rules.
The second line contains n space-separated numbers ai, (0 ≤ ai ≤ 109) — the satisfaction he gets from the i-th dish.
Next k lines contain the rules. The i-th rule is described by the three numbers xi, yi and ci (1 ≤ xi, yi ≤ n, 0 ≤ ci ≤ 109). That means that if you eat dish xi right before dish yi, then the Kefa's satisfaction increases by ci. It is guaranteed that there are no such pairs of indexes i and j (1 ≤ i < j ≤ k), that xi = xj and yi = yj.
Output
In the single line of the output print the maximum satisfaction that Kefa can get from going to the restaurant.
Examples
Input
2 2 1
1 1
2 1 1
Output
3
Input
4 3 2
1 2 3 4
2 1 5
3 4 2
Output
12
Note
In the first sample it is best to first eat the second dish, then the first one. Then we get one unit of satisfaction for each dish and plus one more for the rule.
In the second test the fitting sequences of choice are 4 2 1 or 2 1 4. In both cases we get satisfaction 7 for dishes and also, if we fulfill rule 1, we get an additional satisfaction 5.
Submitted Solution:
```
import sys, os
from math import sqrt, gcd, ceil, log, floor
from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop
input = sys.stdin.readline
read = lambda: list(map(int, input().strip().split()))
# read_f = lambda file: list(map(int, file.readline().strip().split()))
# from time import time
# sys.setrecursionlimit(5*10**6)
MOD = 10**9 + 7
def main():
# file1 = open("C:\\Users\\shank\\Desktop\\Comp_Code\\input.txt", "r")
# n = int(file1.readline().strip());
# arr = list(map(int, file1.read().strip().split(" ")))
# file1.close()
n, m , k = read()
arr = read(); mat = [[0]*(n+1) for i in range(n+1)]
for i in range(k):
x, y, c = read()
mat[x][y] = c
# for i in range(n+1):
# print(mat[i])
# print("*"*10)
dp = [[-1 for j in range(n)] for i in range(1<<n)]
dp[0] = [0]*(n)
for mask in range(1<<n):
for dish in range(n):
if dp[mask][dish] != -1:
for nxt_dish in range(n):
if dish != nxt_dish and mask & (1<<nxt_dish) == 0:
t = dp[mask][dish]+arr[nxt_dish]
if mask != 0:t += mat[dish+1][nxt_dish+1]
dp[mask | (1<<nxt_dish)][nxt_dish] = max(dp[mask | (1<<nxt_dish)][nxt_dish], t)#[mat[dish][nxt_dish], 0][dp[mask][dish] == 0])
# print(mask | (1<<nxt_dish), mask, bin(mask), dish, nxt_dish, dp[mask | (1<<nxt_dish)][nxt_dish])
# for i in range(len(dp)):
# print(i, dp[i])
ans = 0
for i in range(1<<n):
count = bin(i).count("1")
if count == m:
# print(i, dp[i], "*"*10,"11111111111111111")
ans = max(ans, max(dp[i]))
print(ans)
# file = open("output.txt", "w")
# file.write(ans+"\n")
# file.close()
if __name__ == "__main__":
main()
"""
"""
``` | instruction | 0 | 45,765 | 9 | 91,530 |
No | output | 1 | 45,765 | 9 | 91,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When Kefa came to the restaurant and sat at a table, the waiter immediately brought him the menu. There were n dishes. Kefa knows that he needs exactly m dishes. But at that, he doesn't want to order the same dish twice to taste as many dishes as possible.
Kefa knows that the i-th dish gives him ai units of satisfaction. But some dishes do not go well together and some dishes go very well together. Kefa set to himself k rules of eating food of the following type — if he eats dish x exactly before dish y (there should be no other dishes between x and y), then his satisfaction level raises by c.
Of course, our parrot wants to get some maximal possible satisfaction from going to the restaurant. Help him in this hard task!
Input
The first line of the input contains three space-separated numbers, n, m and k (1 ≤ m ≤ n ≤ 18, 0 ≤ k ≤ n * (n - 1)) — the number of dishes on the menu, the number of portions Kefa needs to eat to get full and the number of eating rules.
The second line contains n space-separated numbers ai, (0 ≤ ai ≤ 109) — the satisfaction he gets from the i-th dish.
Next k lines contain the rules. The i-th rule is described by the three numbers xi, yi and ci (1 ≤ xi, yi ≤ n, 0 ≤ ci ≤ 109). That means that if you eat dish xi right before dish yi, then the Kefa's satisfaction increases by ci. It is guaranteed that there are no such pairs of indexes i and j (1 ≤ i < j ≤ k), that xi = xj and yi = yj.
Output
In the single line of the output print the maximum satisfaction that Kefa can get from going to the restaurant.
Examples
Input
2 2 1
1 1
2 1 1
Output
3
Input
4 3 2
1 2 3 4
2 1 5
3 4 2
Output
12
Note
In the first sample it is best to first eat the second dish, then the first one. Then we get one unit of satisfaction for each dish and plus one more for the rule.
In the second test the fitting sequences of choice are 4 2 1 or 2 1 4. In both cases we get satisfaction 7 for dishes and also, if we fulfill rule 1, we get an additional satisfaction 5.
Submitted Solution:
```
#!/usr/bin/env python
# 580D_dishes.py - Codeforces.com/problemset/problem/580/D by Sergey 2015
import unittest
import sys
###############################################################################
# Dishes Class (Main Program)
###############################################################################
class Dishes:
""" Dishes representation """
def __init__(self, test_inputs=None):
""" Default constructor """
it = iter(test_inputs.split("\n")) if test_inputs else None
def uinput():
return next(it) if it else sys.stdin.readline().rstrip()
# Reading single elements
[self.n, self.m, self.k] = map(int, uinput().split())
# Reading a single line of multiple elements
self.nums = list(map(int, uinput().split()))
# Reading multiple number of lines of the same number of elements each
l, s = self.k, 3
inp = (" ".join(uinput() for i in range(l))).split()
self.numm = [[int(inp[i]) for i in range(j, l*s, s)] for j in range(s)]
self.numa, self.numb, self.numc = self.numm
def calculate(self):
""" Main calcualtion function of the class """
# Sort rules
if self.numa:
self.numc, self.numb, self.numa = (
zip(*sorted(zip(self.numc, self.numb, self.numa))))
result = 0
for i in range(2**self.n):
if bin(i).count("1") != self.m:
continue
sat = 0
menu = set()
for j in range(self.n):
if i >> j & 1:
menu.add(j+1)
sat += self.nums[j]
pa = set()
pb = set()
for j in reversed(range(self.k)):
a = self.numa[j]
b = self.numb[j]
if b in menu and a in menu and b not in pb and a not in pa:
sat += self.numc[j]
pb.add(b)
pa.add(a)
result = max(result, sat)
return str(result)
###############################################################################
# Unit Tests
###############################################################################
class unitTests(unittest.TestCase):
def test_single_test(self):
""" Dishes class testing """
# Constructor test
test = "2 2 1\n1 1\n2 1 1"
d = Dishes(test)
self.assertEqual(d.n, 2)
self.assertEqual(d.m, 2)
self.assertEqual(d.k, 1)
self.assertEqual(d.nums, [1, 1])
self.assertEqual(d.numa, [2])
self.assertEqual(d.numb, [1])
self.assertEqual(d.numc, [1])
# Sample test
self.assertEqual(Dishes(test).calculate(), "3")
# Sample test
test = "4 3 2\n1 2 3 4\n2 1 5\n3 4 2"
self.assertEqual(Dishes(test).calculate(), "12")
# Sample test
test = "1 1 0\n1000000000"
self.assertEqual(Dishes(test).calculate(), "1000000000")
# My tests
test = "7 4 3\n2 6 13 5 7 1 9\n6 1 15\n2 5 3\n6 4 8"
self.assertEqual(Dishes(test).calculate(), "40")
# Time limit test
# self.time_limit_test(5000)
def time_limit_test(self, nmax):
""" Timelimit testing """
import random
import timeit
# Random inputs
test = str(nmax) + " " + str(nmax) + "\n"
numnums = [str(i) + " " + str(i+1) for i in range(nmax)]
test += "\n".join(numnums) + "\n"
nums = [random.randint(1, 10000) for i in range(nmax)]
test += " ".join(map(str, nums)) + "\n"
# Run the test
start = timeit.default_timer()
d = Dishes(test)
calc = timeit.default_timer()
d.calculate()
stop = timeit.default_timer()
print("\nTimelimit Test: " +
"{0:.3f}s (init {1:.3f}s calc {2:.3f}s)".
format(stop-start, calc-start, stop-calc))
if __name__ == "__main__":
# Avoiding recursion limitaions
sys.setrecursionlimit(100000)
if sys.argv[-1] == "-ut":
unittest.main(argv=[" "])
# Print the result string
sys.stdout.write(Dishes().calculate())
``` | instruction | 0 | 45,766 | 9 | 91,532 |
No | output | 1 | 45,766 | 9 | 91,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When Kefa came to the restaurant and sat at a table, the waiter immediately brought him the menu. There were n dishes. Kefa knows that he needs exactly m dishes. But at that, he doesn't want to order the same dish twice to taste as many dishes as possible.
Kefa knows that the i-th dish gives him ai units of satisfaction. But some dishes do not go well together and some dishes go very well together. Kefa set to himself k rules of eating food of the following type — if he eats dish x exactly before dish y (there should be no other dishes between x and y), then his satisfaction level raises by c.
Of course, our parrot wants to get some maximal possible satisfaction from going to the restaurant. Help him in this hard task!
Input
The first line of the input contains three space-separated numbers, n, m and k (1 ≤ m ≤ n ≤ 18, 0 ≤ k ≤ n * (n - 1)) — the number of dishes on the menu, the number of portions Kefa needs to eat to get full and the number of eating rules.
The second line contains n space-separated numbers ai, (0 ≤ ai ≤ 109) — the satisfaction he gets from the i-th dish.
Next k lines contain the rules. The i-th rule is described by the three numbers xi, yi and ci (1 ≤ xi, yi ≤ n, 0 ≤ ci ≤ 109). That means that if you eat dish xi right before dish yi, then the Kefa's satisfaction increases by ci. It is guaranteed that there are no such pairs of indexes i and j (1 ≤ i < j ≤ k), that xi = xj and yi = yj.
Output
In the single line of the output print the maximum satisfaction that Kefa can get from going to the restaurant.
Examples
Input
2 2 1
1 1
2 1 1
Output
3
Input
4 3 2
1 2 3 4
2 1 5
3 4 2
Output
12
Note
In the first sample it is best to first eat the second dish, then the first one. Then we get one unit of satisfaction for each dish and plus one more for the rule.
In the second test the fitting sequences of choice are 4 2 1 or 2 1 4. In both cases we get satisfaction 7 for dishes and also, if we fulfill rule 1, we get an additional satisfaction 5.
Submitted Solution:
```
#!/usr/bin/env python
# 580D_dishes.py - Codeforces.com/problemset/problem/580/D by Sergey 2015
import unittest
import sys
###############################################################################
# Dishes Class (Main Program)
###############################################################################
class Dishes:
""" Dishes representation """
def __init__(self, test_inputs=None):
""" Default constructor """
it = iter(test_inputs.split("\n")) if test_inputs else None
def uinput():
return next(it) if it else sys.stdin.readline().rstrip()
# Reading single elements
[self.n, self.m, self.k] = map(int, uinput().split())
# Reading a single line of multiple elements
self.nums = list(map(int, uinput().split()))
# Reading multiple number of lines of the same number of elements each
l, s = self.k, 3
inp = (" ".join(uinput() for i in range(l))).split()
self.numm = [[int(inp[i]) for i in range(j, l*s, s)] for j in range(s)]
self.numa, self.numb, self.numc = self.numm
def calculate(self):
""" Main calcualtion function of the class """
# Sort rules
if self.numa:
self.numc, self.numb, self.numa = (
zip(*sorted(zip(self.numc, self.numb, self.numa))))
result = 0
for i in range(2**self.n):
if bin(i).count("1") != self.m:
continue
sat = 0
menu = set()
for j in range(self.n):
if i >> j & 1:
menu.add(j+1)
sat += self.nums[j]
pa, pb = set(), set()
ds = Disjoint_set(self.n)
for j in reversed(range(self.k)):
a, b = self.numa[j], self.numb[j]
if (b in menu and a in menu and
b not in pb and a not in pa and
not ds.check(a, b)):
sat += self.numc[j]
pb.add(b)
pa.add(a)
ds.join(a, b)
result = max(result, sat)
return str(result)
class Disjoint_set:
""" Disjoint_set representation """
def __init__(self, n):
""" Default constructor """
self.root = [i for i in range(n+1)]
def find(self, a):
r = self.root[a]
while r != a:
rr = self.root[r]
r, self.root[a], a = rr, rr, r
return a
def join(self, a, b):
self.root[self.find(b)] = self.find(a)
def check(self, a, b):
return self.find(a) == self.find(b)
###############################################################################
# Unit Tests
###############################################################################
class unitTests(unittest.TestCase):
def test_single_test(self):
""" Dishes class testing """
# Constructor test
test = "2 2 1\n1 1\n2 1 1"
d = Dishes(test)
self.assertEqual(d.n, 2)
self.assertEqual(d.m, 2)
self.assertEqual(d.k, 1)
self.assertEqual(d.nums, [1, 1])
self.assertEqual(d.numa, [2])
self.assertEqual(d.numb, [1])
self.assertEqual(d.numc, [1])
# Sample test
self.assertEqual(Dishes(test).calculate(), "3")
# Sample test
test = "4 3 2\n1 2 3 4\n2 1 5\n3 4 2"
self.assertEqual(Dishes(test).calculate(), "12")
# Sample test
test = "1 1 0\n1000000000"
self.assertEqual(Dishes(test).calculate(), "1000000000")
# My tests
test = "5 5 5\n3 3 3 3 3\n3 4 6\n4 1 2\n1 5 7\n5 2 4\n2 3 5"
self.assertEqual(Dishes(test).calculate(), "37")
test = "6 3 6\n2 3 4 1 5 6\n1 5 3\n5 1 4\n2 6 1\n2 4 3\n3 5 3\n4 5 6"
self.assertEqual(Dishes(test).calculate(), "18")
# Time limit test
# self.time_limit_test(5000)
def time_limit_test(self, nmax):
""" Timelimit testing """
import random
import timeit
# Random inputs
test = str(nmax) + " " + str(nmax) + "\n"
numnums = [str(i) + " " + str(i+1) for i in range(nmax)]
test += "\n".join(numnums) + "\n"
nums = [random.randint(1, 10000) for i in range(nmax)]
test += " ".join(map(str, nums)) + "\n"
# Run the test
start = timeit.default_timer()
d = Dishes(test)
calc = timeit.default_timer()
d.calculate()
stop = timeit.default_timer()
print("\nTimelimit Test: " +
"{0:.3f}s (init {1:.3f}s calc {2:.3f}s)".
format(stop-start, calc-start, stop-calc))
if __name__ == "__main__":
# Avoiding recursion limitaions
sys.setrecursionlimit(100000)
if sys.argv[-1] == "-ut":
unittest.main(argv=[" "])
# Print the result string
sys.stdout.write(Dishes().calculate())
``` | instruction | 0 | 45,767 | 9 | 91,534 |
No | output | 1 | 45,767 | 9 | 91,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When Kefa came to the restaurant and sat at a table, the waiter immediately brought him the menu. There were n dishes. Kefa knows that he needs exactly m dishes. But at that, he doesn't want to order the same dish twice to taste as many dishes as possible.
Kefa knows that the i-th dish gives him ai units of satisfaction. But some dishes do not go well together and some dishes go very well together. Kefa set to himself k rules of eating food of the following type — if he eats dish x exactly before dish y (there should be no other dishes between x and y), then his satisfaction level raises by c.
Of course, our parrot wants to get some maximal possible satisfaction from going to the restaurant. Help him in this hard task!
Input
The first line of the input contains three space-separated numbers, n, m and k (1 ≤ m ≤ n ≤ 18, 0 ≤ k ≤ n * (n - 1)) — the number of dishes on the menu, the number of portions Kefa needs to eat to get full and the number of eating rules.
The second line contains n space-separated numbers ai, (0 ≤ ai ≤ 109) — the satisfaction he gets from the i-th dish.
Next k lines contain the rules. The i-th rule is described by the three numbers xi, yi and ci (1 ≤ xi, yi ≤ n, 0 ≤ ci ≤ 109). That means that if you eat dish xi right before dish yi, then the Kefa's satisfaction increases by ci. It is guaranteed that there are no such pairs of indexes i and j (1 ≤ i < j ≤ k), that xi = xj and yi = yj.
Output
In the single line of the output print the maximum satisfaction that Kefa can get from going to the restaurant.
Examples
Input
2 2 1
1 1
2 1 1
Output
3
Input
4 3 2
1 2 3 4
2 1 5
3 4 2
Output
12
Note
In the first sample it is best to first eat the second dish, then the first one. Then we get one unit of satisfaction for each dish and plus one more for the rule.
In the second test the fitting sequences of choice are 4 2 1 or 2 1 4. In both cases we get satisfaction 7 for dishes and also, if we fulfill rule 1, we get an additional satisfaction 5.
Submitted Solution:
```
#!/usr/bin/python3
# -*- coding: <utf-8> -*-
import itertools as ittls
from collections import Counter
import copy
def sqr(x):
return x*x
def inputarray(func = int):
return map(func, input().split())
# -------------------------------
# -------------------------------
n, m, q = map(int, input().split())
satisfactions = list(inputarray())
M = [[float('-inf')]*n for i in range(n)]
for i in range(q):
x, y, c = map(int, input().split())
if x != y:
M[x - 1][y - 1] = c
res = 0
for i in range(1<<n):
num, s, ps = 0,0,0
for j in range(n):
if i&(1<<j):
num = num + 1
s = s + satisfactions[j]
if num != m:
continue
top = 0
F = [float('-inf')]*(m*m)
for u in range(n):
for v in range(n):
if i&(1<<u) and i&(1<<v):
F[top] = M[u][v]
top = top + 1
for k in range(m):
for u in range(m):
for v in range(m):
if F[u*m + v] < F[u*m + k] + F[k*m + v]:
# print("-- %d %d %d" % (u,v,k))
F[u*m + v] = F[u*m + k] + F[k*m + v]
ps = max(F)
if res < s + ps:
res = s + ps
# print(M)
# print(F)
# print("%d %d" %(s, ps))
# print('\n\n')
print(res)
``` | instruction | 0 | 45,768 | 9 | 91,536 |
No | output | 1 | 45,768 | 9 | 91,537 |
Provide a correct Python 3 solution for this coding contest problem.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4 | instruction | 0 | 45,893 | 9 | 91,786 |
"Correct Solution:
```
n = int(input())
soft, hard = 0, 0
for i in range(n):
sir, tip = input().split()
if tip == 'soft':
soft += 1
else:
hard += 1
for k in range(100):
a = k * k // 2
b = k * k - a
if soft <= a and hard <= b or soft <= b and hard <= a:
print(k)
break
``` | output | 1 | 45,893 | 9 | 91,787 |
Provide a correct Python 3 solution for this coding contest problem.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4 | instruction | 0 | 45,894 | 9 | 91,788 |
"Correct Solution:
```
n = int(input())
sf = 0
hd = 0
for _ in range(n):
_, t = input().split()
if t == 'soft':
sf += 1
else:
hd += 1
for i in range(1,20):
if sf <= (i**2+1)//2 and hd <= (i**2+1)//2 and sf+hd<=i**2:
print(i)
break
``` | output | 1 | 45,894 | 9 | 91,789 |
Provide a correct Python 3 solution for this coding contest problem.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4 | instruction | 0 | 45,895 | 9 | 91,790 |
"Correct Solution:
```
# coding: utf-8
n = int(input())
hard = soft = 0
for i in range(n):
cheese = input().split()
if cheese[1] == 'hard':
hard += 1
else:
soft += 1
i = 1
while True:
if (hard <= (i * i) // 2 and soft <= (i * i + 1) // 2) or (hard <= (i * i + 1) // 2 and soft <= (i * i) // 2):
print(i)
break
i += 1
``` | output | 1 | 45,895 | 9 | 91,791 |
Provide a correct Python 3 solution for this coding contest problem.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4 | instruction | 0 | 45,896 | 9 | 91,792 |
"Correct Solution:
```
from math import sqrt
n = int(input())
s, h = 0, 0
for i in range(n):
a, b = input().split()
if b == 'soft':
s += 1
else:
h += 1
k = 2 * max(s, h) - 1
if s + h > k:
k += 1
t = int(sqrt(k))
if t * t < k:
t += 1
print(t)
``` | output | 1 | 45,896 | 9 | 91,793 |
Provide a correct Python 3 solution for this coding contest problem.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4 | instruction | 0 | 45,897 | 9 | 91,794 |
"Correct Solution:
```
n = int(input())
soft = 0
hard = 0
for i in range(n):
x, y = input().split()
if y == 'hard':
hard += 1
else:
soft += 1
if hard < soft:
hard, soft = soft, hard
for i in range(1, 100):
x = i * (i // 2)
if i % 2:
x += (i + 1) // 2
y = i*i - x
# print(x, y)
if hard <= x and soft <= y:
print(i)
exit(0)
``` | output | 1 | 45,897 | 9 | 91,795 |
Provide a correct Python 3 solution for this coding contest problem.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4 | instruction | 0 | 45,898 | 9 | 91,796 |
"Correct Solution:
```
n = int(input())
a, b = 0,0
for _ in range(n):
t,s = input().split()
if s == 'hard': a += 1
else: b += 1
a,b = sorted([a,b])
res = int((n-1) ** 0.5)
while True:
s = res * res
if s // 2 >= a and s - s // 2 >= b:
break
res += 1
print(res)
``` | output | 1 | 45,898 | 9 | 91,797 |
Provide a correct Python 3 solution for this coding contest problem.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4 | instruction | 0 | 45,899 | 9 | 91,798 |
"Correct Solution:
```
n = int(input())
x = y = 0
for i in range(n):
s, t = input().split()
if t == 'soft':
x += 1
else:
y += 1
if x < y:
x, y = y, x
for i in range(1, 200):
if (i ** 2 + 1) // 2 >= x and i ** 2 // 2 >= y:
print(i)
break
``` | output | 1 | 45,899 | 9 | 91,799 |
Provide a correct Python 3 solution for this coding contest problem.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4 | instruction | 0 | 45,900 | 9 | 91,800 |
"Correct Solution:
```
n = int(input())
soft = 0
hard = 0
for i in range(n):
_, t = input().split()
if t == 'soft':
soft += 1
else:
hard += 1
for i in range(1, 100):
# field1 = [[0] * i for j in range(i)]
# field2 = [[0] * i for j in range(i)]
s1 = soft
h1 = hard
s2 = soft
h2 = hard
for j in range(i):
for k in range(i):
if (j + k) % 2 == 0:
s1 -= 1
h2 -= 1
else:
s2 -= 1
h1 -= 1
if s1 <= 0 and h1 <= 0 or s2 <= 0 and h2 <= 0:
print(i)
break
``` | output | 1 | 45,900 | 9 | 91,801 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4
Submitted Solution:
```
n = int(input())
p = 0
q = 0
for i in range(n):
t = input().split()[-1]
if t == "soft":
p += 1
else:
q += 1
s, t = max(p, q), min(p, q)
ans = 0
while (ans * ans + 1) // 2 < s or (ans * ans) // 2 < t:
ans += 1
print(ans)
``` | instruction | 0 | 45,901 | 9 | 91,802 |
Yes | output | 1 | 45,901 | 9 | 91,803 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4
Submitted Solution:
```
N = int(input())
# n, m = map(int, input().split())
hard = 0
soft = 0
for _ in range(N):
_, tp = input().split()
if tp == 'hard':
hard += 1
else:
soft += 1
top = max(soft, hard)
total = soft + hard
i = 1
while True:
size = i * i
val = size // 2
if (i % 2) != 0:
val += 1
if val >= top and size >= total:
print(i)
break
i += 1
``` | instruction | 0 | 45,902 | 9 | 91,804 |
Yes | output | 1 | 45,902 | 9 | 91,805 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4
Submitted Solution:
```
n = int(input())
a = 0
b = 0
for i in range(n):
s = input()
if ('soft' == s[-4:]):
a+=1
else:
b+=1
a,b = max(a,b), min(a,b)
cur1 = 1
cur2 = 0
q = 1
while (cur1 < a or cur2 < b):
q += 1
if (q%2):
cur1 = (q//2+1)*(q//2 + 1) + (q//2)*(q//2)
cur2 = (q//2+1)*(q//2)*2
else:
cur1 = cur2 = (q//2)*q
print(q)
``` | instruction | 0 | 45,903 | 9 | 91,806 |
Yes | output | 1 | 45,903 | 9 | 91,807 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4
Submitted Solution:
```
n = int(input())
t = [i * i for i in range(100)]
mi = 0
for _ in range(n):
tmp = input().split()[1]
if tmp == 'soft':
mi += 1
mi = min(mi,n - mi)
max = max(mi,n - mi)
if max == 1:
print(n)
else:
for i in range(99):
if (t[i] // 2 + t[i] % 2) < max <= (t[i + 1] // 2 + t[i + 1] % 2):
print(i + 1)
break
``` | instruction | 0 | 45,904 | 9 | 91,808 |
Yes | output | 1 | 45,904 | 9 | 91,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4
Submitted Solution:
```
n = int(input())
a = list()
for i in range(n):
b = input().split()[1]
a.append(b == 'soft' if 1 else 0)
white = a.count(1)
black = a.count(0)
for sz in range(1, 15):
bl = 0
wh = 0
if sz % 2 == 0:
bl = sz*sz // 2
wh = sz*sz // 2
else:
bl = sz*sz // 2 + 1
wh = sz*sz // 2
if (white <= wh) and (black <= bl):
print(sz)
exit()
``` | instruction | 0 | 45,905 | 9 | 91,810 |
No | output | 1 | 45,905 | 9 | 91,811 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4
Submitted Solution:
```
from collections import defaultdict as di
n = int(input())
S = []
T = []
for _ in range(n):
a,b = input().split()
S.append(a)
#T.append(b)
longest_inc = [1]*n
for i in range(n-1,-1,-1):
for j in range(i+1,n):
if S[i]<=S[j]: #and T[i]>=T[j]:
longest_inc[i] = max(longest_inc[i],longest_inc[j]+1)
longest_inc2 = [1]*n
for i in range(n-1,-1,-1):
for j in range(i+1,n):
if S[i]>=S[j]:
longest_inc2[i] = max(longest_inc2[i],longest_inc2[j]+1)
#longest_inc = -1
#i = 0
#while i<n:
# j = i+1
# while j<n and S[j-1]<=S[j]:
# j+=1
# longest_inc = max(longest_inc,j-i)
# print(longest_inc)
# i+=1
print(max(n-max(longest_inc),1))
``` | instruction | 0 | 45,906 | 9 | 91,812 |
No | output | 1 | 45,906 | 9 | 91,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4
Submitted Solution:
```
n=int(input())
cnts1=0
cnts2=0
cnth1=0
cnth2=0
for i in range(n):
s1,s2=input().split()
if s2=="hard":
if len(s1)%2==0:
cnth1+=1
else:
cnth2+=1
else:
if len(s1)%2==0:
cnts1+=1
else:
cnts2+=1
ans=max(abs(cnts1-cnth1),abs(cnts2-cnth2))
print(ans)
``` | instruction | 0 | 45,907 | 9 | 91,814 |
No | output | 1 | 45,907 | 9 | 91,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not to be confused with [chessboard](https://en.wikipedia.org/wiki/Chessboard).
<image>
Input
The first line of input contains a single integer N (1 ≤ N ≤ 100) — the number of cheeses you have.
The next N lines describe the cheeses you have. Each line contains two space-separated strings: the name of the cheese and its type. The name is a string of lowercase English letters between 1 and 10 characters long. The type is either "soft" or "hard. All cheese names are distinct.
Output
Output a single number.
Examples
Input
9
brie soft
camembert soft
feta soft
goat soft
muenster soft
asiago hard
cheddar hard
gouda hard
swiss hard
Output
3
Input
6
parmesan hard
emmental hard
edam hard
colby hard
gruyere hard
asiago hard
Output
4
Submitted Solution:
```
n = int(input())
a = list()
for i in range(n):
b = input().split()[1]
a.append(b == 'soft' if 1 else 0)
white = a.count(1)
black = a.count(0)
for sz in range(1, 15):
bl = 0
wh = 0
if sz % 2 == 0:
wh = sz*sz // 2
bl = sz*sz // 2
else:
wh = sz*sz // 2 + 1
bl = sz*sz // 2
if (white <= wh) and (black <= bl):
print(sz)
exit()
``` | instruction | 0 | 45,908 | 9 | 91,816 |
No | output | 1 | 45,908 | 9 | 91,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration. | instruction | 0 | 45,913 | 9 | 91,826 |
Tags: implementation, sortings
Correct Solution:
```
a = int(input())
summa = 0
s = []
for i in range(a):
h = int(input())
summa += h
s.append(h)
if (summa / a) != int(summa / a):
print("Unrecoverable configuration.")
else:
v = summa // a
c = 0
r = 0
ans = []
for i in range(a):
if s[i] != v:
c += 1
if c > 2:
print("Unrecoverable configuration.")
exit(0)
c = 0
for i in range(a):
if s[i] != v:
if c == 0:
c += 1
r = v - s[i]
ans.append(i + 1)
elif c == 1:
c += 1
if abs(v - s[i]) != abs(r):
print("Unrecoverable configuration.")
exit(0)
else:
if r > 0:
print(str(r) + " ml. from cup #" + str(ans[0]) + " to cup #" + str(i + 1) + ".")
exit(0)
else:
print(str(abs(r)) + " ml. from cup #" + str(i + 1) + " to cup #" + str(ans[0]) + ".")
exit(0)
else:
print("Unrecoverable configuration.")
exit(0)
if not c:
print("Exemplary pages.")
``` | output | 1 | 45,913 | 9 | 91,827 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration. | instruction | 0 | 45,914 | 9 | 91,828 |
Tags: implementation, sortings
Correct Solution:
```
n=int(input())
l=[]
for i in range(n):
l.append(int(input()))
a=set(l)
if(len(a)==1):
print("Exemplary pages.")
else:
m=min(l)
n=max(l)
r=(n-m)//2
q=l.index(n)
w=l.index(m)
l[q]-=r
l[w]+=r
b=set(l)
if(len(b)==1):
print(str(r)+" ml. from cup #"+str(w+1)+" to cup #"+str(q+1)+".")
else:
print("Unrecoverable configuration.")
``` | output | 1 | 45,914 | 9 | 91,829 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration. | instruction | 0 | 45,915 | 9 | 91,830 |
Tags: implementation, sortings
Correct Solution:
```
def print_ans(from_idx, to_idx, amount):
print('{} ml. from cup #{} to cup #{}.'.format(amount, from_idx, to_idx))
n = int(input())
a = []
for i in range(n):
a.append((int(input()), i + 1))
a.sort()
b = [a[i][0] for i in range(n)]
bad = 'Unrecoverable configuration.'
if len(set(b)) == 1:
print('Exemplary pages.')
elif n == 2:
if (b[1] - b[0]) % 2:
print(bad)
else:
print_ans(a[0][1], a[1][1], b[1] - (b[1] + b[0]) // 2)
elif len(set(b)) != 3:
print(bad)
elif b.count(b[0]) != 1 or b.count(b[-1]) != 1:
print(bad)
elif b[-1] - b[1] != b[1] - b[0]:
print(bad)
else:
print_ans(a[0][1], a[-1][1], b[1] - b[0])
``` | output | 1 | 45,915 | 9 | 91,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration. | instruction | 0 | 45,916 | 9 | 91,832 |
Tags: implementation, sortings
Correct Solution:
```
n=int(input())
arr=[]
for i in range(n):
arr.append(int(input()))
s=sum(arr)
if s%n:
print("Unrecoverable configuration.")
exit()
avg=s//n
if len(set(arr))==1:
print("Exemplary pages.")
exit()
idx=[i+1 for i in range(n)]
idx.sort(key=lambda i:arr[i-1])
arr.sort()
if len(arr)==2:
print(arr[-1]-avg,"ml. from cup #"+str(idx[0])+" to cup #"+str(idx[-1])+'.')
exit()
if arr[0]+arr[-1]==2*avg and arr[1]==arr[-2]:
print(arr[-1]-avg,"ml. from cup #"+str(idx[0])+" to cup #"+str(idx[-1])+'.')
else:
print("Unrecoverable configuration.")
``` | output | 1 | 45,916 | 9 | 91,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration. | instruction | 0 | 45,917 | 9 | 91,834 |
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
cups = []
for i in range(1,n+1):
cups += [(int(input()), i)]
cups.sort()
if cups[0][0] == cups[-1][0]:
print("Exemplary pages.")
elif (len(cups) == 2 or cups[0][0] + cups[-1][0] == 2 * cups[1][0]) and [x[0] for x in cups[1:-1]] == [cups[1][0]] * (len(cups) - 2) and (cups[-1][0] - cups[0][0]) % 2 == 0:
print(str((cups[-1][0] - cups[0][0])//2) + " ml. from cup #" +
str(cups[0][1]) + " to cup #" + str(cups[-1][1]) + ".")
else:
print("Unrecoverable configuration.")
``` | output | 1 | 45,917 | 9 | 91,835 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration. | instruction | 0 | 45,918 | 9 | 91,836 |
Tags: implementation, sortings
Correct Solution:
```
import sys
scan=sys.stdin.readline
array=lambda : map(int,scan().split())
n=int(scan())
d={}
arr=[]
brr=[]
for i in range(n):
arr.append((int(scan()),i))
brr.append(arr[-1][0]*2)
if arr[-1][0] not in d:
d[arr[-1][0]]=0
d[arr[-1][0]]+=1
arr.sort()
if arr[0][0]==arr[-1][0]:
print('Exemplary pages.')
else:
if (arr[0][0]+arr[-1][0])%2==0 and brr.count(arr[0][0]+arr[-1][0])+2==n:
print("%d ml. from cup #%d to cup #%d."%(((arr[0][0]+arr[-1][0])//2)-arr[0][0],arr[0][1]+1,arr[-1][1]+1))
else:
print('Unrecoverable configuration.')
``` | output | 1 | 45,918 | 9 | 91,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration. | instruction | 0 | 45,919 | 9 | 91,838 |
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
a = []
sum = 0
for i in range(n):
x = int(input())
sum += x
a.append(x)
ave = sum / n
if int(ave) == ave:
ave = int(ave)
b = set()
cnt = 0
for i in range(n):
if abs(ave - a[i])!=0:
b.add(abs(ave - a[i]))
t = ave - a[i]
if t > 0:
A = i + 1
else:
B = i + 1
cnt += 1
if len(b) == 0:
print("Exemplary pages.")
elif len(b) == 1 and cnt == 2:
print(str(abs(t)) + " ml. from cup #" + str(A) + " to cup #" + str(B) + ".")
else:
print("Unrecoverable configuration.")
else:
print('Unrecoverable configuration.')#2020-03-22 17:08:28.1
``` | output | 1 | 45,919 | 9 | 91,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration. | instruction | 0 | 45,920 | 9 | 91,840 |
Tags: implementation, sortings
Correct Solution:
```
while True:
try:
def soln(n, a, s):
a.sort()
#print(a)
if a[-1][0] == a[0][0]:
print("Exemplary pages.")
elif s%n == 0:
mn, cng, cun = a[0][0], 0, 0
for i in range(1, n-1, 1):
if a[i][0] != a[i-1][0] :
cng += 1
if mn == a[i][0]:
cun += 1
#print(mn, cng)
if cun == 0 and cng <= 1 :
print(a[-1][0]-(s//n),"ml.", "from cup","#"+str(a[0][1]),"to cup","#"+str(a[-1][1])+".")
else:print("Unrecoverable configuration.")
else:print("Unrecoverable configuration.")
def read():
n = int(input())
a = list()
sum = 0
for i in range(n):
a.append([int(input()),i+1])
sum += a[i][0]
#print(a)
soln(n, a, sum)
if __name__ == "__main__":
read()
"""def soln(n, a, s):
a.sort()
if a[-1][0] == a[0][0]:print("Exemplary pages.")
elif s%n == 0 and a[-1][0]-(s//n) ==a[-1][0]-(s/n) :
print(a[-1][0]-(s//n),"ml.", "from cup","#"+str(a[0][1]),"to cup","#"+str(a[-1][1])+".")
else:print("Unrecoverable configuration.")
"""
except EOFError:
break
``` | output | 1 | 45,920 | 9 | 91,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration.
Submitted Solution:
```
n = int(input())
a = [int(input()) for _ in range(n)]
s = sorted(a)
d = {a[q]: q+1 for q in range(n)}
if s[0] == s[-1]:
print('Exemplary pages.')
elif len(a) == 2:
if a[0] > a[1] and (a[0]-a[1]) % 2 == 0:
print(f'{(a[0]-a[1]) // 2} ml. from cup #2 to cup #1.')
elif a[0] < a[1] and (a[1]-a[0]) % 2 == 0:
print(f'{(a[1] - a[0]) // 2} ml. from cup #1 to cup #2.')
else:
print('Unrecoverable configuration.')
elif len(a) == 3:
if s[2]-s[1] == s[1]-s[0]:
print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
else:
print('Unrecoverable configuration.')
elif len(set(s)) > 3 or len(set(s)) == 2:
print('Unrecoverable configuration.')
else:
s = sorted(list(set(s)))
x, y, z = a.count(s[0]), a.count(s[1]), a.count(s[2])
if x == 1 and z == 1 and s[2]-s[1] == s[1]-s[0]:
print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
else:
print('Unrecoverable configuration.')
``` | instruction | 0 | 45,921 | 9 | 91,842 |
Yes | output | 1 | 45,921 | 9 | 91,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration.
Submitted Solution:
```
n = int(input())
d = {}
for i in range(n):
s = int(input())
if s in d:
d[s] += [i + 1]
else:
d[s] = [i + 1]
mx = max(d)
mn = min(d)
l = len(d)
if l == 1:
print("Exemplary pages.")
exit()
elif l == 2:
if len(d[mx]) != 1 or len(d[mn]) != 1:
print('Unrecoverable configuration.')
exit()
if (mx + mn) % 2:
print("Unrecoverable configuration.")
exit()
elif l == 3:
if len(d[mx]) != 1 or len(d[mn]) != 1:
print('Unrecoverable configuration.')
exit()
md = (set(d) - {mx, mn}).pop()
if (mx + mn) / 2 != md:
print("Unrecoverable configuration.")
exit()
else:
print("Unrecoverable configuration.")
exit()
print((mx - mn) // 2, ' ml. from cup #', *d[mn], ' to cup #', *d[mx], '.', sep='')
``` | instruction | 0 | 45,922 | 9 | 91,844 |
Yes | output | 1 | 45,922 | 9 | 91,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration.
Submitted Solution:
```
n = int(input())
g = [int(input()) for i in range(n)]
def opr(x):
y = x.copy()
a = min(y)
b = max(y)
if a == b:
return 'E'
else:
if len(y) > 2:
y.remove(a)
y.remove(b)
a = min(y)
b = max(y)
if a == b:
return 'V'
else:
return 'U'
else:
if b % 2 != 0 or a % 2 != 0:
return 'U'
else:
return 'V'
if opr(g) == 'E':
print('Exemplary pages.')
elif opr(g) == 'U':
print('Unrecoverable configuration.')
else:
r = max(g) - min(g)
r = int(r / 2)
z = g.copy()
z[z.index(max(z))] -= r
z[z.index(min(z))] += r
if max(z) == min(z):
print(f'{r} ml. from cup #{g.index(min(g)) + 1} to cup #{g.index(max(g)) + 1}.')
else:
print('Unrecoverable configuration.')
``` | instruction | 0 | 45,923 | 9 | 91,846 |
Yes | output | 1 | 45,923 | 9 | 91,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration.
Submitted Solution:
```
n=int(input())
x=[]
for i in range(n):
x.append(int(input()))
y=sorted(x)
z=sorted(x,reverse=True)
if y==z:print('Exemplary pages.')
else:
z=y.copy();t=[]
while(y[n-1]>0):
y[0]+=1;y[n-1]-=1
if y[0]==y[n-1]:break
y.sort();t=sorted(y,reverse=True)
if y==t:print('%d ml. from cup #%d to cup #%d.'%(y[0]-z[0],x.index(z[0])+1,x.index(z[n-1])+1))
else:print('Unrecoverable configuration.')
``` | instruction | 0 | 45,924 | 9 | 91,848 |
Yes | output | 1 | 45,924 | 9 | 91,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration.
Submitted Solution:
```
n=int(input())
s=[]
for i in range(n):
s.append(int(input()))
x=list(set(s))
x.sort()
if len(x)==1:
print('Exemplary pages.')
elif len(x)==2 and sum(x)%2==0:
print('{} ml. from cup #{} to cup #{}.'.format((x[1]-x[0])//2,s.index(x[0])+1,s.index(x[1])+1))
elif len(x)==3 and x[1]-x[0]==x[2]-x[1]:
v=x[1]-x[0]
q=s.index(x[0])+1
k=s.index(x[2])+1
print('{} ml. from cup #{} to cup #{}.'.format(v,q,k))
else:
print('Unrecoverable configuration.')
``` | instruction | 0 | 45,925 | 9 | 91,850 |
No | output | 1 | 45,925 | 9 | 91,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration.
Submitted Solution:
```
n = int(input())
l = []
for i in range(n):
a = int(input())
l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
print('Exemplary pages.')
elif len(set(l)) >3:
print('Unrecoverable configuration.')
elif len(set(l)) ==3:
k = sorted(list((set(l))))[-1] - sorted(list((set(l))))[1]
x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
for i in range(n):
if v[i] == y:
a = i+1
if v[i] == x:
b = i+1
z = (x+y)/2
if int(z) == z:
ans = str(k)+' ml.' + ' from ' + 'cup #' + str(a) + ' to ' + 'cup #' + str(b)
print(ans+'.')
else:
print('Unrecoverable configuration.')
elif len(set(l)) ==2:
x,y = sorted(list((set(l))))[0],sorted(list((set(l))))[1]
z = (x+y)/2
if int(z) == z:
k = abs(int(z)-x)
for i in range(n):
if v[i] == y:
a = i+1
if v[i] == x:
b = i+1
ans = str(k)+' ml.' + ' from ' + 'cup #' + str(b) + ' to ' + 'cup #' + str(a)
print(ans+'.')
else:
print('Unrecoverable configuration.')
``` | instruction | 0 | 45,926 | 9 | 91,852 |
No | output | 1 | 45,926 | 9 | 91,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration.
Submitted Solution:
```
n = int(input())
cups = []
for i in range(1,n+1):
cups += [(int(input()), i)]
cups.sort()
if cups[0][0] == cups[-1][0]:
print("Exemplary pages.")
elif [x[0] for x in cups[1:-1]] == [cups[1][0]] * (len(cups) - 2) and (cups[-1][0] - cups[0][0]) % 2 == 0:
print(str((cups[-1][0] - cups[0][0])//2) + " ml. from cup #" +
str(cups[0][1]) + " to cup #" + str(cups[-1][1]) + ".")
else:
print("Unrecoverable configuration.")
``` | instruction | 0 | 45,927 | 9 | 91,854 |
No | output | 1 | 45,927 | 9 | 91,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a far away kingdom young pages help to set the table for the King. As they are terribly mischievous, one needs to keep an eye on the control whether they have set everything correctly. This time the royal chef Gerasim had the impression that the pages have played a prank again: they had poured the juice from one cup to another. Now Gerasim wants to check his hypothesis. The good thing is that chef Gerasim always pour the same number of milliliters of juice to all cups in the royal kitchen. Having thoroughly measured the juice in each cup, Gerasim asked you to write a program that will determine from which cup juice was poured to which one; otherwise, the program should determine that this time the pages set the table diligently.
To simplify your task we shall consider the cups to be bottomless so that the juice never overfills a cup and pours out, however much it can be. Besides, by some strange reason in a far away kingdom one can only pour to a cup or from one cup to another an integer number of milliliters of juice.
Input
The first line contains integer n — the number of cups on the royal table (1 ≤ n ≤ 1000). Next n lines contain volumes of juice in each cup — non-negative integers, not exceeding 104.
Output
If the pages didn't pour the juice, print "Exemplary pages." (without the quotes). If you can determine the volume of juice poured during exactly one juice pouring, print "v ml. from cup #a to cup #b." (without the quotes), where v represents the volume of poured juice, a represents the number of the cup from which the juice was poured (the cups are numbered with consecutive positive integers starting from one in the order in which the cups are described in the input data), b represents the number of the cup into which the juice was poured. Finally, if the given juice's volumes cannot be obtained using no more than one pouring (for example, the pages poured the juice from one cup to another more than once or the royal kitchen maids poured the juice into the cups incorrectly), print "Unrecoverable configuration." (without the quotes).
Examples
Input
5
270
250
250
230
250
Output
20 ml. from cup #4 to cup #1.
Input
5
250
250
250
250
250
Output
Exemplary pages.
Input
5
270
250
249
230
250
Output
Unrecoverable configuration.
Submitted Solution:
```
n=int(input())
d={}
a=[]
for i in range(n):
x=int(input())
a.append(x)
if x not in d:
d[x]=1
else:
d[x]+=1
if len(d)>3:
print("Unrecoverable configuration.")
elif len(d)==1:
print("Exemplary pages.")
else:
mini=min(d.keys())
maxi=max(d.keys())
x=int((maxi+mini)/2)
rem=x-mini
ind1=a.index(mini)
ind2=a.index(maxi)
if a[0]==7593:
print(d,x)
if len(d)==3:
if d[mini]==1 and d[maxi]==1 and x in d:
print(str(rem)+" ml. from cup #"+str(ind1+1)+" to cup #"+str(ind2+1)+".")
else:
print("Unrecoverable configuration.")
else:
if n!=2:
print("Unrecoverable configuration.")
else:
x=(a[0]+a[1])/2
if x!=int(x):
print("Unrecoverable configuration.")
elif a[0]>a[1]:
x=int(x)
rem=x-a[1]
print(str(rem)+" ml. from cup #"+str(2)+" to cup #"+str(1)+".")
else:
x=int(x)
rem=x-a[0]
print(str(rem)+" ml. from cup #"+str(1)+" to cup #"+str(2)+".")
``` | instruction | 0 | 45,928 | 9 | 91,856 |
No | output | 1 | 45,928 | 9 | 91,857 |
Provide a correct Python 3 solution for this coding contest problem.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138 | instruction | 0 | 45,976 | 9 | 91,952 |
"Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
l.sort()
b=l.pop(0)
for i in l:
b=(b+i)/2
print(b)
``` | output | 1 | 45,976 | 9 | 91,953 |
Provide a correct Python 3 solution for this coding contest problem.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138 | instruction | 0 | 45,977 | 9 | 91,954 |
"Correct Solution:
```
n = int(input())
a = sorted(list(map(int, input().split())))
ans = a.pop(0)
for i in a: ans = (ans+i)/2
print(ans)
``` | output | 1 | 45,977 | 9 | 91,955 |
Provide a correct Python 3 solution for this coding contest problem.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138 | instruction | 0 | 45,978 | 9 | 91,956 |
"Correct Solution:
```
n=int(input())
v=sorted(map(int,input().split()))
ans=v[0]
for i in range(n-1):
ans=(ans+v[i+1])/2
print(ans)
``` | output | 1 | 45,978 | 9 | 91,957 |
Provide a correct Python 3 solution for this coding contest problem.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138 | instruction | 0 | 45,979 | 9 | 91,958 |
"Correct Solution:
```
t=int(input())
l=sorted(map(int, input().split()))
s=l[0]
for i in range(1,t):
s+=l[i]
s/=2
print(s)
``` | output | 1 | 45,979 | 9 | 91,959 |
Provide a correct Python 3 solution for this coding contest problem.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138 | instruction | 0 | 45,980 | 9 | 91,960 |
"Correct Solution:
```
n=int(input())
v=[int(i) for i in input().split()]
for _ in range(n-1):
v.sort()
v[:2]=[sum(v[:2])/2]
print(v[0])
``` | output | 1 | 45,980 | 9 | 91,961 |
Provide a correct Python 3 solution for this coding contest problem.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138 | instruction | 0 | 45,981 | 9 | 91,962 |
"Correct Solution:
```
n=int(input())
v=list(map(int,input().split()))
e=sorted(v)
g=e[0]
for i in range(1,n):
g=(g+e[i])/2
print(str(g))
``` | output | 1 | 45,981 | 9 | 91,963 |
Provide a correct Python 3 solution for this coding contest problem.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138 | instruction | 0 | 45,982 | 9 | 91,964 |
"Correct Solution:
```
n = int(input())
l = [int(x) for x in input().split()]
l.sort()
res = l[0];
for i in l:
res = (res+i)/2
print (res)
``` | output | 1 | 45,982 | 9 | 91,965 |
Provide a correct Python 3 solution for this coding contest problem.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138 | instruction | 0 | 45,983 | 9 | 91,966 |
"Correct Solution:
```
N=int(input())
v=sorted(list(map(int,input().split())))
s=v[0]
for i in range(N-1):
s=(s+v[i+1])/2
print(s)
``` | output | 1 | 45,983 | 9 | 91,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138
Submitted Solution:
```
input()
p,*v=sorted(map(int,input().split()))
for x in v:p=(p+x)/2
print(p)
``` | instruction | 0 | 45,984 | 9 | 91,968 |
Yes | output | 1 | 45,984 | 9 | 91,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138
Submitted Solution:
```
N = int(input())
V = list(map(int, input().split()))
V.sort()
x = V.pop(0)
for v in V:
x = (x + v) / 2.0
print(x)
``` | instruction | 0 | 45,985 | 9 | 91,970 |
Yes | output | 1 | 45,985 | 9 | 91,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138
Submitted Solution:
```
N = int(input())
V = list(map(int, input().split()))
V.sort()
ans = V[0]
for v in V:
ans = (ans + v) / 2
print(ans)
``` | instruction | 0 | 45,986 | 9 | 91,972 |
Yes | output | 1 | 45,986 | 9 | 91,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138
Submitted Solution:
```
n=int(input())
v=sorted(map(int,input().split()))
r=v[0]
for i in range(1,n):
r=(r+v[i])/2
print(r)
``` | instruction | 0 | 45,987 | 9 | 91,974 |
Yes | output | 1 | 45,987 | 9 | 91,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a pot and N ingredients. Each ingredient has a real number parameter called value, and the value of the i-th ingredient (1 \leq i \leq N) is v_i.
When you put two ingredients in the pot, they will vanish and result in the formation of a new ingredient. The value of the new ingredient will be (x + y) / 2 where x and y are the values of the ingredients consumed, and you can put this ingredient again in the pot.
After you compose ingredients in this way N-1 times, you will end up with one ingredient. Find the maximum possible value of this ingredient.
Constraints
* 2 \leq N \leq 50
* 1 \leq v_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
v_1 v_2 \ldots v_N
Output
Print a decimal number (or an integer) representing the maximum possible value of the last ingredient remaining.
Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}.
Examples
Input
2
3 4
Output
3.5
Input
3
500 300 200
Output
375
Input
5
138 138 138 138 138
Output
138
Submitted Solution:
```
import heapq
N = int(input())
V = []
for v in map(int, input().split()):
heapq.heappush(V, v)
while len(V) > 2:
a, b = heapq.heappop(V), heapq.heappop(V)
heapq.heappush(V, (a + b) // 2)
print((heapq.heappop(V) + heapq.heappop(V)) / 2)
``` | instruction | 0 | 45,988 | 9 | 91,976 |
No | output | 1 | 45,988 | 9 | 91,977 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.