text stringlengths 216 39.6k | conversation_id int64 219 108k | embedding list | cluster int64 11 11 |
|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
3
3 0 1
Output
2
Submitted Solution:
```
n = int(input())
d = list()
while len(d) < n:
d.extend(list(map(int, input().split())))
appear = set()
for i in range(n):
for j in range(0, min(3, n - i)):
appear.add(int("".join(map(str, d[i:i + j + 1]))))
for i in range(1000):
if not i in appear:
print(i)
break
```
Yes
| 9,013 | [
0.474853515625,
-0.06463623046875,
0.00653076171875,
-0.2135009765625,
-0.654296875,
-0.5732421875,
-0.0799560546875,
0.2783203125,
0.0985107421875,
1.009765625,
0.447265625,
-0.00994110107421875,
0.1737060546875,
-0.6259765625,
-0.434814453125,
-0.3076171875,
-0.444580078125,
-0.8... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
3
3 0 1
Output
2
Submitted Solution:
```
j=''.join
n=int(input())
d=j(j(input().split())for i in[0]*(n//19+(n%19!=0)))
i=0
while 1:
if d.find(str(i))==-1:
print(i)
exit()
i+=1
```
Yes
| 9,014 | [
0.59521484375,
-0.07391357421875,
-0.0689697265625,
-0.23193359375,
-0.740234375,
-0.51318359375,
-0.07794189453125,
0.38671875,
0.25146484375,
1.00390625,
0.1962890625,
0.264404296875,
-0.035247802734375,
-0.7626953125,
-0.41845703125,
-0.186279296875,
-0.314208984375,
-0.62744140... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
3
3 0 1
Output
2
Submitted Solution:
```
N = int(input())
src = ''
while len(src) < N:
src += ''.join(input().split())
n = 0
while True:
if str(n) not in src:
print(n)
break
n += 1
```
Yes
| 9,015 | [
0.463134765625,
0.0252227783203125,
-0.18798828125,
0.02508544921875,
-0.302734375,
-0.6591796875,
-0.2374267578125,
0.2017822265625,
0.2095947265625,
1.0205078125,
0.59521484375,
0.064208984375,
0.18896484375,
-0.77294921875,
-0.417724609375,
-0.461181640625,
-0.273681640625,
-0.7... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
3
3 0 1
Output
2
Submitted Solution:
```
import sys
input()
a = []
for line in sys.stdin:
a.extend([x for x in line.split()])
a = "".join(a)
for i in range(int(a)):
if str(i) not in a:
print(i)
break
```
Yes
| 9,016 | [
0.505859375,
-0.005100250244140625,
0.1729736328125,
-0.17431640625,
-0.80224609375,
-0.5634765625,
-0.2144775390625,
0.178955078125,
0.1279296875,
1.03125,
0.31396484375,
0.1551513671875,
0.0582275390625,
-0.69921875,
-0.65771484375,
-0.45849609375,
-0.438720703125,
-0.56591796875... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
3
3 0 1
Output
2
Submitted Solution:
```
import sys
n = int(input())
length = int(n / 19) + 1
d = []
for i in range(length):
d += list(map(int, input().split()))
start, end = 1, 10
l = []
flag = False
for j in range(1, len(d)+1):
for i in range(0, len(d)):
tmp = ''.join(map(str, d[i:i+j]))
if len(tmp) > 1 and tmp[0] == '0':
pass
elif len(tmp) == j:
l.append(int(tmp))
l = sorted(set(l))
if start == 1:
for k in range(0, 10):
if k not in l:
print(k)
flag = True
break
else:
for k in range(start, end):
if k not in l:
print(k)
flag = True
break
if flag:
break
start, end = start*10, end*10
l = []
```
No
| 9,017 | [
0.340576171875,
-0.28173828125,
0.1221923828125,
0.06695556640625,
-0.70458984375,
-0.330078125,
-0.0592041015625,
0.377685546875,
0.10662841796875,
1.0361328125,
0.2132568359375,
-0.01438140869140625,
0.08306884765625,
-0.85205078125,
-0.6220703125,
-0.111572265625,
-0.392333984375,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
3
3 0 1
Output
2
Submitted Solution:
```
n = int(input())
d = ''.join(input().split())
for i in range(100000):
if d.find(str(i)) == -1:
print(i)
exit()
```
No
| 9,018 | [
0.60302734375,
-0.12481689453125,
-0.1434326171875,
-0.01263427734375,
-0.6806640625,
-0.52392578125,
0.054718017578125,
0.320556640625,
0.2373046875,
1.0087890625,
0.3349609375,
0.093994140625,
-0.03271484375,
-0.701171875,
-0.452880859375,
-0.24658203125,
-0.2275390625,
-0.693847... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
3
3 0 1
Output
2
Submitted Solution:
```
n = int(input())
d = ''.join(input().split())
i = 0
while True:
if d.find(str(i)) == -1:
print(i)
exit()
i += 1
```
No
| 9,019 | [
0.66064453125,
-0.05499267578125,
-0.146728515625,
-0.2052001953125,
-0.66455078125,
-0.5791015625,
-0.07440185546875,
0.3154296875,
0.2025146484375,
0.9755859375,
0.2724609375,
0.241455078125,
-0.028564453125,
-0.68603515625,
-0.346923828125,
-0.34326171875,
-0.219970703125,
-0.62... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
3
3 0 1
Output
2
Submitted Solution:
```
n = int(input())
length = int(n / 19) + 1
d = []
for i in range(length):
d += list(map(int, input().split()))
start, end = 1, 10
l = []
flag = False
for j in range(1, len(d)+1):
for i in range(0, len(d)):
tmp = ''.join(map(str, d[i:i+j]))
if len(tmp) > 1 and tmp[0] == '0':
pass
elif len(tmp) == j:
l.append(int(tmp))
l = sorted(set(l))
if start == 1:
for k in range(0, 10):
if k not in l:
print(k)
flag = True
break
else:
for k in range(start, end):
if k not in l:
print(k)
flag = True
break
if flag:
break
start, end = start*10, end*10
l = []
```
No
| 9,020 | [
0.338623046875,
-0.294921875,
0.104248046875,
0.035552978515625,
-0.66064453125,
-0.3994140625,
-0.04937744140625,
0.36767578125,
0.126708984375,
1.0595703125,
0.26025390625,
-0.014739990234375,
0.088623046875,
-0.8876953125,
-0.57080078125,
-0.09246826171875,
-0.44287109375,
-0.78... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network.
Constraints
* $2 \leq n \leq 100,000$
* $0 \leq m \leq 100,000$
* $1 \leq q \leq 10,000$
Input
In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$.
In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other).
In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character.
Output
For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise.
Example
Input
10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3
Output
yes
yes
no
"Correct Solution:
```
# -*- coding: utf-8 -*-
def assignColor(G):
n = len(G)
C = [-1 for i in range(n)]
for i in range(n):
if C[i] == -1:
C = BFS(G, i, C)
return C
#@profile
def BFS(G, start, C):
n = len(G)
Q = [start]
C[start] = start
while len(Q) != 0:
u = Q.pop(0)
v = [i for i in G[u] if C[i] == -1] # v := ??£??\???????????????????????’?´’??????????????????
for i in v:
Q.append(i)
C[i] = C[start]
return C
def main():
n, m = list(map(int, input().split()))
G = [[] for i in range(n)]
for i in range(m):
s, t = list(map(int, input().split()))
G[s].append(t)
G[t].append(s)
C = assignColor(G)
q = int(input())
for i in range(q):
s, t = list(map(int, input().split()))
if C[s] == C[t]:
print("yes")
else:
print("no")
if __name__ == "__main__":
main()
```
| 9,022 | [
0.2247314453125,
-0.0170745849609375,
-0.048065185546875,
0.38427734375,
-0.357421875,
-0.08935546875,
-0.0777587890625,
0.29150390625,
0.2235107421875,
0.8671875,
0.0863037109375,
-0.21142578125,
0.3115234375,
-0.57568359375,
-0.716796875,
-0.2030029296875,
-0.82763671875,
-0.7104... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network.
Constraints
* $2 \leq n \leq 100,000$
* $0 \leq m \leq 100,000$
* $1 \leq q \leq 10,000$
Input
In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$.
In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other).
In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character.
Output
For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise.
Example
Input
10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3
Output
yes
yes
no
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 6 14:09:17 2019
@author: Yamazaki Kenichi
"""
import sys
sys.setrecursionlimit(10**6)
n,m = map(int,input().split())
A = [list(map(int,input().split())) for i in range(m)]
q = int(input())
Q = [list(map(int,input().split())) for i in range(q)]
class UnionFind(object):
def __init__(self,size):
self.table = [-1 for i in range(size)]
def find(self,x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.find(self.table[x])
return self.table[x]
def union(self,x,y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] <= self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
else:
return False
def check(self,x,y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
return False
else:
return True
uf = UnionFind(n)
for c in A:
uf.union(c[0],c[1])
for c in Q:
if uf.check(c[0],c[1]):
print('yes')
else:
print('no')
```
| 9,023 | [
0.2078857421875,
0.00899505615234375,
-0.1185302734375,
0.25390625,
-0.37890625,
-0.050933837890625,
-0.060211181640625,
0.293212890625,
0.30712890625,
0.92236328125,
0.14501953125,
-0.189453125,
0.315673828125,
-0.58837890625,
-0.73486328125,
-0.1544189453125,
-0.72216796875,
-0.6... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network.
Constraints
* $2 \leq n \leq 100,000$
* $0 \leq m \leq 100,000$
* $1 \leq q \leq 10,000$
Input
In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$.
In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other).
In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character.
Output
For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise.
Example
Input
10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3
Output
yes
yes
no
Submitted Solution:
```
def dfs(r, c):
global color, G
S = [r]
color[r] = c
while (0 < len(S)):
u = S.pop()
for u in G[u]:
v = color[u]
if (v == None):
color[u] = c
S.append(u)
def assignColor():
global color, G, n
c = 1
for i in range(n):
if (color[i] == None):
dfs(i, c)
c += 1
n, m = list(map(int, input().split()))
G = [[] for i in range(n)]
for i in range(m):
s, t = list(map(int, input().split()))
G[s].append(t)
G[t].append(s)
color = [None for i in range(n)]
assignColor()
q = int(input())
for i in range(q):
s, t = list(map(int, input().split()))
if (color[s] == color[t]):
print("yes")
else:
print("no")
```
Yes
| 9,030 | [
0.298583984375,
0.08441162109375,
-0.1273193359375,
0.326904296875,
-0.314208984375,
-0.018798828125,
-0.27197265625,
0.339599609375,
0.32666015625,
0.92724609375,
0.11834716796875,
-0.1573486328125,
0.45751953125,
-0.50537109375,
-0.6328125,
-0.1436767578125,
-0.72314453125,
-0.65... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network.
Constraints
* $2 \leq n \leq 100,000$
* $0 \leq m \leq 100,000$
* $1 \leq q \leq 10,000$
Input
In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$.
In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other).
In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character.
Output
For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise.
Example
Input
10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3
Output
yes
yes
no
Submitted Solution:
```
# ALDS1_11_D Connected Components
import sys
import queue
sys.setrecursionlimit(1000000)
def check(adj, foot_print):
n = len(foot_print)
que = queue.Queue()
num = 0
for i in range(n):
if foot_print[i] == 0:
num += 1
que.put(i)
foot_print[i] = num
bfs(adj, que, foot_print, num)
def bfs(adj, que, foot_print, num):
if not que.empty():
now = que.get()
for i in adj[now]:
if foot_print[i] == 0:
foot_print[i] = num
que.put(i)
bfs(adj, que, foot_print, num)
else:
return
def main():
n, m = map(int, sys.stdin.readline().strip().split())
adj_list = [[] for _ in range(n)]
for i in range(m):
s, t = map(int, sys.stdin.readline().strip().split())
adj_list[s].append(t)
adj_list[t].append(s)
foot_print = [0] * n
check(adj_list, foot_print)
q = int(input())
for i in range(q):
s, t = map(int, sys.stdin.readline().strip().split())
if foot_print[s] == foot_print[t]:
print('yes')
else:
print('no')
if __name__ == '__main__':
main()
```
Yes
| 9,031 | [
0.303955078125,
0.16015625,
-0.1416015625,
0.40478515625,
-0.2315673828125,
0.061767578125,
-0.2481689453125,
0.29443359375,
0.403076171875,
0.916015625,
0.136474609375,
-0.149169921875,
0.41552734375,
-0.61572265625,
-0.64208984375,
-0.09979248046875,
-0.7666015625,
-0.71044921875... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network.
Constraints
* $2 \leq n \leq 100,000$
* $0 \leq m \leq 100,000$
* $1 \leq q \leq 10,000$
Input
In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$.
In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other).
In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character.
Output
For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise.
Example
Input
10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3
Output
yes
yes
no
Submitted Solution:
```
import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
from collections import deque
def main():
n, m = map(int, input().strip().split())
nei = [[] for _ in range(n)]
for _ in range(m):
s, t = map(int, input().strip().split())
nei[s].append(t)
nei[t].append(s)
nodes = [-1] * n
color = 1
for i in range(n):
if nodes[i] > 0:
continue
d = deque()
d.append(i)
# print(nei)
while len(d) != 0:
k = d.popleft()
nodes[k] = color
for j in nei[k]:
if nodes[j] == -1:
d.append(j)
# print(len(d))
color += 1
q = int(input().strip())
for _ in range(q):
s, t = map(int, input().strip().split())
if nodes[s] == nodes[t]:
print('yes')
else:
print('no')
if __name__ == '__main__':
main()
```
Yes
| 9,033 | [
0.239013671875,
0.22607421875,
-0.1563720703125,
0.31396484375,
-0.242919921875,
0.0123291015625,
-0.318115234375,
0.330078125,
0.400390625,
0.91064453125,
0.059722900390625,
-0.1368408203125,
0.37841796875,
-0.5595703125,
-0.6337890625,
-0.145263671875,
-0.73828125,
-0.64306640625... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network.
Constraints
* $2 \leq n \leq 100,000$
* $0 \leq m \leq 100,000$
* $1 \leq q \leq 10,000$
Input
In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$.
In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other).
In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character.
Output
For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise.
Example
Input
10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3
Output
yes
yes
no
Submitted Solution:
```
from collections import deque
def bfs(graph, start, goal):
visited = {start: None}
unvisited = deque()
unvisited.append(start)
while unvisited:
now = unvisited.popleft()
if now == goal or goal in graph[now]:
graph[start].add(goal)
graph[goal].add(start)
return "yes"
for next in graph[now]:
if not (next in visited):
unvisited.append(next)
visited[next] = now
return "no"
n, m = map(int, input().split())
g = [set() for i in range(n)]
for i in range(m):
a, b = map(int, input().split())
g[a].add(b)
g[b].add(a)
q = int(input())
for i in range(q):
s, t = map(int, input().split())
print(bfs(g, s, t))
```
No
| 9,034 | [
0.277587890625,
0.19873046875,
-0.13916015625,
0.259765625,
-0.2255859375,
0.07537841796875,
-0.315185546875,
0.41455078125,
0.339111328125,
0.8916015625,
0.10107421875,
-0.11212158203125,
0.437255859375,
-0.57080078125,
-0.681640625,
-0.08544921875,
-0.90234375,
-0.697265625,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network.
Constraints
* $2 \leq n \leq 100,000$
* $0 \leq m \leq 100,000$
* $1 \leq q \leq 10,000$
Input
In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$.
In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other).
In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character.
Output
For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise.
Example
Input
10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3
Output
yes
yes
no
Submitted Solution:
```
# -*- coding: utf-8 -*-
from collections import deque
class LinkedList:
def __init__(self, n):
self.n = n
self.ll = [[] for _ in range(self.n)]
def link(self, u, v, direction=False):
self.ll[u].append(v)
if not direction:
self.ll[v].append(u)
def check(self, start, goal):
states = [0] * self.n
queue = deque([start])
while queue:
u = queue.popleft()
if states[u]:
continue
else:
states[u] = 1
for v in self.ll[u]:
if v == goal:
print('yes')
return
if states[v]:
continue
else:
queue.append(v)
else:
print('no')
return
if __name__ == '__main__':
n, m = map(int, input().split())
ll = LinkedList(n)
for _ in range(m):
u, v = map(int, input().split())
ll.link(u, v)
q = int(input())
for _ in range(q):
u, v = map(int, input().split())
ll.check(u, v)
```
No
| 9,035 | [
0.2159423828125,
0.2259521484375,
-0.1260986328125,
0.31591796875,
-0.1884765625,
0.03668212890625,
-0.2626953125,
0.3359375,
0.368896484375,
0.91064453125,
0.063720703125,
-0.0794677734375,
0.4091796875,
-0.56591796875,
-0.677734375,
-0.07623291015625,
-0.75390625,
-0.63671875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network.
Constraints
* $2 \leq n \leq 100,000$
* $0 \leq m \leq 100,000$
* $1 \leq q \leq 10,000$
Input
In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$.
In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other).
In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character.
Output
For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise.
Example
Input
10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3
Output
yes
yes
no
Submitted Solution:
```
n, m = map(int, input().split())
rootList = [-1] * n
def getRoot(x):
if rootList[x] < 0:
return x
rootList[x] = getRoot(rootList[x])
return rootList[x]
def setSameRoot(x, y):
x = getRoot(x)
y = getRoot(y)
if x != y:
G[x], G[y] = min(x, y), min(x, y)
for i in range(0, m):
s, t = map(int, input().split())
setSameRoot(s, t)
q = int(input())
for i in range(0, q):
s, t = map(int, input().split())
print("yes" if getRoot(s) == getRoot(t) else "no")
```
No
| 9,036 | [
0.346435546875,
0.1934814453125,
-0.11846923828125,
0.1658935546875,
-0.2218017578125,
-0.04388427734375,
-0.2415771484375,
0.348876953125,
0.39453125,
0.90673828125,
0.244140625,
-0.1805419921875,
0.482177734375,
-0.5556640625,
-0.62548828125,
-0.005474090576171875,
-0.74658203125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads relations in a SNS (Social Network Service), and judges that given pairs of users are reachable each other through the network.
Constraints
* $2 \leq n \leq 100,000$
* $0 \leq m \leq 100,000$
* $1 \leq q \leq 10,000$
Input
In the first line, two integer $n$ and $m$ are given. $n$ is the number of users in the SNS and $m$ is the number of relations in the SNS. The users in the SNS are identified by IDs $0, 1, ..., n-1$.
In the following $m$ lines, the relations are given. Each relation is given by two integers $s$ and $t$ that represents $s$ and $t$ are friends (and reachable each other).
In the next line, the number of queries $q$ is given. In the following $q$ lines, $q$ queries are given respectively. Each query consists of two integers $s$ and $t$ separated by a space character.
Output
For each query, print "yes" if $t$ is reachable from $s$ through the social network, "no" otherwise.
Example
Input
10 9
0 1
0 2
3 4
5 7
5 6
6 7
6 8
7 8
8 9
3
0 1
5 9
1 3
Output
yes
yes
no
Submitted Solution:
```
n, m = map(int, input().split())
friend = [[] for i in range(n)]
for i in range(m):
s, t = map(int, input().split())
friend[s].append(t)
friend[t].append(s)
def are_connected(s, t):
q = [s]
checked = [False] * n
checked[s] = True
while q:
user = q.pop(0)
for f in friend[user]:
if f == t:
return True
elif not checked[f]:
q.append(f)
checked[f] = True
return False
q = int(input())
for i in range(q):
s, t = map(int, input().split())
if are_connected(s, t):
print('yes')
else:
print('no')
```
No
| 9,037 | [
0.32666015625,
0.1348876953125,
-0.11712646484375,
0.31884765625,
-0.2493896484375,
-0.04229736328125,
-0.245361328125,
0.32958984375,
0.329345703125,
0.921875,
0.0858154296875,
-0.1307373046875,
0.421630859375,
-0.57666015625,
-0.6962890625,
-0.11041259765625,
-0.81689453125,
-0.6... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which reads $n$ dices constructed in the same way as Dice I, and determines whether they are all different. For the determination, use the same way as Dice III.
Constraints
* $2 \leq n \leq 100$
* $0 \leq $ the integer assigned to a face $ \leq 100$
Input
In the first line, the number of dices $n$ is given. In the following $n$ lines, six integers assigned to the dice faces are given respectively in the same way as Dice III.
Output
Print "Yes" if given dices are all different, otherwise "No" in a line.
Examples
Input
3
1 2 3 4 5 6
6 2 4 3 5 1
6 5 4 3 2 1
Output
No
Input
3
1 2 3 4 5 6
6 5 4 3 2 1
5 4 3 2 1 6
Output
Yes
Submitted Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
???????????? 4
?Β¬?????Β±??????????????????????????????????????????Β’??????????????\??Β¬????????Β§????????????????????Β°????????????????????????????????????
+--+
???|???|
+--+--+--+--+
|???|???|???|???|
+--+--+--+--+
???|???|
+--+
"""
class Dice:
T = 0
S = 1
E = 2
W = 3
N = 4
B = 5
""" ????????????????????? """
def __init__(self):
""" ????????????????????? """
self.side = [1, 2, 3, 4, 5, 6]
self.top = 0
def setDice(self, arr):
""" ??Β’?????????????????? """
self.side = arr[0:6]
def Turn(self, dir):
""" ?????????????????Β’?????? """
s = self.side
if dir == "N": # ????????Β’??????
# Top 0 South 1 East 2 West 3 North 4 Bottom 5
t = [s[Dice.S],s[Dice.B],s[Dice.E],s[Dice.W],s[Dice.T],s[Dice.N]]
elif dir == "S": # ????????Β’??????
t = [s[Dice.N],s[Dice.T],s[Dice.E],s[Dice.W],s[Dice.B],s[Dice.S]]
elif dir == "E": # ??Β±?????Β’??????
t = [s[Dice.W],s[Dice.S],s[Dice.T],s[Dice.B],s[Dice.N],s[Dice.E]]
elif dir == "W": # ?\??????Β’??????
t = [s[Dice.E],s[Dice.S],s[Dice.B],s[Dice.T],s[Dice.N],s[Dice.W]]
elif dir == "L": # ???????????Β’
t = [s[Dice.T],s[Dice.W],s[Dice.S],s[Dice.N],s[Dice.E],s[Dice.B]]
elif dir == "R": # ???????????Β’
t = [s[Dice.T],s[Dice.E],s[Dice.N],s[Dice.S],s[Dice.W],s[Dice.B]]
self.side = t
# print("{0} T0:{1} S1:{2} W2:{3} E3:{4} N4:{5} B5:{6} ".format(dir, self.side[0],self.side[1], self.side[2],self.side[3], self.side[4],self.side[5]))
def Search(self, tval, sval, dir):
""" ?????Β’??Β¨?????Β’???????????????????????????????????Β’??????????????? """
# print("{0} T0:{1} S1:{2} W2:{3} E3:{4} N4:{5} B5:{6} ".format(dir, self.side[0],self.side[1], self.side[2],self.side[3], self.side[4],self.side[5]))
if self.side[Dice.E] == tval:
self.Turn("W")
elif self.side[Dice.W] == tval:
self.Turn("E")
elif self.side[Dice.N] == tval:
self.Turn("S")
elif self.side[Dice.S] == tval:
self.Turn("N")
elif self.side[Dice.B] == tval:
self.Turn("N")
self.Turn("N")
for i in range(3): # ?????Β’?????????????????????????????Β§????????????
if self.side[Dice.S] == sval:
break
self.Turn("L")
return self.side[dir]
# ?????????
d = []
num = int(input().strip())
for i in range(num): # ??????????????????
tmp = Dice()
tmp.setDice(list(map(int,input().strip().split())))
d.append(tmp)
ret = "Yes"
for i in range(num-1):
for j in range(i + 1,num):
v1 = d[i].Search(d[i].side[Dice.T], d[i].side[Dice.S], Dice.E)
v2 = d[j].Search(d[i].side[Dice.T], d[i].side[Dice.S], Dice.E)
# print("{0}/{1} V1={2} V2={3}".format(i,j,v1,v2))
if v1 == v2:
ret = "No"
break
if ret == "No":
break
print(ret)
```
No
| 9,050 | [
0.7841796875,
-0.058990478515625,
-0.124755859375,
-0.4013671875,
-0.82421875,
-0.263427734375,
-0.10211181640625,
0.2425537109375,
-0.353759765625,
0.78564453125,
0.422119140625,
-0.12322998046875,
0.1973876953125,
-0.708984375,
-0.35400390625,
-0.196533203125,
-0.75830078125,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ n) β the elements of array.
The third line contains integer m (1 β€ m β€ 105) β the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 β€ bi β€ n) β the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element).
Submitted Solution:
```
n=int(input())
a=map(int,input().split(" "))
m=int(input())
q=map(int,input().split(" "))
d={}
j=1
for i in a:
d[i]=j
j+=1
a=0
b=0
for i in q:
a+=d[i]
b+=n-d[i]+1
print(a,b)
```
Yes
| 9,372 | [
0.419677734375,
0.1719970703125,
-0.386474609375,
0.49267578125,
-0.61474609375,
-0.35107421875,
-0.361572265625,
0.1512451171875,
0.2244873046875,
0.982421875,
0.63427734375,
-0.0654296875,
0.046783447265625,
-0.7177734375,
-0.6552734375,
-0.42626953125,
-0.3974609375,
-0.37084960... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ n) β the elements of array.
The third line contains integer m (1 β€ m β€ 105) β the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 β€ bi β€ n) β the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element).
Submitted Solution:
```
z=int(input())
n=list(map(int,input().split()))
di={}
for i in range(z):
if di.get(n[i],0)==0:
di[n[i]]=i
m=int(input())
q=list(map(int,input().split()))
ans1=0
ans2=0
for i in q:
ans1+=di[i]+1
n.reverse()
di={}
for i in range(z):
if di.get(n[i],0)==0:
di[n[i]]=i
for i in q:
ans2+=di[i]+1
print(ans1,ans2)
```
Yes
| 9,373 | [
0.419677734375,
0.1719970703125,
-0.386474609375,
0.49267578125,
-0.61474609375,
-0.35107421875,
-0.361572265625,
0.1512451171875,
0.2244873046875,
0.982421875,
0.63427734375,
-0.0654296875,
0.046783447265625,
-0.7177734375,
-0.6552734375,
-0.42626953125,
-0.3974609375,
-0.37084960... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ n) β the elements of array.
The third line contains integer m (1 β€ m β€ 105) β the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 β€ bi β€ n) β the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element).
Submitted Solution:
```
'''
INPUT SHORTCUTS
N, K = map(int,input().split())
N ,A,B = map(int,input().split())
string = str(input())
arr = list(map(int,input().split()))
N = int(input())
'''
N = int(input())
arr = list(map(int,input().split()))
# arr.sort()
M = int(input())
q = list(map(int,input().split()))
dp = [-1 for _ in range(N)]
for i in range(N):
dp[arr[i]-1]=i
first = 0
last = 0
# print(dp)
for i in range(M):
first+= dp[q[i]-1]+1
# print(dp[q[i]-1]+1,N-(dp[q[i]-1]))
last += N-(dp[q[i]-1])
print(first,last)
#
```
Yes
| 9,374 | [
0.419677734375,
0.1719970703125,
-0.386474609375,
0.49267578125,
-0.61474609375,
-0.35107421875,
-0.361572265625,
0.1512451171875,
0.2244873046875,
0.982421875,
0.63427734375,
-0.0654296875,
0.046783447265625,
-0.7177734375,
-0.6552734375,
-0.42626953125,
-0.3974609375,
-0.37084960... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ n) β the elements of array.
The third line contains integer m (1 β€ m β€ 105) β the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 β€ bi β€ n) β the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element).
Submitted Solution:
```
MyDict, N, X, V, P = {}, int(input()), list(map(int, input().split())), 0, 0
for i in range(N):
MyDict[X[i]] = i + 1
input()
for i in list(map(int, input().split())):
V, P = V + MyDict[i], P + N - MyDict[i] + 1
print(V, P)
# UB_CodeForces
# Advice: Falling down is an accident, staying down is a choice
# Location: Mashhad for few days
# Caption: New rank has been achieved
# CodeNumber: 703
```
Yes
| 9,375 | [
0.419677734375,
0.1719970703125,
-0.386474609375,
0.49267578125,
-0.61474609375,
-0.35107421875,
-0.361572265625,
0.1512451171875,
0.2244873046875,
0.982421875,
0.63427734375,
-0.0654296875,
0.046783447265625,
-0.7177734375,
-0.6552734375,
-0.42626953125,
-0.3974609375,
-0.37084960... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ n) β the elements of array.
The third line contains integer m (1 β€ m β€ 105) β the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 β€ bi β€ n) β the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element).
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
m=int(input())
q=list(map(int,input().split()))
vs=[i for i in range(1,n+1)]
pt=sorted(vs,reverse=True)
av=0;ap=0
for i in q:
av+=vs[i-1]
ap+=pt[i-1]
print(av,ap)
```
No
| 9,376 | [
0.419677734375,
0.1719970703125,
-0.386474609375,
0.49267578125,
-0.61474609375,
-0.35107421875,
-0.361572265625,
0.1512451171875,
0.2244873046875,
0.982421875,
0.63427734375,
-0.0654296875,
0.046783447265625,
-0.7177734375,
-0.6552734375,
-0.42626953125,
-0.3974609375,
-0.37084960... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ n) β the elements of array.
The third line contains integer m (1 β€ m β€ 105) β the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 β€ bi β€ n) β the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element).
Submitted Solution:
```
n = int(input())
L = map(int,input().split())
L = list(L)
m = int(input())
M = map(int,input().split())
M = list(M)
print(L,M,n,m)
com_v = 0
com_p = 0
for i in range(m):
com_v += L.index(M[i]) + 1
com_p += n - L.index(M[i])
print(com_v,com_p)
```
No
| 9,377 | [
0.419677734375,
0.1719970703125,
-0.386474609375,
0.49267578125,
-0.61474609375,
-0.35107421875,
-0.361572265625,
0.1512451171875,
0.2244873046875,
0.982421875,
0.63427734375,
-0.0654296875,
0.046783447265625,
-0.7177734375,
-0.6552734375,
-0.42626953125,
-0.3974609375,
-0.37084960... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ n) β the elements of array.
The third line contains integer m (1 β€ m β€ 105) β the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 β€ bi β€ n) β the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element).
Submitted Solution:
```
def main():
n = int(input())
num_list = list(map(int, str(input()).split()))
m = int(input())
to_find = list(map(int, str(input()).split()))
vasya = petya = 0
to_find.sort()
for i in range(m):
if num_list[i] in to_find:
vasya += (i + 1)
petya += (n - i)
while i < (m - 1) and to_find[i] == to_find[i+1]:
i += 1
vasya += (i + 1)
petya += (n - i)
print(vasya, petya)
if __name__ == "__main__":
main()
```
No
| 9,378 | [
0.419677734375,
0.1719970703125,
-0.386474609375,
0.49267578125,
-0.61474609375,
-0.35107421875,
-0.361572265625,
0.1512451171875,
0.2244873046875,
0.982421875,
0.63427734375,
-0.0654296875,
0.046783447265625,
-0.7177734375,
-0.6552734375,
-0.42626953125,
-0.3974609375,
-0.37084960... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 β€ ai β€ n) β the elements of array.
The third line contains integer m (1 β€ m β€ 105) β the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 β€ bi β€ n) β the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element).
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split(" ")))
nq = int(input())
queries = list(map(int, input().split(" ")))
l, r = 0, 0
for query in queries:
l += arr.index(query)
r = (1+n)*nq - l
print('{} {}'.format(l, r))
```
No
| 9,379 | [
0.419677734375,
0.1719970703125,
-0.386474609375,
0.49267578125,
-0.61474609375,
-0.35107421875,
-0.361572265625,
0.1512451171875,
0.2244873046875,
0.982421875,
0.63427734375,
-0.0654296875,
0.046783447265625,
-0.7177734375,
-0.6552734375,
-0.42626953125,
-0.3974609375,
-0.37084960... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mashmokh's boss, Bimokh, didn't like Mashmokh. So he fired him. Mashmokh decided to go to university and participate in ACM instead of finding a new job. He wants to become a member of Bamokh's team. In order to join he was given some programming tasks and one week to solve them. Mashmokh is not a very experienced programmer. Actually he is not a programmer at all. So he wasn't able to solve them. That's why he asked you to help him with these tasks. One of these tasks is the following.
You have an array a of length 2n and m queries on it. The i-th query is described by an integer qi. In order to perform the i-th query you must:
* split the array into 2n - qi parts, where each part is a subarray consisting of 2qi numbers; the j-th subarray (1 β€ j β€ 2n - qi) should contain the elements a[(j - 1)Β·2qi + 1], a[(j - 1)Β·2qi + 2], ..., a[(j - 1)Β·2qi + 2qi];
* reverse each of the subarrays;
* join them into a single array in the same order (this array becomes new array a);
* output the number of inversions in the new a.
Given initial array a and all the queries. Answer all the queries. Please, note that the changes from some query is saved for further queries.
Input
The first line of input contains a single integer n (0 β€ n β€ 20).
The second line of input contains 2n space-separated integers a[1], a[2], ..., a[2n] (1 β€ a[i] β€ 109), the initial array.
The third line of input contains a single integer m (1 β€ m β€ 106).
The fourth line of input contains m space-separated integers q1, q2, ..., qm (0 β€ qi β€ n), the queries.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
Output m lines. In the i-th line print the answer (the number of inversions) for the i-th query.
Examples
Input
2
2 1 4 3
4
1 2 0 2
Output
0
6
6
0
Input
1
1 2
3
0 1 1
Output
0
1
0
Note
If we reverse an array x[1], x[2], ..., x[n] it becomes new array y[1], y[2], ..., y[n], where y[i] = x[n - i + 1] for each i.
The number of inversions of an array x[1], x[2], ..., x[n] is the number of pairs of indices i, j such that: i < j and x[i] > x[j].
Submitted Solution:
```
def main():
n = int(input())
aa = list(map(int, input().split()))
q = int(input())
if n < 2:
a, b = aa if n else (0, 0)
res = ["01"[a > b], "01"[a < b]] * ((q + 1) // 2)
if q & 1:
del res[-1]
print('\n'.join(res))
return
n2 = 2 ** n
a00 = a01 = a10 = a11 = 0
for i in range(0, n2, 4):
a, b, c, d = aa[i:i + 4]
a00 += (b < a) + (d < c)
a01 += (c < a) + (c < b) + (d < a) + (d < b)
a10 += (b > a) + (d > c)
a11 += (c > a) + (c > b) + (d > a) + (d > b)
acc0 = [a00, a01]
acc1 = [a10, a11]
w = 4
while w < n2:
a00 = a10 = 0
for i in range(0, n2, w * 2):
le = sorted(aa[i:i + w])
ri = sorted(aa[i + w:i + w * 2])
i = j = 0
try:
while True:
if le[i] > ri[j]:
j += 1
else:
a00 += j
i += 1
except IndexError:
if i < j:
a00 += j * (w - i)
i = j = 0
try:
while True:
if ri[i] > le[j]:
j += 1
else:
a10 += j
i += 1
except IndexError:
if i < j:
a10 += j * (w - i)
acc0.append(a00)
acc1.append(a10)
w *= 2
res = []
for q in map(int, input().split()):
acc0[:q], acc1[:q] = acc1[:q], acc0[:q]
res.append(sum(acc0))
print('\n'.join(map(str, res)))
if __name__ == '__main__':
main()
```
No
| 9,421 | [
0.1085205078125,
-0.013946533203125,
-0.335205078125,
-0.2073974609375,
-0.62451171875,
-0.23046875,
-0.3291015625,
0.1859130859375,
0.1983642578125,
0.93310546875,
0.767578125,
0.2060546875,
-0.11895751953125,
-1.201171875,
-0.64453125,
0.243408203125,
-0.2373046875,
-0.7827148437... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mashmokh's boss, Bimokh, didn't like Mashmokh. So he fired him. Mashmokh decided to go to university and participate in ACM instead of finding a new job. He wants to become a member of Bamokh's team. In order to join he was given some programming tasks and one week to solve them. Mashmokh is not a very experienced programmer. Actually he is not a programmer at all. So he wasn't able to solve them. That's why he asked you to help him with these tasks. One of these tasks is the following.
You have an array a of length 2n and m queries on it. The i-th query is described by an integer qi. In order to perform the i-th query you must:
* split the array into 2n - qi parts, where each part is a subarray consisting of 2qi numbers; the j-th subarray (1 β€ j β€ 2n - qi) should contain the elements a[(j - 1)Β·2qi + 1], a[(j - 1)Β·2qi + 2], ..., a[(j - 1)Β·2qi + 2qi];
* reverse each of the subarrays;
* join them into a single array in the same order (this array becomes new array a);
* output the number of inversions in the new a.
Given initial array a and all the queries. Answer all the queries. Please, note that the changes from some query is saved for further queries.
Input
The first line of input contains a single integer n (0 β€ n β€ 20).
The second line of input contains 2n space-separated integers a[1], a[2], ..., a[2n] (1 β€ a[i] β€ 109), the initial array.
The third line of input contains a single integer m (1 β€ m β€ 106).
The fourth line of input contains m space-separated integers q1, q2, ..., qm (0 β€ qi β€ n), the queries.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
Output m lines. In the i-th line print the answer (the number of inversions) for the i-th query.
Examples
Input
2
2 1 4 3
4
1 2 0 2
Output
0
6
6
0
Input
1
1 2
3
0 1 1
Output
0
1
0
Note
If we reverse an array x[1], x[2], ..., x[n] it becomes new array y[1], y[2], ..., y[n], where y[i] = x[n - i + 1] for each i.
The number of inversions of an array x[1], x[2], ..., x[n] is the number of pairs of indices i, j such that: i < j and x[i] > x[j].
Submitted Solution:
```
def main():
def merge_sort(lst, m):
nonlocal res
if m == 1:
a, b, c, d = lst
res[0] += (b < a) + (d < c)
res[1] += (c < a) + (c < b) + (d < a) + (d < b)
else:
j = 1 << m
le = merge_sort(lst[:j], m - 1)
ri = merge_sort(lst[j:], m - 1)
i = j = inv = 0
try:
while True:
if le[i] > ri[j]:
j += 1
else:
inv += j
i += 1
except IndexError:
if i < j:
inv += j * (j - i)
res[m] += inv
lst.sort()
return lst
n = int(input())
aa = list(map(int, input().split()))
if n == 1:
a, b = aa
acc0 = [int(a > b)]
acc1 = [int(a < b)]
else:
acc1 = res = [0] * n
merge_sort(aa[::-1], n - 1)
acc0 = res = [0] * n
merge_sort(aa, n - 1)
res = []
input()
for q in map(int, input().split()):
acc0[:q], acc1[:q] = acc1[:q], acc0[:q]
res.append(sum(acc0))
print('\n'.join(map(str, res)))
if __name__ == '__main__':
main()
```
No
| 9,422 | [
0.1085205078125,
-0.013946533203125,
-0.335205078125,
-0.2073974609375,
-0.62451171875,
-0.23046875,
-0.3291015625,
0.1859130859375,
0.1983642578125,
0.93310546875,
0.767578125,
0.2060546875,
-0.11895751953125,
-1.201171875,
-0.64453125,
0.243408203125,
-0.2373046875,
-0.7827148437... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
import sys
def f(x,y):
if not x: return y
elif not y: return x
else: return min(x,y)
n = int(input())
mask = 1
res = [0] * n
while mask <= n:
a = list(map(str, filter(lambda x: (x & mask) == 0, range(1, n+1))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
a = list(map(str, filter(lambda x: x & mask, range(1, n+1))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
mask <<= 1
print(-1)
print(" ".join(map(str, res)))
sys.stdout.flush()
```
No
| 9,558 | [
0.24755859375,
0.244140625,
-0.03466796875,
0.210205078125,
-0.6640625,
-0.560546875,
-0.04241943359375,
-0.041839599609375,
-0.045501708984375,
0.61572265625,
0.64013671875,
0.0513916015625,
-0.229248046875,
-0.61767578125,
-0.482177734375,
-0.46826171875,
-0.454833984375,
-0.8037... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
import sys
def f(x,y):
if not x: return y
elif not y: return x
else: return min(x,y)
count = 0
n = int(input())
mask = 1
res = [0] * n
while mask <= n:
a = list(map(lambda x: str(x+1), filter(lambda x: (x & mask) == 0, range(n))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
count += 1
if count == 20: break
a = list(map(lambda x: str(x+1), filter(lambda x: x & mask, range(n))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
count += 1
if count == 20: break
mask <<= 1
print(-1)
print(" ".join(map(str, res)))
sys.stdout.flush()
```
No
| 9,559 | [
0.24755859375,
0.244140625,
-0.03466796875,
0.210205078125,
-0.6640625,
-0.560546875,
-0.04241943359375,
-0.041839599609375,
-0.045501708984375,
0.61572265625,
0.64013671875,
0.0513916015625,
-0.229248046875,
-0.61767578125,
-0.482177734375,
-0.46826171875,
-0.454833984375,
-0.8037... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
import sys
def f(x,y):
if not x: return y
elif not y: return x
else: return min(x,y)
count = 0
n = int(input())
mask = 1
res = [1000000000] * n
while mask <= n:
a = list(map(lambda x: str(x+1), filter(lambda x: (x & mask) == 0, range(n))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
for i in range(n):
if i+1 in a:
current[i] = 1000000000
res = list(map(min, res, current))
count += 1
if count == 20: break
a = list(map(lambda x: str(x+1), filter(lambda x: x & mask, range(n))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
for i in range(n):
if i+1 in a:
current[i] = 1000000000
res = list(map(min, res, current))
count += 1
if count == 20: break
mask <<= 1
print(-1)
print(" ".join(map(str, res)))
sys.stdout.flush()
```
No
| 9,560 | [
0.24755859375,
0.244140625,
-0.03466796875,
0.210205078125,
-0.6640625,
-0.560546875,
-0.04241943359375,
-0.041839599609375,
-0.045501708984375,
0.61572265625,
0.64013671875,
0.0513916015625,
-0.229248046875,
-0.61767578125,
-0.482177734375,
-0.46826171875,
-0.454833984375,
-0.8037... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
import sys
def f(x,y):
if not x: return y
elif not y: return x
else: return min(x,y)
count = 0
n = int(input())
mask = 1
res = [0] * n
while mask <= n:
a = list(map(str, filter(lambda x: (x & mask) == 0, range(1, n+1))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
count += 1
if count == 20: break
a = list(map(str, filter(lambda x: x & mask, range(1, n+1))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
count += 1
if count == 20: break
mask <<= 1
print(-1)
print(" ".join(map(str, res)))
sys.stdout.flush()
```
No
| 9,561 | [
0.24755859375,
0.244140625,
-0.03466796875,
0.210205078125,
-0.6640625,
-0.560546875,
-0.04241943359375,
-0.041839599609375,
-0.045501708984375,
0.61572265625,
0.64013671875,
0.0513916015625,
-0.229248046875,
-0.61767578125,
-0.482177734375,
-0.46826171875,
-0.454833984375,
-0.8037... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
"Correct Solution:
```
x=int(input())
y=int(input())
print(y+(y-x))
```
| 9,721 | [
0.452880859375,
0.129150390625,
-0.48291015625,
0.0887451171875,
-0.359375,
-0.380615234375,
-0.11968994140625,
-0.050079345703125,
-0.1070556640625,
0.81396484375,
0.6748046875,
-0.2357177734375,
0.07281494140625,
-1.01171875,
-0.2208251953125,
0.031646728515625,
-0.78955078125,
-... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
"Correct Solution:
```
r = int(input());g = int(input()); print(2 * g - r)
```
| 9,722 | [
0.4228515625,
0.07220458984375,
-0.51318359375,
0.07763671875,
-0.36474609375,
-0.40234375,
-0.0736083984375,
-0.0435791015625,
-0.14453125,
0.76220703125,
0.66748046875,
-0.24072265625,
0.04632568359375,
-1.0078125,
-0.23974609375,
0.0498046875,
-0.765625,
-0.791015625,
-0.35937... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
"Correct Solution:
```
l = int(input())
l2 = int(input())
print(l+(l2-l)*2)
```
| 9,723 | [
0.44970703125,
0.1109619140625,
-0.48291015625,
0.07904052734375,
-0.362548828125,
-0.37890625,
-0.08880615234375,
-0.05426025390625,
-0.12353515625,
0.783203125,
0.6328125,
-0.232666015625,
0.06201171875,
-1.01953125,
-0.26513671875,
0.056549072265625,
-0.77587890625,
-0.799804687... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
"Correct Solution:
```
r=int(input())
g=int(input())
x = int((g*2)-r)
print(x)
```
| 9,724 | [
0.451416015625,
0.08447265625,
-0.489013671875,
0.09027099609375,
-0.3330078125,
-0.39404296875,
-0.07818603515625,
-0.03997802734375,
-0.1451416015625,
0.76513671875,
0.67529296875,
-0.2325439453125,
0.030029296875,
-1.013671875,
-0.2252197265625,
0.060455322265625,
-0.76220703125,
... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
"Correct Solution:
```
r=int(input())
s=int(input())
print(2*s-r)
```
| 9,725 | [
0.43212890625,
0.10443115234375,
-0.513671875,
0.0802001953125,
-0.359375,
-0.385986328125,
-0.092041015625,
-0.058258056640625,
-0.143798828125,
0.78271484375,
0.6572265625,
-0.255615234375,
0.051788330078125,
-1.01171875,
-0.2493896484375,
0.039794921875,
-0.77490234375,
-0.80322... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
"Correct Solution:
```
a = int(input())
g = int(input())
print(g-a+g)
```
| 9,726 | [
0.435302734375,
0.10345458984375,
-0.50537109375,
0.08465576171875,
-0.355224609375,
-0.390380859375,
-0.08880615234375,
-0.04931640625,
-0.13427734375,
0.7646484375,
0.66845703125,
-0.244384765625,
0.06500244140625,
-1.0224609375,
-0.234375,
0.04022216796875,
-0.76513671875,
-0.79... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
"Correct Solution:
```
R=int(input())
G=int(input())
print((G-R)+G)
```
| 9,727 | [
0.4267578125,
0.09307861328125,
-0.51220703125,
0.0841064453125,
-0.34228515625,
-0.399658203125,
-0.074462890625,
-0.048187255859375,
-0.1405029296875,
0.76611328125,
0.66552734375,
-0.2449951171875,
0.042022705078125,
-1.00390625,
-0.2301025390625,
0.03369140625,
-0.77099609375,
... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
"Correct Solution:
```
a = int(input())
g = 2 * int(input())
print(g - a)
```
| 9,728 | [
0.43505859375,
0.1007080078125,
-0.494140625,
0.0872802734375,
-0.373779296875,
-0.388427734375,
-0.089599609375,
-0.0531005859375,
-0.1370849609375,
0.77490234375,
0.6630859375,
-0.2479248046875,
0.057861328125,
-1.01171875,
-0.2354736328125,
0.050994873046875,
-0.77294921875,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
Submitted Solution:
```
x=int(input())
y=int(input())
print(y+y-x)
```
Yes
| 9,729 | [
0.52783203125,
0.0634765625,
-0.3828125,
0.10498046875,
-0.35546875,
-0.285888671875,
-0.08233642578125,
-0.0440673828125,
-0.1409912109375,
0.90380859375,
0.485107421875,
-0.16650390625,
0.055450439453125,
-0.857421875,
-0.25830078125,
-0.035430908203125,
-0.62255859375,
-0.708007... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
Submitted Solution:
```
x = int(input())
y = int(input())
print(y - x + y)
```
Yes
| 9,730 | [
0.5283203125,
0.06036376953125,
-0.3828125,
0.1021728515625,
-0.350830078125,
-0.286865234375,
-0.08392333984375,
-0.044281005859375,
-0.1451416015625,
0.90380859375,
0.486328125,
-0.165283203125,
0.055999755859375,
-0.8564453125,
-0.260009765625,
-0.03277587890625,
-0.62158203125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
Submitted Solution:
```
n=int(input())
m=int(input())
l=m*2-n
print(l)
```
Yes
| 9,731 | [
0.51806640625,
0.053070068359375,
-0.395263671875,
0.10595703125,
-0.34912109375,
-0.284912109375,
-0.0731201171875,
-0.05316162109375,
-0.1473388671875,
0.921875,
0.48388671875,
-0.1622314453125,
0.060272216796875,
-0.85498046875,
-0.261962890625,
-0.005428314208984375,
-0.608398437... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
Submitted Solution:
```
R=int(input())
G=int(input())
a=2*G-R
print(a)
```
Yes
| 9,732 | [
0.51416015625,
0.038909912109375,
-0.394287109375,
0.139892578125,
-0.348876953125,
-0.296875,
-0.0589599609375,
-0.03253173828125,
-0.1376953125,
0.869140625,
0.49072265625,
-0.1702880859375,
0.0494384765625,
-0.85791015625,
-0.24365234375,
-0.0088043212890625,
-0.5927734375,
-0.7... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
Submitted Solution:
```
R,G = map(int,input().split())
print((2*G)-R)
```
No
| 9,733 | [
0.50634765625,
0.0732421875,
-0.44189453125,
0.11273193359375,
-0.352783203125,
-0.3349609375,
-0.0718994140625,
-0.007171630859375,
-0.154052734375,
0.8984375,
0.498291015625,
-0.154541015625,
0.1082763671875,
-0.8955078125,
-0.2144775390625,
-0.0177001953125,
-0.59521484375,
-0.7... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
Submitted Solution:
```
r=int(input())
g=int(input())
print(g*2βr)
```
No
| 9,734 | [
0.51220703125,
0.044158935546875,
-0.401123046875,
0.1270751953125,
-0.3447265625,
-0.32275390625,
-0.054656982421875,
-0.03326416015625,
-0.14697265625,
0.85791015625,
0.5302734375,
-0.18212890625,
0.03765869140625,
-0.87158203125,
-0.245849609375,
-0.0139617919921875,
-0.619140625,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
Submitted Solution:
```
g,r=map(int,input().split())
print(2*g-r)
```
No
| 9,735 | [
0.498779296875,
0.07415771484375,
-0.431884765625,
0.09307861328125,
-0.349609375,
-0.333251953125,
-0.06976318359375,
-0.0225677490234375,
-0.1668701171875,
0.90087890625,
0.487548828125,
-0.150146484375,
0.1060791015625,
-0.87890625,
-0.2130126953125,
-0.02484130859375,
-0.60009765... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is a user of a site that hosts programming contests.
When a user competes in a contest, the rating of the user (not necessarily an integer) changes according to the performance of the user, as follows:
* Let the current rating of the user be a.
* Suppose that the performance of the user in the contest is b.
* Then, the new rating of the user will be the avarage of a and b.
For example, if a user with rating 1 competes in a contest and gives performance 1000, his/her new rating will be 500.5, the average of 1 and 1000.
Takahashi's current rating is R, and he wants his rating to be exactly G after the next contest.
Find the performance required to achieve it.
Constraints
* 0 \leq R, G \leq 4500
* All input values are integers.
Input
Input is given from Standard Input in the following format:
R
G
Output
Print the performance required to achieve the objective.
Examples
Input
2002
2017
Output
2032
Input
4500
0
Output
-4500
Submitted Solution:
```
s = list(input())
t = list(input())
def eq(s, t):
for i in range(len(s)):
if s[i] != t[i] and s[i] != '?':
return False
return True
for i in reversed(range(len(s) - len(t)+1)):
if eq(s[i:i+len(t)], t[:]):
s[i:i + len(t)] = t[:]
ans = ''.join(s)
print(ans.replace('?', 'b'))
quit()
print('UNRESTORABLE')
```
No
| 9,736 | [
0.4189453125,
0.01654052734375,
-0.352783203125,
0.10540771484375,
-0.364013671875,
-0.259765625,
-0.10296630859375,
-0.00215911865234375,
-0.11700439453125,
0.90869140625,
0.53466796875,
-0.1685791015625,
0.139892578125,
-0.9306640625,
-0.27490234375,
-0.08746337890625,
-0.737304687... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Example
Input
3 5 4
3
6
12
Output
Hanako
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def check(N, A, B, S):
K = min(A, B)
g = 0
for s in S:
g ^= s % (K+1)
if A == B:
return g != 0
if A > B:
if g != 0:
return 1
for s in S:
if s > B:
return 1
return 0
cnt = 0; m = 1
r = 0
for s in S:
if s > A:
cnt += 1
r = s
g0 = g ^ (s % (K+1))
if cnt > 1:
return 0
if cnt == 0:
return g != 0
return g0 <= A and 1 <= r - g0 <= A
def solve():
N, A, B = map(int, readline().split())
S = [int(readline()) for i in range(N)]
if check(N, A, B, S):
write("Hanako\n")
else:
write("Jiro\n")
solve()
```
| 9,867 | [
0.23095703125,
0.09368896484375,
0.0229949951171875,
0.1031494140625,
-0.327880859375,
-0.689453125,
-0.201171875,
0.20263671875,
0.137939453125,
0.908203125,
0.427001953125,
-0.1043701171875,
-0.07208251953125,
-0.896484375,
-0.81591796875,
-0.1514892578125,
-0.392333984375,
-0.77... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
C: Short-circuit evaluation
problem
Naodai-kun and Hokkaido University-kun are playing games. Hokkaido University first generates the following logical formula represented by BNF.
<formula> :: = <or-expr>
<or-expr> :: = <and-expr>
| <or-expr> "|" <and-expr>
<and-expr> :: = <term>
| <and-expr> "&" <term>
<term> :: = "(" <or-expr> ")" | "?"
`&` represents the logical product, `|` represents the logical sum, and `&` is evaluated before `|`.
Naodai reads this formula from the left (as a string), and when he finds a `?`, He does the following:
* If it is certain that the evaluation result of the formula does not change regardless of whether the `?` Is `0` or` 1`, read it without doing anything.
* If not, pay 1 yen to Hokkaido University and replace the `?` With `0` or` 1`.
The logical expression is evaluated as follows. It is a so-called ordinary formula.
(0 &?) == 0
(1 & 0) == 0
(1 & 1) == 1
(0 | 0) == 0
(0 | 1) == 1
(1 |?) == 1
What is the minimum amount Naodai has to pay to finalize the evaluation result of a well-formed formula? Obtain the evaluation result depending on whether it is set to `0` or` 1`.
Input format
A formula that follows the BNF above is given in one line.
Constraint
The length of the formula does not exceed 2 \ times 10 ^ 5.
Output format
Output the minimum amount required to make the evaluation result `0`,` 1`, separated by blanks.
Input example 1
? &? |? &? |? &?
Output example 1
3 2
If you want to make it `0`, rewrite it with` 0 0 0` to make it `0 &? | 0 &? | 0 &?`, If you want to make it `1`, rewrite it with` 1 1` and make it `1 & 1 |? &? |? & It is best to use? `.
Input example 2
? &? &? |? &? &?
Output example 2
twenty three
They are `0 &? &? | 0 &? &?` And `1 & 1 & 1 |? &? &?`, Respectively.
Input example 3
(? |? |?) &? &? &? &? |? &? |? &?
Output example 3
4 4
Example
Input
?&?|?&?|?&?
Output
3 2
"Correct Solution:
```
import sys
sys.setrecursionlimit(2*10**5)
question = 1
AND = -1
OR = -2
left = -3
right = -4
tr = {'?': 1, '&': -1, '|': -2, '(': -3, ')': -4}
def evalor(L):
if len(L) == 1:
return L[0]
x0, x1 = L[0]
for i in range(1, len(L)):
y0, y1 = L[i]
x0, x1 = x0 + y0, min(x1, x0 + y1)
return (x0, x1)
def push(f, s):
if f and f[-1] == (AND, AND):
f.pop()
p = f.pop()
return push(f, andeval(p, s))
else:
f.append(s)
return f
def andeval(p, s):
x0, x1 = p
y0, y1 = s
return (min(x0, x1 + y0), x1 + y1)
S = [tr[s] for s in input().strip()]
f = []
for s in S:
if s == question:
f = push(f, (s, s))
elif s == AND or s == left:
f.append((s, s))
elif s == right:
stack = []
while f[-1] != (left, left):
sp = f.pop()
assert sp[0] > 0 and sp[1] > 0
stack.append(sp)
assert f.pop() == (left, left)
push(f, evalor(stack[::-1]))
f = evalor(f)
print(*f)
```
| 9,884 | [
0.0188140869140625,
0.0382080078125,
0.10638427734375,
-0.1614990234375,
-0.26953125,
-0.48388671875,
0.15478515625,
-0.08575439453125,
-0.35107421875,
0.491943359375,
0.9541015625,
0.257568359375,
0.21728515625,
-0.9091796875,
-0.84521484375,
0.2467041015625,
-0.57958984375,
-1.06... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
C: Short-circuit evaluation
problem
Naodai-kun and Hokkaido University-kun are playing games. Hokkaido University first generates the following logical formula represented by BNF.
<formula> :: = <or-expr>
<or-expr> :: = <and-expr>
| <or-expr> "|" <and-expr>
<and-expr> :: = <term>
| <and-expr> "&" <term>
<term> :: = "(" <or-expr> ")" | "?"
`&` represents the logical product, `|` represents the logical sum, and `&` is evaluated before `|`.
Naodai reads this formula from the left (as a string), and when he finds a `?`, He does the following:
* If it is certain that the evaluation result of the formula does not change regardless of whether the `?` Is `0` or` 1`, read it without doing anything.
* If not, pay 1 yen to Hokkaido University and replace the `?` With `0` or` 1`.
The logical expression is evaluated as follows. It is a so-called ordinary formula.
(0 &?) == 0
(1 & 0) == 0
(1 & 1) == 1
(0 | 0) == 0
(0 | 1) == 1
(1 |?) == 1
What is the minimum amount Naodai has to pay to finalize the evaluation result of a well-formed formula? Obtain the evaluation result depending on whether it is set to `0` or` 1`.
Input format
A formula that follows the BNF above is given in one line.
Constraint
The length of the formula does not exceed 2 \ times 10 ^ 5.
Output format
Output the minimum amount required to make the evaluation result `0`,` 1`, separated by blanks.
Input example 1
? &? |? &? |? &?
Output example 1
3 2
If you want to make it `0`, rewrite it with` 0 0 0` to make it `0 &? | 0 &? | 0 &?`, If you want to make it `1`, rewrite it with` 1 1` and make it `1 & 1 |? &? |? & It is best to use? `.
Input example 2
? &? &? |? &? &?
Output example 2
twenty three
They are `0 &? &? | 0 &? &?` And `1 & 1 & 1 |? &? &?`, Respectively.
Input example 3
(? |? |?) &? &? &? &? |? &? |? &?
Output example 3
4 4
Example
Input
?&?|?&?|?&?
Output
3 2
"Correct Solution:
```
# from inspect import currentframe
# from sys import exit, stderr
# debug function
# def debug(*args):
# names = {id(v):k for k,v in currentframe().f_back.f_locals.items()}
# print(', '.join(names.get(id(arg),'???') + str(id(arg)) +' = '+repr(arg) for arg in args), file=stderr)
src = list(str(input()))
tokens = [tok for tok in src if tok != " "]
# debug(tokens)
# "" as EOF
tokens.append("")
cur = 0
def parse_formula():
return parse_or()
def parse_or():
global cur
lhs = parse_and()
if tokens[cur] == "|":
cur += 1
rhs = parse_or()
zero = lhs[0] + rhs[0]
one = min(lhs[1], lhs[0] + rhs[1])
return (zero, one)
return lhs
def parse_and():
global cur
lhs = parse_term()
if tokens[cur] == "&":
cur += 1
rhs = parse_and()
zero = min(lhs[0], lhs[1] + rhs[0])
one = lhs[1] + rhs[1]
return (zero, one)
return lhs
def parse_term():
global cur
if tokens[cur] == "?":
cur += 1
# debug(cur, 1)
return [1, 1]
elif tokens[cur] == "(":
cur += 1
# debug(cur, "or")
res = parse_or()
if tokens[cur] != ")":
raise Exception("not closed")
cur += 1
# debug(cur)
return res
ans = parse_formula()
print(ans[0], ans[1])
# debug(cur)
# print(len(tokens))
```
| 9,885 | [
0.0188140869140625,
0.0382080078125,
0.10638427734375,
-0.1614990234375,
-0.26953125,
-0.48388671875,
0.15478515625,
-0.08575439453125,
-0.35107421875,
0.491943359375,
0.9541015625,
0.257568359375,
0.21728515625,
-0.9091796875,
-0.84521484375,
0.2467041015625,
-0.57958984375,
-1.06... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Contest T-shirts
Segtree has $ M $ contest T-shirts.
He decided to spend $ N $ days on the contest T-shirt alone, and told $ i = 1, 2, 3, \ dots, N $ "$ A_i $ T-shirt on the $ i $ day." I made a plan for $ N $ to wear.
However, if you keep the current plan, you may not be able to do the laundry in time, so I would like to change the plan if necessary so that I will not wear the same clothes for two consecutive days.
Find the minimum number of plans that need to be changed. It can be proved that the conditions can always be met by changing the plan under the given constraints.
input
Input is given from standard input in the following format.
$ M $ $ N $
$ A_1 $ $ A_2 $ $ \ ldots $ $ A_N $
output
Output the minimum number of plans that need to be changed.
However, insert a line break at the end.
Constraint
* $ 2 \ leq M \ leq 10 ^ 9 $
* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq A_i \ leq M $
* All inputs are integers.
Input example 1
twenty three
2 2 1
Output example 1
1
Input example 2
3 6
1 1 1 2 2 3
Output example 2
2
Example
Input
2 3
2 2 1
Output
1
"Correct Solution:
```
M, N = map(int,input().split())
A = list(map(int,input().split()))
if M >= 3:
now = A[0]
ans = 0
for k in range(1,N):
if A[k] == now:
now = -1
ans += 1
else:
now = A[k]
print(ans)
else:
now = A[0]
ans1 = 0
for k in range(1,N):
if A[k] == now:
now = 3-now
ans1 += 1
else:
now = A[k]
ans2 = 1
now = 3-A[0]
for k in range(1,N):
if A[k] == now:
now = 3-now
ans2 += 1
else:
now = A[k]
print(min(ans1,ans2))
```
| 9,886 | [
0.43603515625,
0.1800537109375,
-0.14306640625,
-0.08123779296875,
-0.61328125,
-0.48974609375,
-0.4296875,
0.1846923828125,
0.009613037109375,
0.9775390625,
0.3251953125,
-0.27294921875,
0.35107421875,
-0.7841796875,
-0.243408203125,
-0.1141357421875,
-0.79443359375,
-0.6220703125... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Contest T-shirts
Segtree has $ M $ contest T-shirts.
He decided to spend $ N $ days on the contest T-shirt alone, and told $ i = 1, 2, 3, \ dots, N $ "$ A_i $ T-shirt on the $ i $ day." I made a plan for $ N $ to wear.
However, if you keep the current plan, you may not be able to do the laundry in time, so I would like to change the plan if necessary so that I will not wear the same clothes for two consecutive days.
Find the minimum number of plans that need to be changed. It can be proved that the conditions can always be met by changing the plan under the given constraints.
input
Input is given from standard input in the following format.
$ M $ $ N $
$ A_1 $ $ A_2 $ $ \ ldots $ $ A_N $
output
Output the minimum number of plans that need to be changed.
However, insert a line break at the end.
Constraint
* $ 2 \ leq M \ leq 10 ^ 9 $
* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq A_i \ leq M $
* All inputs are integers.
Input example 1
twenty three
2 2 1
Output example 1
1
Input example 2
3 6
1 1 1 2 2 3
Output example 2
2
Example
Input
2 3
2 2 1
Output
1
"Correct Solution:
```
import sys
input = sys.stdin.readline
M,N=map(int,input().split())
A=list(map(int,input().split()))
if M==2:
ANS0=0
ANS1=0
for i in range(N):
if A[i]%2==i%2:
ANS0+=1
else:
ANS1+=1
print(min(ANS0,ANS1))
else:
A.append(10**10)
count=0
ANS=0
for i in range(N+1):
if A[i]==A[i-1]:
count+=1
else:
ANS+=count//2
count=1
print(ANS)
```
| 9,887 | [
0.434326171875,
0.1435546875,
-0.11566162109375,
-0.072509765625,
-0.66064453125,
-0.43603515625,
-0.464599609375,
0.1580810546875,
0.011688232421875,
0.94189453125,
0.242431640625,
-0.27734375,
0.32861328125,
-0.78564453125,
-0.341796875,
-0.143798828125,
-0.74609375,
-0.646484375... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Contest T-shirts
Segtree has $ M $ contest T-shirts.
He decided to spend $ N $ days on the contest T-shirt alone, and told $ i = 1, 2, 3, \ dots, N $ "$ A_i $ T-shirt on the $ i $ day." I made a plan for $ N $ to wear.
However, if you keep the current plan, you may not be able to do the laundry in time, so I would like to change the plan if necessary so that I will not wear the same clothes for two consecutive days.
Find the minimum number of plans that need to be changed. It can be proved that the conditions can always be met by changing the plan under the given constraints.
input
Input is given from standard input in the following format.
$ M $ $ N $
$ A_1 $ $ A_2 $ $ \ ldots $ $ A_N $
output
Output the minimum number of plans that need to be changed.
However, insert a line break at the end.
Constraint
* $ 2 \ leq M \ leq 10 ^ 9 $
* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq A_i \ leq M $
* All inputs are integers.
Input example 1
twenty three
2 2 1
Output example 1
1
Input example 2
3 6
1 1 1 2 2 3
Output example 2
2
Example
Input
2 3
2 2 1
Output
1
"Correct Solution:
```
M, N = map(int, input().split())
A = [int(i) for i in input().split()]
if M == 2 :
a, b = 0, 0
for i in range(N) :
if (i % 2) == (A[i] % 2) :
a += 1
else :
b += 1
print(min(a, b))
else :
ret = 0
for i in range(1, N) :
if A[i] == A[i - 1] :
ret += 1
A[i] = 0
print(ret)
```
| 9,888 | [
0.426025390625,
0.1412353515625,
-0.1131591796875,
-0.10760498046875,
-0.6298828125,
-0.4130859375,
-0.4423828125,
0.1787109375,
-0.0016260147094726562,
0.96728515625,
0.27490234375,
-0.259765625,
0.3232421875,
-0.8017578125,
-0.284912109375,
-0.140625,
-0.80615234375,
-0.650878906... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Contest T-shirts
Segtree has $ M $ contest T-shirts.
He decided to spend $ N $ days on the contest T-shirt alone, and told $ i = 1, 2, 3, \ dots, N $ "$ A_i $ T-shirt on the $ i $ day." I made a plan for $ N $ to wear.
However, if you keep the current plan, you may not be able to do the laundry in time, so I would like to change the plan if necessary so that I will not wear the same clothes for two consecutive days.
Find the minimum number of plans that need to be changed. It can be proved that the conditions can always be met by changing the plan under the given constraints.
input
Input is given from standard input in the following format.
$ M $ $ N $
$ A_1 $ $ A_2 $ $ \ ldots $ $ A_N $
output
Output the minimum number of plans that need to be changed.
However, insert a line break at the end.
Constraint
* $ 2 \ leq M \ leq 10 ^ 9 $
* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq A_i \ leq M $
* All inputs are integers.
Input example 1
twenty three
2 2 1
Output example 1
1
Input example 2
3 6
1 1 1 2 2 3
Output example 2
2
Example
Input
2 3
2 2 1
Output
1
"Correct Solution:
```
m,n = map(int,input().split())
a = list(map(int,input().split()))
if m == 2:
ans = n
for i in range(2):
t = 0
for j in range(n):
idx = (i+j)%2 + 1
if idx != a[j]:
t += 1
ans = min(ans, t)
else:
ans = 0
prev = a[0]
for i in range(1,n):
if prev == a[i]:
ans += 1
a[i] = -1
prev = a[i]
print(ans)
```
| 9,889 | [
0.443603515625,
0.1494140625,
-0.11102294921875,
-0.0848388671875,
-0.61865234375,
-0.43212890625,
-0.449951171875,
0.2061767578125,
0.005245208740234375,
0.96875,
0.295166015625,
-0.27880859375,
0.31884765625,
-0.7802734375,
-0.2900390625,
-0.10174560546875,
-0.7744140625,
-0.6313... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Contest T-shirts
Segtree has $ M $ contest T-shirts.
He decided to spend $ N $ days on the contest T-shirt alone, and told $ i = 1, 2, 3, \ dots, N $ "$ A_i $ T-shirt on the $ i $ day." I made a plan for $ N $ to wear.
However, if you keep the current plan, you may not be able to do the laundry in time, so I would like to change the plan if necessary so that I will not wear the same clothes for two consecutive days.
Find the minimum number of plans that need to be changed. It can be proved that the conditions can always be met by changing the plan under the given constraints.
input
Input is given from standard input in the following format.
$ M $ $ N $
$ A_1 $ $ A_2 $ $ \ ldots $ $ A_N $
output
Output the minimum number of plans that need to be changed.
However, insert a line break at the end.
Constraint
* $ 2 \ leq M \ leq 10 ^ 9 $
* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq A_i \ leq M $
* All inputs are integers.
Input example 1
twenty three
2 2 1
Output example 1
1
Input example 2
3 6
1 1 1 2 2 3
Output example 2
2
Example
Input
2 3
2 2 1
Output
1
"Correct Solution:
```
m,n=map(int,input().split())
a=list(map(int,input().split()))
if m==2:
x=y=0
for i in range(n):
b=i%2+1
c=(i+1)%2+1
if a[i]!=b:x+=1
if a[i]!=c:y+=1
print(min(x,y))
exit()
x=0
for i in range(1,n):
if a[i-1]==a[i]:a[i]=-1;x+=1
print(x)
```
| 9,890 | [
0.45703125,
0.15380859375,
-0.09820556640625,
-0.0982666015625,
-0.6171875,
-0.415283203125,
-0.47900390625,
0.21826171875,
0.00449371337890625,
0.97607421875,
0.2568359375,
-0.23876953125,
0.342041015625,
-0.78369140625,
-0.264892578125,
-0.13134765625,
-0.76904296875,
-0.65234375... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Contest T-shirts
Segtree has $ M $ contest T-shirts.
He decided to spend $ N $ days on the contest T-shirt alone, and told $ i = 1, 2, 3, \ dots, N $ "$ A_i $ T-shirt on the $ i $ day." I made a plan for $ N $ to wear.
However, if you keep the current plan, you may not be able to do the laundry in time, so I would like to change the plan if necessary so that I will not wear the same clothes for two consecutive days.
Find the minimum number of plans that need to be changed. It can be proved that the conditions can always be met by changing the plan under the given constraints.
input
Input is given from standard input in the following format.
$ M $ $ N $
$ A_1 $ $ A_2 $ $ \ ldots $ $ A_N $
output
Output the minimum number of plans that need to be changed.
However, insert a line break at the end.
Constraint
* $ 2 \ leq M \ leq 10 ^ 9 $
* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq A_i \ leq M $
* All inputs are integers.
Input example 1
twenty three
2 2 1
Output example 1
1
Input example 2
3 6
1 1 1 2 2 3
Output example 2
2
Example
Input
2 3
2 2 1
Output
1
"Correct Solution:
```
m,n=map(int,input().split())
a=list(map(int,input().split()))
if m == 2:
ans1=0
for i in range(n):
if i % 2 != a[i] % 2:
ans1+=1
ans2=0
for i in range(n):
if i % 2 == a[i] % 2:
ans2+=1
print(min(ans1,ans2))
else:
ans=0
for i in range(n-1):
if a[i] == a[i+1]:
a[i+1]=-1
ans+=1
print(ans)
```
| 9,891 | [
0.42626953125,
0.1370849609375,
-0.107177734375,
-0.09564208984375,
-0.6318359375,
-0.4375,
-0.450927734375,
0.182861328125,
0.00414276123046875,
0.9970703125,
0.296142578125,
-0.2578125,
0.32275390625,
-0.7998046875,
-0.29931640625,
-0.1243896484375,
-0.791015625,
-0.634765625,
... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Contest T-shirts
Segtree has $ M $ contest T-shirts.
He decided to spend $ N $ days on the contest T-shirt alone, and told $ i = 1, 2, 3, \ dots, N $ "$ A_i $ T-shirt on the $ i $ day." I made a plan for $ N $ to wear.
However, if you keep the current plan, you may not be able to do the laundry in time, so I would like to change the plan if necessary so that I will not wear the same clothes for two consecutive days.
Find the minimum number of plans that need to be changed. It can be proved that the conditions can always be met by changing the plan under the given constraints.
input
Input is given from standard input in the following format.
$ M $ $ N $
$ A_1 $ $ A_2 $ $ \ ldots $ $ A_N $
output
Output the minimum number of plans that need to be changed.
However, insert a line break at the end.
Constraint
* $ 2 \ leq M \ leq 10 ^ 9 $
* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq A_i \ leq M $
* All inputs are integers.
Input example 1
twenty three
2 2 1
Output example 1
1
Input example 2
3 6
1 1 1 2 2 3
Output example 2
2
Example
Input
2 3
2 2 1
Output
1
"Correct Solution:
```
from itertools import *
from bisect import *
from math import *
from collections import *
from heapq import *
from random import *
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def MF(): return map(float, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LF(): return list(map(float, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
dij = [(1, 0), (0, 1), (-1, 0), (0, -1)]
def main():
m,n=MI()
aa=LI()
ans=0
if m==2:
for i,a in enumerate(aa):
if i%2+1==a:ans+=1
ans=min(ans,n-ans)
else:
cnt=1
for a0,a1 in zip(aa,aa[1:]):
if a0==a1:cnt+=1
else:
ans+=cnt//2
cnt=1
ans+=cnt//2
print(ans)
main()
```
| 9,892 | [
0.375732421875,
0.2047119140625,
-0.1279296875,
-0.01678466796875,
-0.69921875,
-0.374267578125,
-0.48583984375,
0.043304443359375,
-0.01239013671875,
0.93359375,
0.1541748046875,
-0.28857421875,
0.324951171875,
-0.77490234375,
-0.3037109375,
-0.1629638671875,
-0.76171875,
-0.72998... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya got really tired of these credits (from problem F) and now wants to earn the money himself! He decided to make a contest to gain a profit.
Vasya has n problems to choose from. They are numbered from 1 to n. The difficulty of the i-th problem is d_i. Moreover, the problems are given in the increasing order by their difficulties. The difficulties of all tasks are pairwise distinct. In order to add the i-th problem to the contest you need to pay c_i burles to its author. For each problem in the contest Vasya gets a burles.
In order to create a contest he needs to choose a consecutive subsegment of tasks.
So the total earnings for the contest are calculated as follows:
* if Vasya takes problem i to the contest, he needs to pay c_i to its author;
* for each problem in the contest Vasya gets a burles;
* let gap(l, r) = max_{l β€ i < r} (d_{i + 1} - d_i)^2. If Vasya takes all the tasks with indices from l to r to the contest, he also needs to pay gap(l, r). If l = r then gap(l, r) = 0.
Calculate the maximum profit that Vasya can earn by taking a consecutive segment of tasks.
Input
The first line contains two integers n and a (1 β€ n β€ 3 β
10^5, 1 β€ a β€ 10^9) β the number of proposed tasks and the profit for a single problem, respectively.
Each of the next n lines contains two integers d_i and c_i (1 β€ d_i, c_i β€ 10^9, d_i < d_{i+1}).
Output
Print one integer β maximum amount of burles Vasya can earn.
Examples
Input
5 10
1 15
5 3
6 11
7 2
11 22
Output
13
Input
3 5
1 8
2 19
3 11
Output
0
Tags: binary search, constructive algorithms, data structures, dp, dsu
Correct Solution:
```
import sys
it = iter(sys.stdin.readlines())
input = it.__next__
n, k = map(int, input().split())
d, c = [0] * n, [0] * n
for i in range(n):
a, b = map(int, input().split())
d[i], c[i] = a, k - b
p, r, pre, suf, sm, mx = list(range(n)), [0] * n, c[:], c[:], c[:], c[:]
def find(x):
if x != p[x]:
p[x] = find(p[x])
return p[x]
def union(x, y, w):
x, y = find(x), find(y)
z = y if r[y] > r[x] else x
r[x] += r[x] == r[y]
mx[z] = max(mx[x], mx[y], suf[x] + pre[y])
pre[z] = max(pre[x], sm[x] + pre[y])
suf[z] = max(suf[x] + sm[y], suf[y])
sm[z] = sm[x] + sm[y]
p[x] = p[y] = z
return mx[z] - w ** 2
ans = max(0, max(c))
for w, i in sorted((d[i + 1] - d[i], i) for i in range(n - 1)):
ans = max(ans, union(i, i + 1, w))
print(ans)
```
| 9,954 | [
0.435302734375,
0.2071533203125,
-0.474853515625,
0.259521484375,
-0.41796875,
-0.2293701171875,
-0.2568359375,
-0.046966552734375,
-0.031707763671875,
0.7587890625,
0.361083984375,
0.0029926300048828125,
0.154296875,
-0.89794921875,
-0.300537109375,
-0.2626953125,
-0.73876953125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya got really tired of these credits (from problem F) and now wants to earn the money himself! He decided to make a contest to gain a profit.
Vasya has n problems to choose from. They are numbered from 1 to n. The difficulty of the i-th problem is d_i. Moreover, the problems are given in the increasing order by their difficulties. The difficulties of all tasks are pairwise distinct. In order to add the i-th problem to the contest you need to pay c_i burles to its author. For each problem in the contest Vasya gets a burles.
In order to create a contest he needs to choose a consecutive subsegment of tasks.
So the total earnings for the contest are calculated as follows:
* if Vasya takes problem i to the contest, he needs to pay c_i to its author;
* for each problem in the contest Vasya gets a burles;
* let gap(l, r) = max_{l β€ i < r} (d_{i + 1} - d_i)^2. If Vasya takes all the tasks with indices from l to r to the contest, he also needs to pay gap(l, r). If l = r then gap(l, r) = 0.
Calculate the maximum profit that Vasya can earn by taking a consecutive segment of tasks.
Input
The first line contains two integers n and a (1 β€ n β€ 3 β
10^5, 1 β€ a β€ 10^9) β the number of proposed tasks and the profit for a single problem, respectively.
Each of the next n lines contains two integers d_i and c_i (1 β€ d_i, c_i β€ 10^9, d_i < d_{i+1}).
Output
Print one integer β maximum amount of burles Vasya can earn.
Examples
Input
5 10
1 15
5 3
6 11
7 2
11 22
Output
13
Input
3 5
1 8
2 19
3 11
Output
0
Submitted Solution:
```
n, k = map(int, input().split())
a = [tuple(map(int, input().split())) for i in range(n)]
class Sparse:
def __init__(self, a, f):
n = len(a)
l = n.bit_length()
self.f = f
self.t = [a] + [[None] * n for i in range(l)]
for j in range(1, l + 1):
p2 = 1 << (j - 1)
for i in range(n):
if i + 2 * p2 > n: break
self.t[j][i] = f(self.t[j - 1][i], self.t[j - 1][i + p2])
def query(self, l, r):
d = (r - l + 1).bit_length() - 1
return self.f(self.t[d][l], self.t[d][r + 1 - (1 << d)])
dif = Sparse([(a[i + 1][0] - a[i][0], i) for i in range(n - 1)], max)
p = [0] + [k - c for d, c in a]
for i in range(1, n + 1):
p[i] += p[i - 1]
gmx, gmn = Sparse(p, max), Sparse(p, min)
def recur(l, r):
if l == r:
return k - a[l][1]
v, m = dif.query(l, r - 1)
lt, rt = p[m + 1] - gmn.query(l, m + 1), gmx.query(m + 1, r + 1) - p[m]
return max(lt + rt - v * v, recur(l, m), recur(m + 1, r))
print(max(0, recur(0, n - 1)))
```
No
| 9,955 | [
0.5185546875,
0.2314453125,
-0.48779296875,
0.2005615234375,
-0.51171875,
-0.1640625,
-0.218505859375,
0.00847625732421875,
-0.1263427734375,
0.833984375,
0.301025390625,
0.1204833984375,
0.176513671875,
-0.85546875,
-0.294921875,
-0.2303466796875,
-0.73974609375,
-1.1591796875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of laptops.
Next n lines contain two integers each, ai and bi (1 β€ ai, bi β€ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
Submitted Solution:
```
n=int(input())
L=[0]*(n+1)
for k in range(n):
a,b=map(int,input().split())
L[a]=b
def s(L,n):
for k in range(n):
if(L[k]>L[k+1]):
return "Happy Alex"
return "Poor Alex"
print(s(L,n))
```
Yes
| 10,336 | [
0.264892578125,
0.206787109375,
0.031097412109375,
-0.0372314453125,
-0.373046875,
-0.5244140625,
0.0927734375,
0.08917236328125,
0.044342041015625,
1.0146484375,
0.327880859375,
0.114501953125,
-0.07763671875,
-0.62158203125,
-0.347900390625,
-0.111083984375,
-0.50634765625,
-0.78... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of laptops.
Next n lines contain two integers each, ai and bi (1 β€ ai, bi β€ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
Submitted Solution:
```
n = int(input())
price = []
quality = []
temp = []
for i in range(n):
temp = input().split(" ")
price.append(int(temp[0]))
quality.append(temp[1])
laptop = {}
for i in range(n):
laptop[price[i]] = quality[i]
sortedLaptop = {}
sortedLaptop = sorted(zip(laptop.keys(), laptop.values()))
q = int(0)
result = 0
for k,v in sortedLaptop:
if int(v) >= q:
q = int(v)
else:
result = 1
break
if result is 1:
print("Happy Alex")
else:
print("Poor Alex")
```
Yes
| 10,337 | [
0.2022705078125,
0.16650390625,
0.0740966796875,
-0.004764556884765625,
-0.304443359375,
-0.50439453125,
0.10003662109375,
0.14453125,
0.09967041015625,
1.041015625,
0.260986328125,
0.00008082389831542969,
-0.0157470703125,
-0.640625,
-0.326904296875,
-0.08660888671875,
-0.544921875,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of laptops.
Next n lines contain two integers each, ai and bi (1 β€ ai, bi β€ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
Submitted Solution:
```
"""http://codeforces.com/problemset/problem/456/A"""
def solve(l):
l = sorted(l, key=lambda x: x[0])
quality = 0
for i in l:
if i[1] <= quality:
return True
quality = i[1]
return False
R = lambda: list(map(int, input().split()))
n = int(input())
l = [R() for _ in range(n)]
r = solve(l)
print('Happy Alex' if r else 'Poor Alex')
```
Yes
| 10,338 | [
0.29736328125,
0.252685546875,
0.04248046875,
0.0037097930908203125,
-0.38818359375,
-0.486083984375,
0.0207977294921875,
0.1612548828125,
0.06298828125,
0.86865234375,
0.1805419921875,
0.0244903564453125,
0.002086639404296875,
-0.57861328125,
-0.442138671875,
-0.158447265625,
-0.488... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of laptops.
Next n lines contain two integers each, ai and bi (1 β€ ai, bi β€ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
Submitted Solution:
```
n = int(input())
p, q = [], []
for _ in range(n):
a, b = map(int, input().split())
p.append(a)
q.append(b)
c = sorted(zip(p, q))
d = list(zip(*c))
m = 0
e = list(d[1])
for i in range(n-1):
if e[i] > e[i+1]:
m = 1
break
if m == 1:
print('Happy Alex')
else:
print('Poor Alex')
```
Yes
| 10,339 | [
0.2088623046875,
0.184326171875,
0.016021728515625,
0.0004241466522216797,
-0.3828125,
-0.51513671875,
0.067626953125,
0.11529541015625,
0.1068115234375,
1.0146484375,
0.287353515625,
0.08038330078125,
-0.02996826171875,
-0.61865234375,
-0.3955078125,
-0.12066650390625,
-0.5009765625... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of laptops.
Next n lines contain two integers each, ai and bi (1 β€ ai, bi β€ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
Submitted Solution:
```
# https://codeforces.com/contest/456/problem/A
n = int(input())
price, quality = map(int, input().split())
high_quality_laptop = (price, quality)
low_price_laptop = (price, quality)
for i in range(n - 1):
price, quality = map(int, input().split())
if price > low_price_laptop[0] and quality < low_price_laptop[1]:
print("Happy Alex")
break
else:
low_price_laptop = price, quality
if price > high_quality_laptop[0] and quality < high_quality_laptop[1]:
print("Happy Alex")
break
else:
high_quality_laptop = price, quality
else:
print("Poor Alex")
```
No
| 10,340 | [
0.239013671875,
0.2509765625,
-0.01332855224609375,
-0.0723876953125,
-0.315185546875,
-0.59716796875,
0.12347412109375,
0.10546875,
0.0223388671875,
1.021484375,
0.31005859375,
0.1416015625,
0.04803466796875,
-0.7080078125,
-0.3369140625,
-0.1656494140625,
-0.48291015625,
-0.84130... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of laptops.
Next n lines contain two integers each, ai and bi (1 β€ ai, bi β€ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
Submitted Solution:
```
import sys
input = sys.stdin.readline
laptops = [[int(i) for i in input().split()] for _ in range(int(input()))]
laptops.sort(reverse = True)
best_qual, best_qual_price, flag = 0, -1, True
for i in range(len(laptops)):
if laptops[i][1] > best_qual:
best_qual = laptops[i][1]
if laptops[i][0] < best_qual_price:
flag = True
break
best_qual_price = laptops[i][0]
if flag:
print("Happy Alex")
else:
print("Poor Alex")
```
No
| 10,341 | [
0.151123046875,
0.1024169921875,
0.023681640625,
0.07879638671875,
-0.372802734375,
-0.435546875,
0.11224365234375,
0.1414794921875,
0.054840087890625,
1.0751953125,
0.277099609375,
0.08306884765625,
-0.043487548828125,
-0.56494140625,
-0.41552734375,
-0.10693359375,
-0.5205078125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of laptops.
Next n lines contain two integers each, ai and bi (1 β€ ai, bi β€ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
Submitted Solution:
```
n=int(input())
c,d=0,0
for i in range(n):
a,b=list(map(int,input().rstrip().split()))
if a<b:
c+=1
else:
d+=1
if c>d:
print("Happy Alex")
else:
print("Poor Alex")
```
No
| 10,342 | [
0.23828125,
0.1890869140625,
0.0243988037109375,
0.00026679039001464844,
-0.344482421875,
-0.55517578125,
0.08502197265625,
0.08685302734375,
0.08111572265625,
1.05859375,
0.368408203125,
0.10858154296875,
-0.028228759765625,
-0.640625,
-0.358154296875,
-0.0916748046875,
-0.5,
-0.7... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.
Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of laptops.
Next n lines contain two integers each, ai and bi (1 β€ ai, bi β€ n), where ai is the price of the i-th laptop, and bi is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).
All ai are distinct. All bi are distinct.
Output
If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).
Examples
Input
2
1 2
2 1
Output
Happy Alex
Submitted Solution:
```
count = int(input())
lis = []
for i in range(0, count):
inp = input()
a = int(inp.split()[0])
b = int(inp.split()[1])
lis.append((a,b))
lis.sort()
for i in range(0, count - 1):
if lis[i][0] < lis[i + 1][0] and lis[i][1] < lis[i + 1][1]:
print("Poor Alex")
exit(0)
print("Happy Alex")
```
No
| 10,343 | [
0.20361328125,
0.1773681640625,
0.0887451171875,
-0.059539794921875,
-0.451416015625,
-0.54296875,
-0.0096282958984375,
0.1337890625,
0.169921875,
0.98974609375,
0.222900390625,
0.1287841796875,
0.03216552734375,
-0.6083984375,
-0.4951171875,
-0.227783203125,
-0.4912109375,
-0.6611... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Input
The input consists of four lines, each line containing a single digit 0 or 1.
Output
Output a single digit, 0 or 1.
Example
Input
0
1
1
0
Output
0
Submitted Solution:
```
a, b, c, d = [int(input()) for i in range(4)]
print(((a^b) & (c | d)) ^ ((b&c) | (a^d)))
```
Yes
| 10,454 | [
0.5,
-0.113525390625,
-0.06964111328125,
-0.1956787109375,
-0.796875,
-0.367919921875,
0.0045623779296875,
0.258544921875,
-0.0748291015625,
1.0224609375,
0.548828125,
0.10296630859375,
-0.10723876953125,
-0.55126953125,
-0.63037109375,
-0.13134765625,
-0.306640625,
-0.62353515625,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Input
The input consists of four lines, each line containing a single digit 0 or 1.
Output
Output a single digit, 0 or 1.
Example
Input
0
1
1
0
Output
0
Submitted Solution:
```
import collections as col
import itertools as its
import sys
import operator
from bisect import bisect_left, bisect_right
from copy import copy, deepcopy
class Solver:
def __init__(self):
pass
def solve(self):
a = int(input())
b = int(input())
c = int(input())
d = int(input())
l11 = a ^ b
l12 = c | d
l13 = b & c
l14 = a ^ d
l21 = l11 & l12
l22 = l13 | l14
print(l21 ^ l22)
if __name__ == '__main__':
s = Solver()
s.solve()
```
Yes
| 10,456 | [
0.491455078125,
0.08990478515625,
-0.157470703125,
-0.2305908203125,
-0.818359375,
-0.2314453125,
-0.266845703125,
0.1600341796875,
0.09326171875,
0.986328125,
0.53564453125,
0.12646484375,
0.0831298828125,
-0.8330078125,
-0.61669921875,
-0.00966644287109375,
-0.263916015625,
-0.89... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Input
The input consists of four lines, each line containing a single digit 0 or 1.
Output
Output a single digit, 0 or 1.
Example
Input
0
1
1
0
Output
0
Submitted Solution:
```
"""
Codeforces April Fools Contest 2017 Problem E
Author : chaotic_iak
Language: Python 3.5.2
"""
################################################### SOLUTION
def main():
a, = read()
b, = read()
c, = read()
d, = read()
n = 8*a + 4*b + 2*c + d
dc = { 0: 0, # test 2 confirmed correct
1: 0,
2: 0,
3: 0,
4: 0,
5: 0,
6: 0, # given
7: 0,
8: 1, # test 3 confirmed correct
9: 0,
10: 0,
11: 0,
12: 1, # test 5 among these, equals 1
13: 0, #
14: 0,
15: 0,
}
print(dc[n])
#################################################### HELPERS
def read(callback=int):
return list(map(callback, input().strip().split()))
def write(value, end="\n"):
if value is None: return
try:
if not isinstance(value, str):
value = " ".join(map(str, value))
except:
pass
print(value, end=end)
write(main())
```
No
| 10,459 | [
0.181884765625,
0.08636474609375,
-0.09185791015625,
-0.0224609375,
-0.73583984375,
-0.5029296875,
-0.2474365234375,
0.111083984375,
0.00582122802734375,
1.1513671875,
0.424560546875,
-0.0123291015625,
0.25732421875,
-0.6201171875,
-0.54248046875,
-0.31201171875,
-0.572265625,
-0.4... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Input
The input consists of four lines, each line containing a single digit 0 or 1.
Output
Output a single digit, 0 or 1.
Example
Input
0
1
1
0
Output
0
Submitted Solution:
```
a1, a2, a3, a4 = [bool(input()) for _ in range(4)]
gate1 = a1 or a2
gate2 = a3 != a4
gate3 = a2 and a3
gate4 = a1 or a4
gate5 = gate1 and gate2
gate6 = gate3 != gate4
gate7 = gate5 or gate6
print(1 - int(gate7))
```
No
| 10,460 | [
0.73046875,
0.129150390625,
-0.132080078125,
-0.04638671875,
-0.90576171875,
-0.60546875,
-0.12115478515625,
0.1229248046875,
-0.110107421875,
0.94580078125,
0.65283203125,
0.011199951171875,
-0.21923828125,
-0.83837890625,
-0.6279296875,
-0.266357421875,
-0.330322265625,
-0.578613... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password".
Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" β thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address.
Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits.
Help Igor K. restore his ISQ account by the encrypted password and encryption specification.
Input
The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.
Output
Print one line containing 8 characters β The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.
Examples
Input
01001100100101100000010110001001011001000101100110010110100001011010100101101100
0100110000
0100110010
0101100000
0101100010
0101100100
0101100110
0101101000
0101101010
0101101100
0101101110
Output
12345678
Input
10101101111001000010100100011010101101110010110111011000100011011110010110001000
1001000010
1101111001
1001000110
1010110111
0010110111
1101001101
1011000001
1110010101
1011011000
0110001000
Output
30234919
Submitted Solution:
```
inp = input("")
ls = []
binaries = []
for i in range(0, 8):
binaries.append(inp[i * 10:(i + 1) * 10])
el = []
result = ''
for i in range(10):
el.append(input(""))
for i in range(8):
if binaries[i] in el:
result += str(el.index(binaries[i]))
print(result)
```
Yes
| 10,519 | [
0.439208984375,
-0.07574462890625,
-0.01236724853515625,
0.14990234375,
-0.44189453125,
-0.2489013671875,
-0.156494140625,
0.135009765625,
-0.18359375,
0.693359375,
0.59912109375,
-0.1097412109375,
0.12152099609375,
-0.8095703125,
-0.740234375,
0.2318115234375,
-0.439697265625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password".
Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" β thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address.
Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits.
Help Igor K. restore his ISQ account by the encrypted password and encryption specification.
Input
The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.
Output
Print one line containing 8 characters β The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.
Examples
Input
01001100100101100000010110001001011001000101100110010110100001011010100101101100
0100110000
0100110010
0101100000
0101100010
0101100100
0101100110
0101101000
0101101010
0101101100
0101101110
Output
12345678
Input
10101101111001000010100100011010101101110010110111011000100011011110010110001000
1001000010
1101111001
1001000110
1010110111
0010110111
1101001101
1011000001
1110010101
1011011000
0110001000
Output
30234919
Submitted Solution:
```
password = input()
str_to_dec = {}
for dec in range(10):
str_to_dec[input()] = dec
dec_pass = ""
for i in range(8):
dec_pass += str(str_to_dec[password[10*i:10*(i+1)]])
print(dec_pass)
```
Yes
| 10,520 | [
0.439208984375,
-0.07574462890625,
-0.01236724853515625,
0.14990234375,
-0.44189453125,
-0.2489013671875,
-0.156494140625,
0.135009765625,
-0.18359375,
0.693359375,
0.59912109375,
-0.1097412109375,
0.12152099609375,
-0.8095703125,
-0.740234375,
0.2318115234375,
-0.439697265625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password".
Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" β thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address.
Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits.
Help Igor K. restore his ISQ account by the encrypted password and encryption specification.
Input
The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.
Output
Print one line containing 8 characters β The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.
Examples
Input
01001100100101100000010110001001011001000101100110010110100001011010100101101100
0100110000
0100110010
0101100000
0101100010
0101100100
0101100110
0101101000
0101101010
0101101100
0101101110
Output
12345678
Input
10101101111001000010100100011010101101110010110111011000100011011110010110001000
1001000010
1101111001
1001000110
1010110111
0010110111
1101001101
1011000001
1110010101
1011011000
0110001000
Output
30234919
Submitted Solution:
```
def main():
encrypted = input()
decrypted = [''] * 8
numbers = {}
for i in range(10):
numbers[input()] = i
start = 0
end = start + 10
for i in range(8):
decrypted[i] = str(numbers[encrypted[start:end]])
start = end
end += 10
print(''.join(decrypted))
if __name__ == '__main__':
main()
```
Yes
| 10,521 | [
0.439208984375,
-0.07574462890625,
-0.01236724853515625,
0.14990234375,
-0.44189453125,
-0.2489013671875,
-0.156494140625,
0.135009765625,
-0.18359375,
0.693359375,
0.59912109375,
-0.1097412109375,
0.12152099609375,
-0.8095703125,
-0.740234375,
0.2318115234375,
-0.439697265625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password".
Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" β thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address.
Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits.
Help Igor K. restore his ISQ account by the encrypted password and encryption specification.
Input
The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.
Output
Print one line containing 8 characters β The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.
Examples
Input
01001100100101100000010110001001011001000101100110010110100001011010100101101100
0100110000
0100110010
0101100000
0101100010
0101100100
0101100110
0101101000
0101101010
0101101100
0101101110
Output
12345678
Input
10101101111001000010100100011010101101110010110111011000100011011110010110001000
1001000010
1101111001
1001000110
1010110111
0010110111
1101001101
1011000001
1110010101
1011011000
0110001000
Output
30234919
Submitted Solution:
```
pwd = str(input())
seq = [str(input()),str(input()),str(input()),str(input()),str(input())
,str(input()),str(input()),str(input()),str(input()),str(input())]
for n in range(0 , 8):
for i in range(0 ,len(seq)) :
if pwd[n*10:n*10+10] ==seq[i] :
print(i , end= '')
```
Yes
| 10,522 | [
0.439208984375,
-0.07574462890625,
-0.01236724853515625,
0.14990234375,
-0.44189453125,
-0.2489013671875,
-0.156494140625,
0.135009765625,
-0.18359375,
0.693359375,
0.59912109375,
-0.1097412109375,
0.12152099609375,
-0.8095703125,
-0.740234375,
0.2318115234375,
-0.439697265625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password".
Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" β thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address.
Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits.
Help Igor K. restore his ISQ account by the encrypted password and encryption specification.
Input
The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.
Output
Print one line containing 8 characters β The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.
Examples
Input
01001100100101100000010110001001011001000101100110010110100001011010100101101100
0100110000
0100110010
0101100000
0101100010
0101100100
0101100110
0101101000
0101101010
0101101100
0101101110
Output
12345678
Input
10101101111001000010100100011010101101110010110111011000100011011110010110001000
1001000010
1101111001
1001000110
1010110111
0010110111
1101001101
1011000001
1110010101
1011011000
0110001000
Output
30234919
Submitted Solution:
```
c = input()
a = []
for x in range(10):
a.append(input())
qwerty = ""
for x in range(8):
for z in range(10):
#print(c[x:x+10])
if a[z]==c[x:x+10]:
qwerty+=str(z)
print(qwerty)
```
No
| 10,523 | [
0.439208984375,
-0.07574462890625,
-0.01236724853515625,
0.14990234375,
-0.44189453125,
-0.2489013671875,
-0.156494140625,
0.135009765625,
-0.18359375,
0.693359375,
0.59912109375,
-0.1097412109375,
0.12152099609375,
-0.8095703125,
-0.740234375,
0.2318115234375,
-0.439697265625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password".
Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" β thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address.
Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits.
Help Igor K. restore his ISQ account by the encrypted password and encryption specification.
Input
The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.
Output
Print one line containing 8 characters β The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.
Examples
Input
01001100100101100000010110001001011001000101100110010110100001011010100101101100
0100110000
0100110010
0101100000
0101100010
0101100100
0101100110
0101101000
0101101010
0101101100
0101101110
Output
12345678
Input
10101101111001000010100100011010101101110010110111011000100011011110010110001000
1001000010
1101111001
1001000110
1010110111
0010110111
1101001101
1011000001
1110010101
1011011000
0110001000
Output
30234919
Submitted Solution:
```
cod = input()
ind = ["" for loop in range(10)]
for i in range(10):
ind[i] = input()
ch =cod[i]
for i in range(1,len(cod)):
j = 0
bol = False
if i%10 == 0:
while bol == False and j<10:
if ind[j] == ch:
bol = True
print (j,end='')
else:
j+=1
ch = cod[i]
else:
ch += cod[i]
j = 0
bol = False
while bol == False and j<10:
if ind[j] == ch:
bol = True
print (j)
else:
j+=1
```
No
| 10,524 | [
0.439208984375,
-0.07574462890625,
-0.01236724853515625,
0.14990234375,
-0.44189453125,
-0.2489013671875,
-0.156494140625,
0.135009765625,
-0.18359375,
0.693359375,
0.59912109375,
-0.1097412109375,
0.12152099609375,
-0.8095703125,
-0.740234375,
0.2318115234375,
-0.439697265625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password".
Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" β thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address.
Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits.
Help Igor K. restore his ISQ account by the encrypted password and encryption specification.
Input
The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.
Output
Print one line containing 8 characters β The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.
Examples
Input
01001100100101100000010110001001011001000101100110010110100001011010100101101100
0100110000
0100110010
0101100000
0101100010
0101100100
0101100110
0101101000
0101101010
0101101100
0101101110
Output
12345678
Input
10101101111001000010100100011010101101110010110111011000100011011110010110001000
1001000010
1101111001
1001000110
1010110111
0010110111
1101001101
1011000001
1110010101
1011011000
0110001000
Output
30234919
Submitted Solution:
```
encoded_string = input()
digits = []
for _ in range(10):
digits.append(input())
for idx, digit in enumerate(digits):
encoded_string = encoded_string.replace(digit, str(idx))
print(encoded_string)
```
No
| 10,525 | [
0.439208984375,
-0.07574462890625,
-0.01236724853515625,
0.14990234375,
-0.44189453125,
-0.2489013671875,
-0.156494140625,
0.135009765625,
-0.18359375,
0.693359375,
0.59912109375,
-0.1097412109375,
0.12152099609375,
-0.8095703125,
-0.740234375,
0.2318115234375,
-0.439697265625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password".
Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" β thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address.
Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits.
Help Igor K. restore his ISQ account by the encrypted password and encryption specification.
Input
The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.
Output
Print one line containing 8 characters β The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.
Examples
Input
01001100100101100000010110001001011001000101100110010110100001011010100101101100
0100110000
0100110010
0101100000
0101100010
0101100100
0101100110
0101101000
0101101010
0101101100
0101101110
Output
12345678
Input
10101101111001000010100100011010101101110010110111011000100011011110010110001000
1001000010
1101111001
1001000110
1010110111
0010110111
1101001101
1011000001
1110010101
1011011000
0110001000
Output
30234919
Submitted Solution:
```
arr=[]
reslt=[]
count=0
rst=''
str_to=''
x=input()
for i in range(10):
arr.append(input())
for i in range(len(x)):
str_to+=x[i]
count+=1
if count==10:
reslt.append(str_to)
str_to=''
count=0
for i in range(len(arr)):
for j in range(len(reslt)):
if arr[i]==reslt[j]:
rst+=str(i)
print(rst)
```
No
| 10,526 | [
0.439208984375,
-0.07574462890625,
-0.01236724853515625,
0.14990234375,
-0.44189453125,
-0.2489013671875,
-0.156494140625,
0.135009765625,
-0.18359375,
0.693359375,
0.59912109375,
-0.1097412109375,
0.12152099609375,
-0.8095703125,
-0.740234375,
0.2318115234375,
-0.439697265625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 β¦ i β¦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j β k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 β¦ N β¦ 10^5
* 1 β¦ a_i β¦ N(2 β¦ i β¦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
from sys import stdin, setrecursionlimit
setrecursionlimit(10**7)
def solve():
N = int(stdin.readline())
Adj = [[] for i in range(N)]
for i in range(N - 1):
a = int(stdin.readline()) - 1
Adj[a].append(i + 1)
ans = dfs(N, Adj, 0, -1)
print(ans)
def dfs(N, Adj, v, p):
dl = []
for u in Adj[v]:
if u == p:
continue
dl.append(dfs(N, Adj, u, v))
dl.sort(reverse=True)
if not dl:
return 0
res = max(dl[i] + i + 1 for i in range(len(dl)))
return res
if __name__ == '__main__':
solve()
```
Yes
| 10,656 | [
0.50244140625,
-0.055084228515625,
0.0318603515625,
0.1466064453125,
-0.48291015625,
-0.1026611328125,
-0.40576171875,
0.427734375,
-0.204833984375,
0.72900390625,
0.52490234375,
-0.05889892578125,
-0.06646728515625,
-0.59375,
-0.49365234375,
0.39453125,
-0.6884765625,
-0.628417968... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 β¦ i β¦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j β k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 β¦ N β¦ 10^5
* 1 β¦ a_i β¦ N(2 β¦ i β¦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**9)
n=int(input())
A=[int(input())-1 for _ in range(n-1)]
C=[[] for _ in range(n)]
for i,a in enumerate(A):
C[a].append(i+1)
def depth(k):
l=len(C[k])
if not l:
return 0
else:
D=[]
ret=-1
for c in C[k]:
D.append(depth(c))
D.sort(reverse=True)
for i,d in enumerate(D):
ret=max(ret,d+i+1)
return ret
print(depth(0))
```
Yes
| 10,657 | [
0.48681640625,
-0.0858154296875,
0.005176544189453125,
0.1138916015625,
-0.481689453125,
-0.11370849609375,
-0.392822265625,
0.41455078125,
-0.18994140625,
0.76611328125,
0.517578125,
-0.056640625,
-0.07269287109375,
-0.62060546875,
-0.51171875,
0.345947265625,
-0.7080078125,
-0.64... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 β¦ i β¦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j β k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 β¦ N β¦ 10^5
* 1 β¦ a_i β¦ N(2 β¦ i β¦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
import sys
input = sys.stdin.readline
N = int(input())
v = [[] for _ in range(N)]
for i in range(N - 1) :
a = int(input())
v[a-1].append(i + 1)
l = [0]
i = 0
while i < len(l) :
cur = l[i]
for nex in v[cur] :
l.append(nex)
i += 1
dp = [0] * N
while len(l) > 0 :
cur = l.pop()
ret = []
for nex in v[cur] :
ret.append(dp[nex])
if len(ret) == 0 :
continue
ret.sort(reverse=True)
dp[cur] = max([i + 1 + ret[i] for i in range(len(ret))])
print(dp[0])
```
Yes
| 10,659 | [
0.4765625,
-0.1019287109375,
0.0010576248168945312,
0.11053466796875,
-0.46142578125,
-0.1358642578125,
-0.387451171875,
0.434326171875,
-0.1822509765625,
0.7626953125,
0.51416015625,
-0.053680419921875,
-0.09393310546875,
-0.63623046875,
-0.51953125,
0.338134765625,
-0.71240234375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera is a coder. Recently he wrote a funny program. The pseudo code for this program is given below:
//input: integers x, k, p
a = x;
for(step = 1; step <= k; step = step + 1){
rnd = [random integer from 1 to 100];
if(rnd <= p)
a = a * 2;
else
a = a + 1;
}
s = 0;
while(remainder after dividing a by 2 equals 0){
a = a / 2;
s = s + 1;
}
Now Valera wonders: given the values x, k and p, what is the expected value of the resulting number s?
Input
The first line of the input contains three integers x, k, p (1 β€ x β€ 109; 1 β€ k β€ 200; 0 β€ p β€ 100).
Output
Print the required expected value. Your answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
1 1 50
Output
1.0000000000000
Input
5 3 0
Output
3.0000000000000
Input
5 3 25
Output
1.9218750000000
Note
If the concept of expected value is new to you, you can read about it by the link:
http://en.wikipedia.org/wiki/Expected_value
Submitted Solution:
```
print("1")
```
No
| 11,140 | [
0.36328125,
0.053802490234375,
-0.16357421875,
-0.314697265625,
-0.68798828125,
-0.1912841796875,
-0.01145172119140625,
0.12158203125,
0.301025390625,
0.8388671875,
0.53173828125,
-0.351318359375,
-0.141845703125,
-0.583984375,
-0.234130859375,
0.079833984375,
-0.79833984375,
-0.70... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 β€ N β€ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667
Submitted Solution:
```
n = int(input())
M = list(map(int, input().split()))
R = list(map(int, input().split()))
def nod(x, y):
while x != 0 and y != 0:
if x > y:
x = x % y
else:
y = y % x
return x + y
k = 1
for i in M:
k = k * i // nod(k, i)
ans = 0
for D in range(k):
for i in range(n):
if D % M[i] == R[i]:
ans += 1
break
print(ans / k)
```
Yes
| 11,231 | [
0.361083984375,
0.08294677734375,
-0.1844482421875,
0.0859375,
-0.76318359375,
-0.2301025390625,
-0.025543212890625,
0.192626953125,
0.251953125,
0.83642578125,
0.37158203125,
0.001495361328125,
-0.03515625,
-0.61865234375,
-0.71142578125,
-0.421142578125,
-0.43017578125,
-0.746582... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 β€ N β€ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667
Submitted Solution:
```
n = int(input())
mod = list(map(int, input().split()))
rem = list(map(int, input().split()))
cnt = 0
for d in range(360360):
we = False
for r, m in zip(rem, mod):
if d % m == r:
we = True
break
if we:
cnt += 1
print(cnt / 360360)
```
Yes
| 11,232 | [
0.3876953125,
0.0531005859375,
-0.1815185546875,
0.08184814453125,
-0.78857421875,
-0.257568359375,
-0.01361083984375,
0.1968994140625,
0.239990234375,
0.88427734375,
0.310791015625,
-0.019134521484375,
-0.0116119384765625,
-0.611328125,
-0.65478515625,
-0.40478515625,
-0.404296875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 β€ N β€ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667
Submitted Solution:
```
class CodeforcesTask656BSolution:
def __init__(self):
self.result = ''
self.n = 0
self.m = []
self.r = []
def read_input(self):
self.n = int(input())
self.m = [int(x) for x in input().split(" ")]
self.r = [int(x) for x in input().split(" ")]
def process_task(self):
bad_days = 0
for day in range(10**5):
for x in range(self.n):
if day % self.m[x] == self.r[x]:
bad_days += 1
break
self.result = str(bad_days / (10 ** 5))
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask656BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
```
Yes
| 11,233 | [
0.42822265625,
0.1304931640625,
-0.09942626953125,
0.1568603515625,
-0.73828125,
-0.265625,
-0.0110015869140625,
0.17138671875,
0.1610107421875,
0.79052734375,
0.344970703125,
-0.047271728515625,
0.00380706787109375,
-0.6015625,
-0.62890625,
-0.411865234375,
-0.407470703125,
-0.728... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 β€ N β€ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667
Submitted Solution:
```
k = int(input())
q1 = list(map(int,input().split()))
q2 = list(map(int,input().split()))
z = 100000
ans = 0
for i in range(1,z+1):
for j in range(len(q1)):
if i%q1[j] == q2[j]:
ans+=1
break
print(ans/z)
```
Yes
| 11,234 | [
0.408447265625,
0.1165771484375,
-0.2081298828125,
0.09979248046875,
-0.775390625,
-0.24658203125,
-0.00858306884765625,
0.171875,
0.177001953125,
0.8076171875,
0.361083984375,
-0.0248260498046875,
-0.080078125,
-0.61474609375,
-0.681640625,
-0.382568359375,
-0.4599609375,
-0.78466... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 β€ N β€ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667
Submitted Solution:
```
n = 16
m = [2] * 16
r = [0] * 16
days = 0
for day in range(1, 100001):
for index in range(n):
if day % m[index] == r[index]:
days += 1
break
print(days / 100000)
```
No
| 11,235 | [
0.372314453125,
0.1103515625,
-0.1961669921875,
0.10626220703125,
-0.759765625,
-0.1893310546875,
-0.0233917236328125,
0.2059326171875,
0.251220703125,
0.79296875,
0.369384765625,
0.00714111328125,
-0.064208984375,
-0.62744140625,
-0.6689453125,
-0.407958984375,
-0.4482421875,
-0.7... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 β€ N β€ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667
Submitted Solution:
```
n=int(input())
m=list(map(int,input().split()))
r=list(map(int,input().split()))
num=[1 for i in range(n)]
p=[]
for i in range(len(r)):
if r[i]!=20:
for j in range(0,i):
if m[j]==m[i]:
num[j]+=1;
r[i]=20;
for i in range(len(m)):
if r[i]!=20:
p.append(num[i]/m[i])
l=len(p)
ans=0
fac=-1
for i in range(1,l+1):
fac=1 if fac==-1 else -1
daaa=0
for j in range(0,l-i+1):
temp=1
for k in range(i):
print(i,j,k,j+k)
temp*=p[j+k]
daaa+=temp
ans+=daaa*fac
print(ans)
```
No
| 11,236 | [
0.361083984375,
0.08294677734375,
-0.1844482421875,
0.0859375,
-0.76318359375,
-0.2301025390625,
-0.025543212890625,
0.192626953125,
0.251953125,
0.83642578125,
0.37158203125,
0.001495361328125,
-0.03515625,
-0.61865234375,
-0.71142578125,
-0.421142578125,
-0.43017578125,
-0.746582... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 β€ N β€ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667
Submitted Solution:
```
N = int(input())
a = input().split()
b = input().split()
primes = [16,9,5,7,11,13]
c = [[0 for x in range(125)] for x in range(142)]
for i in range(N):
if a[i] == '1':
print(0)
exit(0)
for j in primes:
if j == 16 or j == 9:
m = 0
if j == 16:
m = 2
else:
m = 3
p = 0
k = int(a[i])
while k % m == 0:
p += 1
k /= m
k = 1
while p > 0:
k *= m
p -= 1
if k > 1:
for z in range(j):
if (int(b[i]) - z) % k == 0:
c[j][z] = 1
elif int(a[i])% j == 0:
c[j][int(b[i])%j] = 1
m = 1
for j in primes:
cnt = 0
for k in range(j):
if c[j][k] == 1:
cnt += 1
m *= 1 - (cnt / j)
print(1 - m)
```
No
| 11,237 | [
0.38330078125,
0.1156005859375,
-0.189453125,
0.078125,
-0.75244140625,
-0.22705078125,
0.01197052001953125,
0.161376953125,
0.21875,
0.82763671875,
0.359375,
-0.0012149810791015625,
-0.0836181640625,
-0.619140625,
-0.6865234375,
-0.435302734375,
-0.429931640625,
-0.759765625,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Btoh yuo adn yuor roomatme lhoate wianshg disehs, btu stlil sdmoeboy msut peorrfm tihs cohre dialy. Oen dya yuo decdie to idourtcne smoe syestm. Yuor rmmotaoe sstgegus teh fooniwllg dael. Yuo argee on tow arayrs of ientgres M adn R, nmebur upmicnog dyas (induiclng teh cunrret oen) wtih sicsescuve irnegets (teh ceurrnt dya is zreo), adn yuo wsah teh diehss on dya D if adn olny if terhe etsixs an iednx i scuh taht D mod M[i] = R[i], otwsehrie yuor rmootmae deos it. Yuo lkie teh cncepot, btu yuor rmotaome's cuinnng simle meaks yuo ssecupt sthnoemig, so yuo itennd to vefriy teh fnerisas of teh aemnrgeet.
Yuo aer geivn ayarrs M adn R. Cuaclatle teh pceanregte of dyas on wchih yuo edn up dnoig teh wisahng. Amsuse taht yuo hvae iiiftlneny mnay dyas aehad of yuo.
Input
The first line of input contains a single integer N (1 β€ N β€ 16).
The second and third lines of input contain N integers each, all between 0 and 16, inclusive, and represent arrays M and R, respectively. All M[i] are positive, for each i R[i] < M[i].
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
1
2
0
Output
0.500000
Input
2
2 3
1 0
Output
0.666667
Submitted Solution:
```
def gcd(a,b):
if(b):
return gcd(b,a%b)
else:
return a
def lcm(A):
m = A[0]
for a in A[1:]:
m = m * a // gcd(m,a)
return m
input()
A = [int(s) for s in input().split()]
m = lcm(A)
cnt=0
for i in range(1,m+1):
flag=True
for a in A:
if(i % a == 0):
flag=False
break
if(flag==False): cnt += 1
print(cnt/m)
```
No
| 11,238 | [
0.304931640625,
-0.0070953369140625,
-0.0274658203125,
0.111328125,
-0.59375,
-0.1163330078125,
0.050140380859375,
0.0775146484375,
0.1708984375,
0.89208984375,
0.477783203125,
-0.1898193359375,
0.02587890625,
-0.7177734375,
-0.66064453125,
-0.408203125,
-0.5576171875,
-0.74609375,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So the Beautiful Regional Contest (BeRC) has come to an end! n students took part in the contest. The final standings are already known: the participant in the i-th place solved p_i problems. Since the participants are primarily sorted by the number of solved problems, then p_1 β₯ p_2 β₯ ... β₯ p_n.
Help the jury distribute the gold, silver and bronze medals. Let their numbers be g, s and b, respectively. Here is a list of requirements from the rules, which all must be satisfied:
* for each of the three types of medals, at least one medal must be awarded (that is, g>0, s>0 and b>0);
* the number of gold medals must be strictly less than the number of silver and the number of bronze (that is, g<s and g<b, but there are no requirements between s and b);
* each gold medalist must solve strictly more problems than any awarded with a silver medal;
* each silver medalist must solve strictly more problems than any awarded a bronze medal;
* each bronze medalist must solve strictly more problems than any participant not awarded a medal;
* the total number of medalists g+s+b should not exceed half of all participants (for example, if n=21, then you can award a maximum of 10 participants, and if n=26, then you can award a maximum of 13 participants).
The jury wants to reward with medals the total maximal number participants (i.e. to maximize g+s+b) so that all of the items listed above are fulfilled. Help the jury find such a way to award medals.
Input
The first line of the input contains an integer t (1 β€ t β€ 10000) β the number of test cases in the input. Then t test cases follow.
The first line of a test case contains an integer n (1 β€ n β€ 4β
10^5) β the number of BeRC participants. The second line of a test case contains integers p_1, p_2, ..., p_n (0 β€ p_i β€ 10^6), where p_i is equal to the number of problems solved by the i-th participant from the final standings. The values p_i are sorted in non-increasing order, i.e. p_1 β₯ p_2 β₯ ... β₯ p_n.
The sum of n over all test cases in the input does not exceed 4β
10^5.
Output
Print t lines, the j-th line should contain the answer to the j-th test case.
The answer consists of three non-negative integers g, s, b.
* Print g=s=b=0 if there is no way to reward participants with medals so that all requirements from the statement are satisfied at the same time.
* Otherwise, print three positive numbers g, s, b β the possible number of gold, silver and bronze medals, respectively. The sum of g+s+b should be the maximum possible. If there are several answers, print any of them.
Example
Input
5
12
5 4 4 3 2 2 1 1 1 1 1 1
4
4 3 2 1
1
1000000
20
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
32
64 64 63 58 58 58 58 58 37 37 37 37 34 34 28 28 28 28 28 28 24 24 19 17 17 17 17 16 16 16 16 11
Output
1 2 3
0 0 0
0 0 0
2 5 3
2 6 6
Note
In the first test case, it is possible to reward 1 gold, 2 silver and 3 bronze medals. In this case, the participant solved 5 tasks will be rewarded with the gold medal, participants solved 4 tasks will be rewarded with silver medals, participants solved 2 or 3 tasks will be rewarded with bronze medals. Participants solved exactly 1 task won't be rewarded. It's easy to see, that in this case, all conditions are satisfied and it is possible to reward participants in this way. It is impossible to give more than 6 medals because the number of medals should not exceed half of the number of participants. The answer 1, 3, 2 is also correct in this test case.
In the second and third test cases, it is impossible to reward medals, because at least one medal of each type should be given, but the number of medals should not exceed half of the number of participants.
Submitted Solution:
```
from collections import Counter
from collections import defaultdict
import math
import bisect
t=int(input())
for _ in range(0,t):
n=int(input())
a=list(map(int,input().split()))
d=defaultdict(lambda:0)
s=a[0]
d[s]=1
ans=1
l=[a[0]]
if(n<5):
print("0 0 0")
continue
for i in range(1,n//2):
if(a[i]==s):
d[a[i]]=d[a[i]]+1
else:
s=a[i]
d[a[i]]=1
l.append(a[i])
ans=d[a[0]]
a2=a[n//2-1]
if(a2==a[n//2]):
#print(a2,a[n//2],"ll")
l.remove(a[n//2-1])
# print("f")
# print(d)
c=0
s2=0
k=0
f1=0
f2=0
for i in range(1,len(l)):
c=c+d[l[i]]
if(c>ans):
s2=c
k=i
f1=1
break
c=0
#print(k)
for i in range(k+1,len(l)):
c=c+d[l[i]]
if(c>ans):
f2=1
s3=c
if(f1 and f2):
print(ans,s2,s3)
else:
print("0 0 0")
```
Yes
| 11,748 | [
0.409912109375,
-0.236328125,
-0.1793212890625,
0.21533203125,
-0.420166015625,
-0.265380859375,
0.0548095703125,
0.29296875,
0.07366943359375,
0.62646484375,
0.84130859375,
-0.175048828125,
0.1153564453125,
-0.84033203125,
-0.44921875,
-0.08856201171875,
-0.48828125,
-0.9301757812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So the Beautiful Regional Contest (BeRC) has come to an end! n students took part in the contest. The final standings are already known: the participant in the i-th place solved p_i problems. Since the participants are primarily sorted by the number of solved problems, then p_1 β₯ p_2 β₯ ... β₯ p_n.
Help the jury distribute the gold, silver and bronze medals. Let their numbers be g, s and b, respectively. Here is a list of requirements from the rules, which all must be satisfied:
* for each of the three types of medals, at least one medal must be awarded (that is, g>0, s>0 and b>0);
* the number of gold medals must be strictly less than the number of silver and the number of bronze (that is, g<s and g<b, but there are no requirements between s and b);
* each gold medalist must solve strictly more problems than any awarded with a silver medal;
* each silver medalist must solve strictly more problems than any awarded a bronze medal;
* each bronze medalist must solve strictly more problems than any participant not awarded a medal;
* the total number of medalists g+s+b should not exceed half of all participants (for example, if n=21, then you can award a maximum of 10 participants, and if n=26, then you can award a maximum of 13 participants).
The jury wants to reward with medals the total maximal number participants (i.e. to maximize g+s+b) so that all of the items listed above are fulfilled. Help the jury find such a way to award medals.
Input
The first line of the input contains an integer t (1 β€ t β€ 10000) β the number of test cases in the input. Then t test cases follow.
The first line of a test case contains an integer n (1 β€ n β€ 4β
10^5) β the number of BeRC participants. The second line of a test case contains integers p_1, p_2, ..., p_n (0 β€ p_i β€ 10^6), where p_i is equal to the number of problems solved by the i-th participant from the final standings. The values p_i are sorted in non-increasing order, i.e. p_1 β₯ p_2 β₯ ... β₯ p_n.
The sum of n over all test cases in the input does not exceed 4β
10^5.
Output
Print t lines, the j-th line should contain the answer to the j-th test case.
The answer consists of three non-negative integers g, s, b.
* Print g=s=b=0 if there is no way to reward participants with medals so that all requirements from the statement are satisfied at the same time.
* Otherwise, print three positive numbers g, s, b β the possible number of gold, silver and bronze medals, respectively. The sum of g+s+b should be the maximum possible. If there are several answers, print any of them.
Example
Input
5
12
5 4 4 3 2 2 1 1 1 1 1 1
4
4 3 2 1
1
1000000
20
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
32
64 64 63 58 58 58 58 58 37 37 37 37 34 34 28 28 28 28 28 28 24 24 19 17 17 17 17 16 16 16 16 11
Output
1 2 3
0 0 0
0 0 0
2 5 3
2 6 6
Note
In the first test case, it is possible to reward 1 gold, 2 silver and 3 bronze medals. In this case, the participant solved 5 tasks will be rewarded with the gold medal, participants solved 4 tasks will be rewarded with silver medals, participants solved 2 or 3 tasks will be rewarded with bronze medals. Participants solved exactly 1 task won't be rewarded. It's easy to see, that in this case, all conditions are satisfied and it is possible to reward participants in this way. It is impossible to give more than 6 medals because the number of medals should not exceed half of the number of participants. The answer 1, 3, 2 is also correct in this test case.
In the second and third test cases, it is impossible to reward medals, because at least one medal of each type should be given, but the number of medals should not exceed half of the number of participants.
Submitted Solution:
```
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
def input():
return sys.stdin.readline().strip()
def iinput():
return int(input())
def finput():
return float(input())
def tinput():
return input().split()
def rinput():
return map(int, tinput())
def rlinput():
return list(rinput())
def main():
n = iinput()
c = rlinput()
q = n//2
w = [[c[0], 0]]
for i in c:
if (w[-1][0] == i):
w[-1][1] += 1
else:
w.append([i,1])
res1, res2, res3 = 0, 0, 0
if (len(w) <= 3):
print(0, 0, 0)
else:
res1 = w[0][1]
res2 = w[1][1]
i = 2
n= len(w)
while ((res1 >= res2) and (i != n)):
res2 += w[i][1]
i += 1
s = res1 + res2
while ((i != n) and (w[i][1] + s <= q)):
s += w[i][1]
res3 += w[i][1]
i += 1
if ((s > q) or (res1 * res2 * res3 == 0) or (res1 >= res2) or (res3 <= res1)):
print(0,0,0)
else:
print(res1, res2, res3)
for j in range(int(input())):
main()
```
Yes
| 11,749 | [
0.409912109375,
-0.236328125,
-0.1793212890625,
0.21533203125,
-0.420166015625,
-0.265380859375,
0.0548095703125,
0.29296875,
0.07366943359375,
0.62646484375,
0.84130859375,
-0.175048828125,
0.1153564453125,
-0.84033203125,
-0.44921875,
-0.08856201171875,
-0.48828125,
-0.9301757812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So the Beautiful Regional Contest (BeRC) has come to an end! n students took part in the contest. The final standings are already known: the participant in the i-th place solved p_i problems. Since the participants are primarily sorted by the number of solved problems, then p_1 β₯ p_2 β₯ ... β₯ p_n.
Help the jury distribute the gold, silver and bronze medals. Let their numbers be g, s and b, respectively. Here is a list of requirements from the rules, which all must be satisfied:
* for each of the three types of medals, at least one medal must be awarded (that is, g>0, s>0 and b>0);
* the number of gold medals must be strictly less than the number of silver and the number of bronze (that is, g<s and g<b, but there are no requirements between s and b);
* each gold medalist must solve strictly more problems than any awarded with a silver medal;
* each silver medalist must solve strictly more problems than any awarded a bronze medal;
* each bronze medalist must solve strictly more problems than any participant not awarded a medal;
* the total number of medalists g+s+b should not exceed half of all participants (for example, if n=21, then you can award a maximum of 10 participants, and if n=26, then you can award a maximum of 13 participants).
The jury wants to reward with medals the total maximal number participants (i.e. to maximize g+s+b) so that all of the items listed above are fulfilled. Help the jury find such a way to award medals.
Input
The first line of the input contains an integer t (1 β€ t β€ 10000) β the number of test cases in the input. Then t test cases follow.
The first line of a test case contains an integer n (1 β€ n β€ 4β
10^5) β the number of BeRC participants. The second line of a test case contains integers p_1, p_2, ..., p_n (0 β€ p_i β€ 10^6), where p_i is equal to the number of problems solved by the i-th participant from the final standings. The values p_i are sorted in non-increasing order, i.e. p_1 β₯ p_2 β₯ ... β₯ p_n.
The sum of n over all test cases in the input does not exceed 4β
10^5.
Output
Print t lines, the j-th line should contain the answer to the j-th test case.
The answer consists of three non-negative integers g, s, b.
* Print g=s=b=0 if there is no way to reward participants with medals so that all requirements from the statement are satisfied at the same time.
* Otherwise, print three positive numbers g, s, b β the possible number of gold, silver and bronze medals, respectively. The sum of g+s+b should be the maximum possible. If there are several answers, print any of them.
Example
Input
5
12
5 4 4 3 2 2 1 1 1 1 1 1
4
4 3 2 1
1
1000000
20
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
32
64 64 63 58 58 58 58 58 37 37 37 37 34 34 28 28 28 28 28 28 24 24 19 17 17 17 17 16 16 16 16 11
Output
1 2 3
0 0 0
0 0 0
2 5 3
2 6 6
Note
In the first test case, it is possible to reward 1 gold, 2 silver and 3 bronze medals. In this case, the participant solved 5 tasks will be rewarded with the gold medal, participants solved 4 tasks will be rewarded with silver medals, participants solved 2 or 3 tasks will be rewarded with bronze medals. Participants solved exactly 1 task won't be rewarded. It's easy to see, that in this case, all conditions are satisfied and it is possible to reward participants in this way. It is impossible to give more than 6 medals because the number of medals should not exceed half of the number of participants. The answer 1, 3, 2 is also correct in this test case.
In the second and third test cases, it is impossible to reward medals, because at least one medal of each type should be given, but the number of medals should not exceed half of the number of participants.
Submitted Solution:
```
import sys,math,itertools
from collections import Counter,deque,defaultdict
from bisect import bisect_left,bisect_right
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
for _ in range(inp()):
n = inp()
a = inpl()
c = Counter(a)
tmp = list(c)
tmp.sort(reverse = True)
cnt = 0
per = []
for key in tmp:
if c[key] + cnt > n//2:
break
cnt += c[key]
per.append(c[key])
ln = len(per)
if ln < 3:
print(0,0,0)
continue
gold = per[0]
bronze = sum(per) - gold
silver = 0
for i in range(1,ln-1):
silver += per[i]
bronze -= per[i]
if silver > gold and bronze > gold:
break
else:
print(0,0,0)
continue
print(gold,silver,bronze)
```
Yes
| 11,750 | [
0.409912109375,
-0.236328125,
-0.1793212890625,
0.21533203125,
-0.420166015625,
-0.265380859375,
0.0548095703125,
0.29296875,
0.07366943359375,
0.62646484375,
0.84130859375,
-0.175048828125,
0.1153564453125,
-0.84033203125,
-0.44921875,
-0.08856201171875,
-0.48828125,
-0.9301757812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So the Beautiful Regional Contest (BeRC) has come to an end! n students took part in the contest. The final standings are already known: the participant in the i-th place solved p_i problems. Since the participants are primarily sorted by the number of solved problems, then p_1 β₯ p_2 β₯ ... β₯ p_n.
Help the jury distribute the gold, silver and bronze medals. Let their numbers be g, s and b, respectively. Here is a list of requirements from the rules, which all must be satisfied:
* for each of the three types of medals, at least one medal must be awarded (that is, g>0, s>0 and b>0);
* the number of gold medals must be strictly less than the number of silver and the number of bronze (that is, g<s and g<b, but there are no requirements between s and b);
* each gold medalist must solve strictly more problems than any awarded with a silver medal;
* each silver medalist must solve strictly more problems than any awarded a bronze medal;
* each bronze medalist must solve strictly more problems than any participant not awarded a medal;
* the total number of medalists g+s+b should not exceed half of all participants (for example, if n=21, then you can award a maximum of 10 participants, and if n=26, then you can award a maximum of 13 participants).
The jury wants to reward with medals the total maximal number participants (i.e. to maximize g+s+b) so that all of the items listed above are fulfilled. Help the jury find such a way to award medals.
Input
The first line of the input contains an integer t (1 β€ t β€ 10000) β the number of test cases in the input. Then t test cases follow.
The first line of a test case contains an integer n (1 β€ n β€ 4β
10^5) β the number of BeRC participants. The second line of a test case contains integers p_1, p_2, ..., p_n (0 β€ p_i β€ 10^6), where p_i is equal to the number of problems solved by the i-th participant from the final standings. The values p_i are sorted in non-increasing order, i.e. p_1 β₯ p_2 β₯ ... β₯ p_n.
The sum of n over all test cases in the input does not exceed 4β
10^5.
Output
Print t lines, the j-th line should contain the answer to the j-th test case.
The answer consists of three non-negative integers g, s, b.
* Print g=s=b=0 if there is no way to reward participants with medals so that all requirements from the statement are satisfied at the same time.
* Otherwise, print three positive numbers g, s, b β the possible number of gold, silver and bronze medals, respectively. The sum of g+s+b should be the maximum possible. If there are several answers, print any of them.
Example
Input
5
12
5 4 4 3 2 2 1 1 1 1 1 1
4
4 3 2 1
1
1000000
20
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
32
64 64 63 58 58 58 58 58 37 37 37 37 34 34 28 28 28 28 28 28 24 24 19 17 17 17 17 16 16 16 16 11
Output
1 2 3
0 0 0
0 0 0
2 5 3
2 6 6
Note
In the first test case, it is possible to reward 1 gold, 2 silver and 3 bronze medals. In this case, the participant solved 5 tasks will be rewarded with the gold medal, participants solved 4 tasks will be rewarded with silver medals, participants solved 2 or 3 tasks will be rewarded with bronze medals. Participants solved exactly 1 task won't be rewarded. It's easy to see, that in this case, all conditions are satisfied and it is possible to reward participants in this way. It is impossible to give more than 6 medals because the number of medals should not exceed half of the number of participants. The answer 1, 3, 2 is also correct in this test case.
In the second and third test cases, it is impossible to reward medals, because at least one medal of each type should be given, but the number of medals should not exceed half of the number of participants.
Submitted Solution:
```
# import sys
# sys.stdin=open("input1.in","r")
# sys.stdout=open("outpul.out","w")
for i in range(int(input())):
N=int(input())
L=list(map(int,input().split()))
X=N//2
X=X-1
x=0
if L[X]==L[X+1]:
for j in range(X,-1,-1):
if L[j]!=L[j-1]:
x=j-1
break
X=x
if X<4:
print("0 0 0")
else:
j=1
r=1
while L[j]==L[j-1] and j<=X:
r+=1
j+=1
g=0
while j<=X and (g<=r or L[j]==L[j-1]):
g+=1
j+=1
b=X+1-(r+g)
if b>r:
print(r,g,b)
else:
print("0 0 0")
```
Yes
| 11,751 | [
0.409912109375,
-0.236328125,
-0.1793212890625,
0.21533203125,
-0.420166015625,
-0.265380859375,
0.0548095703125,
0.29296875,
0.07366943359375,
0.62646484375,
0.84130859375,
-0.175048828125,
0.1153564453125,
-0.84033203125,
-0.44921875,
-0.08856201171875,
-0.48828125,
-0.9301757812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So the Beautiful Regional Contest (BeRC) has come to an end! n students took part in the contest. The final standings are already known: the participant in the i-th place solved p_i problems. Since the participants are primarily sorted by the number of solved problems, then p_1 β₯ p_2 β₯ ... β₯ p_n.
Help the jury distribute the gold, silver and bronze medals. Let their numbers be g, s and b, respectively. Here is a list of requirements from the rules, which all must be satisfied:
* for each of the three types of medals, at least one medal must be awarded (that is, g>0, s>0 and b>0);
* the number of gold medals must be strictly less than the number of silver and the number of bronze (that is, g<s and g<b, but there are no requirements between s and b);
* each gold medalist must solve strictly more problems than any awarded with a silver medal;
* each silver medalist must solve strictly more problems than any awarded a bronze medal;
* each bronze medalist must solve strictly more problems than any participant not awarded a medal;
* the total number of medalists g+s+b should not exceed half of all participants (for example, if n=21, then you can award a maximum of 10 participants, and if n=26, then you can award a maximum of 13 participants).
The jury wants to reward with medals the total maximal number participants (i.e. to maximize g+s+b) so that all of the items listed above are fulfilled. Help the jury find such a way to award medals.
Input
The first line of the input contains an integer t (1 β€ t β€ 10000) β the number of test cases in the input. Then t test cases follow.
The first line of a test case contains an integer n (1 β€ n β€ 4β
10^5) β the number of BeRC participants. The second line of a test case contains integers p_1, p_2, ..., p_n (0 β€ p_i β€ 10^6), where p_i is equal to the number of problems solved by the i-th participant from the final standings. The values p_i are sorted in non-increasing order, i.e. p_1 β₯ p_2 β₯ ... β₯ p_n.
The sum of n over all test cases in the input does not exceed 4β
10^5.
Output
Print t lines, the j-th line should contain the answer to the j-th test case.
The answer consists of three non-negative integers g, s, b.
* Print g=s=b=0 if there is no way to reward participants with medals so that all requirements from the statement are satisfied at the same time.
* Otherwise, print three positive numbers g, s, b β the possible number of gold, silver and bronze medals, respectively. The sum of g+s+b should be the maximum possible. If there are several answers, print any of them.
Example
Input
5
12
5 4 4 3 2 2 1 1 1 1 1 1
4
4 3 2 1
1
1000000
20
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
32
64 64 63 58 58 58 58 58 37 37 37 37 34 34 28 28 28 28 28 28 24 24 19 17 17 17 17 16 16 16 16 11
Output
1 2 3
0 0 0
0 0 0
2 5 3
2 6 6
Note
In the first test case, it is possible to reward 1 gold, 2 silver and 3 bronze medals. In this case, the participant solved 5 tasks will be rewarded with the gold medal, participants solved 4 tasks will be rewarded with silver medals, participants solved 2 or 3 tasks will be rewarded with bronze medals. Participants solved exactly 1 task won't be rewarded. It's easy to see, that in this case, all conditions are satisfied and it is possible to reward participants in this way. It is impossible to give more than 6 medals because the number of medals should not exceed half of the number of participants. The answer 1, 3, 2 is also correct in this test case.
In the second and third test cases, it is impossible to reward medals, because at least one medal of each type should be given, but the number of medals should not exceed half of the number of participants.
Submitted Solution:
```
import sys
import math
from collections import defaultdict,Counter,deque
import bisect
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
import os
import sys
from io import BytesIO, IOBase
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")
# sys.stdout=open("CP1/output.txt",'w')
# sys.stdin=open("CP1/input.txt",'r')
# mod=pow(10,9)+7
t=int(input())
for i in range(t):
n=int(input())
a=list(map(int,input().split()))
g=s=b=0
ele=a[n//2]
ind=0
for j in range(n-1,-1,-1):
if a[j]>ele:
ind=j+1
break
g=1
ind1=ind
for j in range(1,ind):
if a[j]==a[0]:
g+=1
else:
ind1=j
break
for j in range(ind1,ind):
if a[j]==a[ind1]:
s+=1
else:
s+=1
ind1=j
if s>g:
for k in range(j+1,ind):
if a[k]==a[ind1]:
s+=1
else:
ind1=k
break
break
else:
ind1=ind
for j in range(ind1,ind):
b+=1
if g>0 and s>0 and b>0:
print(g,s,b)
else:
print(0,0,0)
```
No
| 11,752 | [
0.409912109375,
-0.236328125,
-0.1793212890625,
0.21533203125,
-0.420166015625,
-0.265380859375,
0.0548095703125,
0.29296875,
0.07366943359375,
0.62646484375,
0.84130859375,
-0.175048828125,
0.1153564453125,
-0.84033203125,
-0.44921875,
-0.08856201171875,
-0.48828125,
-0.9301757812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So the Beautiful Regional Contest (BeRC) has come to an end! n students took part in the contest. The final standings are already known: the participant in the i-th place solved p_i problems. Since the participants are primarily sorted by the number of solved problems, then p_1 β₯ p_2 β₯ ... β₯ p_n.
Help the jury distribute the gold, silver and bronze medals. Let their numbers be g, s and b, respectively. Here is a list of requirements from the rules, which all must be satisfied:
* for each of the three types of medals, at least one medal must be awarded (that is, g>0, s>0 and b>0);
* the number of gold medals must be strictly less than the number of silver and the number of bronze (that is, g<s and g<b, but there are no requirements between s and b);
* each gold medalist must solve strictly more problems than any awarded with a silver medal;
* each silver medalist must solve strictly more problems than any awarded a bronze medal;
* each bronze medalist must solve strictly more problems than any participant not awarded a medal;
* the total number of medalists g+s+b should not exceed half of all participants (for example, if n=21, then you can award a maximum of 10 participants, and if n=26, then you can award a maximum of 13 participants).
The jury wants to reward with medals the total maximal number participants (i.e. to maximize g+s+b) so that all of the items listed above are fulfilled. Help the jury find such a way to award medals.
Input
The first line of the input contains an integer t (1 β€ t β€ 10000) β the number of test cases in the input. Then t test cases follow.
The first line of a test case contains an integer n (1 β€ n β€ 4β
10^5) β the number of BeRC participants. The second line of a test case contains integers p_1, p_2, ..., p_n (0 β€ p_i β€ 10^6), where p_i is equal to the number of problems solved by the i-th participant from the final standings. The values p_i are sorted in non-increasing order, i.e. p_1 β₯ p_2 β₯ ... β₯ p_n.
The sum of n over all test cases in the input does not exceed 4β
10^5.
Output
Print t lines, the j-th line should contain the answer to the j-th test case.
The answer consists of three non-negative integers g, s, b.
* Print g=s=b=0 if there is no way to reward participants with medals so that all requirements from the statement are satisfied at the same time.
* Otherwise, print three positive numbers g, s, b β the possible number of gold, silver and bronze medals, respectively. The sum of g+s+b should be the maximum possible. If there are several answers, print any of them.
Example
Input
5
12
5 4 4 3 2 2 1 1 1 1 1 1
4
4 3 2 1
1
1000000
20
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
32
64 64 63 58 58 58 58 58 37 37 37 37 34 34 28 28 28 28 28 28 24 24 19 17 17 17 17 16 16 16 16 11
Output
1 2 3
0 0 0
0 0 0
2 5 3
2 6 6
Note
In the first test case, it is possible to reward 1 gold, 2 silver and 3 bronze medals. In this case, the participant solved 5 tasks will be rewarded with the gold medal, participants solved 4 tasks will be rewarded with silver medals, participants solved 2 or 3 tasks will be rewarded with bronze medals. Participants solved exactly 1 task won't be rewarded. It's easy to see, that in this case, all conditions are satisfied and it is possible to reward participants in this way. It is impossible to give more than 6 medals because the number of medals should not exceed half of the number of participants. The answer 1, 3, 2 is also correct in this test case.
In the second and third test cases, it is impossible to reward medals, because at least one medal of each type should be given, but the number of medals should not exceed half of the number of participants.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
l = [int(s) for s in input().split()]
if len(set(l))<3:
print(0,0,0)
continue
i = n//2-1
# print(i)
if l[n//2-1]==l[n//2]:
while i>=0 and l[i]==l[n//2]:
i-=1
if i<0:
print(0,0,0)
continue
# print(i)
# print(l)
l = l[:i+1]
# print(l)
if len(set(l))<3:
print(0,0,0)
continue
i = 1
while l[i]==l[0]:
i+=1
g = i
s = 0
while s<g:
j =i
while l[i]==l[j]:
i+=1
s = i-g
b = len(l)-g-s
if g>=b or g>=s:
print(0,0,0)
print(g,s,b)
```
No
| 11,753 | [
0.409912109375,
-0.236328125,
-0.1793212890625,
0.21533203125,
-0.420166015625,
-0.265380859375,
0.0548095703125,
0.29296875,
0.07366943359375,
0.62646484375,
0.84130859375,
-0.175048828125,
0.1153564453125,
-0.84033203125,
-0.44921875,
-0.08856201171875,
-0.48828125,
-0.9301757812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So the Beautiful Regional Contest (BeRC) has come to an end! n students took part in the contest. The final standings are already known: the participant in the i-th place solved p_i problems. Since the participants are primarily sorted by the number of solved problems, then p_1 β₯ p_2 β₯ ... β₯ p_n.
Help the jury distribute the gold, silver and bronze medals. Let their numbers be g, s and b, respectively. Here is a list of requirements from the rules, which all must be satisfied:
* for each of the three types of medals, at least one medal must be awarded (that is, g>0, s>0 and b>0);
* the number of gold medals must be strictly less than the number of silver and the number of bronze (that is, g<s and g<b, but there are no requirements between s and b);
* each gold medalist must solve strictly more problems than any awarded with a silver medal;
* each silver medalist must solve strictly more problems than any awarded a bronze medal;
* each bronze medalist must solve strictly more problems than any participant not awarded a medal;
* the total number of medalists g+s+b should not exceed half of all participants (for example, if n=21, then you can award a maximum of 10 participants, and if n=26, then you can award a maximum of 13 participants).
The jury wants to reward with medals the total maximal number participants (i.e. to maximize g+s+b) so that all of the items listed above are fulfilled. Help the jury find such a way to award medals.
Input
The first line of the input contains an integer t (1 β€ t β€ 10000) β the number of test cases in the input. Then t test cases follow.
The first line of a test case contains an integer n (1 β€ n β€ 4β
10^5) β the number of BeRC participants. The second line of a test case contains integers p_1, p_2, ..., p_n (0 β€ p_i β€ 10^6), where p_i is equal to the number of problems solved by the i-th participant from the final standings. The values p_i are sorted in non-increasing order, i.e. p_1 β₯ p_2 β₯ ... β₯ p_n.
The sum of n over all test cases in the input does not exceed 4β
10^5.
Output
Print t lines, the j-th line should contain the answer to the j-th test case.
The answer consists of three non-negative integers g, s, b.
* Print g=s=b=0 if there is no way to reward participants with medals so that all requirements from the statement are satisfied at the same time.
* Otherwise, print three positive numbers g, s, b β the possible number of gold, silver and bronze medals, respectively. The sum of g+s+b should be the maximum possible. If there are several answers, print any of them.
Example
Input
5
12
5 4 4 3 2 2 1 1 1 1 1 1
4
4 3 2 1
1
1000000
20
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
32
64 64 63 58 58 58 58 58 37 37 37 37 34 34 28 28 28 28 28 28 24 24 19 17 17 17 17 16 16 16 16 11
Output
1 2 3
0 0 0
0 0 0
2 5 3
2 6 6
Note
In the first test case, it is possible to reward 1 gold, 2 silver and 3 bronze medals. In this case, the participant solved 5 tasks will be rewarded with the gold medal, participants solved 4 tasks will be rewarded with silver medals, participants solved 2 or 3 tasks will be rewarded with bronze medals. Participants solved exactly 1 task won't be rewarded. It's easy to see, that in this case, all conditions are satisfied and it is possible to reward participants in this way. It is impossible to give more than 6 medals because the number of medals should not exceed half of the number of participants. The answer 1, 3, 2 is also correct in this test case.
In the second and third test cases, it is impossible to reward medals, because at least one medal of each type should be given, but the number of medals should not exceed half of the number of participants.
Submitted Solution:
```
from math import ceil
from math import factorial
from collections import Counter
from operator import itemgetter
ii = lambda: int(input())
iia = lambda: list(map(int,input().split()))
isa = lambda: list(input().split())
t = ii()
for i in range(t):
n = ii()
a = iia()
d = Counter(a)
d = sorted(d.items(), key=itemgetter(0),reverse=True)
s = 0
x = []
for i in range(n):
if(s+d[i][1]<=n//2):
s+=d[i][1]
x.append(d[i][1])
else:
break
if(s<5):
print('0 0 0')
else:
k = 0
for i in range(1,n):
if(k<x[0]):
k+=x[i]
if(s//3>x[0]):
print(x[0],k,s-x[0]-(s-x[0]-k)//2)
else:
print('0 0 0')
```
No
| 11,754 | [
0.409912109375,
-0.236328125,
-0.1793212890625,
0.21533203125,
-0.420166015625,
-0.265380859375,
0.0548095703125,
0.29296875,
0.07366943359375,
0.62646484375,
0.84130859375,
-0.175048828125,
0.1153564453125,
-0.84033203125,
-0.44921875,
-0.08856201171875,
-0.48828125,
-0.9301757812... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So the Beautiful Regional Contest (BeRC) has come to an end! n students took part in the contest. The final standings are already known: the participant in the i-th place solved p_i problems. Since the participants are primarily sorted by the number of solved problems, then p_1 β₯ p_2 β₯ ... β₯ p_n.
Help the jury distribute the gold, silver and bronze medals. Let their numbers be g, s and b, respectively. Here is a list of requirements from the rules, which all must be satisfied:
* for each of the three types of medals, at least one medal must be awarded (that is, g>0, s>0 and b>0);
* the number of gold medals must be strictly less than the number of silver and the number of bronze (that is, g<s and g<b, but there are no requirements between s and b);
* each gold medalist must solve strictly more problems than any awarded with a silver medal;
* each silver medalist must solve strictly more problems than any awarded a bronze medal;
* each bronze medalist must solve strictly more problems than any participant not awarded a medal;
* the total number of medalists g+s+b should not exceed half of all participants (for example, if n=21, then you can award a maximum of 10 participants, and if n=26, then you can award a maximum of 13 participants).
The jury wants to reward with medals the total maximal number participants (i.e. to maximize g+s+b) so that all of the items listed above are fulfilled. Help the jury find such a way to award medals.
Input
The first line of the input contains an integer t (1 β€ t β€ 10000) β the number of test cases in the input. Then t test cases follow.
The first line of a test case contains an integer n (1 β€ n β€ 4β
10^5) β the number of BeRC participants. The second line of a test case contains integers p_1, p_2, ..., p_n (0 β€ p_i β€ 10^6), where p_i is equal to the number of problems solved by the i-th participant from the final standings. The values p_i are sorted in non-increasing order, i.e. p_1 β₯ p_2 β₯ ... β₯ p_n.
The sum of n over all test cases in the input does not exceed 4β
10^5.
Output
Print t lines, the j-th line should contain the answer to the j-th test case.
The answer consists of three non-negative integers g, s, b.
* Print g=s=b=0 if there is no way to reward participants with medals so that all requirements from the statement are satisfied at the same time.
* Otherwise, print three positive numbers g, s, b β the possible number of gold, silver and bronze medals, respectively. The sum of g+s+b should be the maximum possible. If there are several answers, print any of them.
Example
Input
5
12
5 4 4 3 2 2 1 1 1 1 1 1
4
4 3 2 1
1
1000000
20
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
32
64 64 63 58 58 58 58 58 37 37 37 37 34 34 28 28 28 28 28 28 24 24 19 17 17 17 17 16 16 16 16 11
Output
1 2 3
0 0 0
0 0 0
2 5 3
2 6 6
Note
In the first test case, it is possible to reward 1 gold, 2 silver and 3 bronze medals. In this case, the participant solved 5 tasks will be rewarded with the gold medal, participants solved 4 tasks will be rewarded with silver medals, participants solved 2 or 3 tasks will be rewarded with bronze medals. Participants solved exactly 1 task won't be rewarded. It's easy to see, that in this case, all conditions are satisfied and it is possible to reward participants in this way. It is impossible to give more than 6 medals because the number of medals should not exceed half of the number of participants. The answer 1, 3, 2 is also correct in this test case.
In the second and third test cases, it is impossible to reward medals, because at least one medal of each type should be given, but the number of medals should not exceed half of the number of participants.
Submitted Solution:
```
t = int(input())
for w in range(t):
n = int(input())
p = [int(i) for i in input().split()]
g, s, b = 0, 0, 0
mid = n // 2
if mid < 3:
print(g, s, b)
continue
maxG = max(p)
lastGoldInx = -1
lastSilverInx = -1
check = []
for i in range(mid):
check.append(p[i])
check = list(set(check))
if len(check) == 1 or len(check) == 1:
print(g, s, b)
for i in range(mid):
if p[i] == maxG:
g += 1
lastGoldInx = i
maxS = p[lastGoldInx + 1]
for i in range(lastGoldInx + 1, mid):
if p[i] == maxS or s < g + 1:
s += 1
lastSilverInx = i
repeatNum = 0
if p[mid] == p[mid + 1]:
repeatNum = p[mid]
for i in range(lastSilverInx + 1, mid):
if p[i] != repeatNum:
b += 1
print(g, s, b)
```
No
| 11,755 | [
0.409912109375,
-0.236328125,
-0.1793212890625,
0.21533203125,
-0.420166015625,
-0.265380859375,
0.0548095703125,
0.29296875,
0.07366943359375,
0.62646484375,
0.84130859375,
-0.175048828125,
0.1153564453125,
-0.84033203125,
-0.44921875,
-0.08856201171875,
-0.48828125,
-0.9301757812... | 11 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.