message
stringlengths 2
39.6k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 219
108k
| cluster
float64 11
11
| __index_level_0__
int64 438
217k
|
|---|---|---|---|---|---|
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
```
|
instruction
| 0
| 9,013
| 11
| 18,026
|
Yes
|
output
| 1
| 9,013
| 11
| 18,027
|
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
```
|
instruction
| 0
| 9,014
| 11
| 18,028
|
Yes
|
output
| 1
| 9,014
| 11
| 18,029
|
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
```
|
instruction
| 0
| 9,015
| 11
| 18,030
|
Yes
|
output
| 1
| 9,015
| 11
| 18,031
|
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
```
|
instruction
| 0
| 9,016
| 11
| 18,032
|
Yes
|
output
| 1
| 9,016
| 11
| 18,033
|
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 = []
```
|
instruction
| 0
| 9,017
| 11
| 18,034
|
No
|
output
| 1
| 9,017
| 11
| 18,035
|
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()
```
|
instruction
| 0
| 9,018
| 11
| 18,036
|
No
|
output
| 1
| 9,018
| 11
| 18,037
|
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
```
|
instruction
| 0
| 9,019
| 11
| 18,038
|
No
|
output
| 1
| 9,019
| 11
| 18,039
|
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 = []
```
|
instruction
| 0
| 9,020
| 11
| 18,040
|
No
|
output
| 1
| 9,020
| 11
| 18,041
|
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
|
instruction
| 0
| 9,022
| 11
| 18,044
|
"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()
```
|
output
| 1
| 9,022
| 11
| 18,045
|
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
|
instruction
| 0
| 9,023
| 11
| 18,046
|
"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')
```
|
output
| 1
| 9,023
| 11
| 18,047
|
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")
```
|
instruction
| 0
| 9,030
| 11
| 18,060
|
Yes
|
output
| 1
| 9,030
| 11
| 18,061
|
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()
```
|
instruction
| 0
| 9,031
| 11
| 18,062
|
Yes
|
output
| 1
| 9,031
| 11
| 18,063
|
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()
```
|
instruction
| 0
| 9,033
| 11
| 18,066
|
Yes
|
output
| 1
| 9,033
| 11
| 18,067
|
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))
```
|
instruction
| 0
| 9,034
| 11
| 18,068
|
No
|
output
| 1
| 9,034
| 11
| 18,069
|
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)
```
|
instruction
| 0
| 9,035
| 11
| 18,070
|
No
|
output
| 1
| 9,035
| 11
| 18,071
|
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")
```
|
instruction
| 0
| 9,036
| 11
| 18,072
|
No
|
output
| 1
| 9,036
| 11
| 18,073
|
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')
```
|
instruction
| 0
| 9,037
| 11
| 18,074
|
No
|
output
| 1
| 9,037
| 11
| 18,075
|
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)
```
|
instruction
| 0
| 9,050
| 11
| 18,100
|
No
|
output
| 1
| 9,050
| 11
| 18,101
|
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)
```
|
instruction
| 0
| 9,372
| 11
| 18,744
|
Yes
|
output
| 1
| 9,372
| 11
| 18,745
|
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)
```
|
instruction
| 0
| 9,373
| 11
| 18,746
|
Yes
|
output
| 1
| 9,373
| 11
| 18,747
|
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)
#
```
|
instruction
| 0
| 9,374
| 11
| 18,748
|
Yes
|
output
| 1
| 9,374
| 11
| 18,749
|
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
```
|
instruction
| 0
| 9,375
| 11
| 18,750
|
Yes
|
output
| 1
| 9,375
| 11
| 18,751
|
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)
```
|
instruction
| 0
| 9,376
| 11
| 18,752
|
No
|
output
| 1
| 9,376
| 11
| 18,753
|
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)
```
|
instruction
| 0
| 9,377
| 11
| 18,754
|
No
|
output
| 1
| 9,377
| 11
| 18,755
|
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()
```
|
instruction
| 0
| 9,378
| 11
| 18,756
|
No
|
output
| 1
| 9,378
| 11
| 18,757
|
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))
```
|
instruction
| 0
| 9,379
| 11
| 18,758
|
No
|
output
| 1
| 9,379
| 11
| 18,759
|
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()
```
|
instruction
| 0
| 9,421
| 11
| 18,842
|
No
|
output
| 1
| 9,421
| 11
| 18,843
|
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()
```
|
instruction
| 0
| 9,422
| 11
| 18,844
|
No
|
output
| 1
| 9,422
| 11
| 18,845
|
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()
```
|
instruction
| 0
| 9,558
| 11
| 19,116
|
No
|
output
| 1
| 9,558
| 11
| 19,117
|
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()
```
|
instruction
| 0
| 9,559
| 11
| 19,118
|
No
|
output
| 1
| 9,559
| 11
| 19,119
|
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()
```
|
instruction
| 0
| 9,560
| 11
| 19,120
|
No
|
output
| 1
| 9,560
| 11
| 19,121
|
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()
```
|
instruction
| 0
| 9,561
| 11
| 19,122
|
No
|
output
| 1
| 9,561
| 11
| 19,123
|
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
|
instruction
| 0
| 9,721
| 11
| 19,442
|
"Correct Solution:
```
x=int(input())
y=int(input())
print(y+(y-x))
```
|
output
| 1
| 9,721
| 11
| 19,443
|
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
|
instruction
| 0
| 9,722
| 11
| 19,444
|
"Correct Solution:
```
r = int(input());g = int(input()); print(2 * g - r)
```
|
output
| 1
| 9,722
| 11
| 19,445
|
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
|
instruction
| 0
| 9,723
| 11
| 19,446
|
"Correct Solution:
```
l = int(input())
l2 = int(input())
print(l+(l2-l)*2)
```
|
output
| 1
| 9,723
| 11
| 19,447
|
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
|
instruction
| 0
| 9,724
| 11
| 19,448
|
"Correct Solution:
```
r=int(input())
g=int(input())
x = int((g*2)-r)
print(x)
```
|
output
| 1
| 9,724
| 11
| 19,449
|
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
|
instruction
| 0
| 9,725
| 11
| 19,450
|
"Correct Solution:
```
r=int(input())
s=int(input())
print(2*s-r)
```
|
output
| 1
| 9,725
| 11
| 19,451
|
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
|
instruction
| 0
| 9,726
| 11
| 19,452
|
"Correct Solution:
```
a = int(input())
g = int(input())
print(g-a+g)
```
|
output
| 1
| 9,726
| 11
| 19,453
|
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
|
instruction
| 0
| 9,727
| 11
| 19,454
|
"Correct Solution:
```
R=int(input())
G=int(input())
print((G-R)+G)
```
|
output
| 1
| 9,727
| 11
| 19,455
|
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
|
instruction
| 0
| 9,728
| 11
| 19,456
|
"Correct Solution:
```
a = int(input())
g = 2 * int(input())
print(g - a)
```
|
output
| 1
| 9,728
| 11
| 19,457
|
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)
```
|
instruction
| 0
| 9,729
| 11
| 19,458
|
Yes
|
output
| 1
| 9,729
| 11
| 19,459
|
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)
```
|
instruction
| 0
| 9,730
| 11
| 19,460
|
Yes
|
output
| 1
| 9,730
| 11
| 19,461
|
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)
```
|
instruction
| 0
| 9,731
| 11
| 19,462
|
Yes
|
output
| 1
| 9,731
| 11
| 19,463
|
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)
```
|
instruction
| 0
| 9,732
| 11
| 19,464
|
Yes
|
output
| 1
| 9,732
| 11
| 19,465
|
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)
```
|
instruction
| 0
| 9,733
| 11
| 19,466
|
No
|
output
| 1
| 9,733
| 11
| 19,467
|
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)
```
|
instruction
| 0
| 9,734
| 11
| 19,468
|
No
|
output
| 1
| 9,734
| 11
| 19,469
|
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)
```
|
instruction
| 0
| 9,735
| 11
| 19,470
|
No
|
output
| 1
| 9,735
| 11
| 19,471
|
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')
```
|
instruction
| 0
| 9,736
| 11
| 19,472
|
No
|
output
| 1
| 9,736
| 11
| 19,473
|
Provide a correct Python 3 solution for this coding contest problem.
Example
Input
3 5 4
3
6
12
Output
Hanako
|
instruction
| 0
| 9,867
| 11
| 19,734
|
"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()
```
|
output
| 1
| 9,867
| 11
| 19,735
|
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
|
instruction
| 0
| 9,884
| 11
| 19,768
|
"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)
```
|
output
| 1
| 9,884
| 11
| 19,769
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.