message stringlengths 2 43.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 853 107k | cluster float64 24 24 | __index_level_0__ int64 1.71k 214k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp loves ciphers. He has invented his own cipher called repeating.
Repeating cipher is used for strings. To encrypt the string s=s_{1}s_{2} ... s_{m} (1 ≤ m ≤ 10), Polycarp uses the following algorithm:
* he writes down s_1 ones,
* he writes down s_2 twice,
* he writes down s_3 three times,
* ...
* he writes down s_m m times.
For example, if s="bab" the process is: "b" → "baa" → "baabbb". So the encrypted s="bab" is "baabbb".
Given string t — the result of encryption of some string s. Your task is to decrypt it, i. e. find the string s.
Input
The first line contains integer n (1 ≤ n ≤ 55) — the length of the encrypted string. The second line of the input contains t — the result of encryption of some string s. It contains only lowercase Latin letters. The length of t is exactly n.
It is guaranteed that the answer to the test exists.
Output
Print such string s that after encryption it equals t.
Examples
Input
6
baabbb
Output
bab
Input
10
ooopppssss
Output
oops
Input
1
z
Output
z
Submitted Solution:
```
"""
VISHVESH BHAVSAR :)
"""
n=int(input())
a=input()
s=''
k=0
p=0
while k<=(n-1):
s+=a[k]
p+=1
k+=p
print(s)
``` | instruction | 0 | 69,870 | 24 | 139,740 |
No | output | 1 | 69,870 | 24 | 139,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp loves ciphers. He has invented his own cipher called repeating.
Repeating cipher is used for strings. To encrypt the string s=s_{1}s_{2} ... s_{m} (1 ≤ m ≤ 10), Polycarp uses the following algorithm:
* he writes down s_1 ones,
* he writes down s_2 twice,
* he writes down s_3 three times,
* ...
* he writes down s_m m times.
For example, if s="bab" the process is: "b" → "baa" → "baabbb". So the encrypted s="bab" is "baabbb".
Given string t — the result of encryption of some string s. Your task is to decrypt it, i. e. find the string s.
Input
The first line contains integer n (1 ≤ n ≤ 55) — the length of the encrypted string. The second line of the input contains t — the result of encryption of some string s. It contains only lowercase Latin letters. The length of t is exactly n.
It is guaranteed that the answer to the test exists.
Output
Print such string s that after encryption it equals t.
Examples
Input
6
baabbb
Output
bab
Input
10
ooopppssss
Output
oops
Input
1
z
Output
z
Submitted Solution:
```
n=int(input())
s=input()
i=2
ans=[]
while i<n:
ans.append(s[i-2])
i=i+i-1
print(*ans, sep='')
``` | instruction | 0 | 69,871 | 24 | 139,742 |
No | output | 1 | 69,871 | 24 | 139,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image> | instruction | 0 | 69,957 | 24 | 139,914 |
Tags: constructive algorithms, greedy, trees
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
impaired_wires = []
plugged_lamb = [0] * (n+1)
plugged_lamb[a[0]] = 1
impaired_wires.append([a[0],None])
print(a[0])
highest=n
for i in range(1, len(a)):
p = a[i]
if plugged_lamb[p] == 0:
wire = impaired_wires.pop(-1)
plugged_lamb[p]=1
print(wire[0],p)
impaired_wires.append([p,None])
if len(impaired_wires)==2:
for c in range(highest, 0,-1):
if plugged_lamb[c]==0:
break
highest = c-1
wire = impaired_wires.pop(0)
plugged_lamb[c]=1
print(wire[0],c)
for c in range(highest,0,-1):
if plugged_lamb[c]==0:
break
print(a[-1], c)
``` | output | 1 | 69,957 | 24 | 139,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image> | instruction | 0 | 69,958 | 24 | 139,916 |
Tags: constructive algorithms, greedy, trees
Correct Solution:
```
# https://codeforces.com/contest/1283/problem/F
n = int(input())
a = [0] + list(map(int, input().split()))
used = [0] * (n+1)
g = {}
cur = [n]
def get_max():
while used[cur[0]] == 1:
cur[0] -= 1
return cur[0]
def push(g, u, v):
if u not in g:
g[u] = []
g[u].append(v)
used[0] = 1
for i, x in enumerate(a[:-1]):
if used[a[i+1]] == 0:
push(g, x, a[i+1])
used[a[i+1]] = 1
else:
max_ = get_max()
push(g, x, max_)
used[max_] = 1
max_ = get_max()
push(g, a[-1], max_)
edge = []
for u, arr in g.items():
if u == 0:
continue
for v in arr:
edge.append(str(u)+' '+str(v))
print(g[0][0])
print('\n'.join([x for x in edge]))
#6
#3 6 3 1 5
``` | output | 1 | 69,958 | 24 | 139,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image> | instruction | 0 | 69,959 | 24 | 139,918 |
Tags: constructive algorithms, greedy, trees
Correct Solution:
```
n = int(input())
p = list(map(int , input().split()))
used = [False] *n
print(p[0])
last_v = n -1
for i,j in enumerate(p):
used[j - 1] = True
while(used[last_v]):
last_v -= 1
if i == n-2 or used[p[i+1]-1]:
print(f"{j} {last_v +1 }")
used[last_v] = True
else:
print(f"{p[i+1]} {j}")
``` | output | 1 | 69,959 | 24 | 139,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image> | instruction | 0 | 69,960 | 24 | 139,920 |
Tags: constructive algorithms, greedy, trees
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
used = [0]*(n+1)
print(a[0])
bigger = n
for x, y in zip(a, a[1:]):
used[x] = 1
if not used[y]:
print(x, y)
else:
while used[bigger]:
bigger -= 1
print(x, bigger)
used[bigger] = 1
used[a[-1]] = 1
while used[bigger]:
bigger -= 1
print(a[-1], bigger)
``` | output | 1 | 69,960 | 24 | 139,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image> | instruction | 0 | 69,961 | 24 | 139,922 |
Tags: constructive algorithms, greedy, trees
Correct Solution:
```
# 1283F - DIY Garland
if __name__ == "__main__":
n = int(input())
inp = input().rstrip().split(" ")
assert len(inp) == n-1
for a in range(len(inp)):
inp[a] = int(inp[a])
marked = {}
edges = [[inp[i], None] for i in range(n-1)]
next_largest_unseen = n
# mark the root node:
root = inp[0]
marked[inp[0]] = True
for i in range(1, n-1):
parent = edges[i][0]
if parent not in marked:
edges[i-1][1] = parent
marked[parent] = True
else:
while (next_largest_unseen in marked):
next_largest_unseen -= 1
edges[i-1][1] = next_largest_unseen
marked[next_largest_unseen] = True
while next_largest_unseen in marked:
next_largest_unseen -= 1
marked[next_largest_unseen] = True
edges[n-2][1] = next_largest_unseen
print(root)
for edge in edges:
edge = [str(edge[0]), str(edge[1])]
print(" ".join(edge))
``` | output | 1 | 69,961 | 24 | 139,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image> | instruction | 0 | 69,962 | 24 | 139,924 |
Tags: constructive algorithms, greedy, trees
Correct Solution:
```
from heapq import heappush, heappop
from collections import Counter
def main():
n = int(input())
aa = [int(a)-1 for a in input().split()]
saa = set(aa)
caa = Counter(aa)
ready = []
for i in range(n):
if i not in saa:
heappush(ready, (i,i))
print(aa[0] + 1)
for a in aa[::-1]:
imp, c = heappop(ready)
print(a+1, c+1)
caa[a] -=1
if caa[a] == 0:
heappush(ready, (max(a, imp), a))
if __name__ == "__main__":
main()
``` | output | 1 | 69,962 | 24 | 139,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image> | instruction | 0 | 69,963 | 24 | 139,926 |
Tags: constructive algorithms, greedy, trees
Correct Solution:
```
n = int(input())
ls = list(map(int, input().split()))
parent = {}
seen = set()
seen.add(ls[0])
lookf = n
for i, e in enumerate(ls):
#print(lookf,e)
if e in seen:
while lookf in seen:
lookf -= 1
parent[lookf] = e
lastarc = (lookf, e)
else:
parent[e] = lastarc[1]
parent[lastarc[0]] = e
lastarc = (lastarc[0], e)
seen.add(e)
seen.add(lookf)
print(ls[0])
for k in parent:
print(k, parent[k])
#print(parent)
``` | output | 1 | 69,963 | 24 | 139,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image> | instruction | 0 | 69,964 | 24 | 139,928 |
Tags: constructive algorithms, greedy, trees
Correct Solution:
```
"""n=int(input())
s=[int(x) for x in input().split()]
print(s[0])
pos=[0]*(n+1)
L=[]
for i in range(0,len(s)):
if(pos[s[i]]==0):
L.append(s[i])
pos[s[i]]=1
else:
for j in range(n,0,-1):
if(pos[j]==0):
L.append(j)
pos[j]=1
break
for j in range(0,len(L)-1):
print(L[j],L[j+1])
L=[s[i]]
for j in range(n,0,-1):
if(pos[j]==0):
L.append(j)
pos[j]=1
break
for j in range(0,len(L)-1):
print(L[j],L[j+1])
"""
n=int(input())
s=[int(x) for x in input().split()]
print(s[0])
pos=[0]*(n+1)
L=[]
ptr=n
for i in range(0,len(s)):
if(pos[s[i]]==0):
L.append(s[i])
pos[s[i]]=1
else:
for j in range(ptr,0,-1):
if(pos[j]==0):
L.append(j)
pos[j]=1
ptr=j-1
break
for j in range(0,len(L)-1):
print(L[j],L[j+1])
L=[s[i]]
for j in range(ptr,0,-1):
if(pos[j]==0):
L.append(j)
pos[j]=1
ptr=j-1
break
for j in range(0,len(L)-1):
print(L[j],L[j+1])
``` | output | 1 | 69,964 | 24 | 139,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
Submitted Solution:
```
from heapq import heappush, heappop
from collections import Counter
def main():
n = int(input())
aa = [int(a)-1 for a in input().split()]
saa = set(aa)
caa = Counter(aa)
ready = []
for i in range(n):
if i not in saa:
heappush(ready, (i,i))
cimp = 0
edges = []
for a in aa[::-1]:
imp, c = heappop(ready)
if imp < cimp:
print(-1)
return
edges.append((a, c))
caa[a] -=1
if caa[a] == 0:
heappush(ready, (max(a, imp), a))
print(aa[0]+1)
for p,c in edges:
print(p+1, c+1)
if __name__ == "__main__":
main()
``` | instruction | 0 | 69,965 | 24 | 139,930 |
Yes | output | 1 | 69,965 | 24 | 139,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
Submitted Solution:
```
import sys
import heapq
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def solve():
n = mint()
x = list(mints())
deg = [0]*(n+1)
for i in x:
deg[i] += 1
deg[x[0]] = int(1e9)
e = [[] for i in range(n+1)]
w = [False]*(n+1)
m = n
first = x[0]
edges = []
hh = []
for j in range(1,n+1):
if deg[j] == 0:
heapq.heappush(hh, j)
for i in range(n-2, -1, -1):
xx = x[i]
y = heapq.heappop(hh)
deg[y] = 1e9
deg[xx] -= 1
if deg[xx] == 0:
heapq.heappush(hh,xx)
e[y].append((xx,len(edges)))
e[xx].append((y,len(edges)))
edges.append((xx,y))
'''q = [0]*n
ql = 0
qr = 1
q[0] = first
w = [False]*(n+1)
w[first] = True
p = [None]*(n+1)
while ql < len(q):
x = q[ql]
ql += 1
for v,_ in e[x]:
if not w[v]:
p[v] = x
w[v] = True
q[qr] = v
qr += 1
d = [0]*(n+1)
order = []
for i in range(qr-1, -1, -1):
x = q[i]
pp = p[x]
dd = 2**x
for v,id in e[x]:
if pp != v:
dd += d[v]
order.append((d[v],id))
d[x] = dd
order.sort()
#print(order)
for i in range(0,len(order)-1):
if order[i][1] > order[i+1][1]:
print(-1)
return
'''
print(first)
for i in edges:
print(*i)
#for i in range(mint()):
solve()
``` | instruction | 0 | 69,966 | 24 | 139,932 |
Yes | output | 1 | 69,966 | 24 | 139,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
Submitted Solution:
```
n = int(input())
p = list(map(int, input().split()))
used = [False] * n
print(p[0])
last_v = n - 1
for i, pp in enumerate(p):
used[pp - 1] = True
while used[last_v]:
last_v -= 1
if i == n - 2 or used[p[i + 1] - 1]:
print(f"{pp} {last_v + 1}")
used[last_v] = True
else:
print(f"{p[i + 1]} {pp}")
``` | instruction | 0 | 69,967 | 24 | 139,934 |
Yes | output | 1 | 69,967 | 24 | 139,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
Submitted Solution:
```
n = int(input())
v = list(map(int, input().split()))
vaz = [0 for x in range(n+10)]
vaz1 = [0 for x in range(2*n+10)]
root = v[0]
node = n
g = []
for i in range(0,n+1):
g.append([])
vaz1[root]=1
last = root
pz = n
for i in range(1,n-1):
if vaz1[v[i]]==1:
while(vaz1[pz]==1):
pz-=1
g[last].append(pz)
vaz1[pz]=1
last=v[i]
else:
vaz1[v[i]]=1
g[last].append(v[i])
last = v[i]
while(vaz1[pz]==1):
pz-=1
g[last].append(pz)
v1 = []
v1.append(root)
vaz[root]=1
pz = 0
while pz<len(v1):
node = v1[pz]
pz +=1
for vec in g[node]:
if vaz[vec]==0:
vaz[vec]=1
v1.append(vec)
ok=0
for i in range(1,n+1):
if vaz[i]==0:
ok=1
if ok==1:
print("-1")
else:
print(str(root))
for i in range(1,n+1):
for x in g[i]:
print(str(i)+" "+str(x))
``` | instruction | 0 | 69,968 | 24 | 139,936 |
Yes | output | 1 | 69,968 | 24 | 139,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split()))
from collections import OrderedDict
garland = OrderedDict()
slot = OrderedDict()
avails = set()
for i in range(1,n+1):
avails.add(i)
slot.update({i:0})
possible=True
slot_=0
for i in range(len(a)):
p = a[i]
if p in avails:
avails.remove(p)
if i>0:
connected=False
if p not in garland.keys():
for node in a[:i][::-1]:
c_num = len(garland[node])
if garland[node][-1]==None:
if len(avails)>0 and p>max(avails) and slot_>1:
m = max(avails)
garland[node][-1]=m
avails.remove(m)
slot_ -=1
else:
garland[node][-1]=p
slot_ -=1
connected=True
for ind in range(c_num):
if garland[node][ind]==None:
if len(avails)==0:
print("avail")
print(-1)
exit()
else:
m = max(avails)
garland[node][ind]=m
slot_ -=1
avails.remove(m)
else:
break
if connected:
break
if not connected:
print("not found where to plug %d"%p)
print(-1)
exit()
if p not in garland.keys():
garland.update({p:[None]})
else:
garland[p].append(None)
slot_ +=1
"""
print(avails)
for p in garland.keys():
print(p,":", garland[p])
"""
for node in a[::-1]:
c_num = len(garland[node])
for i in range(c_num):
if garland[node][c_num-1-i]==None:
if len(avails)==0:
print(-1)
exit()
m = min(avails)
garland[node][c_num-1-i]=m
avails.remove(m)
print(a[0])
for p in garland.keys():
for c in garland[p]:
print(p,c)
``` | instruction | 0 | 69,969 | 24 | 139,938 |
No | output | 1 | 69,969 | 24 | 139,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
Submitted Solution:
```
n = int(input())
arr = list(map(int,input().split()))
d = {}
for i in range(len(arr)) :
if arr[i] not in d.keys() :
d[arr[i]] = 1
else :
d[arr[i]] +=1
c = {}
for i in d.keys() :
if d[i] not in c.keys() :
c[d[i]] = [i]
else :
c[d[i]].append(i)
z = list(c.keys())
champ = []
for i in range(len(z)) :
for j in c[z[i]] :
champ.append(j)
#print(champ)
q = len(champ)
#print(d)
visited = [False for i in range(n+1)]
for i in range(len(champ)) :
visited[champ[i]] = True
for i in range(1 , len(visited)) :
if visited[i] == False :
champ.append(i)
#print(champ)
deg = {}
for i in d.keys() :
deg[i] = 0
count = 0
idx = 1
print(champ[0])
for i in range(q) :
count = 0
while count < d[champ[i]] :
print(champ[idx] , champ[i])
count +=1
idx +=1
``` | instruction | 0 | 69,970 | 24 | 139,940 |
No | output | 1 | 69,970 | 24 | 139,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split()))
from collections import OrderedDict
pair_list=[]
leaf=[]
for i in range(1,n+1):
if i not in a:
leaf.append(i)
leaf = leaf[::-1]
garland_p = OrderedDict()
consistent = True
garland_p.update({a[0]:[None]})
for i in range(1,len(a)):
if a[i] not in garland_p.keys():
garland_p.update({a[i]:[None]})
else:
garland_p[a[i]].append(None)
if a[i] not in a[:i]:
found = False
for j in range(i):
proposal_p = a[j]
for index in range(len(garland_p[proposal_p])):
if garland_p[proposal_p][index]==None:
found=True
garland_p[proposal_p][index]=a[i]
break
if found:
break
if not found:
consistent=False
if consistent == False:
print(-1)
exit()
pointers = OrderedDict()
for p in garland_p.keys():
pointers.update({p:0})
for p in a:
if garland_p[p][pointers[p]]==None:
c = leaf[0]
if len(leaf)>1:
leaf = leaf[1:]
garland_p[p][pointers[p]]=c
pointers[p] +=1
for p in garland_p.keys():
for c in garland_p[p]:
print(p,c)
``` | instruction | 0 | 69,971 | 24 | 139,942 |
No | output | 1 | 69,971 | 24 | 139,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has decided to decorate his room because the New Year is soon. One of the main decorations that Polycarp will install is the garland he is going to solder himself.
Simple garlands consisting of several lamps connected by one wire are too boring for Polycarp. He is going to solder a garland consisting of n lamps and n - 1 wires. Exactly one lamp will be connected to power grid, and power will be transmitted from it to other lamps by the wires. Each wire connectes exactly two lamps; one lamp is called the main lamp for this wire (the one that gets power from some other wire and transmits it to this wire), the other one is called the auxiliary lamp (the one that gets power from this wire). Obviously, each lamp has at most one wire that brings power to it (and this lamp is the auxiliary lamp for this wire, and the main lamp for all other wires connected directly to it).
Each lamp has a brightness value associated with it, the i-th lamp has brightness 2^i. We define the importance of the wire as the sum of brightness values over all lamps that become disconnected from the grid if the wire is cut (and all other wires are still working).
Polycarp has drawn the scheme of the garland he wants to make (the scheme depicts all n lamp and n - 1 wires, and the lamp that will be connected directly to the grid is marked; the wires are placed in such a way that the power can be transmitted to each lamp). After that, Polycarp calculated the importance of each wire, enumerated them from 1 to n - 1 in descending order of their importance, and then wrote the index of the main lamp for each wire (in the order from the first wire to the last one).
The following day Polycarp bought all required components of the garland and decided to solder it — but he could not find the scheme. Fortunately, Polycarp found the list of indices of main lamps for all wires. Can you help him restore the original scheme?
Input
The first line contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of lamps.
The second line contains n - 1 integers a_1, a_2, ..., a_{n - 1} (1 ≤ a_i ≤ n), where a_i is the index of the main lamp for the i-th wire (wires are numbered in descending order of importance).
Output
If it is impossible to restore the original scheme, print one integer -1.
Otherwise print the scheme as follows. In the first line, print one integer k (1 ≤ k ≤ n) — the index of the lamp that is connected to the power grid. Then print n - 1 lines, each containing two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the indices of the lamps connected by some wire. The descriptions of the wires (and the lamps connected by a wire) can be printed in any order. The printed description must correspond to a scheme of a garland such that Polycarp could have written the list a_1, a_2, ..., a_{n - 1} from it. If there are multiple such schemes, output any of them.
Example
Input
6
3 6 3 1 5
Output
3
6 3
6 5
1 3
1 4
5 2
Note
The scheme for the first example (R denotes the lamp connected to the grid, the numbers on wires are their importance values):
<image>
Submitted Solution:
```
n = int(input())
a = [int(i) for i in input().split()]
g = dict()
for i in range(n):
g[i+1] = 2**(i + 1)
ed = []
root = -1
sl = set([i + 1 for i in range(n)])
while len(a) > 0:
if len(a) == 1:
root = a[0]
l = sl - set(a)
l = list(sorted(l))
ci = len(a) - 1
for x in l:
g[a[ci]] += g[x]
ed.append([a[ci], x])
a.pop(ci)
ci -= 1
sl -= set(l)
if root < 0:
print(-1)
else:
print(root)
for i in ed:
print(i[0], i[1])
``` | instruction | 0 | 69,972 | 24 | 139,944 |
No | output | 1 | 69,972 | 24 | 139,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8 | instruction | 0 | 70,418 | 24 | 140,836 |
Tags: greedy, math
Correct Solution:
```
x,y = map(int,input().split())
fx,fy = map(int,input().split())
ans = 0
if x == fx or y==fy :
ans=2
ans += abs(fx-x)*2 + abs(fy-y)*2 + 4
print(ans)
``` | output | 1 | 70,418 | 24 | 140,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8 | instruction | 0 | 70,419 | 24 | 140,838 |
Tags: greedy, math
Correct Solution:
```
def main():
x1,y1 = map(int,input().split())
x2,y2 = map(int,input().split())
res = (abs(x2-x1) + abs(y2 - y1) +2)*2
if x1==x2:
res +=2
if y1 == y2:
res +=2
print( res)
main()
``` | output | 1 | 70,419 | 24 | 140,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8 | instruction | 0 | 70,420 | 24 | 140,840 |
Tags: greedy, math
Correct Solution:
```
#!/usr/bin/env python3
def main():
x0, y0 = map(int, input().split())
x1, y1 = map(int, input().split())
print((max(abs(x1 - x0), 1) + max(abs(y1 - y0), 1)) * 2 + 4)
try:
while True:
main()
except EOFError:
pass
``` | output | 1 | 70,420 | 24 | 140,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8 | instruction | 0 | 70,421 | 24 | 140,842 |
Tags: greedy, math
Correct Solution:
```
x1, y1 = map(int, input().split())
x2, y2 = map(int, input().split())
if x1 == x2 and y1 != y2:
print(str(2*((abs(x2-x1)+2)+(abs(y2-y1)+1))))
if x1 != x2 and y1 == y2:
print(str(2*((abs(x2-x1)+1)+(abs(y2-y1)+2))))
if x1 != x2 and y1 != y2:
print(str(2*((abs(x2-x1)+1)+(abs(y2-y1)+1))))
if x1 == x2 and y1 == y2:
print(str(10))
``` | output | 1 | 70,421 | 24 | 140,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8 | instruction | 0 | 70,422 | 24 | 140,844 |
Tags: greedy, math
Correct Solution:
```
x,y=map(int,input().split())
p,q=map(int,input().split())
ans = (abs(x-p)+abs(y-q)+2)*2
if x==p or y==q: ans+=2
print(ans)
``` | output | 1 | 70,422 | 24 | 140,845 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8 | instruction | 0 | 70,423 | 24 | 140,846 |
Tags: greedy, math
Correct Solution:
```
x1,y1 = [i for i in map(int,(input().split()))]
x2,y2 = [i for i in map(int,(input().split()))]
#print(x1,x2,y1,y2)
if x1 == x2 or y1 == y2:
if x1==x2:
x1 +=1
if y1==y2:
y1 +=1
#print(y1)
x = x1-x2
y = y1-y2
#print(x,y)
if x<0:
x = -1*x
if y<0:
y = -1*y
x = 2*(x+1)
y = 2*(y+1)
print(x+y)
``` | output | 1 | 70,423 | 24 | 140,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8 | instruction | 0 | 70,424 | 24 | 140,848 |
Tags: greedy, math
Correct Solution:
```
f = lambda: map(int, input().split())
print(2 * sum(max(1, abs(a - b)) + 1 for a, b in zip(f(), f())))
``` | output | 1 | 70,424 | 24 | 140,849 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:
* start the race from some point of a field,
* go around the flag,
* close cycle returning back to the starting point.
Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).
Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.
<image> The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2).
What is the minimal length of the quadcopter path?
Input
The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point.
The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag.
It is guaranteed that the quadcopter starting point and the flag do not coincide.
Output
Print the length of minimal path of the quadcopter to surround the flag and return back.
Examples
Input
1 5
5 2
Output
18
Input
0 1
0 0
Output
8 | instruction | 0 | 70,425 | 24 | 140,850 |
Tags: greedy, math
Correct Solution:
```
lstIn = map(int, input().split())
x1, y1 = lstIn
lstIn = map(int, input().split())
x2, y2 = lstIn
dx = abs(x1-x2)
dy = abs(y1-y2)
if dx<2:
dx=2
else:
dx += 1
if dy<2:
dy=2
else:
dy += 1
dist = dx*2 + dy*2
print(dist)
``` | output | 1 | 70,425 | 24 | 140,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1. | instruction | 0 | 70,945 | 24 | 141,890 |
Tags: dp, graphs
Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 5)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(mi())
for _ in range(ii()):
n = ii()
a = li()
dp = [0 for i in range(n)]
for i in range(n - 1, -1, -1):
dp[i] = a[i]
if i + a[i] < n:
dp[i] += dp[i + a[i]]
print(max(dp))
``` | output | 1 | 70,945 | 24 | 141,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1. | instruction | 0 | 70,946 | 24 | 141,892 |
Tags: dp, graphs
Correct Solution:
```
t = int(input())
for j in range(t):
n = int(input())
a = list(map(int, input().split()))
c = [0] * n
for i in range(n - 1, -1, -1):
if i + a[i] < n:
c[i] = a[i] + c[i + a[i]]
else:
c[i] = a[i]
print(max(c))
``` | output | 1 | 70,946 | 24 | 141,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1. | instruction | 0 | 70,947 | 24 | 141,894 |
Tags: dp, graphs
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
dp = [0]*n
arr = list(map(int,input().split()))
i = n-1
while i>=0:
next_idx = i+arr[i]
if next_idx<n:
dp[i]+=dp[next_idx]
dp[i]+=arr[i]
i-=1
print(max(dp))
``` | output | 1 | 70,947 | 24 | 141,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1. | instruction | 0 | 70,948 | 24 | 141,896 |
Tags: dp, graphs
Correct Solution:
```
for t in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
for i in range(n-1,-1,-1):
if i+a[i]<n:
a[i]+=a[i+a[i]]
print(max(a))
``` | output | 1 | 70,948 | 24 | 141,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1. | instruction | 0 | 70,949 | 24 | 141,898 |
Tags: dp, graphs
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = a
for i in range(n-1, -1, -1):
if i + a[i]<n:
b[i] = a[i] + a[i+a[i]]
else:
b[i] = a[i]
print(max(b))
``` | output | 1 | 70,949 | 24 | 141,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1. | instruction | 0 | 70,950 | 24 | 141,900 |
Tags: dp, graphs
Correct Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
b=[]
[b.append(i) for i in a]
for i in range(n):
if i +a[i]<n:
b[i+a[i]]=max(b[i+a[i]],b[i]+a[i+a[i]])
print(max(b))
``` | output | 1 | 70,950 | 24 | 141,901 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1. | instruction | 0 | 70,951 | 24 | 141,902 |
Tags: dp, graphs
Correct Solution:
```
import sys
input = sys.stdin.readline
import math
import copy
import collections
from collections import deque
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
dp = [0]*n
for i in range(n):
ind = i+arr[i]
if ind<n:
dp[ind] = max(dp[ind],dp[i]+arr[i])
ans = 0
for i in range(n):
ans = max(ans,dp[i]+arr[i])
print(ans)
``` | output | 1 | 70,951 | 24 | 141,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1. | instruction | 0 | 70,952 | 24 | 141,904 |
Tags: dp, graphs
Correct Solution:
```
"""
___. .__ .__ .__ __ __ _________
_____ \_ |__ | |__ |__| _____| |__ ____ | | _| | __ \______ \
\__ \ | __ \| | \| |/ ___/ | \_/ __ \| |/ / |/ / / /
/ __ \| \_\ \ Y \ |\___ \| Y \ ___/| <| < / /
(____ /___ /___| /__/____ >___| /\___ >__|_ \__|_ \_____/____/
\/ \/ \/ \/ \/ \/ \/ \/_____/
"""
MOD = 1000000007
# from collections import defaultdict as dd,Counter,deque
def si(): return input()
def ii(): return int(input())
def li(): return list(map(int, input().split()))
def mi(): return map(int, input().split())
def sout(v): print(v, end=' ')
def d2b(n): return bin(n).replace("0b", "")
def twod(n, m, num): return [[num for x in range(m)] for y in range(n)]
def vow(): return ['a', 'e', 'i', 'o', 'u']
def let(): return [chr(i) for i in range(97, 123)]
def gcd(x, y):
while y:
x, y = y, x % y
return x
def ispow2(x):
return (x and (not (x & (x - 1))))
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i:
i += 1
else:
n //= i
factors.append(i)
if n > 1: factors.append(n)
return (list(factors))
def isPalindrome(s):
i=0
j=len(s)-1
while i<j:
if s[i]!=s[j]: return False
i+=1
j-=1
return True
t = ii()
while t:
t -= 1
n=ii()
a=li()
ans=-1
dp=[a[i] for i in range(n)]
for i in range(n-1,-1,-1):
if i+a[i]<n:
dp[i]+=dp[i+a[i]]
print(max(dp))
``` | output | 1 | 70,952 | 24 | 141,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1.
Submitted Solution:
```
def isPossible(arr, n):
j=0
for i in range(n-1,-1,-1):
if(arr[i]+i+1>n):
continue
else:
arr[i]+=arr[i+arr[i]]
return (max(arr))
for i in range(int(input())):
x=int(input())
y=(list(map(int,input().split())))
print(isPossible(y,len(y)))
``` | instruction | 0 | 70,953 | 24 | 141,906 |
Yes | output | 1 | 70,953 | 24 | 141,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
def main():
import bisect
import math
# import itertools
# import heapq
# from queue import PriorityQueue, LifoQueue, SimpleQueue
# import sys.stdout.flush() use for interactive problems
alpha = 'abcdefghijklmnopqrstuvwxyz'
ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
inf = 1e17
mod = 10 ** 9 + 7
Max = 10 ** 6
primes = []
prime = [True for i in range(Max + 1)]
p = 2
while (p * p <= Max + 1):
# If prime[p] is not
# changed, then it is a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * p, Max + 1, p):
prime[i] = False
p += 1
for p in range(2, Max + 1):
if prime[p]:
primes.append(p)
def factorial(n):
f = 1
for i in range(1, n + 1):
f = (f * i) % mod # Now f never can
# exceed 10^9+7
return f
def ncr(n, r):
# initialize numerator
# and denominator
num = den = 1
for i in range(r):
num = (num * (n - i)) % mod
den = (den * (i + 1)) % mod
return (num * pow(den,
mod - 2, mod)) % mod
def solve(n,arr):
dp = [0]*n
for i in range(n-1,-1,-1):
if i+arr[i] >= n:
dp[i] = arr[i]
else:
dp[i] += arr[i]+dp[i+arr[i]]
#print(dp)
return max(dp)
pass
t = int(input())
ans = []
for _ in range(t):
n = int(input())
# x = int(input())
# y = int(input())
# n,m = map(int, input().split())
arr = [int(x) for x in input().split()]
# arr = list(input())
# s = input()
# t = input()
# grid = []
# for i in range(n):
# grid.append([int(x) for x in input().split()])
# arr = []
# for j in range(n):
# arr.append(int(input()))
ans.append(solve(n,arr))
for j in range(len(ans)):
# print('Case #' + str(j + 1) + ": " + str(ans[j]))
print(ans[j])
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | instruction | 0 | 70,954 | 24 | 141,908 |
Yes | output | 1 | 70,954 | 24 | 141,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
a = [*map(int, input().split())]
b = a[:]
for i in range(n):
x = i+a[i]
try:
b[x] = max(b[x], b[i]+a[x])
except:
pass
print(max(b))
``` | instruction | 0 | 70,955 | 24 | 141,910 |
Yes | output | 1 | 70,955 | 24 | 141,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1.
Submitted Solution:
```
t = int(input())
while t:
n = int(input())
arr = list(map(int, input().split()))
arr2 = arr[::]
for i in range(n):
index = arr[i] + i
if index < n :
arr2[index] = max(arr2[index], arr[index] + arr2[i])
print(max(arr2))
t -= 1
``` | instruction | 0 | 70,956 | 24 | 141,912 |
Yes | output | 1 | 70,956 | 24 | 141,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1.
Submitted Solution:
```
import sys,os,io,time,copy,math
from collections import deque
if os.path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def main():
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
table={}
max_count=0
for i in range(n-1,-1,-1):
j=i
count=0
while j<n:
if j in table:
count+=table[j]
break
else:
count+=arr[j]
j+=arr[i]
table[i]=count
if count>max_count:
max_count=count
print(max_count)
print(table)
main()
``` | instruction | 0 | 70,957 | 24 | 141,914 |
No | output | 1 | 70,957 | 24 | 141,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1.
Submitted Solution:
```
def solver(arr, n):
score = [0 for i in range(n)]
for i in range(n):
sum = 0
j = n - 1 - i
while j < n:
if score[j] == 0:
sum += int(arr[j])
j += int(arr[j])
else:
sum += score[j]
break
# print(sum,j)
score[n - 1 - i] = sum
print("score:", score)
Max = max(score)
# print(score.index(Max) + 1)
print(Max)
c = int(input())
for i in range(c):
l = int(input())
arr = input().split()
solver(arr, l)
``` | instruction | 0 | 70,958 | 24 | 141,916 |
No | output | 1 | 70,958 | 24 | 141,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1.
Submitted Solution:
```
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math
from collections import defaultdict,Counter
for _ in range(ri()):
n=ri()
l=ria()
ans=0
x=[0 for _ in range(n)]
x[-1]=l[-1]
for i in range(n-2,-1,-1):
sc=l[i]
j=i+l[i]
if j<n:
sc+=x[j]
x[i]=sc
ans=max(ans,x[i])
wi(ans)
``` | instruction | 0 | 70,959 | 24 | 141,918 |
No | output | 1 | 70,959 | 24 | 141,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp found under the Christmas tree an array a of n elements and instructions for playing with it:
* At first, choose index i (1 ≤ i ≤ n) — starting position in the array. Put the chip at the index i (on the value a_i).
* While i ≤ n, add a_i to your score and move the chip a_i positions to the right (i.e. replace i with i + a_i).
* If i > n, then Polycarp ends the game.
For example, if n = 5 and a = [7, 3, 1, 2, 3], then the following game options are possible:
* Polycarp chooses i = 1. Game process: i = 1 \overset{+7}{\longrightarrow} 8. The score of the game is: a_1 = 7.
* Polycarp chooses i = 2. Game process: i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_2 + a_5 = 6.
* Polycarp chooses i = 3. Game process: i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_3 + a_4 = 3.
* Polycarp chooses i = 4. Game process: i = 4 \overset{+2}{\longrightarrow} 6. The score of the game is: a_4 = 2.
* Polycarp chooses i = 5. Game process: i = 5 \overset{+3}{\longrightarrow} 8. The score of the game is: a_5 = 3.
Help Polycarp to find out the maximum score he can get if he chooses the starting index in an optimal way.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The next line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — elements of the array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output on a separate line one number — the maximum score that Polycarp can get by playing the game on the corresponding array according to the instruction from the statement. Note that Polycarp chooses any starting position from 1 to n in such a way as to maximize his result.
Example
Input
4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1
Output
7
6
1000
5
Note
The first test case is explained in the statement.
In the second test case, the maximum score can be achieved by choosing i = 1.
In the third test case, the maximum score can be achieved by choosing i = 2.
In the fourth test case, the maximum score can be achieved by choosing i = 1.
Submitted Solution:
```
def solve(arr):
n = len(arr)
maks = [0 for _ in range(n)]
ans = [arr[i] for i in range(n)]
for i in range(n):
if i + arr[i] < n:
if maks[i + arr[i]] < ans[i]:
ans[i + arr[i]] -= maks[i + arr[i]]
ans[i + arr[i]] += ans[i]
maks[i + arr[i]] = arr[i]
return max(ans)
t = int(input())
while t:
t -= 1
n = int(input())
arr = list(map(int, input().split()))
print(solve(arr))
``` | instruction | 0 | 70,960 | 24 | 141,920 |
No | output | 1 | 70,960 | 24 | 141,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The problem uses a simplified TCP/IP address model, please make sure you've read the statement attentively.
Polycarpus has found a job, he is a system administrator. One day he came across n IP addresses. Each IP address is a 32 bit number, represented as a group of four 8-bit numbers (without leading zeroes), separated by dots. For example, the record 0.255.1.123 shows a correct IP address and records 0.256.1.123 and 0.255.1.01 do not. In this problem an arbitrary group of four 8-bit numbers is a correct IP address.
Having worked as an administrator for some time, Polycarpus learned that if you know the IP address, you can use the subnet mask to get the address of the network that has this IP addess.
The subnet mask is an IP address that has the following property: if we write this IP address as a 32 bit string, that it is representable as "11...11000..000". In other words, the subnet mask first has one or more one bits, and then one or more zero bits (overall there are 32 bits). For example, the IP address 2.0.0.0 is not a correct subnet mask as its 32-bit record looks as 00000010000000000000000000000000.
To get the network address of the IP address, you need to perform the operation of the bitwise "and" of the IP address and the subnet mask. For example, if the subnet mask is 255.192.0.0, and the IP address is 192.168.1.2, then the network address equals 192.128.0.0. In the bitwise "and" the result has a bit that equals 1 if and only if both operands have corresponding bits equal to one.
Now Polycarpus wants to find all networks to which his IP addresses belong. Unfortunately, Polycarpus lost subnet mask. Fortunately, Polycarpus remembers that his IP addresses belonged to exactly k distinct networks. Help Polycarpus find the subnet mask, such that his IP addresses will belong to exactly k distinct networks. If there are several such subnet masks, find the one whose bit record contains the least number of ones. If such subnet mask do not exist, say so.
Input
The first line contains two integers, n and k (1 ≤ k ≤ n ≤ 105) — the number of IP addresses and networks. The next n lines contain the IP addresses. It is guaranteed that all IP addresses are distinct.
Output
In a single line print the IP address of the subnet mask in the format that is described in the statement, if the required subnet mask exists. Otherwise, print -1.
Examples
Input
5 3
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.254.0
Input
5 2
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.0.0
Input
2 1
255.0.0.1
0.0.0.2
Output
-1 | instruction | 0 | 71,056 | 24 | 142,112 |
Tags: *special, bitmasks, brute force, implementation
Correct Solution:
```
def parse(ip_address):
a, b, c, d = [int(x) for x in ip_address.split('.')]
return (a << 24) | (b << 16) | (c << 8) | d
n, k = [int(x) for x in input().split()]
ips = [parse(input()) for i in range(n)]
all_ones = (1 << 32) - 1
eight_ones = (1 << 8) - 1
for n_zeros in range(31, 0, -1):
mask = all_ones << n_zeros
if len(set(mask & ip for ip in ips)) == k:
address = [(mask >> 24) & eight_ones, (mask >> 16) & eight_ones, (mask >> 8) & eight_ones, mask & eight_ones]
print('.'.join(str(x) for x in address))
exit(0)
print(-1)
``` | output | 1 | 71,056 | 24 | 142,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The problem uses a simplified TCP/IP address model, please make sure you've read the statement attentively.
Polycarpus has found a job, he is a system administrator. One day he came across n IP addresses. Each IP address is a 32 bit number, represented as a group of four 8-bit numbers (without leading zeroes), separated by dots. For example, the record 0.255.1.123 shows a correct IP address and records 0.256.1.123 and 0.255.1.01 do not. In this problem an arbitrary group of four 8-bit numbers is a correct IP address.
Having worked as an administrator for some time, Polycarpus learned that if you know the IP address, you can use the subnet mask to get the address of the network that has this IP addess.
The subnet mask is an IP address that has the following property: if we write this IP address as a 32 bit string, that it is representable as "11...11000..000". In other words, the subnet mask first has one or more one bits, and then one or more zero bits (overall there are 32 bits). For example, the IP address 2.0.0.0 is not a correct subnet mask as its 32-bit record looks as 00000010000000000000000000000000.
To get the network address of the IP address, you need to perform the operation of the bitwise "and" of the IP address and the subnet mask. For example, if the subnet mask is 255.192.0.0, and the IP address is 192.168.1.2, then the network address equals 192.128.0.0. In the bitwise "and" the result has a bit that equals 1 if and only if both operands have corresponding bits equal to one.
Now Polycarpus wants to find all networks to which his IP addresses belong. Unfortunately, Polycarpus lost subnet mask. Fortunately, Polycarpus remembers that his IP addresses belonged to exactly k distinct networks. Help Polycarpus find the subnet mask, such that his IP addresses will belong to exactly k distinct networks. If there are several such subnet masks, find the one whose bit record contains the least number of ones. If such subnet mask do not exist, say so.
Input
The first line contains two integers, n and k (1 ≤ k ≤ n ≤ 105) — the number of IP addresses and networks. The next n lines contain the IP addresses. It is guaranteed that all IP addresses are distinct.
Output
In a single line print the IP address of the subnet mask in the format that is described in the statement, if the required subnet mask exists. Otherwise, print -1.
Examples
Input
5 3
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.254.0
Input
5 2
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.0.0
Input
2 1
255.0.0.1
0.0.0.2
Output
-1 | instruction | 0 | 71,057 | 24 | 142,114 |
Tags: *special, bitmasks, brute force, implementation
Correct Solution:
```
import sys, io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
n, k = map(int, input().decode().split())
mvals = []
for _ in range(n):
x, y, z, w = map(int, input().decode().split('.'))
mvals.append((x << 24) | (y << 16) | (z << 8) | w)
mv = (1 << 32) - 1
for ind in range(31,0,-1):
st = set()
mask = mv - ((1 << ind) - 1)
for i in range(n):
st.add(mask & mvals[i])
if len(st) == k:
x, y, z, w = (mask >> 24), (mask >> 16) % 256, (mask >> 8) % 256, mask % 256
print(f"{str(x)}.{str(y)}.{str(z)}.{str(w)}")
exit()
print(-1)
``` | output | 1 | 71,057 | 24 | 142,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The problem uses a simplified TCP/IP address model, please make sure you've read the statement attentively.
Polycarpus has found a job, he is a system administrator. One day he came across n IP addresses. Each IP address is a 32 bit number, represented as a group of four 8-bit numbers (without leading zeroes), separated by dots. For example, the record 0.255.1.123 shows a correct IP address and records 0.256.1.123 and 0.255.1.01 do not. In this problem an arbitrary group of four 8-bit numbers is a correct IP address.
Having worked as an administrator for some time, Polycarpus learned that if you know the IP address, you can use the subnet mask to get the address of the network that has this IP addess.
The subnet mask is an IP address that has the following property: if we write this IP address as a 32 bit string, that it is representable as "11...11000..000". In other words, the subnet mask first has one or more one bits, and then one or more zero bits (overall there are 32 bits). For example, the IP address 2.0.0.0 is not a correct subnet mask as its 32-bit record looks as 00000010000000000000000000000000.
To get the network address of the IP address, you need to perform the operation of the bitwise "and" of the IP address and the subnet mask. For example, if the subnet mask is 255.192.0.0, and the IP address is 192.168.1.2, then the network address equals 192.128.0.0. In the bitwise "and" the result has a bit that equals 1 if and only if both operands have corresponding bits equal to one.
Now Polycarpus wants to find all networks to which his IP addresses belong. Unfortunately, Polycarpus lost subnet mask. Fortunately, Polycarpus remembers that his IP addresses belonged to exactly k distinct networks. Help Polycarpus find the subnet mask, such that his IP addresses will belong to exactly k distinct networks. If there are several such subnet masks, find the one whose bit record contains the least number of ones. If such subnet mask do not exist, say so.
Input
The first line contains two integers, n and k (1 ≤ k ≤ n ≤ 105) — the number of IP addresses and networks. The next n lines contain the IP addresses. It is guaranteed that all IP addresses are distinct.
Output
In a single line print the IP address of the subnet mask in the format that is described in the statement, if the required subnet mask exists. Otherwise, print -1.
Examples
Input
5 3
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.254.0
Input
5 2
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.0.0
Input
2 1
255.0.0.1
0.0.0.2
Output
-1 | instruction | 0 | 71,058 | 24 | 142,116 |
Tags: *special, bitmasks, brute force, implementation
Correct Solution:
```
import sys
n, k = map(int, input().split())
mvals = []
for _ in range(n):
x, y, z, w = map(int, input().split('.'))
mvals.append((x << 24) | (y << 16) | (z << 8) | w)
mv = (1 << 32) - 1
for ind in range(31,0,-1):
st = set()
mask = mv - ((1 << ind) - 1)
for i in range(n):
st.add(mask & mvals[i])
if len(st) == k:
x, y, z, w = (mask >> 24), (mask >> 16) % 256, (mask >> 8) % 256, mask % 256
print(f"{str(x)}.{str(y)}.{str(z)}.{str(w)}")
exit()
print(-1)
``` | output | 1 | 71,058 | 24 | 142,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The problem uses a simplified TCP/IP address model, please make sure you've read the statement attentively.
Polycarpus has found a job, he is a system administrator. One day he came across n IP addresses. Each IP address is a 32 bit number, represented as a group of four 8-bit numbers (without leading zeroes), separated by dots. For example, the record 0.255.1.123 shows a correct IP address and records 0.256.1.123 and 0.255.1.01 do not. In this problem an arbitrary group of four 8-bit numbers is a correct IP address.
Having worked as an administrator for some time, Polycarpus learned that if you know the IP address, you can use the subnet mask to get the address of the network that has this IP addess.
The subnet mask is an IP address that has the following property: if we write this IP address as a 32 bit string, that it is representable as "11...11000..000". In other words, the subnet mask first has one or more one bits, and then one or more zero bits (overall there are 32 bits). For example, the IP address 2.0.0.0 is not a correct subnet mask as its 32-bit record looks as 00000010000000000000000000000000.
To get the network address of the IP address, you need to perform the operation of the bitwise "and" of the IP address and the subnet mask. For example, if the subnet mask is 255.192.0.0, and the IP address is 192.168.1.2, then the network address equals 192.128.0.0. In the bitwise "and" the result has a bit that equals 1 if and only if both operands have corresponding bits equal to one.
Now Polycarpus wants to find all networks to which his IP addresses belong. Unfortunately, Polycarpus lost subnet mask. Fortunately, Polycarpus remembers that his IP addresses belonged to exactly k distinct networks. Help Polycarpus find the subnet mask, such that his IP addresses will belong to exactly k distinct networks. If there are several such subnet masks, find the one whose bit record contains the least number of ones. If such subnet mask do not exist, say so.
Input
The first line contains two integers, n and k (1 ≤ k ≤ n ≤ 105) — the number of IP addresses and networks. The next n lines contain the IP addresses. It is guaranteed that all IP addresses are distinct.
Output
In a single line print the IP address of the subnet mask in the format that is described in the statement, if the required subnet mask exists. Otherwise, print -1.
Examples
Input
5 3
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.254.0
Input
5 2
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.0.0
Input
2 1
255.0.0.1
0.0.0.2
Output
-1 | instruction | 0 | 71,059 | 24 | 142,118 |
Tags: *special, bitmasks, brute force, implementation
Correct Solution:
```
def f(t):
a, b, c, d = map(int, t.split('.'))
return d + (c << 8) + (b << 16) + (a << 24)
def g(x):
p = [0] * 4
for i in range(4):
p[3 - i] = str(x % 256)
x //= 256
return '.'.join(p)
n, k = map(int, input().split())
t = [f(input()) for i in range(n)]
p = [0] * n
x = 1 << 31
for i in range(32):
for j, y in enumerate(t):
if y & x: p[j] += x
if len(set(p)) >= k: break
x >>= 1
print(-1 if len(set(p)) != k else g((1 << 32) - x))
``` | output | 1 | 71,059 | 24 | 142,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The problem uses a simplified TCP/IP address model, please make sure you've read the statement attentively.
Polycarpus has found a job, he is a system administrator. One day he came across n IP addresses. Each IP address is a 32 bit number, represented as a group of four 8-bit numbers (without leading zeroes), separated by dots. For example, the record 0.255.1.123 shows a correct IP address and records 0.256.1.123 and 0.255.1.01 do not. In this problem an arbitrary group of four 8-bit numbers is a correct IP address.
Having worked as an administrator for some time, Polycarpus learned that if you know the IP address, you can use the subnet mask to get the address of the network that has this IP addess.
The subnet mask is an IP address that has the following property: if we write this IP address as a 32 bit string, that it is representable as "11...11000..000". In other words, the subnet mask first has one or more one bits, and then one or more zero bits (overall there are 32 bits). For example, the IP address 2.0.0.0 is not a correct subnet mask as its 32-bit record looks as 00000010000000000000000000000000.
To get the network address of the IP address, you need to perform the operation of the bitwise "and" of the IP address and the subnet mask. For example, if the subnet mask is 255.192.0.0, and the IP address is 192.168.1.2, then the network address equals 192.128.0.0. In the bitwise "and" the result has a bit that equals 1 if and only if both operands have corresponding bits equal to one.
Now Polycarpus wants to find all networks to which his IP addresses belong. Unfortunately, Polycarpus lost subnet mask. Fortunately, Polycarpus remembers that his IP addresses belonged to exactly k distinct networks. Help Polycarpus find the subnet mask, such that his IP addresses will belong to exactly k distinct networks. If there are several such subnet masks, find the one whose bit record contains the least number of ones. If such subnet mask do not exist, say so.
Input
The first line contains two integers, n and k (1 ≤ k ≤ n ≤ 105) — the number of IP addresses and networks. The next n lines contain the IP addresses. It is guaranteed that all IP addresses are distinct.
Output
In a single line print the IP address of the subnet mask in the format that is described in the statement, if the required subnet mask exists. Otherwise, print -1.
Examples
Input
5 3
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.254.0
Input
5 2
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.0.0
Input
2 1
255.0.0.1
0.0.0.2
Output
-1 | instruction | 0 | 71,060 | 24 | 142,120 |
Tags: *special, bitmasks, brute force, implementation
Correct Solution:
```
import math
import re
from fractions import Fraction
from collections import Counter
class Task:
ips = []
k = 0
answer = ''
def __init__(self):
n, self.k = [int(x) for x in input().split()]
self.ips = ['' for _ in range(n)]
for i in range(len(self.ips)):
self.ips[i] = input()
def solve(self):
ips, k = self.ips, self.k
ipAsNumbers = []
for currentIp in ips:
number = 0
parts = currentIp.split('.')
for i in range(0, len(parts)):
number += int(parts[i]) * 2**(32 - (i + 1) * 8)
ipAsNumbers += [number]
mask = 0
for i in range(31, -1, -1):
mask += 2**i
netAddresses = set()
for ip in ipAsNumbers:
netAddresses.add(mask & ip)
if len(netAddresses) == k:
mask = bin(mask)[2:]
self.answer = '.'.join([str(int(mask[i : i + 8], 2)) \
for i in range(0, len(mask), 8)])
return
self.answer = '-1'
def printAnswer(self):
print(self.answer)
#for line in self.answer:
# print(line)
task = Task()
task.solve()
task.printAnswer()
``` | output | 1 | 71,060 | 24 | 142,121 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The problem uses a simplified TCP/IP address model, please make sure you've read the statement attentively.
Polycarpus has found a job, he is a system administrator. One day he came across n IP addresses. Each IP address is a 32 bit number, represented as a group of four 8-bit numbers (without leading zeroes), separated by dots. For example, the record 0.255.1.123 shows a correct IP address and records 0.256.1.123 and 0.255.1.01 do not. In this problem an arbitrary group of four 8-bit numbers is a correct IP address.
Having worked as an administrator for some time, Polycarpus learned that if you know the IP address, you can use the subnet mask to get the address of the network that has this IP addess.
The subnet mask is an IP address that has the following property: if we write this IP address as a 32 bit string, that it is representable as "11...11000..000". In other words, the subnet mask first has one or more one bits, and then one or more zero bits (overall there are 32 bits). For example, the IP address 2.0.0.0 is not a correct subnet mask as its 32-bit record looks as 00000010000000000000000000000000.
To get the network address of the IP address, you need to perform the operation of the bitwise "and" of the IP address and the subnet mask. For example, if the subnet mask is 255.192.0.0, and the IP address is 192.168.1.2, then the network address equals 192.128.0.0. In the bitwise "and" the result has a bit that equals 1 if and only if both operands have corresponding bits equal to one.
Now Polycarpus wants to find all networks to which his IP addresses belong. Unfortunately, Polycarpus lost subnet mask. Fortunately, Polycarpus remembers that his IP addresses belonged to exactly k distinct networks. Help Polycarpus find the subnet mask, such that his IP addresses will belong to exactly k distinct networks. If there are several such subnet masks, find the one whose bit record contains the least number of ones. If such subnet mask do not exist, say so.
Input
The first line contains two integers, n and k (1 ≤ k ≤ n ≤ 105) — the number of IP addresses and networks. The next n lines contain the IP addresses. It is guaranteed that all IP addresses are distinct.
Output
In a single line print the IP address of the subnet mask in the format that is described in the statement, if the required subnet mask exists. Otherwise, print -1.
Examples
Input
5 3
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.254.0
Input
5 2
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.0.0
Input
2 1
255.0.0.1
0.0.0.2
Output
-1
Submitted Solution:
```
n,k=map(int,input().split())
IP=[]
for i in range(n):
S=input()
Result=[]
Temp=""
for i in S:
if i==".":
Result.append(int(Temp))
Temp=""
else:
Temp+=i
Result.append(int(Temp))
IP.append(Result)
Mask=[0]*4
Mask[0]=128
Result=set()
Answer=""
for c in range(4):
for j in range(7,-1,-1):
for i in IP:
A=(i[0] & Mask[0], i[1] & Mask[1], i[2] & Mask[2], i[3] & Mask[3])
Result.add(A)
if len(Result)==k:
print(Mask[0], Mask[1], Mask[2], Mask[3],sep=".")
exit()
if c==0 and j==7:
continue
else:
Mask[c]+=(2**j)
print(-1)
``` | instruction | 0 | 71,061 | 24 | 142,122 |
No | output | 1 | 71,061 | 24 | 142,123 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The problem uses a simplified TCP/IP address model, please make sure you've read the statement attentively.
Polycarpus has found a job, he is a system administrator. One day he came across n IP addresses. Each IP address is a 32 bit number, represented as a group of four 8-bit numbers (without leading zeroes), separated by dots. For example, the record 0.255.1.123 shows a correct IP address and records 0.256.1.123 and 0.255.1.01 do not. In this problem an arbitrary group of four 8-bit numbers is a correct IP address.
Having worked as an administrator for some time, Polycarpus learned that if you know the IP address, you can use the subnet mask to get the address of the network that has this IP addess.
The subnet mask is an IP address that has the following property: if we write this IP address as a 32 bit string, that it is representable as "11...11000..000". In other words, the subnet mask first has one or more one bits, and then one or more zero bits (overall there are 32 bits). For example, the IP address 2.0.0.0 is not a correct subnet mask as its 32-bit record looks as 00000010000000000000000000000000.
To get the network address of the IP address, you need to perform the operation of the bitwise "and" of the IP address and the subnet mask. For example, if the subnet mask is 255.192.0.0, and the IP address is 192.168.1.2, then the network address equals 192.128.0.0. In the bitwise "and" the result has a bit that equals 1 if and only if both operands have corresponding bits equal to one.
Now Polycarpus wants to find all networks to which his IP addresses belong. Unfortunately, Polycarpus lost subnet mask. Fortunately, Polycarpus remembers that his IP addresses belonged to exactly k distinct networks. Help Polycarpus find the subnet mask, such that his IP addresses will belong to exactly k distinct networks. If there are several such subnet masks, find the one whose bit record contains the least number of ones. If such subnet mask do not exist, say so.
Input
The first line contains two integers, n and k (1 ≤ k ≤ n ≤ 105) — the number of IP addresses and networks. The next n lines contain the IP addresses. It is guaranteed that all IP addresses are distinct.
Output
In a single line print the IP address of the subnet mask in the format that is described in the statement, if the required subnet mask exists. Otherwise, print -1.
Examples
Input
5 3
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.254.0
Input
5 2
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.0.0
Input
2 1
255.0.0.1
0.0.0.2
Output
-1
Submitted Solution:
```
import sys
n, k = map(int, input().split())
mvals = []
for _ in range(n):
x, y, z, w = map(int, input().split('.'))
mvals.append((x << 24) | (y << 16) | (z << 8) | w)
mv = (1 << 32) - 1
for ind in range(31,-1,-1):
st = set()
mask = mv - ((1 << ind) - 1)
for i in range(n):
st.add(mask & mvals[i])
if len(st) == k:
x, y, z, w = (mask >> 24), (mask >> 16) % 256, (mask >> 8) % 256, mask % 256
print(f"{str(x)}.{str(y)}.{str(z)}.{str(w)}")
exit()
print(-1)
``` | instruction | 0 | 71,062 | 24 | 142,124 |
No | output | 1 | 71,062 | 24 | 142,125 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The problem uses a simplified TCP/IP address model, please make sure you've read the statement attentively.
Polycarpus has found a job, he is a system administrator. One day he came across n IP addresses. Each IP address is a 32 bit number, represented as a group of four 8-bit numbers (without leading zeroes), separated by dots. For example, the record 0.255.1.123 shows a correct IP address and records 0.256.1.123 and 0.255.1.01 do not. In this problem an arbitrary group of four 8-bit numbers is a correct IP address.
Having worked as an administrator for some time, Polycarpus learned that if you know the IP address, you can use the subnet mask to get the address of the network that has this IP addess.
The subnet mask is an IP address that has the following property: if we write this IP address as a 32 bit string, that it is representable as "11...11000..000". In other words, the subnet mask first has one or more one bits, and then one or more zero bits (overall there are 32 bits). For example, the IP address 2.0.0.0 is not a correct subnet mask as its 32-bit record looks as 00000010000000000000000000000000.
To get the network address of the IP address, you need to perform the operation of the bitwise "and" of the IP address and the subnet mask. For example, if the subnet mask is 255.192.0.0, and the IP address is 192.168.1.2, then the network address equals 192.128.0.0. In the bitwise "and" the result has a bit that equals 1 if and only if both operands have corresponding bits equal to one.
Now Polycarpus wants to find all networks to which his IP addresses belong. Unfortunately, Polycarpus lost subnet mask. Fortunately, Polycarpus remembers that his IP addresses belonged to exactly k distinct networks. Help Polycarpus find the subnet mask, such that his IP addresses will belong to exactly k distinct networks. If there are several such subnet masks, find the one whose bit record contains the least number of ones. If such subnet mask do not exist, say so.
Input
The first line contains two integers, n and k (1 ≤ k ≤ n ≤ 105) — the number of IP addresses and networks. The next n lines contain the IP addresses. It is guaranteed that all IP addresses are distinct.
Output
In a single line print the IP address of the subnet mask in the format that is described in the statement, if the required subnet mask exists. Otherwise, print -1.
Examples
Input
5 3
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.254.0
Input
5 2
0.0.0.1
0.1.1.2
0.0.2.1
0.1.1.0
0.0.2.3
Output
255.255.0.0
Input
2 1
255.0.0.1
0.0.0.2
Output
-1
Submitted Solution:
```
import math
import re
from fractions import Fraction
from collections import Counter
class Task:
ips = []
k = 0
answer = ''
def __init__(self):
n, self.k = [int(x) for x in input().split()]
self.ips = ['' for _ in range(n)]
for i in range(len(self.ips)):
self.ips[i] = input()
def solve(self):
ips, k = self.ips, self.k
ipAsNumbers = []
for currentIp in ips:
number = 0
parts = currentIp.split('.')
for i in range(0, len(parts)):
number += int(parts[i]) * 2**(32 - (i + 1) * 8)
ipAsNumbers += [number]
mask = 0
for i in range(31, -1, -1):
mask += 2**i
netAddresses = set()
for ip in ipAsNumbers:
netAddresses.add(mask & ip)
if len(netAddresses) == k:
mask = bin(mask)[2:]
self.answer = '.'.join([str(int(mask[i : i + 8], 2)) \
for i in range(0, len(mask), 8)])
return
self.answer = '-1'
def printAnswer(self):
print(self.answer)
#for line in self.answer:
# print(line)
task = Task()
task.solve()
task.printAnswer()
# Made By Mostafa_Khaled
``` | instruction | 0 | 71,063 | 24 | 142,126 |
No | output | 1 | 71,063 | 24 | 142,127 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.