text stringlengths 1.02k 43.5k | conversation_id int64 853 107k | embedding list | cluster int64 24 24 |
|---|---|---|---|
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)
```
No
| 69,870 | [
0.50146484375,
0.157958984375,
0.2181396484375,
0.2183837890625,
-0.6513671875,
-0.182861328125,
-0.475341796875,
0.2093505859375,
0.135498046875,
0.66796875,
0.73046875,
-0.129150390625,
-0.106201171875,
-1.1513671875,
-0.52197265625,
-0.15625,
-0.31298828125,
-0.374755859375,
-... | 24 |
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='')
```
No
| 69,871 | [
0.55615234375,
0.1468505859375,
0.28369140625,
0.1949462890625,
-0.66796875,
-0.1910400390625,
-0.5390625,
0.1822509765625,
0.184326171875,
0.64990234375,
0.74609375,
-0.163818359375,
-0.154052734375,
-1.083984375,
-0.4912109375,
-0.1722412109375,
-0.296142578125,
-0.325927734375,
... | 24 |
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>
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)
```
| 69,957 | [
0.2841796875,
-0.343505859375,
-0.17919921875,
0.05438232421875,
-0.61279296875,
-0.578125,
-0.0833740234375,
-0.220703125,
0.5732421875,
0.5849609375,
0.78564453125,
-0.3857421875,
0.0810546875,
-0.73876953125,
-0.492919921875,
0.2861328125,
-0.58154296875,
-0.49169921875,
-0.75... | 24 |
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>
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
```
| 69,958 | [
0.2841796875,
-0.343505859375,
-0.17919921875,
0.05438232421875,
-0.61279296875,
-0.578125,
-0.0833740234375,
-0.220703125,
0.5732421875,
0.5849609375,
0.78564453125,
-0.3857421875,
0.0810546875,
-0.73876953125,
-0.492919921875,
0.2861328125,
-0.58154296875,
-0.49169921875,
-0.75... | 24 |
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>
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}")
```
| 69,959 | [
0.2841796875,
-0.343505859375,
-0.17919921875,
0.05438232421875,
-0.61279296875,
-0.578125,
-0.0833740234375,
-0.220703125,
0.5732421875,
0.5849609375,
0.78564453125,
-0.3857421875,
0.0810546875,
-0.73876953125,
-0.492919921875,
0.2861328125,
-0.58154296875,
-0.49169921875,
-0.75... | 24 |
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>
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)
```
| 69,960 | [
0.2841796875,
-0.343505859375,
-0.17919921875,
0.05438232421875,
-0.61279296875,
-0.578125,
-0.0833740234375,
-0.220703125,
0.5732421875,
0.5849609375,
0.78564453125,
-0.3857421875,
0.0810546875,
-0.73876953125,
-0.492919921875,
0.2861328125,
-0.58154296875,
-0.49169921875,
-0.75... | 24 |
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>
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))
```
| 69,961 | [
0.2841796875,
-0.343505859375,
-0.17919921875,
0.05438232421875,
-0.61279296875,
-0.578125,
-0.0833740234375,
-0.220703125,
0.5732421875,
0.5849609375,
0.78564453125,
-0.3857421875,
0.0810546875,
-0.73876953125,
-0.492919921875,
0.2861328125,
-0.58154296875,
-0.49169921875,
-0.75... | 24 |
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>
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()
```
| 69,962 | [
0.2841796875,
-0.343505859375,
-0.17919921875,
0.05438232421875,
-0.61279296875,
-0.578125,
-0.0833740234375,
-0.220703125,
0.5732421875,
0.5849609375,
0.78564453125,
-0.3857421875,
0.0810546875,
-0.73876953125,
-0.492919921875,
0.2861328125,
-0.58154296875,
-0.49169921875,
-0.75... | 24 |
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>
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)
```
| 69,963 | [
0.2841796875,
-0.343505859375,
-0.17919921875,
0.05438232421875,
-0.61279296875,
-0.578125,
-0.0833740234375,
-0.220703125,
0.5732421875,
0.5849609375,
0.78564453125,
-0.3857421875,
0.0810546875,
-0.73876953125,
-0.492919921875,
0.2861328125,
-0.58154296875,
-0.49169921875,
-0.75... | 24 |
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>
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])
```
| 69,964 | [
0.2841796875,
-0.343505859375,
-0.17919921875,
0.05438232421875,
-0.61279296875,
-0.578125,
-0.0833740234375,
-0.220703125,
0.5732421875,
0.5849609375,
0.78564453125,
-0.3857421875,
0.0810546875,
-0.73876953125,
-0.492919921875,
0.2861328125,
-0.58154296875,
-0.49169921875,
-0.75... | 24 |
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()
```
Yes
| 69,965 | [
0.387451171875,
-0.2685546875,
-0.23876953125,
0.10662841796875,
-0.6513671875,
-0.438232421875,
-0.09649658203125,
-0.21337890625,
0.5322265625,
0.55029296875,
0.701171875,
-0.34130859375,
0.056732177734375,
-0.73388671875,
-0.467041015625,
0.199462890625,
-0.478515625,
-0.4670410... | 24 |
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()
```
Yes
| 69,966 | [
0.387451171875,
-0.2685546875,
-0.23876953125,
0.10662841796875,
-0.6513671875,
-0.438232421875,
-0.09649658203125,
-0.21337890625,
0.5322265625,
0.55029296875,
0.701171875,
-0.34130859375,
0.056732177734375,
-0.73388671875,
-0.467041015625,
0.199462890625,
-0.478515625,
-0.4670410... | 24 |
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}")
```
Yes
| 69,967 | [
0.387451171875,
-0.2685546875,
-0.23876953125,
0.10662841796875,
-0.6513671875,
-0.438232421875,
-0.09649658203125,
-0.21337890625,
0.5322265625,
0.55029296875,
0.701171875,
-0.34130859375,
0.056732177734375,
-0.73388671875,
-0.467041015625,
0.199462890625,
-0.478515625,
-0.4670410... | 24 |
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))
```
Yes
| 69,968 | [
0.387451171875,
-0.2685546875,
-0.23876953125,
0.10662841796875,
-0.6513671875,
-0.438232421875,
-0.09649658203125,
-0.21337890625,
0.5322265625,
0.55029296875,
0.701171875,
-0.34130859375,
0.056732177734375,
-0.73388671875,
-0.467041015625,
0.199462890625,
-0.478515625,
-0.4670410... | 24 |
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)
```
No
| 69,969 | [
0.387451171875,
-0.2685546875,
-0.23876953125,
0.10662841796875,
-0.6513671875,
-0.438232421875,
-0.09649658203125,
-0.21337890625,
0.5322265625,
0.55029296875,
0.701171875,
-0.34130859375,
0.056732177734375,
-0.73388671875,
-0.467041015625,
0.199462890625,
-0.478515625,
-0.4670410... | 24 |
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
```
No
| 69,970 | [
0.387451171875,
-0.2685546875,
-0.23876953125,
0.10662841796875,
-0.6513671875,
-0.438232421875,
-0.09649658203125,
-0.21337890625,
0.5322265625,
0.55029296875,
0.701171875,
-0.34130859375,
0.056732177734375,
-0.73388671875,
-0.467041015625,
0.199462890625,
-0.478515625,
-0.4670410... | 24 |
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)
```
No
| 69,971 | [
0.387451171875,
-0.2685546875,
-0.23876953125,
0.10662841796875,
-0.6513671875,
-0.438232421875,
-0.09649658203125,
-0.21337890625,
0.5322265625,
0.55029296875,
0.701171875,
-0.34130859375,
0.056732177734375,
-0.73388671875,
-0.467041015625,
0.199462890625,
-0.478515625,
-0.4670410... | 24 |
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])
```
No
| 69,972 | [
0.387451171875,
-0.2685546875,
-0.23876953125,
0.10662841796875,
-0.6513671875,
-0.438232421875,
-0.09649658203125,
-0.21337890625,
0.5322265625,
0.55029296875,
0.701171875,
-0.34130859375,
0.056732177734375,
-0.73388671875,
-0.467041015625,
0.199462890625,
-0.478515625,
-0.4670410... | 24 |
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
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)
```
| 70,418 | [
0.4248046875,
-0.019317626953125,
0.1396484375,
0.350830078125,
-0.1341552734375,
-0.10577392578125,
-0.312744140625,
-0.020111083984375,
0.249267578125,
0.80419921875,
0.58349609375,
0.1663818359375,
-0.083740234375,
-0.578125,
-0.1875,
0.01293182373046875,
-0.315673828125,
-0.652... | 24 |
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
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()
```
| 70,419 | [
0.4248046875,
-0.0076446533203125,
0.11602783203125,
0.33837890625,
-0.1280517578125,
-0.06781005859375,
-0.33544921875,
-0.037628173828125,
0.288330078125,
0.7919921875,
0.58544921875,
0.12164306640625,
-0.089111328125,
-0.56689453125,
-0.2034912109375,
0.0106353759765625,
-0.334228... | 24 |
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
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
```
| 70,420 | [
0.443115234375,
-0.039642333984375,
0.1068115234375,
0.331298828125,
-0.1387939453125,
-0.0804443359375,
-0.32373046875,
-0.0621337890625,
0.2998046875,
0.77783203125,
0.54833984375,
0.09088134765625,
-0.071533203125,
-0.5205078125,
-0.201416015625,
0.0010881423950195312,
-0.35083007... | 24 |
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
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))
```
| 70,421 | [
0.418701171875,
-0.0013780593872070312,
0.11053466796875,
0.342041015625,
-0.12469482421875,
-0.0863037109375,
-0.327880859375,
-0.0489501953125,
0.28515625,
0.8046875,
0.59228515625,
0.1182861328125,
-0.055908203125,
-0.60302734375,
-0.193603515625,
-0.0239105224609375,
-0.340087890... | 24 |
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
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)
```
| 70,422 | [
0.42041015625,
-0.007450103759765625,
0.123046875,
0.329833984375,
-0.1209716796875,
-0.0965576171875,
-0.345703125,
-0.0248260498046875,
0.27734375,
0.8125,
0.59423828125,
0.1368408203125,
-0.08197021484375,
-0.59326171875,
-0.1993408203125,
0.01316070556640625,
-0.32958984375,
-0... | 24 |
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
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)
```
| 70,423 | [
0.419921875,
-0.02301025390625,
0.1334228515625,
0.34716796875,
-0.11590576171875,
-0.09185791015625,
-0.353271484375,
-0.037353515625,
0.288818359375,
0.8017578125,
0.6015625,
0.1146240234375,
-0.058349609375,
-0.57373046875,
-0.2081298828125,
0.00347900390625,
-0.337646484375,
-0... | 24 |
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
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())))
```
| 70,424 | [
0.406005859375,
0.0198822021484375,
0.1322021484375,
0.397705078125,
-0.09490966796875,
-0.05364990234375,
-0.3671875,
-0.0173492431640625,
0.25390625,
0.76904296875,
0.60693359375,
0.10986328125,
-0.11761474609375,
-0.55615234375,
-0.2470703125,
0.0218048095703125,
-0.314208984375,
... | 24 |
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
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)
```
| 70,425 | [
0.46044921875,
0.055694580078125,
0.1666259765625,
0.32861328125,
-0.1632080078125,
-0.04718017578125,
-0.353759765625,
-0.0589599609375,
0.2149658203125,
0.82568359375,
0.5673828125,
0.164794921875,
-0.11004638671875,
-0.5595703125,
-0.2197265625,
-0.00028634071350097656,
-0.328125,... | 24 |
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.
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))
```
| 70,945 | [
0.1983642578125,
0.2061767578125,
0.33740234375,
0.09503173828125,
-0.32568359375,
-0.72998046875,
-0.371826171875,
0.06671142578125,
0.223388671875,
0.80712890625,
1.0498046875,
-0.16650390625,
0.1439208984375,
-0.84375,
-0.42333984375,
0.34375,
-0.72900390625,
-0.892578125,
-0.... | 24 |
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.
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))
```
| 70,946 | [
0.1983642578125,
0.2061767578125,
0.33740234375,
0.09503173828125,
-0.32568359375,
-0.72998046875,
-0.371826171875,
0.06671142578125,
0.223388671875,
0.80712890625,
1.0498046875,
-0.16650390625,
0.1439208984375,
-0.84375,
-0.42333984375,
0.34375,
-0.72900390625,
-0.892578125,
-0.... | 24 |
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.
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))
```
| 70,947 | [
0.1983642578125,
0.2061767578125,
0.33740234375,
0.09503173828125,
-0.32568359375,
-0.72998046875,
-0.371826171875,
0.06671142578125,
0.223388671875,
0.80712890625,
1.0498046875,
-0.16650390625,
0.1439208984375,
-0.84375,
-0.42333984375,
0.34375,
-0.72900390625,
-0.892578125,
-0.... | 24 |
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.
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))
```
| 70,948 | [
0.1983642578125,
0.2061767578125,
0.33740234375,
0.09503173828125,
-0.32568359375,
-0.72998046875,
-0.371826171875,
0.06671142578125,
0.223388671875,
0.80712890625,
1.0498046875,
-0.16650390625,
0.1439208984375,
-0.84375,
-0.42333984375,
0.34375,
-0.72900390625,
-0.892578125,
-0.... | 24 |
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.
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))
```
| 70,949 | [
0.1983642578125,
0.2061767578125,
0.33740234375,
0.09503173828125,
-0.32568359375,
-0.72998046875,
-0.371826171875,
0.06671142578125,
0.223388671875,
0.80712890625,
1.0498046875,
-0.16650390625,
0.1439208984375,
-0.84375,
-0.42333984375,
0.34375,
-0.72900390625,
-0.892578125,
-0.... | 24 |
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.
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))
```
| 70,950 | [
0.1983642578125,
0.2061767578125,
0.33740234375,
0.09503173828125,
-0.32568359375,
-0.72998046875,
-0.371826171875,
0.06671142578125,
0.223388671875,
0.80712890625,
1.0498046875,
-0.16650390625,
0.1439208984375,
-0.84375,
-0.42333984375,
0.34375,
-0.72900390625,
-0.892578125,
-0.... | 24 |
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.
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)
```
| 70,951 | [
0.1983642578125,
0.2061767578125,
0.33740234375,
0.09503173828125,
-0.32568359375,
-0.72998046875,
-0.371826171875,
0.06671142578125,
0.223388671875,
0.80712890625,
1.0498046875,
-0.16650390625,
0.1439208984375,
-0.84375,
-0.42333984375,
0.34375,
-0.72900390625,
-0.892578125,
-0.... | 24 |
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.
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))
```
| 70,952 | [
0.1983642578125,
0.2061767578125,
0.33740234375,
0.09503173828125,
-0.32568359375,
-0.72998046875,
-0.371826171875,
0.06671142578125,
0.223388671875,
0.80712890625,
1.0498046875,
-0.16650390625,
0.1439208984375,
-0.84375,
-0.42333984375,
0.34375,
-0.72900390625,
-0.892578125,
-0.... | 24 |
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)))
```
Yes
| 70,953 | [
0.260986328125,
0.267578125,
0.316162109375,
0.086181640625,
-0.392822265625,
-0.5537109375,
-0.5205078125,
0.0780029296875,
0.18603515625,
0.74609375,
1.0068359375,
-0.148193359375,
0.07904052734375,
-0.78955078125,
-0.40234375,
0.28125,
-0.61962890625,
-0.802734375,
-0.47167968... | 24 |
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()
```
Yes
| 70,954 | [
0.260986328125,
0.267578125,
0.316162109375,
0.086181640625,
-0.392822265625,
-0.5537109375,
-0.5205078125,
0.0780029296875,
0.18603515625,
0.74609375,
1.0068359375,
-0.148193359375,
0.07904052734375,
-0.78955078125,
-0.40234375,
0.28125,
-0.61962890625,
-0.802734375,
-0.47167968... | 24 |
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))
```
Yes
| 70,955 | [
0.260986328125,
0.267578125,
0.316162109375,
0.086181640625,
-0.392822265625,
-0.5537109375,
-0.5205078125,
0.0780029296875,
0.18603515625,
0.74609375,
1.0068359375,
-0.148193359375,
0.07904052734375,
-0.78955078125,
-0.40234375,
0.28125,
-0.61962890625,
-0.802734375,
-0.47167968... | 24 |
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
```
Yes
| 70,956 | [
0.260986328125,
0.267578125,
0.316162109375,
0.086181640625,
-0.392822265625,
-0.5537109375,
-0.5205078125,
0.0780029296875,
0.18603515625,
0.74609375,
1.0068359375,
-0.148193359375,
0.07904052734375,
-0.78955078125,
-0.40234375,
0.28125,
-0.61962890625,
-0.802734375,
-0.47167968... | 24 |
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()
```
No
| 70,957 | [
0.260986328125,
0.267578125,
0.316162109375,
0.086181640625,
-0.392822265625,
-0.5537109375,
-0.5205078125,
0.0780029296875,
0.18603515625,
0.74609375,
1.0068359375,
-0.148193359375,
0.07904052734375,
-0.78955078125,
-0.40234375,
0.28125,
-0.61962890625,
-0.802734375,
-0.47167968... | 24 |
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)
```
No
| 70,958 | [
0.260986328125,
0.267578125,
0.316162109375,
0.086181640625,
-0.392822265625,
-0.5537109375,
-0.5205078125,
0.0780029296875,
0.18603515625,
0.74609375,
1.0068359375,
-0.148193359375,
0.07904052734375,
-0.78955078125,
-0.40234375,
0.28125,
-0.61962890625,
-0.802734375,
-0.47167968... | 24 |
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)
```
No
| 70,959 | [
0.260986328125,
0.267578125,
0.316162109375,
0.086181640625,
-0.392822265625,
-0.5537109375,
-0.5205078125,
0.0780029296875,
0.18603515625,
0.74609375,
1.0068359375,
-0.148193359375,
0.07904052734375,
-0.78955078125,
-0.40234375,
0.28125,
-0.61962890625,
-0.802734375,
-0.47167968... | 24 |
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))
```
No
| 70,960 | [
0.260986328125,
0.267578125,
0.316162109375,
0.086181640625,
-0.392822265625,
-0.5537109375,
-0.5205078125,
0.0780029296875,
0.18603515625,
0.74609375,
1.0068359375,
-0.148193359375,
0.07904052734375,
-0.78955078125,
-0.40234375,
0.28125,
-0.61962890625,
-0.802734375,
-0.47167968... | 24 |
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
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)
```
| 71,056 | [
0.380126953125,
-0.00688934326171875,
-0.0816650390625,
0.0048980712890625,
-0.25244140625,
-0.418701171875,
-0.10595703125,
-0.10687255859375,
0.3505859375,
0.9052734375,
0.60986328125,
-0.1761474609375,
0.430908203125,
-0.6484375,
-0.70849609375,
0.288330078125,
-0.27880859375,
-... | 24 |
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
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)
```
| 71,057 | [
0.380126953125,
-0.00688934326171875,
-0.0816650390625,
0.0048980712890625,
-0.25244140625,
-0.418701171875,
-0.10595703125,
-0.10687255859375,
0.3505859375,
0.9052734375,
0.60986328125,
-0.1761474609375,
0.430908203125,
-0.6484375,
-0.70849609375,
0.288330078125,
-0.27880859375,
-... | 24 |
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
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)
```
| 71,058 | [
0.380126953125,
-0.00688934326171875,
-0.0816650390625,
0.0048980712890625,
-0.25244140625,
-0.418701171875,
-0.10595703125,
-0.10687255859375,
0.3505859375,
0.9052734375,
0.60986328125,
-0.1761474609375,
0.430908203125,
-0.6484375,
-0.70849609375,
0.288330078125,
-0.27880859375,
-... | 24 |
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
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))
```
| 71,059 | [
0.380126953125,
-0.00688934326171875,
-0.0816650390625,
0.0048980712890625,
-0.25244140625,
-0.418701171875,
-0.10595703125,
-0.10687255859375,
0.3505859375,
0.9052734375,
0.60986328125,
-0.1761474609375,
0.430908203125,
-0.6484375,
-0.70849609375,
0.288330078125,
-0.27880859375,
-... | 24 |
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
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()
```
| 71,060 | [
0.380126953125,
-0.00688934326171875,
-0.0816650390625,
0.0048980712890625,
-0.25244140625,
-0.418701171875,
-0.10595703125,
-0.10687255859375,
0.3505859375,
0.9052734375,
0.60986328125,
-0.1761474609375,
0.430908203125,
-0.6484375,
-0.70849609375,
0.288330078125,
-0.27880859375,
-... | 24 |
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)
```
No
| 71,061 | [
0.386962890625,
0.059112548828125,
-0.075927734375,
-0.0227203369140625,
-0.31591796875,
-0.241943359375,
-0.1558837890625,
-0.0253143310546875,
0.251953125,
0.85205078125,
0.54541015625,
-0.12213134765625,
0.358642578125,
-0.6376953125,
-0.66943359375,
0.2293701171875,
-0.2653808593... | 24 |
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)
```
No
| 71,062 | [
0.386962890625,
0.059112548828125,
-0.075927734375,
-0.0227203369140625,
-0.31591796875,
-0.241943359375,
-0.1558837890625,
-0.0253143310546875,
0.251953125,
0.85205078125,
0.54541015625,
-0.12213134765625,
0.358642578125,
-0.6376953125,
-0.66943359375,
0.2293701171875,
-0.2653808593... | 24 |
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
```
No
| 71,063 | [
0.386962890625,
0.059112548828125,
-0.075927734375,
-0.0227203369140625,
-0.31591796875,
-0.241943359375,
-0.1558837890625,
-0.0253143310546875,
0.251953125,
0.85205078125,
0.54541015625,
-0.12213134765625,
0.358642578125,
-0.6376953125,
-0.66943359375,
0.2293701171875,
-0.2653808593... | 24 |
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(0,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)
```
No
| 71,064 | [
0.386962890625,
0.059112548828125,
-0.075927734375,
-0.0227203369140625,
-0.31591796875,
-0.241943359375,
-0.1558837890625,
-0.0253143310546875,
0.251953125,
0.85205078125,
0.54541015625,
-0.12213134765625,
0.358642578125,
-0.6376953125,
-0.66943359375,
0.2293701171875,
-0.2653808593... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Tags: *special, greedy, two pointers
Correct Solution:
```
n = int(input())
call = list(map(int, input().split()))
cp = []
ans = []
for i in range(1, n):
x = call[i]
cp.append([x, i + 1])
cp.sort(reverse=True)
l = [[call[0], 1]]
j = 0
while len(cp) > 0 and len(l) > 0 and j < len(cp):
s = l[0]
x = s[0]
p = s[1]
for i in range(j, min(j + x, len(cp))):
ans.append([str(p), str(cp[i][1])])
l.append(cp[i])
j = min(j + x, len(cp))
l.remove(l[0])
if j < len(cp):
print(-1)
else:
print(len(ans))
for i in range(len(ans)):
print(' '.join(ans[i]))
```
| 72,185 | [
0.44580078125,
-0.03924560546875,
0.2020263671875,
0.544921875,
-0.1646728515625,
-0.348388671875,
-0.46435546875,
-0.061370849609375,
0.036285400390625,
0.6240234375,
0.64013671875,
-0.23583984375,
0.6435546875,
-0.4775390625,
-0.724609375,
-0.0179595947265625,
-0.42724609375,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Tags: *special, greedy, two pointers
Correct Solution:
```
from operator import itemgetter
n = input()
n = int(n)
a = str()
a = input()
a = a.split()
a = list(map(int, a))
asum = sum(a)
if a[0] == 0 or asum < n - 1:
print(-1)
exit(0)
b1 = [0, a[:1][0]]
a2 = a[1:]
b2 = list()
for i in range(0, n - 1):
b2.append([i + 1, a2[i]])
b2 = sorted(b2, key=itemgetter(1), reverse=True)
b = [b1] + b2
c = 1
ai = 0
print(n - 1)
for el in b:
ai += 1
for i in range(0, el[1]):
print(el[0] + 1, ' ', b[c][0] + 1)
c += 1
if c == n:
exit(0)
```
| 72,186 | [
0.44580078125,
-0.03924560546875,
0.2020263671875,
0.544921875,
-0.1646728515625,
-0.348388671875,
-0.46435546875,
-0.061370849609375,
0.036285400390625,
0.6240234375,
0.64013671875,
-0.23583984375,
0.6435546875,
-0.4775390625,
-0.724609375,
-0.0179595947265625,
-0.42724609375,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Tags: *special, greedy, two pointers
Correct Solution:
```
def solve():
n = int(input())
A = list(map(int, input().split()))
x, A = A[0], A[1:]
A = [(A[i], i + 2) for i in range(len(A))]
A.sort(reverse=True)
cnt = 1
msg = x
total = 1
for a in A:
if not msg:
print(-1)
return
msg += a[0] - 1
total += a[0]
cnt += 1
if total >= n:
break
print(n - 1)
total = x
for j in range(min(x, len(A))):
print(1, A[j][1])
if total >= n - 1:
return
for i in range(len(A)):
for j in range(total, min(total + A[i][0], len(A))):
print(A[i][1], A[j][1])
total += 1
if total >= n - 1:
return
solve()
```
| 72,187 | [
0.44580078125,
-0.03924560546875,
0.2020263671875,
0.544921875,
-0.1646728515625,
-0.348388671875,
-0.46435546875,
-0.061370849609375,
0.036285400390625,
0.6240234375,
0.64013671875,
-0.23583984375,
0.6435546875,
-0.4775390625,
-0.724609375,
-0.0179595947265625,
-0.42724609375,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Tags: *special, greedy, two pointers
Correct Solution:
```
import sys
import math
studentsNum = int(sys.stdin.readline())
messagesLimit = [int(c) for c in sys.stdin.readline().split()]
firstLimit = messagesLimit[0]
messagesLimit = sorted(enumerate(messagesLimit), key = lambda v: v[1], reverse = True)
messagesLimit.remove((0, firstLimit))
messagesLimit.insert(0, (0, firstLimit))
lastSender = 0
lastReciever = 0
pairs = []
while lastReciever < studentsNum and messagesLimit[lastSender][1] > 0:
for reciever in range(lastReciever+1, min(studentsNum, lastReciever+messagesLimit[lastSender][1]+1)):
pairs.append((messagesLimit[lastSender][0]+1, messagesLimit[reciever][0]+1))
lastReciever += messagesLimit[lastSender][1]
lastSender += 1
if lastReciever+1 < studentsNum:
print(-1)
else:
print(len(pairs))
for p in pairs:
print(p[0], p[1])
```
| 72,188 | [
0.44580078125,
-0.03924560546875,
0.2020263671875,
0.544921875,
-0.1646728515625,
-0.348388671875,
-0.46435546875,
-0.061370849609375,
0.036285400390625,
0.6240234375,
0.64013671875,
-0.23583984375,
0.6435546875,
-0.4775390625,
-0.724609375,
-0.0179595947265625,
-0.42724609375,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Tags: *special, greedy, two pointers
Correct Solution:
```
if __name__ == "__main__":
n = int(input())
arr = [int(x) for x in input().split()]
users = []
invited_users = []
messages_count = 0
output = ''
for i in range(len(arr)):
users.append([i, arr[i]])
sender = users[0]
users = users[1:]
users.sort(key=lambda row: row[1])
while messages_count != n - 1 and len(users) > 0:
invites_count = sender[1]
person = sender[0]
if invites_count == 0:
break
while invites_count != 0:
invited_user = users[len(users) - 1]
invited_users.append(invited_user)
users = users[:-1]
output += str(person + 1) + ' ' + str(invited_user[0] + 1) + '\n'
invites_count -= 1
messages_count += 1
if messages_count == n - 1:
break
if len(invited_users) > 0:
sender = invited_users[0]
invited_users = invited_users[1:]
if messages_count < n - 1:
print(-1)
else:
print(messages_count)
print(output)
```
| 72,189 | [
0.44580078125,
-0.03924560546875,
0.2020263671875,
0.544921875,
-0.1646728515625,
-0.348388671875,
-0.46435546875,
-0.061370849609375,
0.036285400390625,
0.6240234375,
0.64013671875,
-0.23583984375,
0.6435546875,
-0.4775390625,
-0.724609375,
-0.0179595947265625,
-0.42724609375,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Tags: *special, greedy, two pointers
Correct Solution:
```
a=int(input());b=list(map(int,input().split()))
if b[0]==0 or sum(b)<a-1:exit(print(-1))
c=sorted([[j,i+1] for i,j in enumerate(b)],reverse=True)
for i in range(a):
if c[i][1]==1:c=[c.pop(i)]+c;break
i=0;j=1;print(a-1)
while(j<a):
print(c[i][1],c[j][1]);j+=1;c[i][0]-=1
if c[i][0]==0:i+=1
```
| 72,190 | [
0.44580078125,
-0.03924560546875,
0.2020263671875,
0.544921875,
-0.1646728515625,
-0.348388671875,
-0.46435546875,
-0.061370849609375,
0.036285400390625,
0.6240234375,
0.64013671875,
-0.23583984375,
0.6435546875,
-0.4775390625,
-0.724609375,
-0.0179595947265625,
-0.42724609375,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Tags: *special, greedy, two pointers
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
if a[0] == 0 or sum(a) < n - 1:
print(-1)
exit(0)
print(n - 1)
m = [[a[i], i + 1] for i in range(1, len(a))]
m.sort(reverse = True)
m = [[a[0], 1]] + m
i, j = 0, 1
while i < n and j < n:
if m[i][0] > 0:
print(m[i][1], m[j][1])
m[i][0] -= 1
j += 1
else:
i += 1
```
| 72,191 | [
0.44580078125,
-0.03924560546875,
0.2020263671875,
0.544921875,
-0.1646728515625,
-0.348388671875,
-0.46435546875,
-0.061370849609375,
0.036285400390625,
0.6240234375,
0.64013671875,
-0.23583984375,
0.6435546875,
-0.4775390625,
-0.724609375,
-0.0179595947265625,
-0.42724609375,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Tags: *special, greedy, two pointers
Correct Solution:
```
import sys
data = sys.stdin.read().split()
data_ptr = 0
def data_next():
global data_ptr, data
data_ptr += 1
return data[data_ptr - 1]
N = int(data_next())
arr = list(zip(map(int, data[2:]), range(2, N + 1)))
arr.sort()
arr.append((int(data[1]), 1))
arr.reverse()
j = 1
good = True
ans = []
for i in range(0, N):
if j > i:
for k in range(arr[i][0]):
if j >= N:
break
ans.append((arr[i][1], arr[j][1]))
j += 1
else:
good = False
break
if good:
print(len(ans))
for x in ans:
print(x[0], x[1])
else:
print(-1)
```
| 72,192 | [
0.44580078125,
-0.03924560546875,
0.2020263671875,
0.544921875,
-0.1646728515625,
-0.348388671875,
-0.46435546875,
-0.061370849609375,
0.036285400390625,
0.6240234375,
0.64013671875,
-0.23583984375,
0.6435546875,
-0.4775390625,
-0.724609375,
-0.0179595947265625,
-0.42724609375,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Submitted Solution:
```
n = int(input())
line = list(map(int, input().split()))
person = []
for i in range(1, n):
person.append([line[i], i])
person.sort(reverse=True)
person = [[line[0], 0]] + person
send = 0
recv = 1
if line[0] == 0 or sum(line) < n - 1:
print(-1)
else:
answer = []
while recv != n:
answer.append([person[send][1] + 1, person[recv][1] + 1])
recv += 1
person[send][0] -= 1
if person[send][0] == 0:
send += 1
print(len(answer))
for elem in answer:
print(*elem)
```
Yes
| 72,193 | [
0.456298828125,
-0.00177764892578125,
0.1602783203125,
0.4560546875,
-0.224609375,
-0.2578125,
-0.470947265625,
0.0022830963134765625,
0.052947998046875,
0.66943359375,
0.57373046875,
-0.213134765625,
0.591796875,
-0.474609375,
-0.69091796875,
-0.031280517578125,
-0.397705078125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Submitted Solution:
```
n = int(input())
l = [[int(i)] for i in input().split()]
for i in range(len(l)): l[i].append(i + 1)
zn = []
ansst = []
if l[0][0] == 0:
print("-1")
else:
zn.append(l[0])
del l[0]
l.sort(key=lambda x: x[0], reverse=True)
while len(zn) > 0 and len(l) > 0:
for i in range(min(zn[0][0], len(l))):
ansst.append([zn[0][1], l[0][1]])
zn.append(l[0])
del l[0]
del zn[0]
if len(l) == 0:
print(len(ansst))
print('\n'.join([' '.join([str(w) for w in q]) for q in ansst]))
else:
print(-1)
```
Yes
| 72,194 | [
0.456298828125,
-0.00177764892578125,
0.1602783203125,
0.4560546875,
-0.224609375,
-0.2578125,
-0.470947265625,
0.0022830963134765625,
0.052947998046875,
0.66943359375,
0.57373046875,
-0.213134765625,
0.591796875,
-0.474609375,
-0.69091796875,
-0.031280517578125,
-0.397705078125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
en_a = list(enumerate(a))
l = [en_a[0]] + sorted(en_a[1:], key=lambda x:-x[1])
res = []
s = 0
r = 1
correct = True
k = l[s][1]
if k == 0:
correct = False
while correct and r < n:
while k > 0 and r < n:
res.append([l[s][0] + 1, l[r][0] + 1])
r += 1
k -= 1
s += 1
k = l[s][1]
if k == 0 and r < n:
correct = False
break
if correct:
print(len(res))
for res_i in res:
print(*res_i)
else:
print(-1)
```
Yes
| 72,195 | [
0.456298828125,
-0.00177764892578125,
0.1602783203125,
0.4560546875,
-0.224609375,
-0.2578125,
-0.470947265625,
0.0022830963134765625,
0.052947998046875,
0.66943359375,
0.57373046875,
-0.213134765625,
0.591796875,
-0.474609375,
-0.69091796875,
-0.031280517578125,
-0.397705078125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Submitted Solution:
```
def send(id):
while a[id] > 0:
if len(g) < n:
li = a.copy()
li[id] = -1
while True:
k = li.index(max(li))
if k + 1 in g:
li[k] = -1
else:
break
g.append(k + 1)
actions.append('{} {}'.format(id + 1, g[-1]))
send(k)
a[id] -= 1
else:
break
n = int(input())
a = list(map(int, input().split()))
actions = []
g = [1]
send(0)
if len(g) < n:
print(-1)
else:
print(len(actions))
for line in actions:
print(line)
```
Yes
| 72,196 | [
0.456298828125,
-0.00177764892578125,
0.1602783203125,
0.4560546875,
-0.224609375,
-0.2578125,
-0.470947265625,
0.0022830963134765625,
0.052947998046875,
0.66943359375,
0.57373046875,
-0.213134765625,
0.591796875,
-0.474609375,
-0.69091796875,
-0.031280517578125,
-0.397705078125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Submitted Solution:
```
studnum = input()
arr = list(map(int, input().split()))
index = 0
bla = list(enumerate(arr))
p = bla[0]
sortedA = sorted(bla[1:], key=lambda x: x[1], reverse=True)
sortedA.insert(0, p)
left = 0
right = 1
result = []
while left < len(sortedA) and right< len(sortedA):
val = sortedA[left][1]
if val == 0:
result.append(-1)
print(-1)
break
for i in range(val):
# print(sortedA[left][0] + 1, sortedA[right][0] + 1)
result.append((sortedA[left][0] + 1, sortedA[right][0] + 1))
right += 1
left += 1
for i in result:
print(i[0], i[1])
```
No
| 72,197 | [
0.456298828125,
-0.00177764892578125,
0.1602783203125,
0.4560546875,
-0.224609375,
-0.2578125,
-0.470947265625,
0.0022830963134765625,
0.052947998046875,
0.66943359375,
0.57373046875,
-0.213134765625,
0.591796875,
-0.474609375,
-0.69091796875,
-0.031280517578125,
-0.397705078125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Submitted Solution:
```
n = int(input())
vals = list(map(int, input().split()))
vals = [(i, vals[i]) for i in range(n)]
vals = [vals[0]]+sorted(vals[1:], key=lambda x: x[1], reverse=True)
most_left_idx = 0
count = 0
output = ''
for i in range(n):
if(most_left_idx>=i):
most_left_idx += vals[i][1]
for j in range(vals[i][1]):
count+=1
output += '{} {} \n'.format(vals[i][0]+1, vals[j][0]+1)
if(most_left_idx>=n-1):
print(count)
print(output)
else:
print(-1)
```
No
| 72,198 | [
0.456298828125,
-0.00177764892578125,
0.1602783203125,
0.4560546875,
-0.224609375,
-0.2578125,
-0.470947265625,
0.0022830963134765625,
0.052947998046875,
0.66943359375,
0.57373046875,
-0.213134765625,
0.591796875,
-0.474609375,
-0.69091796875,
-0.031280517578125,
-0.397705078125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Submitted Solution:
```
n=int(input())
A=input().split()
for i in range(len(A)):
A[i]=int(A[i])
isch=[]
for i in range(len(A)):
isch.append(A[i])
otv=[]
o=0
k=0
l=len(A)-1
while l>0:
if isch[k]!=0:
isch[k]=-10**3
ma=isch.index(max(isch))
row=[k+1, ma+1]
otv.append(row)
l-=1
for i in range(A[k]-1):
mi=isch.index(min(isch, key=abs))
row=[k+1, mi+1]
otv.append(row)
isch[mi]=-10**3
l-=1
k=ma
else:
o=-1
break
if o==-1:
print(o)
else:
for i in range(len(otv)):
print(otv[i][0], otv[i][1])
```
No
| 72,199 | [
0.456298828125,
-0.00177764892578125,
0.1602783203125,
0.4560546875,
-0.224609375,
-0.2578125,
-0.470947265625,
0.0022830963134765625,
0.052947998046875,
0.66943359375,
0.57373046875,
-0.213134765625,
0.591796875,
-0.474609375,
-0.69091796875,
-0.031280517578125,
-0.397705078125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai — the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 ≤ n ≤ 100) — the number of students.
The second line contains the sequence a1, a2, ..., an (0 ≤ ai ≤ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k — the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit.
Submitted Solution:
```
import sys
import math
studentsNum = int(sys.stdin.readline())
messagesLimit = [int(c) for c in sys.stdin.readline().split()]
firstLimit = messagesLimit[0]
messagesLimit = sorted(enumerate(messagesLimit), key = lambda v: v[1], reverse = True)
messagesLimit.remove((0, firstLimit))
messagesLimit.insert(0, (0, firstLimit))
lastSender = 0
lastReciever = 0
pairs = []
while lastReciever < studentsNum and messagesLimit[lastReciever][1] > 0:
for reciever in range(lastReciever+1, min(studentsNum, lastReciever+messagesLimit[lastSender][1]+1)):
pairs.append((messagesLimit[lastSender][0]+1, messagesLimit[reciever][0]+1))
lastReciever += messagesLimit[lastSender][1]
lastSender += 1
if lastReciever+1 < studentsNum:
print(-1)
else:
print(len(pairs))
for p in pairs:
print(p[0], p[1])
```
No
| 72,200 | [
0.456298828125,
-0.00177764892578125,
0.1602783203125,
0.4560546875,
-0.224609375,
-0.2578125,
-0.470947265625,
0.0022830963134765625,
0.052947998046875,
0.66943359375,
0.57373046875,
-0.213134765625,
0.591796875,
-0.474609375,
-0.69091796875,
-0.031280517578125,
-0.397705078125,
-... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Tags: implementation, math
Correct Solution:
```
for _ in range(int(input())):
p_current = c_current = 0
incomplete = True
for _ in range(int(input())):
p_next, c_next = (int(i) for i in input().split())
if incomplete and (c_next - c_current > p_next - p_current or c_next < c_current or p_next < p_current):
print("NO")
incomplete = False
else:
p_current, c_current = p_next, c_next
if incomplete:
print("YES")
```
| 72,656 | [
-0.122802734375,
0.11163330078125,
0.2529296875,
0.08404541015625,
0.0457763671875,
-0.646484375,
-0.3525390625,
0.08258056640625,
0.28857421875,
0.97607421875,
0.56689453125,
-0.1246337890625,
0.266845703125,
-0.697265625,
-0.537109375,
0.143310546875,
-0.6767578125,
-0.650390625,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Tags: implementation, math
Correct Solution:
```
t=int(input())
for _ in range(t):
valid=True
n=int(input())
lasta,lastb=[int(x) for x in input().split()]
if lasta<lastb:
valid = False
for __ in range(n-1):
a,b=[int(x) for x in input().split()]
if a<b or a<lasta or b<lastb or a-lasta<b-lastb:
valid=False
lasta,lastb=a,b
if valid:
print("YES")
else:
print("NO")
```
| 72,657 | [
-0.122802734375,
0.11163330078125,
0.2529296875,
0.08404541015625,
0.0457763671875,
-0.646484375,
-0.3525390625,
0.08258056640625,
0.28857421875,
0.97607421875,
0.56689453125,
-0.1246337890625,
0.266845703125,
-0.697265625,
-0.537109375,
0.143310546875,
-0.6767578125,
-0.650390625,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Tags: implementation, math
Correct Solution:
```
"""
arr = list(map(int, input().split()))
n,k=map(int, input().split())
"""
cases = int(input())
for _ in range(cases):
size = int(input())
lst = []
for __ in range(size):
arr = tuple(map(int, input().split()))
lst.append(arr)
if lst[0][0] < lst[0][1]:
print('NO')
else:
flag = True
for i in range(1, size):
clear_diff = lst[i][1] - lst[i-1][1]
if lst[i][0] - lst[i-1][0] < 0 or clear_diff < 0:
print('NO')
flag = False
break
elif lst[i][0] - lst[i-1][0] < clear_diff:
print('NO')
flag = False
break
else:
continue
if flag:
print('YES')
```
| 72,658 | [
-0.122802734375,
0.11163330078125,
0.2529296875,
0.08404541015625,
0.0457763671875,
-0.646484375,
-0.3525390625,
0.08258056640625,
0.28857421875,
0.97607421875,
0.56689453125,
-0.1246337890625,
0.266845703125,
-0.697265625,
-0.537109375,
0.143310546875,
-0.6767578125,
-0.650390625,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Tags: implementation, math
Correct Solution:
```
t = int(input())
e = []
for i in range(t):
n = int(input())
p0 = 0
c0 = 0
d = 'YES'
for j in range(n):
p1, c1 = input().split(' ')
p1 = int(p1)
c1 = int(c1)
#print((p1 >= c1), (p1 > p0), (c1 > c0), (p1-p0 >= c1-c0))
if (d == 'YES'):
if (p1 >= c1) and (p1 >= p0) and (c1 >= c0) and (p1-p0 >= c1-c0):
pass
else:
d = 'NO'
p0 = p1
c0 = c1
e.append(d)
for i in e:
print(i)
```
| 72,659 | [
-0.122802734375,
0.11163330078125,
0.2529296875,
0.08404541015625,
0.0457763671875,
-0.646484375,
-0.3525390625,
0.08258056640625,
0.28857421875,
0.97607421875,
0.56689453125,
-0.1246337890625,
0.266845703125,
-0.697265625,
-0.537109375,
0.143310546875,
-0.6767578125,
-0.650390625,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Tags: implementation, math
Correct Solution:
```
no_test = int(input())
for i in range(0, no_test):
moment = int(input())
preplays, preclear = -1, -1
result = 'Yes'
for j in range(0, moment):
plays, clears = input().split(' ')
plays = int(plays)
clears = int(clears)
if plays >= clears and ((plays > preplays and (clears in range(preclear, preclear+plays-preplays+1))) or (plays==preplays and clears==preclear)):
preplays, preclear = plays, clears
else:
result = 'No'
print(result)
```
| 72,660 | [
-0.122802734375,
0.11163330078125,
0.2529296875,
0.08404541015625,
0.0457763671875,
-0.646484375,
-0.3525390625,
0.08258056640625,
0.28857421875,
0.97607421875,
0.56689453125,
-0.1246337890625,
0.266845703125,
-0.697265625,
-0.537109375,
0.143310546875,
-0.6767578125,
-0.650390625,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Tags: implementation, math
Correct Solution:
```
t = int(input())
for k in range(t):
a = int(input())
flag = True
vet = []
for r in range(a):
x, y = list(map(int,input().split()))
vet.append([x,y])
if vet[0][1] > vet[0][0]:
flag = False
for i in range(1,len(vet)):
pA = vet[i][0]
pAA = vet[i-1][0]
cA = vet[i][1]
cAA = vet[i-1][1]
if pA < pAA:
flag = False
break
if cA < cAA:
flag = False
break
if pA-pAA < cA-cAA:
flag = False
break
if cA > pA:
flag = False
break
if flag:
print("YES")
else:
print("NO")
```
| 72,661 | [
-0.122802734375,
0.11163330078125,
0.2529296875,
0.08404541015625,
0.0457763671875,
-0.646484375,
-0.3525390625,
0.08258056640625,
0.28857421875,
0.97607421875,
0.56689453125,
-0.1246337890625,
0.266845703125,
-0.697265625,
-0.537109375,
0.143310546875,
-0.6767578125,
-0.650390625,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Tags: implementation, math
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
a,b=map(int,input().split())
f=0
if(a<b):
f=1
for i in range(n-1):
p,c=map(int,input().split())
if(f==0):
if(p<a or c<b):
f=1
#break
elif(p-a<c-b):
f=1
#break
elif(p<c):
f=1
else:
a=p
b=c
if(f==1):
print("NO")
else:
print("YES")
```
| 72,662 | [
-0.122802734375,
0.11163330078125,
0.2529296875,
0.08404541015625,
0.0457763671875,
-0.646484375,
-0.3525390625,
0.08258056640625,
0.28857421875,
0.97607421875,
0.56689453125,
-0.1246337890625,
0.266845703125,
-0.697265625,
-0.537109375,
0.143310546875,
-0.6767578125,
-0.650390625,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Tags: implementation, math
Correct Solution:
```
testNumb = input ()
answers = []
for _ in range (int(testNumb)):
inputsNumb = input()
isCorrect = True
previousInput = [0, 0]
for i in range (int (inputsNumb)):
newInput = input().split()
newP = int(newInput[0])
newC = int(newInput[1])
if newC > newP:
isCorrect = False
if (i == 0):
previousInput[0] = newP
previousInput[1] = newC
else:
if newP < previousInput[0] or newC < previousInput[1] or (newC - previousInput[1]) > (newP - previousInput[0]):
isCorrect = False
previousInput[0] = newP
previousInput[1] = newC
answers.append(isCorrect)
for i in range (len (answers)):
if answers[i] == True:
print ("YES")
else:
print ("NO")
```
| 72,663 | [
-0.122802734375,
0.11163330078125,
0.2529296875,
0.08404541015625,
0.0457763671875,
-0.646484375,
-0.3525390625,
0.08258056640625,
0.28857421875,
0.97607421875,
0.56689453125,
-0.1246337890625,
0.266845703125,
-0.697265625,
-0.537109375,
0.143310546875,
-0.6767578125,
-0.650390625,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Submitted Solution:
```
itr=int(input())
for _ in range(itr):
n=int(input())
prev=[0,0]
stats=[]
for i in range(n):
stats.append(list(map(int,input().split())))
for j in stats:
if j[0]<prev[0] or j[1] <prev[1] or j[0]<j[1] or j[1]-prev[1] > j[0]-prev[0]:
ans='NO'
break
prev=j
else :
ans='YES'
print(ans)
```
Yes
| 72,664 | [
0.0557861328125,
0.1451416015625,
0.2396240234375,
0.07452392578125,
-0.060882568359375,
-0.4794921875,
-0.440673828125,
0.135009765625,
0.215576171875,
0.98681640625,
0.5322265625,
-0.07421875,
0.1949462890625,
-0.64453125,
-0.489013671875,
0.00678253173828125,
-0.68798828125,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Submitted Solution:
```
import sys
input = sys.stdin.readline
T = int(input())
for _ in range(T):
n = int(input())
a = []
f = True
for i in range(n):
p,c = map(int,input().split())
if c>p:
f = False
for x,y in a:
if p<x:
f = False
if p==x and y!=c:
f = False
if c<y:
f = False
if c-y > p-x:
f = False
a.append((p,c))
print('YES' if f else 'NO')
```
Yes
| 72,665 | [
0.0557861328125,
0.1451416015625,
0.2396240234375,
0.07452392578125,
-0.060882568359375,
-0.4794921875,
-0.440673828125,
0.135009765625,
0.215576171875,
0.98681640625,
0.5322265625,
-0.07421875,
0.1949462890625,
-0.64453125,
-0.489013671875,
0.00678253173828125,
-0.68798828125,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Submitted Solution:
```
# 1334A
t = int(input())
while t:
n = int(input())
a = []
b = []
d = 0
z = 0
x = 0
for i in range(n):
q,w = map(int,input().split())
a.append(q)
b.append(w)
for i in range(n):
if (a[i] < z or b[i] < x) or (b[i] - x > a[i] - z):
print('NO')
d += 1
break
else:
z = a[i]
x = b[i]
if d == 0:
print("YES")
t -= 1
```
Yes
| 72,666 | [
0.0557861328125,
0.1451416015625,
0.2396240234375,
0.07452392578125,
-0.060882568359375,
-0.4794921875,
-0.440673828125,
0.135009765625,
0.215576171875,
0.98681640625,
0.5322265625,
-0.07421875,
0.1949462890625,
-0.64453125,
-0.489013671875,
0.00678253173828125,
-0.68798828125,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
pp=[]
cc=[]
for i in range(n):
p,c = input().split()
pp.append(int(p))
cc.append(int(c))
y=0
for i in range(1,n):
if(pp[i]<cc[i] or pp[i]<pp[i-1] or cc[i]<cc[i-1] or pp[i]-pp[i-1]<cc[i]-cc[i-1]):
y=1
break
if(n==1 and cc[0]>pp[0]):
print("NO")
elif(y==1 or cc[0]>pp[0]):
print("NO")
else:
print("YES")
```
Yes
| 72,667 | [
0.0557861328125,
0.1451416015625,
0.2396240234375,
0.07452392578125,
-0.060882568359375,
-0.4794921875,
-0.440673828125,
0.135009765625,
0.215576171875,
0.98681640625,
0.5322265625,
-0.07421875,
0.1949462890625,
-0.64453125,
-0.489013671875,
0.00678253173828125,
-0.68798828125,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Submitted Solution:
```
from pprint import pprint
import sys
input = sys.stdin.readline
q = int(input())
for _ in range(q):
n = int(input())
d = dict()
f = True
lp = -1
for _ in range(n):
p, c = map(int, input().split())
if lp > p:
f = False
if p in d:
if d[p] != c:
f = False
if p < c:
f = False
d[p] = c
lp = p
k = list(d.keys())
k.sort()
#print(k)
c = 0
for x in k:
if d[x] < c:
f = False
c = d[x]
print("YES" if f else "NO")
```
No
| 72,668 | [
0.0557861328125,
0.1451416015625,
0.2396240234375,
0.07452392578125,
-0.060882568359375,
-0.4794921875,
-0.440673828125,
0.135009765625,
0.215576171875,
0.98681640625,
0.5322265625,
-0.07421875,
0.1949462890625,
-0.64453125,
-0.489013671875,
0.00678253173828125,
-0.68798828125,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Submitted Solution:
```
t=int(input())
for q in range(t):
n=int(input())
c=[]
d=[]
count=0
for w in range(n):
inp1=str(input())
inp=inp1.split()
a=int(inp[0])
b=int(inp[1])
c.append(a)
d.append(b)
if(a>=b and a>=c[w-1] and b>=d[w-1]):
continue
else:
count+=1
if(count==0):
print("YES")
else:
print("NO")
```
No
| 72,669 | [
0.0557861328125,
0.1451416015625,
0.2396240234375,
0.07452392578125,
-0.060882568359375,
-0.4794921875,
-0.440673828125,
0.135009765625,
0.215576171875,
0.98681640625,
0.5322265625,
-0.07421875,
0.1949462890625,
-0.64453125,
-0.489013671875,
0.00678253173828125,
-0.68798828125,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Submitted Solution:
```
t=int(input())
while t:
n=int(input())
count=1
for i in range(n):
p,c=input().split()
p=int(p)
c=int(c)
if c>p:
pass
else:
if i!=0:
if p<prev_p:
pass
elif c<prev_c:
pass
elif c-prev_c>0 and prev_p==p:
pass
else:
count+=1
prev_p=p
prev_c=c
if count==n:
print("YES")
else:
print("NO")
t-=1
```
No
| 72,670 | [
0.0557861328125,
0.1451416015625,
0.2396240234375,
0.07452392578125,
-0.060882568359375,
-0.4794921875,
-0.440673828125,
0.135009765625,
0.215576171875,
0.98681640625,
0.5322265625,
-0.07421875,
0.1949462890625,
-0.64453125,
-0.489013671875,
0.00678253173828125,
-0.68798828125,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has recently created a new level in this cool new game Berlio Maker 85 and uploaded it online. Now players from all over the world can try his level.
All levels in this game have two stats to them: the number of plays and the number of clears. So when a player attempts the level, the number of plays increases by 1. If he manages to finish the level successfully then the number of clears increases by 1 as well. Note that both of the statistics update at the same time (so if the player finishes the level successfully then the number of plays will increase at the same time as the number of clears).
Polycarp is very excited about his level, so he keeps peeking at the stats to know how hard his level turns out to be.
So he peeked at the stats n times and wrote down n pairs of integers — (p_1, c_1), (p_2, c_2), ..., (p_n, c_n), where p_i is the number of plays at the i-th moment of time and c_i is the number of clears at the same moment of time. The stats are given in chronological order (i.e. the order of given pairs is exactly the same as Polycarp has written down).
Between two consecutive moments of time Polycarp peeked at the stats many players (but possibly zero) could attempt the level.
Finally, Polycarp wonders if he hasn't messed up any records and all the pairs are correct. If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then he considers his records correct.
Help him to check the correctness of his records.
For your convenience you have to answer multiple independent test cases.
Input
The first line contains a single integer T (1 ≤ T ≤ 500) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of moments of time Polycarp peeked at the stats.
Each of the next n lines contains two integers p_i and c_i (0 ≤ p_i, c_i ≤ 1000) — the number of plays and the number of clears of the level at the i-th moment of time.
Note that the stats are given in chronological order.
Output
For each test case print a single line.
If there could exist such a sequence of plays (and clears, respectively) that the stats were exactly as Polycarp has written down, then print "YES".
Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
3
0 0
1 1
1 2
2
1 0
1000 3
4
10 1
15 2
10 2
15 2
1
765 432
2
4 4
4 3
5
0 0
1 0
1 0
1 0
1 0
Output
NO
YES
NO
YES
NO
YES
Note
In the first test case at the third moment of time the number of clears increased but the number of plays did not, that couldn't have happened.
The second test case is a nice example of a Super Expert level.
In the third test case the number of plays decreased, which is impossible.
The fourth test case is probably an auto level with a single jump over the spike.
In the fifth test case the number of clears decreased, which is also impossible.
Nobody wanted to play the sixth test case; Polycarp's mom attempted it to make him feel better, however, she couldn't clear it.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
plays = [0]
wins = [0]
ok = True
for i in range(n):
p, w = map(int, input().split())
if(p < max(plays) or (w > max(plays) and w > p) or w < max(wins) or w > p):
ok = False
plays.append(p)
wins.append(w)
if(ok):
print('YES')
else:
print('NO')
```
No
| 72,671 | [
0.0557861328125,
0.1451416015625,
0.2396240234375,
0.07452392578125,
-0.060882568359375,
-0.4794921875,
-0.440673828125,
0.135009765625,
0.215576171875,
0.98681640625,
0.5322265625,
-0.07421875,
0.1949462890625,
-0.64453125,
-0.489013671875,
0.00678253173828125,
-0.68798828125,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is sure that his life fits the description: "first there is a white stripe, then a black one, then a white one again". So, Polycarpus is sure that this rule is going to fulfill during the next n days. Polycarpus knows that he is in for w good events and b not-so-good events. At least one event is going to take place during each day. As each day is unequivocally characterizes as a part of a white or a black stripe, then each day is going to have events of the same type only (ether good or not-so-good).
What is the number of distinct ways this scenario can develop over the next n days if Polycarpus is in for a white stripe (a stripe that has good events only, the stripe's length is at least 1 day), the a black stripe (a stripe that has not-so-good events only, the stripe's length is at least 1 day) and a white stripe again (a stripe that has good events only, the stripe's length is at least 1 day). Each of n days will belong to one of the three stripes only.
Note that even the events of the same type are distinct from each other. Even if some events occur on the same day, they go in some order (there are no simultaneous events).
Write a code that prints the number of possible configurations to sort the events into days. See the samples for clarifications on which scenarios should be considered distinct. Print the answer modulo 1000000009 (109 + 9).
Input
The single line of the input contains integers n, w and b (3 ≤ n ≤ 4000, 2 ≤ w ≤ 4000, 1 ≤ b ≤ 4000) — the number of days, the number of good events and the number of not-so-good events. It is guaranteed that w + b ≥ n.
Output
Print the required number of ways modulo 1000000009 (109 + 9).
Examples
Input
3 2 1
Output
2
Input
4 2 2
Output
4
Input
3 2 2
Output
4
Note
We'll represent the good events by numbers starting from 1 and the not-so-good events — by letters starting from 'a'. Vertical lines separate days.
In the first sample the possible ways are: "1|a|2" and "2|a|1". In the second sample the possible ways are: "1|a|b|2", "2|a|b|1", "1|b|a|2" and "2|b|a|1". In the third sample the possible ways are: "1|ab|2", "2|ab|1", "1|ba|2" and "2|ba|1".
Tags: combinatorics, number theory
Correct Solution:
```
import sys
MOD = int(1e9) + 9
def inv(n):
return pow(n, MOD - 2, MOD)
def combo(n):
rv = [0 for __ in range(n + 1)]
rv[0] = 1
for k in range(n):
rv[k + 1] = rv[k] * (n - k) % MOD * inv(k + 1) % MOD
return rv
with sys.stdin as fin, sys.stdout as fout:
n, w, b = map(int, next(fin).split())
combw = combo(w - 1)
combb = combo(b - 1)
ans = 0
for black in range(max(1, n - w), min(n - 2, b) + 1):
ans = (ans + (n - 1 - black) * combw[n - black - 1] % MOD * combb[black - 1]) % MOD
for f in w, b:
for k in range(1, f + 1):
ans = k * ans % MOD
print(ans, file=fout)
```
| 72,823 | [
0.367431640625,
0.061370849609375,
0.140869140625,
0.04339599609375,
-0.591796875,
-0.4697265625,
-0.331298828125,
0.10479736328125,
0.272705078125,
1.1142578125,
0.72607421875,
-0.399169921875,
0.37451171875,
-0.79638671875,
-0.54541015625,
-0.05645751953125,
-1.1162109375,
-0.408... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is sure that his life fits the description: "first there is a white stripe, then a black one, then a white one again". So, Polycarpus is sure that this rule is going to fulfill during the next n days. Polycarpus knows that he is in for w good events and b not-so-good events. At least one event is going to take place during each day. As each day is unequivocally characterizes as a part of a white or a black stripe, then each day is going to have events of the same type only (ether good or not-so-good).
What is the number of distinct ways this scenario can develop over the next n days if Polycarpus is in for a white stripe (a stripe that has good events only, the stripe's length is at least 1 day), the a black stripe (a stripe that has not-so-good events only, the stripe's length is at least 1 day) and a white stripe again (a stripe that has good events only, the stripe's length is at least 1 day). Each of n days will belong to one of the three stripes only.
Note that even the events of the same type are distinct from each other. Even if some events occur on the same day, they go in some order (there are no simultaneous events).
Write a code that prints the number of possible configurations to sort the events into days. See the samples for clarifications on which scenarios should be considered distinct. Print the answer modulo 1000000009 (109 + 9).
Input
The single line of the input contains integers n, w and b (3 ≤ n ≤ 4000, 2 ≤ w ≤ 4000, 1 ≤ b ≤ 4000) — the number of days, the number of good events and the number of not-so-good events. It is guaranteed that w + b ≥ n.
Output
Print the required number of ways modulo 1000000009 (109 + 9).
Examples
Input
3 2 1
Output
2
Input
4 2 2
Output
4
Input
3 2 2
Output
4
Note
We'll represent the good events by numbers starting from 1 and the not-so-good events — by letters starting from 'a'. Vertical lines separate days.
In the first sample the possible ways are: "1|a|2" and "2|a|1". In the second sample the possible ways are: "1|a|b|2", "2|a|b|1", "1|b|a|2" and "2|b|a|1". In the third sample the possible ways are: "1|ab|2", "2|ab|1", "1|ba|2" and "2|ba|1".
Submitted Solution:
```
def fact(x):
fn=1
while x>0:
fn*=x
x-=1
return fn
n,w,b=list(map(int,input().split()))
F=0
if b>n-2: d=n-2
else: d=b
for i in range (1,d+1):
if n-i<=w:
F+=((n-i-1)*(w-1)*fact(w)*fact(b))
if b>1: F*=(b-1)
print(F%1000000009)
```
No
| 72,824 | [
0.329833984375,
0.2022705078125,
0.1510009765625,
0.0178985595703125,
-0.7138671875,
-0.415771484375,
-0.3818359375,
0.17919921875,
0.2174072265625,
1.0869140625,
0.7041015625,
-0.394287109375,
0.35986328125,
-0.8056640625,
-0.5400390625,
-0.072021484375,
-1.0283203125,
-0.47143554... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is sure that his life fits the description: "first there is a white stripe, then a black one, then a white one again". So, Polycarpus is sure that this rule is going to fulfill during the next n days. Polycarpus knows that he is in for w good events and b not-so-good events. At least one event is going to take place during each day. As each day is unequivocally characterizes as a part of a white or a black stripe, then each day is going to have events of the same type only (ether good or not-so-good).
What is the number of distinct ways this scenario can develop over the next n days if Polycarpus is in for a white stripe (a stripe that has good events only, the stripe's length is at least 1 day), the a black stripe (a stripe that has not-so-good events only, the stripe's length is at least 1 day) and a white stripe again (a stripe that has good events only, the stripe's length is at least 1 day). Each of n days will belong to one of the three stripes only.
Note that even the events of the same type are distinct from each other. Even if some events occur on the same day, they go in some order (there are no simultaneous events).
Write a code that prints the number of possible configurations to sort the events into days. See the samples for clarifications on which scenarios should be considered distinct. Print the answer modulo 1000000009 (109 + 9).
Input
The single line of the input contains integers n, w and b (3 ≤ n ≤ 4000, 2 ≤ w ≤ 4000, 1 ≤ b ≤ 4000) — the number of days, the number of good events and the number of not-so-good events. It is guaranteed that w + b ≥ n.
Output
Print the required number of ways modulo 1000000009 (109 + 9).
Examples
Input
3 2 1
Output
2
Input
4 2 2
Output
4
Input
3 2 2
Output
4
Note
We'll represent the good events by numbers starting from 1 and the not-so-good events — by letters starting from 'a'. Vertical lines separate days.
In the first sample the possible ways are: "1|a|2" and "2|a|1". In the second sample the possible ways are: "1|a|b|2", "2|a|b|1", "1|b|a|2" and "2|b|a|1". In the third sample the possible ways are: "1|ab|2", "2|ab|1", "1|ba|2" and "2|ba|1".
Submitted Solution:
```
def fact(x):
fn=1
while x>0:
fn*=x
x-=1
return fn
n,w,b=list(map(int,input().split()))
F=0
if b>n-2: d=n-2
else: d=b
for i in range (1,d+1):
if n-i<=w:
F+=((n-i-1)*(w-1)*fact(w)*fact(b))
if w>1: F*=(w-1)
print(F%1000000009)
```
No
| 72,825 | [
0.329833984375,
0.2022705078125,
0.1510009765625,
0.0178985595703125,
-0.7138671875,
-0.415771484375,
-0.3818359375,
0.17919921875,
0.2174072265625,
1.0869140625,
0.7041015625,
-0.394287109375,
0.35986328125,
-0.8056640625,
-0.5400390625,
-0.072021484375,
-1.0283203125,
-0.47143554... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is sure that his life fits the description: "first there is a white stripe, then a black one, then a white one again". So, Polycarpus is sure that this rule is going to fulfill during the next n days. Polycarpus knows that he is in for w good events and b not-so-good events. At least one event is going to take place during each day. As each day is unequivocally characterizes as a part of a white or a black stripe, then each day is going to have events of the same type only (ether good or not-so-good).
What is the number of distinct ways this scenario can develop over the next n days if Polycarpus is in for a white stripe (a stripe that has good events only, the stripe's length is at least 1 day), the a black stripe (a stripe that has not-so-good events only, the stripe's length is at least 1 day) and a white stripe again (a stripe that has good events only, the stripe's length is at least 1 day). Each of n days will belong to one of the three stripes only.
Note that even the events of the same type are distinct from each other. Even if some events occur on the same day, they go in some order (there are no simultaneous events).
Write a code that prints the number of possible configurations to sort the events into days. See the samples for clarifications on which scenarios should be considered distinct. Print the answer modulo 1000000009 (109 + 9).
Input
The single line of the input contains integers n, w and b (3 ≤ n ≤ 4000, 2 ≤ w ≤ 4000, 1 ≤ b ≤ 4000) — the number of days, the number of good events and the number of not-so-good events. It is guaranteed that w + b ≥ n.
Output
Print the required number of ways modulo 1000000009 (109 + 9).
Examples
Input
3 2 1
Output
2
Input
4 2 2
Output
4
Input
3 2 2
Output
4
Note
We'll represent the good events by numbers starting from 1 and the not-so-good events — by letters starting from 'a'. Vertical lines separate days.
In the first sample the possible ways are: "1|a|2" and "2|a|1". In the second sample the possible ways are: "1|a|b|2", "2|a|b|1", "1|b|a|2" and "2|b|a|1". In the third sample the possible ways are: "1|ab|2", "2|ab|1", "1|ba|2" and "2|ba|1".
Submitted Solution:
```
def fact(x):
fn=1
while x>0:
fn*=x
x-=1
return fn
n,w,b=list(map(int,input().split()))
F=0
if b>n-2: d=n-2
else: d=b
for i in range (1,d+1):
if n-i<=w:
F+=((n-i-1)*(w-1)*fact(w)*fact(b))
print(F)
```
No
| 72,826 | [
0.329833984375,
0.2022705078125,
0.1510009765625,
0.0178985595703125,
-0.7138671875,
-0.415771484375,
-0.3818359375,
0.17919921875,
0.2174072265625,
1.0869140625,
0.7041015625,
-0.394287109375,
0.35986328125,
-0.8056640625,
-0.5400390625,
-0.072021484375,
-1.0283203125,
-0.47143554... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Tags: implementation
Correct Solution:
```
t = 1
p = []
for i in range(int(input())):
s, d = map(int, input().split())
if t > s:
for i, q in enumerate(p):
if q[0] <= s <= q[0] + q[1] - d:
print(s, s + d - 1)
p.insert(i + 1, [s + d, q[1] - d - s + q[0]])
q[1] = s - q[0]
break
else:
for q in p:
if q[1] >= d:
print(q[0], q[0] + d - 1)
q[0] += d
q[1] -= d
break
else:
print(t, t + d - 1)
t += d
else:
p.append([t, s - t])
print(s, s + d - 1)
t = s + d
```
| 72,952 | [
0.23291015625,
0.26904296875,
-0.1153564453125,
-0.011199951171875,
-0.60693359375,
-0.265869140625,
-0.467529296875,
0.0165252685546875,
0.265625,
0.84619140625,
0.7568359375,
-0.045867919921875,
0.22705078125,
-0.81787109375,
-0.73876953125,
0.1324462890625,
-0.372314453125,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Tags: implementation
Correct Solution:
```
t, p = 1, []
for i in range(int(input())):
l, d = map(int, input().split())
if t > l:
for i, q in enumerate(p, 1):
if q[0] <= l <= q[1] - d:
p.insert(i, [l + d, q[1]])
q[1] = l
break
else:
for q in p:
if q[0] <= q[1] - d:
l = q[0]
q[0] += d
break
else:
l = t
t += d
else:
p.append([t, l])
t = l + d
print(l, l + d - 1)
```
| 72,953 | [
0.23291015625,
0.26904296875,
-0.1153564453125,
-0.011199951171875,
-0.60693359375,
-0.265869140625,
-0.467529296875,
0.0165252685546875,
0.265625,
0.84619140625,
0.7568359375,
-0.045867919921875,
0.22705078125,
-0.81787109375,
-0.73876953125,
0.1324462890625,
-0.372314453125,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Tags: implementation
Correct Solution:
```
import sys
lines = iter(sys.stdin.read().splitlines())
next(lines)
s,d = map(int,next(lines).split())
dates = [[0,0],[s, s + d -1],[10000000001,10000000001]]
res = [[s, s + d -1]]
for line in lines:
s,d = map(int,line.split())
nhueco = True
for i in range(len(dates)):
if s > dates[i][1] and s+d-1 < dates[i+1][0]:
dates.insert(i+1,[s, s + d -1])
res.append([s, s + d -1])
break
elif nhueco and -dates[i][1] +dates[i+1][0] -1 >= d:
nhueco = False
ld = dates[i][1] + 1
li = i+1
else:
dates.insert(li,[ld, ld + d -1])
res.append([ld, ld + d -1])
for date in res:
print(" ".join(map(str,date)))
```
| 72,954 | [
0.23291015625,
0.26904296875,
-0.1153564453125,
-0.011199951171875,
-0.60693359375,
-0.265869140625,
-0.467529296875,
0.0165252685546875,
0.265625,
0.84619140625,
0.7568359375,
-0.045867919921875,
0.22705078125,
-0.81787109375,
-0.73876953125,
0.1324462890625,
-0.372314453125,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Tags: implementation
Correct Solution:
```
n=int(input())
L=[]
for j in range(n):
ch=input().split()
s,d=int(ch[0]),int(ch[1])
if j==0:
print(s,d+s-1)
L.append([s,s+d-1])
L.sort()
else:
B=True
C=True
for i in range(len(L)):
if i<(len(L)-1) and s>L[i][1] and s+d-1<L[i+1][0]:
print(s,s+d-1)
L.append([s,s+d-1])
L.sort()
C=False
break
if L[i][1]>=s>=L[i][0] or L[i][0]<=(s+d-1)<=L[i][1] or (s<=L[i][0] and (s+d-1)>=L[i][1]):
B=False
break
if B and C:
print(s,s+d-1)
L.append([s,s+d-1])
L.sort()
C=False
if C:
if d<L[0][0]:
print(1,d)
L.append([1,d])
L.sort()
C=False
else:
for i in range(len(L)):
if i<(len(L)-1) and (L[i][1]+d)<L[i+1][0]:
print(L[i][1]+1,L[i][1]+d)
L.append([L[i][1]+1,L[i][1]+d])
L.sort()
C=False
break
if not B and C:
print(L[len(L)-1][1]+1,L[len(L)-1][1]+d)
L.append([L[len(L)-1][1]+1,L[len(L)-1][1]+d])
L.sort()
```
| 72,955 | [
0.23291015625,
0.26904296875,
-0.1153564453125,
-0.011199951171875,
-0.60693359375,
-0.265869140625,
-0.467529296875,
0.0165252685546875,
0.265625,
0.84619140625,
0.7568359375,
-0.045867919921875,
0.22705078125,
-0.81787109375,
-0.73876953125,
0.1324462890625,
-0.372314453125,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Tags: implementation
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
# sys.setrecursionlimit(300000)
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
# sys.setrecursionlimit(300000)
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")
# -------------------game starts now----------------------------------------------------import math
# -----------------------------------------------binary seacrh tree---------------------------------------
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n = int(input())
l=[]
for i in range(n):
s,d=map(int,input().split())
l.append((s,d))
ans=[]
heapq.heapify(ans)
for i in range(n):
s,d=l[i]
f=0
#print(ans)
for j in range(len(ans)):
if s>ans[j][1] or s+d-1<ans[j][0]:
continue
else:
f=1
break
if f==0:
print(s,s+d-1)
heapq.heappush(ans,(s,s+d-1))
continue
res=[]
e=heapq.heappop(ans)
#print(ans,e)
if d<e[0]:
print(1,d)
heapq.heappush(ans,e)
heapq.heappush(ans,(1,d))
continue
heapq.heappush(ans,e)
#print(ans,l[i])
while(len(ans)>0):
e=heapq.heappop(ans)
e1=(9999999999999999999,9999999999999999999)
if len(ans)>0:
e1=heapq.heappop(ans)
#print(e,e1,ans)
if e[1]+1+d-1<e1[0]:
print(e[1]+1,e[1]+1+d-1)
heapq.heappush(ans,(e[1]+1,e[1]+1+d-1))
res.append(e)
if e1[0] != 9999999999999999999:
heapq.heappush(ans, e1)
break
res.append(e)
if e1[0]!=9999999999999999999:
heapq.heappush(ans,e1)
for i in res:
heapq.heappush(ans,i)
```
| 72,956 | [
0.23291015625,
0.26904296875,
-0.1153564453125,
-0.011199951171875,
-0.60693359375,
-0.265869140625,
-0.467529296875,
0.0165252685546875,
0.265625,
0.84619140625,
0.7568359375,
-0.045867919921875,
0.22705078125,
-0.81787109375,
-0.73876953125,
0.1324462890625,
-0.372314453125,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Tags: implementation
Correct Solution:
```
n = int(input())
cur = []
def good(s, e):
if s < 1:
return False
assert s <= e
for l, r in cur:
if max(l, s) <= min(r, e):
return False
return True
for i in range(n):
s, d = map(int, input().split())
e = s+d-1
if not good(s, e):
s = int(2e9)
if good(1, d):
s = 1
for l, r in cur:
if good(l-d, l-1):
s = min(s, l-d)
if good(r+1, r+d):
s = min(s, r+1)
cur.append((s, s+d-1))
cur.sort()
print(s, s+d-1)
```
| 72,957 | [
0.23291015625,
0.26904296875,
-0.1153564453125,
-0.011199951171875,
-0.60693359375,
-0.265869140625,
-0.467529296875,
0.0165252685546875,
0.265625,
0.84619140625,
0.7568359375,
-0.045867919921875,
0.22705078125,
-0.81787109375,
-0.73876953125,
0.1324462890625,
-0.372314453125,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Tags: implementation
Correct Solution:
```
#!/usr/bin/env python3
def main():
try:
while True:
n = int(input())
req = [tuple(map(int, input().split())) for i in range(n)]
used = [(req[0][0], req[0][0] + req[0][1])]
print(used[0][0], used[0][1] - 1)
for start, dur in req[1:]:
last = 1
for a, b in used:
if last <= start and start + dur <= a:
used.append((start, start + dur))
used.sort()
print(start, start + dur - 1)
break
last = b
else:
if start >= used[-1][1]:
used.append((start, start + dur))
used.sort()
print(start, start + dur - 1)
else:
last = 1
for a, b in used:
if a - last >= dur:
used.append((last, last + dur))
used.sort()
break
last = b
else:
used.append((last, last + dur))
# used.sort()
print(last, last + dur - 1)
except EOFError:
pass
main()
```
| 72,958 | [
0.23291015625,
0.26904296875,
-0.1153564453125,
-0.011199951171875,
-0.60693359375,
-0.265869140625,
-0.467529296875,
0.0165252685546875,
0.265625,
0.84619140625,
0.7568359375,
-0.045867919921875,
0.22705078125,
-0.81787109375,
-0.73876953125,
0.1324462890625,
-0.372314453125,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Tags: implementation
Correct Solution:
```
n = int(input())
l, r = [0] * n, [0] * n
f = lambda x, y: all(x > r[j] or y < l[j] for j in range(i))
for i in range(n):
x, d = map(int, input().split())
y = x + d - 1
if not f(x, y):
k = min(r[j] for j in range(i + 1) if f(r[j] + 1, r[j] + d))
x, y = k + 1, k + d
l[i], r[i] = x, y
print(x, y)
```
| 72,959 | [
0.23291015625,
0.26904296875,
-0.1153564453125,
-0.011199951171875,
-0.60693359375,
-0.265869140625,
-0.467529296875,
0.0165252685546875,
0.265625,
0.84619140625,
0.7568359375,
-0.045867919921875,
0.22705078125,
-0.81787109375,
-0.73876953125,
0.1324462890625,
-0.372314453125,
-0.4... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Submitted Solution:
```
from bisect import bisect_left, insort_left
a = []
n = int(input())
for _ in range(n):
#print(a)
s, d = map(int, input().split())
if len(a) == 0:
print(s, s+d - 1)
a.append((s, s + d - 1))
continue
p = bisect_left(a, (s, s + d - 1))
#print('p', p)
ok = True
if p > 0 and a[p-1][1] >= s:
ok = False
if p < len(a) and a[p][0] <= s + d - 1:
ok = False
if ok:
insort_left(a, (s, s + d - 1))
print(s, s + d - 1)
else:
ok = False
for i in range(len(a)):
if i == 0:
if a[0][0] > d:
print(1,d)
a = [(1, d)] + a
ok = True
break
else:
if a[i - 1][1] + d < a[i][0]:
print(a[i - 1][1] + 1, a[i - 1][1] + d)
insort_left(a, (a[i - 1][1] + 1, a[i - 1][1] + d))
ok = True
break
if not ok:
print(a[-1][1] + 1, a[-1][1] + d)
insort_left(a, (a[-1][1] + 1, a[-1][1] + d))
```
Yes
| 72,960 | [
0.2486572265625,
0.2783203125,
-0.151611328125,
0.029327392578125,
-0.65380859375,
-0.10809326171875,
-0.5244140625,
0.07843017578125,
0.28955078125,
0.8125,
0.66015625,
-0.049468994140625,
0.182373046875,
-0.806640625,
-0.74365234375,
0.08148193359375,
-0.360107421875,
-0.46484375... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Submitted Solution:
```
def dotwointervals(l1,r1,l2,r2):
if(l1<l2 and r1<l2):
return 0
elif(l1>r2 and r1>r2):
return 0
return 1
n=int(input())
lofdays=[]
for you in range(n):
l=input().split()
si=int(l[0])
di=int(l[1])
if(you==0):
lofdays.append((si,si+di-1))
print(si,si+di-1)
else:
nowint=(si,si+di-1)
done=1
for i in lofdays:
if(dotwointervals(nowint[0],nowint[1],i[0],i[1])):
done=0
break
if(done==1):
lofdays.append(nowint)
print(si,si+di-1)
else:
mina=min(lofdays)
if(mina[0]-di>0):
print(1,di)
lofdays.append((1,di))
else:
lofdays.sort()
done=0
for i in range(1,len(lofdays)):
if(lofdays[i][0]-lofdays[i-1][1]-1>=di):
done=1
print(lofdays[i-1][1]+1,lofdays[i-1][1]+di)
lofdays.append((lofdays[i-1][1]+1,lofdays[i-1][1]+di))
break
if(done==0):
print(lofdays[-1][1]+1,lofdays[-1][1]+di)
lofdays.append((lofdays[-1][1]+1,lofdays[-1][1]+di))
```
Yes
| 72,961 | [
0.2486572265625,
0.2783203125,
-0.151611328125,
0.029327392578125,
-0.65380859375,
-0.10809326171875,
-0.5244140625,
0.07843017578125,
0.28955078125,
0.8125,
0.66015625,
-0.049468994140625,
0.182373046875,
-0.806640625,
-0.74365234375,
0.08148193359375,
-0.360107421875,
-0.46484375... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
# sys.setrecursionlimit(300000)
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
# sys.setrecursionlimit(300000)
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")
# -------------------game starts now----------------------------------------------------import math
# -----------------------------------------------binary seacrh tree---------------------------------------
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n = int(input())
l=[]
for i in range(n):
s,d=map(int,input().split())
l.append((s,d))
ans=[]
heapq.heapify(ans)
for i in range(n):
s,d=l[i]
f=0
for j in range(len(ans)):
if s>ans[j][1] or s+d-1<ans[j][0]:
continue
else:
f=1
break
if f==0:
print(s,s+d-1)
heapq.heappush(ans,(s,s+d-1))
continue
res=[]
e=heapq.heappop(ans)
#print(ans,e)
if d<e[0]:
print(1,d)
heapq.heappush(ans,e)
heapq.heappush(ans,(1,d))
continue
heapq.heappush(ans, e)
#print(ans,l[i])
while(len(ans)>0):
e=heapq.heappop(ans)
e1=(9999999999999999,9999999999999999)
if len(ans)>0:
e1=heapq.heappop(ans)
#print(e,e1,ans)
if e[1]+1+d-1<e1[0]:
print(e[1]+1,e[1]+1+d-1)
heapq.heappush(ans,(e[1]+1,e[1]+1+d-1))
break
res.append(e)
heapq.heappush(ans,e1)
for i in res:
heapq.heappush(ans,i)
```
No
| 72,962 | [
0.2486572265625,
0.2783203125,
-0.151611328125,
0.029327392578125,
-0.65380859375,
-0.10809326171875,
-0.5244140625,
0.07843017578125,
0.28955078125,
0.8125,
0.66015625,
-0.049468994140625,
0.182373046875,
-0.806640625,
-0.74365234375,
0.08148193359375,
-0.360107421875,
-0.46484375... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Submitted Solution:
```
n=int(input())
L=[]
for j in range(n):
ch=input().split()
s,d=int(ch[0]),int(ch[1])
if j==0:
print(s,d+s-1)
L.append([s,s+d-1])
L.sort()
else:
B=True
C=True
for i in range(len(L)):
if i<(len(L)-1) and s>L[i][1] and s+d-1<L[i+1][0]:
print(s,s+d-1)
L.append([s,s+d-1])
L.sort()
C=False
break
if L[i][1]>=s>=L[i][0] or L[i][0]<=(s+d-1)<=L[i][1] or (s<=L[i][0] and (s+d-1)>=L[i][1]):
B=False
break
if C:
if d<L[0][0]:
print(1,d)
L.append([1,d])
L.sort()
C=False
else:
for i in range(len(L)):
if i<(len(L)-1) and (L[i][1]+d)<L[i+1][0]:
print(L[i][1]+1,L[i][1]+d)
L.append([L[i][1]+1,L[i][1]+d])
L.sort()
C=False
break
if B and C:
print(s,s+d-1)
L.append([s,s+d-1])
L.sort()
elif not B and C:
print(L[len(L)-1][1]+1,L[len(L)-1][1]+d)
L.append([L[len(L)-1][1]+1,L[len(L)-1][1]+d])
L.sort()
```
No
| 72,963 | [
0.2486572265625,
0.2783203125,
-0.151611328125,
0.029327392578125,
-0.65380859375,
-0.10809326171875,
-0.5244140625,
0.07843017578125,
0.28955078125,
0.8125,
0.66015625,
-0.049468994140625,
0.182373046875,
-0.806640625,
-0.74365234375,
0.08148193359375,
-0.360107421875,
-0.46484375... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp starts his own business. Tomorrow will be the first working day of his car repair shop. For now the car repair shop is very small and only one car can be repaired at a given time.
Polycarp is good at marketing, so he has already collected n requests from clients. The requests are numbered from 1 to n in order they came.
The i-th request is characterized by two values: si — the day when a client wants to start the repair of his car, di — duration (in days) to repair the car. The days are enumerated from 1, the first day is tomorrow, the second day is the day after tomorrow and so on.
Polycarp is making schedule by processing requests in the order from the first to the n-th request. He schedules the i-th request as follows:
* If the car repair shop is idle for di days starting from si (si, si + 1, ..., si + di - 1), then these days are used to repair a car of the i-th client.
* Otherwise, Polycarp finds the first day x (from 1 and further) that there are di subsequent days when no repair is scheduled starting from x. In other words he chooses the smallest positive x that all days x, x + 1, ..., x + di - 1 are not scheduled for repair of any car. So, the car of the i-th client will be repaired in the range [x, x + di - 1]. It is possible that the day x when repair is scheduled to start will be less than si.
Given n requests, you are asked to help Polycarp schedule all of them according to the rules above.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of requests from clients.
The following n lines contain requests, one request per line. The i-th request is given as the pair of integers si, di (1 ≤ si ≤ 109, 1 ≤ di ≤ 5·106), where si is the preferred time to start repairing the i-th car, di is the number of days to repair the i-th car.
The requests should be processed in the order they are given in the input.
Output
Print n lines. The i-th line should contain two integers — the start day to repair the i-th car and the finish day to repair the i-th car.
Examples
Input
3
9 2
7 3
2 4
Output
9 10
1 3
4 7
Input
4
1000000000 1000000
1000000000 1000000
100000000 1000000
1000000000 1000000
Output
1000000000 1000999999
1 1000000
100000000 100999999
1000001 2000000
Submitted Solution:
```
t, p = 1, []
for i in range(int(input())):
l, d = map(int, input().split())
r = l + d
if t > l:
for i, q in enumerate(p, 1):
if q[0] <= l <= q[1] - d:
p.insert(i, [r, q[1]])
q[1] = l
break
else:
for q in p:
if q[0] <= q[1] - d:
l = q[0]
q[0] += d
break
else:
l = t
t += d
else:
p.append([t, l])
t = r
print(l, r - 1)
```
No
| 72,964 | [
0.2486572265625,
0.2783203125,
-0.151611328125,
0.029327392578125,
-0.65380859375,
-0.10809326171875,
-0.5244140625,
0.07843017578125,
0.28955078125,
0.8125,
0.66015625,
-0.049468994140625,
0.182373046875,
-0.806640625,
-0.74365234375,
0.08148193359375,
-0.360107421875,
-0.46484375... | 24 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.