message stringlengths 2 43.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 853 107k | cluster float64 24 24 | __index_level_0__ int64 1.71k 214k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has a favorite sequence a[1 ... n] consisting of n integers. He wrote it out on the whiteboard as follows:
* he wrote the number a_1 to the left side (at the beginning of the whiteboard);
* he wrote the number a_2 to the right side (at the end of the whiteboard);
* then as far to the left as possible (but to the right from a_1), he wrote the number a_3;
* then as far to the right as possible (but to the left from a_2), he wrote the number a_4;
* Polycarp continued to act as well, until he wrote out the entire sequence on the whiteboard.
<image> The beginning of the result looks like this (of course, if n ≥ 4).
For example, if n=7 and a=[3, 1, 4, 1, 5, 9, 2], then Polycarp will write a sequence on the whiteboard [3, 4, 5, 2, 9, 1, 1].
You saw the sequence written on the whiteboard and now you want to restore Polycarp's favorite sequence.
Input
The first line contains a single positive integer t (1 ≤ t ≤ 300) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 300) — the length of the sequence written on the whiteboard.
The next line contains n integers b_1, b_2,…, b_n (1 ≤ b_i ≤ 10^9) — the sequence written on the whiteboard.
Output
Output t answers to the test cases. Each answer — is a sequence a that Polycarp wrote out on the whiteboard.
Example
Input
6
7
3 4 5 2 9 1 1
4
9 2 7 1
11
8 4 3 1 2 7 8 7 9 4 2
1
42
2
11 7
8
1 1 1 1 1 1 1 1
Output
3 1 4 1 5 9 2
9 1 2 7
8 2 4 4 3 9 1 7 2 8 7
42
11 7
1 1 1 1 1 1 1 1
Note
In the first test case, the sequence a matches the sequence from the statement. The whiteboard states after each step look like this:
[3] ⇒ [3, 1] ⇒ [3, 4, 1] ⇒ [3, 4, 1, 1] ⇒ [3, 4, 5, 1, 1] ⇒ [3, 4, 5, 9, 1, 1] ⇒ [3, 4, 5, 2, 9, 1, 1].
Submitted Solution:
```
try:
for t in range(int(input())):
n=int(input())
arr=[int(x) for x in input().split()]
a=0
b=-1
ans=[]
for i in range(len(arr)):
if i%2==0:
ans.append(arr[a])
a=a+1
else:
ans.append(arr[b])
b=b-1
for i in arr:
print(i,end=' ')
except:
pass
``` | instruction | 0 | 31,964 | 24 | 63,928 |
No | output | 1 | 31,964 | 24 | 63,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has a favorite sequence a[1 ... n] consisting of n integers. He wrote it out on the whiteboard as follows:
* he wrote the number a_1 to the left side (at the beginning of the whiteboard);
* he wrote the number a_2 to the right side (at the end of the whiteboard);
* then as far to the left as possible (but to the right from a_1), he wrote the number a_3;
* then as far to the right as possible (but to the left from a_2), he wrote the number a_4;
* Polycarp continued to act as well, until he wrote out the entire sequence on the whiteboard.
<image> The beginning of the result looks like this (of course, if n ≥ 4).
For example, if n=7 and a=[3, 1, 4, 1, 5, 9, 2], then Polycarp will write a sequence on the whiteboard [3, 4, 5, 2, 9, 1, 1].
You saw the sequence written on the whiteboard and now you want to restore Polycarp's favorite sequence.
Input
The first line contains a single positive integer t (1 ≤ t ≤ 300) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 300) — the length of the sequence written on the whiteboard.
The next line contains n integers b_1, b_2,…, b_n (1 ≤ b_i ≤ 10^9) — the sequence written on the whiteboard.
Output
Output t answers to the test cases. Each answer — is a sequence a that Polycarp wrote out on the whiteboard.
Example
Input
6
7
3 4 5 2 9 1 1
4
9 2 7 1
11
8 4 3 1 2 7 8 7 9 4 2
1
42
2
11 7
8
1 1 1 1 1 1 1 1
Output
3 1 4 1 5 9 2
9 1 2 7
8 2 4 4 3 9 1 7 2 8 7
42
11 7
1 1 1 1 1 1 1 1
Note
In the first test case, the sequence a matches the sequence from the statement. The whiteboard states after each step look like this:
[3] ⇒ [3, 1] ⇒ [3, 4, 1] ⇒ [3, 4, 1, 1] ⇒ [3, 4, 5, 1, 1] ⇒ [3, 4, 5, 9, 1, 1] ⇒ [3, 4, 5, 2, 9, 1, 1].
Submitted Solution:
```
import math
for i in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
k = [0]*n
for i in range(0,n//2):
k[2*i] = l[i]
#print(k)
k[-1] = l[n//2]
#print(l)
for i in range(0,n//2):
k[2*i + 1] = l[n-1-i]
print(k)
``` | instruction | 0 | 31,965 | 24 | 63,930 |
No | output | 1 | 31,965 | 24 | 63,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has a favorite sequence a[1 ... n] consisting of n integers. He wrote it out on the whiteboard as follows:
* he wrote the number a_1 to the left side (at the beginning of the whiteboard);
* he wrote the number a_2 to the right side (at the end of the whiteboard);
* then as far to the left as possible (but to the right from a_1), he wrote the number a_3;
* then as far to the right as possible (but to the left from a_2), he wrote the number a_4;
* Polycarp continued to act as well, until he wrote out the entire sequence on the whiteboard.
<image> The beginning of the result looks like this (of course, if n ≥ 4).
For example, if n=7 and a=[3, 1, 4, 1, 5, 9, 2], then Polycarp will write a sequence on the whiteboard [3, 4, 5, 2, 9, 1, 1].
You saw the sequence written on the whiteboard and now you want to restore Polycarp's favorite sequence.
Input
The first line contains a single positive integer t (1 ≤ t ≤ 300) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 300) — the length of the sequence written on the whiteboard.
The next line contains n integers b_1, b_2,…, b_n (1 ≤ b_i ≤ 10^9) — the sequence written on the whiteboard.
Output
Output t answers to the test cases. Each answer — is a sequence a that Polycarp wrote out on the whiteboard.
Example
Input
6
7
3 4 5 2 9 1 1
4
9 2 7 1
11
8 4 3 1 2 7 8 7 9 4 2
1
42
2
11 7
8
1 1 1 1 1 1 1 1
Output
3 1 4 1 5 9 2
9 1 2 7
8 2 4 4 3 9 1 7 2 8 7
42
11 7
1 1 1 1 1 1 1 1
Note
In the first test case, the sequence a matches the sequence from the statement. The whiteboard states after each step look like this:
[3] ⇒ [3, 1] ⇒ [3, 4, 1] ⇒ [3, 4, 1, 1] ⇒ [3, 4, 5, 1, 1] ⇒ [3, 4, 5, 9, 1, 1] ⇒ [3, 4, 5, 2, 9, 1, 1].
Submitted Solution:
```
ans = []
def solve(arr):
a = ""
index = 0
eq = 0
if len(arr) % 2 == 0:
l = len(arr) // 2
else:
l = len(arr) // 2 + 1
while index != l:
if eq % 2 == 0:
a += str(arr[0 + index]) + " "
else:
a += str(arr[-1 - index]) + " "
index += 1
eq += 1
if len(arr) % 2 != 0 and len(arr) > 4:
return a[0:-2]
return a
if __name__ == '__main__':
k = int(input())
arr = []
for i in range(k):
n = input()
arr.append([int(x) for x in input().split()])
for i in range(len(arr)):
print(solve(arr[i]))
``` | instruction | 0 | 31,966 | 24 | 63,932 |
No | output | 1 | 31,966 | 24 | 63,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has a favorite sequence a[1 ... n] consisting of n integers. He wrote it out on the whiteboard as follows:
* he wrote the number a_1 to the left side (at the beginning of the whiteboard);
* he wrote the number a_2 to the right side (at the end of the whiteboard);
* then as far to the left as possible (but to the right from a_1), he wrote the number a_3;
* then as far to the right as possible (but to the left from a_2), he wrote the number a_4;
* Polycarp continued to act as well, until he wrote out the entire sequence on the whiteboard.
<image> The beginning of the result looks like this (of course, if n ≥ 4).
For example, if n=7 and a=[3, 1, 4, 1, 5, 9, 2], then Polycarp will write a sequence on the whiteboard [3, 4, 5, 2, 9, 1, 1].
You saw the sequence written on the whiteboard and now you want to restore Polycarp's favorite sequence.
Input
The first line contains a single positive integer t (1 ≤ t ≤ 300) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 300) — the length of the sequence written on the whiteboard.
The next line contains n integers b_1, b_2,…, b_n (1 ≤ b_i ≤ 10^9) — the sequence written on the whiteboard.
Output
Output t answers to the test cases. Each answer — is a sequence a that Polycarp wrote out on the whiteboard.
Example
Input
6
7
3 4 5 2 9 1 1
4
9 2 7 1
11
8 4 3 1 2 7 8 7 9 4 2
1
42
2
11 7
8
1 1 1 1 1 1 1 1
Output
3 1 4 1 5 9 2
9 1 2 7
8 2 4 4 3 9 1 7 2 8 7
42
11 7
1 1 1 1 1 1 1 1
Note
In the first test case, the sequence a matches the sequence from the statement. The whiteboard states after each step look like this:
[3] ⇒ [3, 1] ⇒ [3, 4, 1] ⇒ [3, 4, 1, 1] ⇒ [3, 4, 5, 1, 1] ⇒ [3, 4, 5, 9, 1, 1] ⇒ [3, 4, 5, 2, 9, 1, 1].
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
i=1
ui=0
uj=n-1
l1=[]
while(ui<=uj):
if(i):
i=0
l1.append(l[ui])
ui+=1
else:
i=1
l1.append(l[uj])
uj-=1
for i in range(n):
print(l[i],end=" ")
``` | instruction | 0 | 31,967 | 24 | 63,934 |
No | output | 1 | 31,967 | 24 | 63,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo". | instruction | 0 | 32,651 | 24 | 65,302 |
Tags: dp, greedy
Correct Solution:
```
for _ in[0]*int(input()):
s=input();i=0;r=[]
while i<len(s):
if'twone'==s[i:i+5]:r+=i+3,;i+=4
if s[i:i+3]in('one','two'):r+=i+2,
i+=1
print(len(r),*r)
``` | output | 1 | 32,651 | 24 | 65,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo". | instruction | 0 | 32,652 | 24 | 65,304 |
Tags: dp, greedy
Correct Solution:
```
if __name__ == "__main__":
for _ in range(int(input())):
s = input()
twone = []
one = []
two = []
n = len(s)
for i in range(n - 5 + 1):
if s[i : i + 5] == "twone":
twone.append(i)
for i in range(n - 3 + 1):
if s[i : i + 3] == "one":
one.append(i)
for i in range(n - 3 + 1):
if s[i : i + 3] == "two":
two.append(i)
print(len(one) + len(two) - len(twone))
twoneset = set(twone)
for num in one:
if num - 2 not in twoneset:
print(num + 2, end = ' ')
for num in two:
if num not in twoneset:
print(num + 2, end = ' ')
for num in twone:
print(num + 3, end = ' ')
# print(one)
print()
``` | output | 1 | 32,652 | 24 | 65,305 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo". | instruction | 0 | 32,653 | 24 | 65,306 |
Tags: dp, greedy
Correct Solution:
```
for _ in range(int(input())):
s = input()
c = []
s = s.replace("twone", "tw+ne")
s = s.replace("two", "t+o")
s = s.replace("one", "o+e")
for i in range(len(s)):
if s[i] == '+':
c.append(i+1)
print(len(c))
print(*c)
``` | output | 1 | 32,653 | 24 | 65,307 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo". | instruction | 0 | 32,654 | 24 | 65,308 |
Tags: dp, greedy
Correct Solution:
```
def find(s, string):
inds = []
for i in range(len(s)):
if i + len(string) > len(s): break
if s[i:i+len(string)] == string: inds.append(i)
return set(inds)
t = int(input())
for i in range(t):
s = input()
ones = find(s, "one")
twos = find(s, "two")
both = find(s, "twone")
inds = []
for item in ones:
if item-2 not in both:
inds.append(item+1)
for item in twos:
if item not in both:
inds.append(item+1)
for item in both:
inds.append(item+2)
print(len(inds))
print(" ".join(str(x+1) for x in inds))
``` | output | 1 | 32,654 | 24 | 65,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo". | instruction | 0 | 32,655 | 24 | 65,310 |
Tags: dp, greedy
Correct Solution:
```
from sys import stdin
from collections import deque
mod = 10**9 + 7
# def rl():
# return [int(w) for w in stdin.readline().split()]
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
ok=55
for i in range(100002):
ok=ok+1
t = int(input())
for _ in range(t):
s = input()
ans = set()
for i in range(len(s)-2):
if i+1 not in ans:
if s[i] == 't' and s[i+1] == 'w' and s[i+2] == 'o':
try:
if s[i+3] == 'o':
ans.add(i+2)
else:
try:
if s[i+3] == 'n' and s[i+4] == 'e':
ans.add(i+3)
else:
ans.add(i+2)
except:
ans.add(i+2)
except:
ans.add(i+2)
if s[i] == 'o' and s[i+1] == 'n' and s[i+2] == 'e' and i+2 not in ans and i+3 not in ans:
ans.add(i+2)
print(len(ans))
print(*ans)
``` | output | 1 | 32,655 | 24 | 65,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo". | instruction | 0 | 32,656 | 24 | 65,312 |
Tags: dp, greedy
Correct Solution:
```
t=int(input())
for _ in range(t):
s=input()+" "
i=0
ans=[]
while i<len(s)-3:
if s[i]=='o':
if s[i+1]=='n':
if s[i+2]=='e':
ans.append(i+1)
i+=2
else:
i+=1
elif s[i]=='t':
if s[i+1]=='w':
if s[i+2]=='o':
if s[i+3]=='n':
ans.append(i+2)
i+=3
else:
ans.append(i+1)
i+=2
else:
i+=1
i+=1
if len(ans)==0:
print(0)
print()
else:
print(len(ans))
for i in ans:
print(i+1,end=" ")
print()
``` | output | 1 | 32,656 | 24 | 65,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo". | instruction | 0 | 32,657 | 24 | 65,314 |
Tags: dp, greedy
Correct Solution:
```
t = int(input())
for _ in range(t):
s = input()
i = 0
R = []
while i < len(s):
# print(s[i:i+5])
if i+4<len(s) and s[i:i+5] == "twone":
# print('paso')
R.append(i+2+1)
i+=5
elif i+2<len(s) and (s[i:i+3] == "one" or s[i:i+3] == "two"):
R.append(i+1+1)
i+=3
else: i+=1
print(len(R))
for i in R:
print(i, end=' ')
print()
``` | output | 1 | 32,657 | 24 | 65,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo". | instruction | 0 | 32,658 | 24 | 65,316 |
Tags: dp, greedy
Correct Solution:
```
from sys import stdin,stdout
from collections import Counter
for _ in range(int(stdin.readline())):
# n=int(stdin.readline())
# a=list(map(int,stdin.readline().split()))
s=list(input())
n=len(s)
ans=[]
for i in range(n-4):
sub=s[i:i+5]
if sub==list('twone'):
ans+=[i+3]
s[i+2]=' '
for i in range(n-2):
sub=s[i:i+3]
if sub in [list('one'),list('two')]:
ans+=[i+2]
s[i+1]=' '
print(len(ans))
print(*ans)
``` | output | 1 | 32,658 | 24 | 65,317 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
Submitted Solution:
```
#Bhargey Mehta (Junior)
#DA-IICT, Gandhinagar
import sys, math
MOD = 10**9+7
#sys.stdin = open('input.txt', 'r')
for _ in range(int(input())):
s = input()+'x'
r = []
for i in range(len(s)):
if s[i:i+3] == 'two':
if s[i:i+5] != 'twone':
r.append(i+2)
else:
r.append(i+3)
elif s[i:i+3] == 'one':
if s[i-2:i+3] != 'twone':
r.append(i+2)
print(len(r))
print(*r)
``` | instruction | 0 | 32,659 | 24 | 65,318 |
Yes | output | 1 | 32,659 | 24 | 65,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
Submitted Solution:
```
t = int(input())
for _ in range(t):
s = input()
ans=[]
i=2
while (i<len(s)):
if (s[i-2:i+1]=='one'):
ans.append(i)
i+=3
elif (s[i-2:i+1]=='two'):
if (i+1<len(s)) and (s[i+1]=='n'):
ans.append(i+1)
else:
ans.append(i)
i += 3
else:
i+=1
print (len(ans))
print (*ans)
``` | instruction | 0 | 32,660 | 24 | 65,320 |
Yes | output | 1 | 32,660 | 24 | 65,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
Submitted Solution:
```
# cook your dish here
for _ in [0]*int(input()):
s = input()
i = 0
r = []
while i < len(s):
if 'twone' == s[i:i+5]:
i += 3
r += i,
if s[i:i+3] in ('one', 'two'):
r += i+2,
i += 1
print(len(r))
print(*r)
``` | instruction | 0 | 32,661 | 24 | 65,322 |
Yes | output | 1 | 32,661 | 24 | 65,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
Submitted Solution:
```
def one_two(s):
ch1="one"
ch2="two"
ch3="twone"
final=""
i=0
count=0
l=[]
while(i<len(s)):
if(s[i:i+5]==ch3):
l.append(i+3)
i=i+5
elif(s[i:i+3:]==ch1 or s[i:i+3:] ==ch2):
l.append(i+2)
i=i+3
else:
i=i+1
print(len(l))
print(*l)
n=int(input())
for i in range(0,n):
s=input()
one_two(s)
``` | instruction | 0 | 32,662 | 24 | 65,324 |
Yes | output | 1 | 32,662 | 24 | 65,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
Submitted Solution:
```
#########################################################################################################\
#########################################################################################################
###################################The_Apurv_Rathore#####################################################
#########################################################################################################
#########################################################################################################
import sys,os,io
from sys import stdin
from types import GeneratorType
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_left , bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')
#for deep recursion__________________________________________-
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,p - 2, p)) % p
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
c = dict(Counter(l))
return list(set(l))
# return c
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
#____________________GetPrimeFactors in log(n)________________________________________
def sieveForSmallestPrimeFactor():
MAXN = 100001
spf = [0 for i in range(MAXN)]
spf[1] = 1
for i in range(2, MAXN):
spf[i] = i
for i in range(4, MAXN, 2):
spf[i] = 2
for i in range(3, math.ceil(math.sqrt(MAXN))):
if (spf[i] == i):
for j in range(i * i, MAXN, i):
if (spf[j] == j):
spf[j] = i
return spf
def getPrimeFactorizationLOGN(x):
spf = sieveForSmallestPrimeFactor()
ret = list()
while (x != 1):
ret.append(spf[x])
x = x // spf[x]
return ret
#____________________________________________________________
def SieveOfEratosthenes(n):
#time complexity = nlog(log(n))
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
def si():
return input()
def divideCeil(n,x):
if (n%x==0):
return n//x
return n//x+1
def ii():
return int(input())
def li():
return list(map(int,input().split()))
#__________________________TEMPLATE__________________OVER_______________________________________________________
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
# else:
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def findall(p, s):
'''Yields all the positions of
the pattern p in the string s.'''
i = s.find(p)
while i != -1:
yield i
i = s.find(p, i+1)
def solve():
x = si()
poss = ['two','one','twoone']
ind = [i for i in findall(poss[2], x)]
ans = []
x = list(x)
for i in ind:
x[i+2]='1'
ans.append(i+1+2)
x = ''.join(x)
ind = [i for i in findall(poss[1], x)]
x = list(x)
for i in ind:
x[i]='1'
ans.append(i+1)
x = ''.join(x)
ind = [i for i in findall(poss[0], x)]
x = list(x)
for i in ind:
x[i]='1'
ans.append(i+1)
# print(x)
print(len(ans))
# print(''.join(x))
print(*ans)
t = 1
t = ii()
for _ in range(t):
solve()
``` | instruction | 0 | 32,663 | 24 | 65,326 |
No | output | 1 | 32,663 | 24 | 65,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
Submitted Solution:
```
if __name__ == "__main__":
for _ in range(int(input())):
s = input()
twone = []
one = []
two = []
n = len(s)
for i in range(n - 4):
if s[i : i + 5] == "twone":
twone.append(i)
for i in range(n - 2):
if s[i : i + 3] == "one":
one.append(i)
for i in range(n - 2):
if s[i : i + 3] == "two":
two.append(i)
print(len(one) + len(two) - len(twone))
twoneset = set(twone)
for num in one:
if num - 2 not in twoneset:
print(num + 1, end = ' ')
for num in two:
if num not in twoneset:
print(num + 1, end = ' ')
for num in twoneset:
print(num + 3, end = ' ')
# print(one)
print()
``` | instruction | 0 | 32,664 | 24 | 65,328 |
No | output | 1 | 32,664 | 24 | 65,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
Submitted Solution:
```
def one_two(s):
ch1="one"
ch2="two"
ch3="twone"
final=""
i=0
count=0
while(i<len(s)):
if(s[i]=='o'):
p=s[i:i+3:]
if(p==ch1):
final=final+str(i+2)+" "
i=i+3
count=count+1
else:
i=i+1
elif(s[i]=='t'):
p=s[i:i+3:]
p1=s[i:i+5:]
if(p==ch3):
final=final+str(i+3)+" "
i=i+5
count=count+1
elif(p1==ch2):
final=final+str(i+2)+" "
i=i+3
count=count+1
else:
i=i+1
else:
i=i+1
print(count)
print(final)
n=int(input())
for i in range(0,n):
s=input()
one_two(s)
``` | instruction | 0 | 32,665 | 24 | 65,330 |
No | output | 1 | 32,665 | 24 | 65,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s=s_1s_2... s_n, which consists only of lowercase Latin letters. Polycarp does not like a string if it contains at least one string "one" or at least one string "two" (or both at the same time) as a substring. In other words, Polycarp does not like the string s if there is an integer j (1 ≤ j ≤ n-2), that s_{j}s_{j+1}s_{j+2}="one" or s_{j}s_{j+1}s_{j+2}="two".
For example:
* Polycarp does not like strings "oneee", "ontwow", "twone" and "oneonetwo" (they all have at least one substring "one" or "two"),
* Polycarp likes strings "oonnee", "twwwo" and "twnoe" (they have no substrings "one" and "two").
Polycarp wants to select a certain set of indices (positions) and remove all letters on these positions. All removals are made at the same time.
For example, if the string looks like s="onetwone", then if Polycarp selects two indices 3 and 6, then "onetwone" will be selected and the result is "ontwne".
What is the minimum number of indices (positions) that Polycarp needs to select to make the string liked? What should these positions be?
Input
The first line of the input contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Next, the test cases are given.
Each test case consists of one non-empty string s. Its length does not exceed 1.5⋅10^5. The string s consists only of lowercase Latin letters.
It is guaranteed that the sum of lengths of all lines for all input data in the test does not exceed 1.5⋅10^6.
Output
Print an answer for each test case in the input in order of their appearance.
The first line of each answer should contain r (0 ≤ r ≤ |s|) — the required minimum number of positions to be removed, where |s| is the length of the given line. The second line of each answer should contain r different integers — the indices themselves for removal in any order. Indices are numbered from left to right from 1 to the length of the string. If r=0, then the second line can be skipped (or you can print empty). If there are several answers, print any of them.
Examples
Input
4
onetwone
testme
oneoneone
twotwo
Output
2
6 3
0
3
4 1 7
2
1 4
Input
10
onetwonetwooneooonetwooo
two
one
twooooo
ttttwo
ttwwoo
ooone
onnne
oneeeee
oneeeeeeetwooooo
Output
6
18 11 12 1 6 21
1
1
1
3
1
2
1
6
0
1
4
0
1
1
2
1 11
Note
In the first example, answers are:
* "onetwone",
* "testme" — Polycarp likes it, there is nothing to remove,
* "oneoneone",
* "twotwo".
In the second example, answers are:
* "onetwonetwooneooonetwooo",
* "two",
* "one",
* "twooooo",
* "ttttwo",
* "ttwwoo" — Polycarp likes it, there is nothing to remove,
* "ooone",
* "onnne" — Polycarp likes it, there is nothing to remove,
* "oneeeee",
* "oneeeeeeetwooooo".
Submitted Solution:
```
t = int(input().strip())
# nums = list(map(int, input().strip().split()))
for _ in range(t):
s = input().strip()
l = len(s)
count = 0
ps = []
for i, c in enumerate(s):
if i == 0 or i == l-1:
continue
elif c == 'n' and s[i-1:i+2] == 'one':
if s[i-3:i+2] != 'twone':
ps.append(str(i))
count += 1
elif c == 'w' and s[i-1:i+2] == 'two':
if s[i-3:i+2] != 'twone':
ps.append(str(i))
count += 1
else:
ps.append(str(i+1))
count += 1
print(count)
print(' '.join(ps))
``` | instruction | 0 | 32,666 | 24 | 65,332 |
No | output | 1 | 32,666 | 24 | 65,333 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur programmer. Now he is analyzing a friend's program. He has already found there the function rangeIncrement(l, r), that adds 1 to each element of some array a for all indexes in the segment [l, r]. In other words, this function does the following:
function rangeIncrement(l, r)
for i := l .. r do
a[i] = a[i] + 1
Polycarpus knows the state of the array a after a series of function calls. He wants to determine the minimum number of function calls that lead to such state. In addition, he wants to find what function calls are needed in this case. It is guaranteed that the required number of calls does not exceed 105.
Before calls of function rangeIncrement(l, r) all array elements equal zero.
Input
The first input line contains a single integer n (1 ≤ n ≤ 105) — the length of the array a[1... n].
The second line contains its integer space-separated elements, a[1], a[2], ..., a[n] (0 ≤ a[i] ≤ 105) after some series of function calls rangeIncrement(l, r).
It is guaranteed that at least one element of the array is positive. It is guaranteed that the answer contains no more than 105 calls of function rangeIncrement(l, r).
Output
Print on the first line t — the minimum number of calls of function rangeIncrement(l, r), that lead to the array from the input data. It is guaranteed that this number will turn out not more than 105.
Then print t lines — the descriptions of function calls, one per line. Each line should contain two integers li, ri (1 ≤ li ≤ ri ≤ n) — the arguments of the i-th call rangeIncrement(l, r). Calls can be applied in any order.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
6
1 2 1 1 4 1
Output
5
2 2
5 5
5 5
5 5
1 6
Input
5
1 0 1 0 1
Output
3
1 1
3 3
5 5
Note
The first sample requires a call for the entire array, and four additional calls:
* one for the segment [2,2] (i.e. the second element of the array),
* three for the segment [5,5] (i.e. the fifth element of the array). | instruction | 0 | 32,787 | 24 | 65,574 |
Tags: data structures, greedy
Correct Solution:
```
n = int(input())
big = 10 ** 5
last = (big + 1) * [ -1 ]
data = list(map(int, input().split()))
data.insert(0, 0)
data.append(0)
result = []
previous = 0
for pos, current in enumerate(data):
if current > previous:
for x in range(previous + 1, current + 1):
last[x] = pos
elif current < previous:
for x in range(previous, current, -1):
result.append('%d %d' % (last[x], pos - 1))
previous = current
print(len(result))
print('\n'.join(result))
``` | output | 1 | 32,787 | 24 | 65,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur programmer. Now he is analyzing a friend's program. He has already found there the function rangeIncrement(l, r), that adds 1 to each element of some array a for all indexes in the segment [l, r]. In other words, this function does the following:
function rangeIncrement(l, r)
for i := l .. r do
a[i] = a[i] + 1
Polycarpus knows the state of the array a after a series of function calls. He wants to determine the minimum number of function calls that lead to such state. In addition, he wants to find what function calls are needed in this case. It is guaranteed that the required number of calls does not exceed 105.
Before calls of function rangeIncrement(l, r) all array elements equal zero.
Input
The first input line contains a single integer n (1 ≤ n ≤ 105) — the length of the array a[1... n].
The second line contains its integer space-separated elements, a[1], a[2], ..., a[n] (0 ≤ a[i] ≤ 105) after some series of function calls rangeIncrement(l, r).
It is guaranteed that at least one element of the array is positive. It is guaranteed that the answer contains no more than 105 calls of function rangeIncrement(l, r).
Output
Print on the first line t — the minimum number of calls of function rangeIncrement(l, r), that lead to the array from the input data. It is guaranteed that this number will turn out not more than 105.
Then print t lines — the descriptions of function calls, one per line. Each line should contain two integers li, ri (1 ≤ li ≤ ri ≤ n) — the arguments of the i-th call rangeIncrement(l, r). Calls can be applied in any order.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
6
1 2 1 1 4 1
Output
5
2 2
5 5
5 5
5 5
1 6
Input
5
1 0 1 0 1
Output
3
1 1
3 3
5 5
Note
The first sample requires a call for the entire array, and four additional calls:
* one for the segment [2,2] (i.e. the second element of the array),
* three for the segment [5,5] (i.e. the fifth element of the array). | instruction | 0 | 32,788 | 24 | 65,576 |
Tags: data structures, greedy
Correct Solution:
```
import re
import sys
exit=sys.exit
from bisect import bisect_left as bsl,bisect_right as bsr
from collections import Counter,defaultdict as ddict,deque
from functools import lru_cache
cache=lru_cache(None)
from heapq import *
from itertools import *
from math import inf
from pprint import pprint as pp
enum=enumerate
ri=lambda:int(rln())
ris=lambda:list(map(int,rfs()))
rln=sys.stdin.readline
rl=lambda:rln().rstrip('\n')
rfs=lambda:rln().split()
mod=1000000007
d4=[(0,-1),(1,0),(0,1),(-1,0)]
d8=[(-1,-1),(0,-1),(1,-1),(-1,0),(1,0),(-1,1),(0,1),(1,1)]
########################################################################
n=ri()
a=ris()
a.append(0)
l,r=[],[]
s=0
for i,x in enum(a):
while s<x:
l.append(i+1)
s+=1
while s>x:
r.append(i)
s-=1
print(len(l))
while l:
print(l.pop(),r.pop())
``` | output | 1 | 32,788 | 24 | 65,577 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur programmer. Now he is analyzing a friend's program. He has already found there the function rangeIncrement(l, r), that adds 1 to each element of some array a for all indexes in the segment [l, r]. In other words, this function does the following:
function rangeIncrement(l, r)
for i := l .. r do
a[i] = a[i] + 1
Polycarpus knows the state of the array a after a series of function calls. He wants to determine the minimum number of function calls that lead to such state. In addition, he wants to find what function calls are needed in this case. It is guaranteed that the required number of calls does not exceed 105.
Before calls of function rangeIncrement(l, r) all array elements equal zero.
Input
The first input line contains a single integer n (1 ≤ n ≤ 105) — the length of the array a[1... n].
The second line contains its integer space-separated elements, a[1], a[2], ..., a[n] (0 ≤ a[i] ≤ 105) after some series of function calls rangeIncrement(l, r).
It is guaranteed that at least one element of the array is positive. It is guaranteed that the answer contains no more than 105 calls of function rangeIncrement(l, r).
Output
Print on the first line t — the minimum number of calls of function rangeIncrement(l, r), that lead to the array from the input data. It is guaranteed that this number will turn out not more than 105.
Then print t lines — the descriptions of function calls, one per line. Each line should contain two integers li, ri (1 ≤ li ≤ ri ≤ n) — the arguments of the i-th call rangeIncrement(l, r). Calls can be applied in any order.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
6
1 2 1 1 4 1
Output
5
2 2
5 5
5 5
5 5
1 6
Input
5
1 0 1 0 1
Output
3
1 1
3 3
5 5
Note
The first sample requires a call for the entire array, and four additional calls:
* one for the segment [2,2] (i.e. the second element of the array),
* three for the segment [5,5] (i.e. the fifth element of the array). | instruction | 0 | 32,789 | 24 | 65,578 |
Tags: data structures, greedy
Correct Solution:
```
N = 100000
v = []
for i in range(0, N) :
v.append([])
line = input()
n = int(line)
line = input()
lineSplit = line.split()
a = 0
for i in range(0, len(lineSplit)) :
b = int(lineSplit[i])
if b > a :
for j in range(a, b) :
v[j].append([i, -1])
elif b < a :
for j in range(a-1, b-1, -1) :
v[j][-1][1] = i
a = b
if a > 0 :
for j in range(0, a) :
v[j][-1][1] = n
c = 0
for i in range(0, N) :
c += len(v[i])
print(c)
#for i in v :
# print(i)
for i in range(0, N) :
for j in range(0, len(v[i])) :
print(v[i][j][0] + 1, v[i][j][1])
``` | output | 1 | 32,789 | 24 | 65,579 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus is an amateur programmer. Now he is analyzing a friend's program. He has already found there the function rangeIncrement(l, r), that adds 1 to each element of some array a for all indexes in the segment [l, r]. In other words, this function does the following:
function rangeIncrement(l, r)
for i := l .. r do
a[i] = a[i] + 1
Polycarpus knows the state of the array a after a series of function calls. He wants to determine the minimum number of function calls that lead to such state. In addition, he wants to find what function calls are needed in this case. It is guaranteed that the required number of calls does not exceed 105.
Before calls of function rangeIncrement(l, r) all array elements equal zero.
Input
The first input line contains a single integer n (1 ≤ n ≤ 105) — the length of the array a[1... n].
The second line contains its integer space-separated elements, a[1], a[2], ..., a[n] (0 ≤ a[i] ≤ 105) after some series of function calls rangeIncrement(l, r).
It is guaranteed that at least one element of the array is positive. It is guaranteed that the answer contains no more than 105 calls of function rangeIncrement(l, r).
Output
Print on the first line t — the minimum number of calls of function rangeIncrement(l, r), that lead to the array from the input data. It is guaranteed that this number will turn out not more than 105.
Then print t lines — the descriptions of function calls, one per line. Each line should contain two integers li, ri (1 ≤ li ≤ ri ≤ n) — the arguments of the i-th call rangeIncrement(l, r). Calls can be applied in any order.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
6
1 2 1 1 4 1
Output
5
2 2
5 5
5 5
5 5
1 6
Input
5
1 0 1 0 1
Output
3
1 1
3 3
5 5
Note
The first sample requires a call for the entire array, and four additional calls:
* one for the segment [2,2] (i.e. the second element of the array),
* three for the segment [5,5] (i.e. the fifth element of the array). | instruction | 0 | 32,790 | 24 | 65,580 |
Tags: data structures, greedy
Correct Solution:
```
import re
import sys
exit=sys.exit
from bisect import bisect_left as bsl,bisect_right as bsr
from collections import Counter,defaultdict as ddict,deque
from functools import lru_cache
cache=lru_cache(None)
from heapq import *
from itertools import *
from math import inf
from pprint import pprint as pp
enum=enumerate
ri=lambda:int(rln())
ris=lambda:list(map(int,rfs()))
rln=sys.stdin.readline
rl=lambda:rln().rstrip('\n')
rfs=lambda:rln().split()
mod=1000000007
d4=[(0,-1),(1,0),(0,1),(-1,0)]
d8=[(-1,-1),(0,-1),(1,-1),(-1,0),(1,0),(-1,1),(0,1),(1,1)]
########################################################################
n=ri()
a=ris()
a.append(0)
ans=[]
stk=[n]
for i,x in enum(a):
while a[stk[-1]]>x:
j=stk.pop()
k=a[j]-max(a[stk[-1]],x)
for _ in range(k):
ans.append((j+1,i))
if a[stk[-1]]<x:
a[j]=x
stk.append(j)
if a[stk[-1]]!=x:
stk.append(i)
print(len(ans))
for i,j in ans:
print(i,j)
``` | output | 1 | 32,790 | 24 | 65,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur programmer. Now he is analyzing a friend's program. He has already found there the function rangeIncrement(l, r), that adds 1 to each element of some array a for all indexes in the segment [l, r]. In other words, this function does the following:
function rangeIncrement(l, r)
for i := l .. r do
a[i] = a[i] + 1
Polycarpus knows the state of the array a after a series of function calls. He wants to determine the minimum number of function calls that lead to such state. In addition, he wants to find what function calls are needed in this case. It is guaranteed that the required number of calls does not exceed 105.
Before calls of function rangeIncrement(l, r) all array elements equal zero.
Input
The first input line contains a single integer n (1 ≤ n ≤ 105) — the length of the array a[1... n].
The second line contains its integer space-separated elements, a[1], a[2], ..., a[n] (0 ≤ a[i] ≤ 105) after some series of function calls rangeIncrement(l, r).
It is guaranteed that at least one element of the array is positive. It is guaranteed that the answer contains no more than 105 calls of function rangeIncrement(l, r).
Output
Print on the first line t — the minimum number of calls of function rangeIncrement(l, r), that lead to the array from the input data. It is guaranteed that this number will turn out not more than 105.
Then print t lines — the descriptions of function calls, one per line. Each line should contain two integers li, ri (1 ≤ li ≤ ri ≤ n) — the arguments of the i-th call rangeIncrement(l, r). Calls can be applied in any order.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
6
1 2 1 1 4 1
Output
5
2 2
5 5
5 5
5 5
1 6
Input
5
1 0 1 0 1
Output
3
1 1
3 3
5 5
Note
The first sample requires a call for the entire array, and four additional calls:
* one for the segment [2,2] (i.e. the second element of the array),
* three for the segment [5,5] (i.e. the fifth element of the array).
Submitted Solution:
```
from bisect import bisect_right
from bisect import bisect_left
n=int(input())
b=list(map(int,input().split()))
res=[]
ind=[[] for i in range(10**5+1)]
j=0
while(j<n):
ind[b[j]].append(j)
j+=1
p=[-1]
p+=ind[0]
ans=[]
p.append(n)
j=0
while(j<len(p)-1):
if p[j]==p[j+1]:
pass
else:
if (p[j]+1)<=(p[j+1]-1):
res.append([p[j]+1,p[j+1]-1])
ans.append([p[j]+1,p[j+1]-1])
j+=1
j=1
while(j<=n):
test_list=ind[j]
i=0
newres=[]
while(i<len(res)):
l,r=res[i][0],res[i][1]
lo = bisect_right(test_list, l-1)
hi = bisect_left(test_list, r+1) - 1
if hi>=lo:
p = [l-1]
p += test_list[lo:hi+1]
p.append(r+1)
q = 0
while (q < len(p)-1):
if p[q] == p[q + 1]:
pass
else:
if (p[q] + 1) <= (p[q + 1] - 1):
newres.append([p[q] + 1, p[q + 1] - 1])
q += 1
else:
if b[l]!=j:
newres.append([l,r])
i+=1
res=[]
for m in newres:
res.append(m)
ans.append(m)
j+=1
print(len(ans))
for j in ans:
print(j[0]+1, j[1]+1)
``` | instruction | 0 | 32,791 | 24 | 65,582 |
No | output | 1 | 32,791 | 24 | 65,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus is an amateur programmer. Now he is analyzing a friend's program. He has already found there the function rangeIncrement(l, r), that adds 1 to each element of some array a for all indexes in the segment [l, r]. In other words, this function does the following:
function rangeIncrement(l, r)
for i := l .. r do
a[i] = a[i] + 1
Polycarpus knows the state of the array a after a series of function calls. He wants to determine the minimum number of function calls that lead to such state. In addition, he wants to find what function calls are needed in this case. It is guaranteed that the required number of calls does not exceed 105.
Before calls of function rangeIncrement(l, r) all array elements equal zero.
Input
The first input line contains a single integer n (1 ≤ n ≤ 105) — the length of the array a[1... n].
The second line contains its integer space-separated elements, a[1], a[2], ..., a[n] (0 ≤ a[i] ≤ 105) after some series of function calls rangeIncrement(l, r).
It is guaranteed that at least one element of the array is positive. It is guaranteed that the answer contains no more than 105 calls of function rangeIncrement(l, r).
Output
Print on the first line t — the minimum number of calls of function rangeIncrement(l, r), that lead to the array from the input data. It is guaranteed that this number will turn out not more than 105.
Then print t lines — the descriptions of function calls, one per line. Each line should contain two integers li, ri (1 ≤ li ≤ ri ≤ n) — the arguments of the i-th call rangeIncrement(l, r). Calls can be applied in any order.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
6
1 2 1 1 4 1
Output
5
2 2
5 5
5 5
5 5
1 6
Input
5
1 0 1 0 1
Output
3
1 1
3 3
5 5
Note
The first sample requires a call for the entire array, and four additional calls:
* one for the segment [2,2] (i.e. the second element of the array),
* three for the segment [5,5] (i.e. the fifth element of the array).
Submitted Solution:
```
import re
import sys
exit=sys.exit
from bisect import bisect_left as bsl,bisect_right as bsr
from collections import Counter,defaultdict as ddict,deque
from functools import lru_cache
cache=lru_cache(None)
from heapq import *
from itertools import *
from math import inf
from pprint import pprint as pp
enum=enumerate
ri=lambda:int(rln())
ris=lambda:list(map(int,rfs()))
rln=sys.stdin.readline
rl=lambda:rln().rstrip('\n')
rfs=lambda:rln().split()
mod=1000000007
d4=[(0,-1),(1,0),(0,1),(-1,0)]
d8=[(-1,-1),(0,-1),(1,-1),(-1,0),(1,0),(-1,1),(0,1),(1,1)]
########################################################################
n=ri()
a=ris()
a.append(0)
ans=[]
stk=[(n,0)]
for i,x in enum(a):
while a[stk[-1][0]]>x:
j,k=stk.pop()
for _ in range(k):
ans.append((j+1,i))
if a[stk[-1][0]]<x:
stk.append((i,x-a[stk[-1][0]]))
elif a[stk[-1][0]]!=x:
stk.append((i,0))
print(len(ans))
for i,j in ans:
print(i,j)
``` | instruction | 0 | 32,792 | 24 | 65,584 |
No | output | 1 | 32,792 | 24 | 65,585 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case. | instruction | 0 | 33,436 | 24 | 66,872 |
Tags: math
Correct Solution:
```
tests = int(input())
for _ in range(tests):
a, b, c, d, k = map(int, input().split(' '))
import math
a = math.ceil(a / c)
b = math.ceil(b / d)
if(a + b) > k:
print(-1)
else:
print(a, b)
``` | output | 1 | 33,436 | 24 | 66,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case. | instruction | 0 | 33,437 | 24 | 66,874 |
Tags: math
Correct Solution:
```
from math import ceil
t = int(input())
for i in range(t):
nLectures, nPractical, nLecturesCap, nPracticalCap, pencilcaseSize = map(int, input().split())
necessaryPens = ceil(nLectures / nLecturesCap)
necessaryPencils = ceil(nPractical / nPracticalCap)
if (necessaryPens + necessaryPencils > pencilcaseSize):
print(-1)
else:
print(necessaryPens, necessaryPencils)
``` | output | 1 | 33,437 | 24 | 66,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case. | instruction | 0 | 33,438 | 24 | 66,876 |
Tags: math
Correct Solution:
```
t=int(input())
for i in range(t):
a,b,c,d,k=map(int,input().split())
if(a%c==0):
x=int(a/c)
else:
x=int((a/c)+1)
if(b%d==0):
y=int(b/d)
else:
y=int((b/d)+1)
if(k>=(x+y)):
print(x,y)
else:
print(-1)
``` | output | 1 | 33,438 | 24 | 66,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case. | instruction | 0 | 33,439 | 24 | 66,878 |
Tags: math
Correct Solution:
```
def main(a, b, c, d, k):
if a < c:
# print('hi')
ac = 1
else:
ac = int(a / c)
if (a % c) != 0:
ac = ac + 1
if b < d:
bd = 1
else:
bd = int(b / d)
if (b % d) != 0:
bd = bd + 1
# print(ac, bd, k)
if (bd + ac) > k:
return -1
else:
return [ac, bd]
if __name__ == '__main__':
t = int(input())
for t_itr in range(t):
z = list(map(int, input().rstrip().split()))
a = z[0]
b = z[1]
c = z[2]
d = z[3]
k = z[4]
res = main(a, b, c, d, k)
if isinstance(res, list):
print(*res)
else:
print(res)
``` | output | 1 | 33,439 | 24 | 66,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case. | instruction | 0 | 33,440 | 24 | 66,880 |
Tags: math
Correct Solution:
```
from math import ceil
t = int(input())
for i in range(t):
a, b, a1, b1, k = [int(i) for i in input().split()]
pen = ceil(a / a1)
pencil = ceil(b / b1)
if pen + pencil > k:
print(-1)
else:
print(pen, pencil)
``` | output | 1 | 33,440 | 24 | 66,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case. | instruction | 0 | 33,441 | 24 | 66,882 |
Tags: math
Correct Solution:
```
# input
t = int(input())
javab_pen = []
javab_pencil = []
for i in range(t):
a, b, c, d, k = [int(x) for x in input().split()]
if a % c != 0:
# print(a//c + 1)
javab_pen.append(a//c + 1)
else:
javab_pen.append(a//c)
if b % d != 0:
javab_pencil.append(b//d + 1)
else:
javab_pencil.append(b//d)
if javab_pen[i]+javab_pencil[i] > k:
javab_pen[i] = (-1)
for i in range(t):
if javab_pen[i] == -1:
print(-1)
continue
print(javab_pen[i], javab_pencil[i])
``` | output | 1 | 33,441 | 24 | 66,883 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case. | instruction | 0 | 33,442 | 24 | 66,884 |
Tags: math
Correct Solution:
```
def main():
t = int(input())
for i in range(t):
a,b,c,d,k = map(int, input().split())
aa = a//c
if a%c != 0:
aa += 1
bb = b//d
if b%d != 0:
bb +=1
if aa + bb > k:
print("-1")
else:
print("{} {}".format(aa, bb))
if __name__ == "__main__":
main()
``` | output | 1 | 33,442 | 24 | 66,885 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case. | instruction | 0 | 33,443 | 24 | 66,886 |
Tags: math
Correct Solution:
```
t = (int(input()))
for i in range(t):
a,b,c,d,k = map(int,input().split())
x = -(-a//c)
y = -(-b//d)
if (x + y > k):
print(-1)
else:
print(x,y)
``` | output | 1 | 33,443 | 24 | 66,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case.
Submitted Solution:
```
import math
t=int(input())
while(t):
a,b,c,d,k=map(int,input().split())
x=math.ceil(a/c)
y=math.ceil(b/d)
if((x+y)>k):
print("-1")
else:
print(x,y)
t=t-1
``` | instruction | 0 | 33,444 | 24 | 66,888 |
Yes | output | 1 | 33,444 | 24 | 66,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case.
Submitted Solution:
```
t = int(input())
import math
for _ in range(t):
a = list(map(int,input().split()))
k = math.ceil(a[0]/a[2])+math.ceil(a[1]/a[3])
if k<=a[4]:
print(math.ceil(a[0]/a[2]),math.ceil(a[1]/a[3]))
else:
print(-1)
``` | instruction | 0 | 33,445 | 24 | 66,890 |
Yes | output | 1 | 33,445 | 24 | 66,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case.
Submitted Solution:
```
def abc(a,b,c,d):
x=(a-1)//c+1
y=(b-1)//d+1
return x,y
for i in range(int(input())):
a,b,c,d,k=map(int,input().split())
x,y=abc(a,b,c,d)
if x+y>k:
print(-1)
else:
print(x,y)
``` | instruction | 0 | 33,446 | 24 | 66,892 |
Yes | output | 1 | 33,446 | 24 | 66,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case.
Submitted Solution:
```
from math import ceil
t = int(input())
reult = ''
for i in range(t):
line = input().split(' ')
a = int(line[0])
b = int(line[1])
c = int(line[2])
d = int(line[3])
k = int(line[4])
pen = ceil(a / c)
pencils = ceil(b / d)
if pen + pencils <= k:
result = '{} {}'.format(pen, pencils)
else:
result = '-1'
print(result)
``` | instruction | 0 | 33,447 | 24 | 66,894 |
Yes | output | 1 | 33,447 | 24 | 66,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case.
Submitted Solution:
```
t = int(input())
c1 = 0
c2 = 0
for i in range(t):
g = list(input().split())
for j in range(len(g)):
g[j] = int(g[j])
if g[2] % g[0] > 0 :
c1 = (g[0] // g[2]) + 1
else:
c1 = g[0] // g[2]
if g[3] % g[1] > 0 :
c2 = (g[1] // g[3]) + 1
else:
c2 = g[1] // g[2]
if g[4] >= c1 + c2:
print(c1, g[4] - c1)
else:
print(-1)
``` | instruction | 0 | 33,448 | 24 | 66,896 |
No | output | 1 | 33,448 | 24 | 66,897 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case.
Submitted Solution:
```
import math
n=int(input())
mas=list()
for i in range(n):
a,b,c,d,k = map(int, input().split())
r = a//c+1+1+b//d
if r <=k:
mas.append(a//c+1)
mas.append(b//d+1)
else:
mas.append(-1)
mas.append(0)
i=0
while i<=(len(mas)-1):
print(mas[i], end=' ')
if mas[i+1]!=0:
print(mas[i+1])
else:
print()
i+=2
``` | instruction | 0 | 33,449 | 24 | 66,898 |
No | output | 1 | 33,449 | 24 | 66,899 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case.
Submitted Solution:
```
import math
t=int(input())
for i in range(t):
a,b,c,d,k=map(int,input().split())
if(a%c==0):
x=math.ceil(a/c)
if(a%c!=0):
x=math.ceil((a/c)+1)
if(b%d==0):
y=math.ceil(b/d)
if(b%d!=0):
y=math.ceil((b/d)+1)
if((x+y)>k):
print('-1')
elif((x+y)<=k):
x += (k - x - y);
print(x,y)
``` | instruction | 0 | 33,450 | 24 | 66,900 |
No | output | 1 | 33,450 | 24 | 66,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tomorrow is a difficult day for Polycarp: he has to attend a lectures and b practical classes at the university! Since Polycarp is a diligent student, he is going to attend all of them.
While preparing for the university, Polycarp wonders whether he can take enough writing implements to write all of the lectures and draw everything he has to during all of the practical classes. Polycarp writes lectures using a pen (he can't use a pencil to write lectures!); he can write down c lectures using one pen, and after that it runs out of ink. During practical classes Polycarp draws blueprints with a pencil (he can't use a pen to draw blueprints!); one pencil is enough to draw all blueprints during d practical classes, after which it is unusable.
Polycarp's pencilcase can hold no more than k writing implements, so if Polycarp wants to take x pens and y pencils, they will fit in the pencilcase if and only if x + y ≤ k.
Now Polycarp wants to know how many pens and pencils should he take. Help him to determine it, or tell that his pencilcase doesn't have enough room for all the implements he needs tomorrow!
Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then the test cases follow.
Each test case is described by one line containing five integers a, b, c, d and k, separated by spaces (1 ≤ a, b, c, d, k ≤ 100) — the number of lectures Polycarp has to attend, the number of practical classes Polycarp has to attend, the number of lectures which can be written down using one pen, the number of practical classes for which one pencil is enough, and the number of writing implements that can fit into Polycarp's pencilcase, respectively.
In hacks it is allowed to use only one test case in the input, so t = 1 should be satisfied.
Output
For each test case, print the answer as follows:
If the pencilcase can't hold enough writing implements to use them during all lectures and practical classes, print one integer -1. Otherwise, print two non-negative integers x and y — the number of pens and pencils Polycarp should put in his pencilcase. If there are multiple answers, print any of them. Note that you don't have to minimize the number of writing implements (though their total number must not exceed k).
Example
Input
3
7 5 4 5 8
7 5 4 5 2
20 53 45 26 4
Output
7 1
-1
1 3
Note
There are many different answers for the first test case; x = 7, y = 1 is only one of them. For example, x = 3, y = 1 is also correct.
x = 1, y = 3 is the only correct answer for the third test case.
Submitted Solution:
```
try:
t = int(input())
while t:
labcdk = list(map(int, input().split()))
a = labcdk[0]
b = labcdk[1]
c = labcdk[2]
d = labcdk[3]
k = labcdk[4]
x = a/c
if type(x) == float:
x = round(x)
x += 1
else:
pass
y = k-x
if y<0:
print("-1")
else:
print(x," ", y)
t -= 1
except Exception as e:
pass
``` | instruction | 0 | 33,451 | 24 | 66,902 |
No | output | 1 | 33,451 | 24 | 66,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139 | instruction | 0 | 34,398 | 24 | 68,796 |
Tags: greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import defaultdict
for T in range(int(input())) :
n = int(input())
arr = []
for i in range(n) :
arr.append(list(input().strip()))
count = 0
for i in range(n):
if arr[i] in arr[i+1 : ] :
count +=1
j = 0
k = 1
while arr[i] in arr[i+1 : ] or arr[i] in arr[:i] :
arr[i][k] = str(j)
if j == 9 :
k +=1
j = (j +1)%10
print(count)
for i in range(n):
print(''.join(arr[i]))
``` | output | 1 | 34,398 | 24 | 68,797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139 | instruction | 0 | 34,399 | 24 | 68,798 |
Tags: greedy, implementation
Correct Solution:
```
import sys
from collections import defaultdict
input = sys.stdin.readline
def main():
t = int(input())
for _ in range(t):
n = int(input())
d = defaultdict(lambda: [])
mk = {}
ans = [0] * n
for i in range(n):
x = input().rstrip()
d[x].append(i)
ans[i] = x
mk[x] = 1
def get_number(x):
for i in range(len(x)):
for d in range(0, 10):
y = x[:i] + str(d) + x[i + 1:]
if y not in mk:
mk[y] = 1
return y
assert(0)
changes = 0
for k, v in d.items():
while len(v) > 1:
changes += 1
p = v.pop()
ans[p] = get_number(k)
ans[v.pop()] = k
print(changes)
print("\n".join(ans))
main()
``` | output | 1 | 34,399 | 24 | 68,799 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139 | instruction | 0 | 34,400 | 24 | 68,800 |
Tags: greedy, implementation
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
a=dict()
b=[]
for i in range(n):
c=input()
a[c]=a.get(c,-1)+1
b.append(c)
print(sum(a.values()))
rlb=range(len(b))
for i in rlb:
v=b[i]
if a.get(v,0)==0:
print(v)
else:
v,vo=v[1:],v
for i in range(10):
if not str(i)+v in a:
a[str(i)+v]=0
a[vo]-=1
print(str(i)+v)
break
``` | output | 1 | 34,400 | 24 | 68,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139 | instruction | 0 | 34,401 | 24 | 68,802 |
Tags: greedy, implementation
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
import math
from decimal import *
getcontext().prec = 25
from itertools import permutations
MOD = pow(10, 9) + 7
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")
# n, k = map(int, input().split(" "))
# l = list(map(int, input().split(" ")))
for _ in range(int(input())):
n = int(input())
l = [int(input()) for i in range(n)]
d = {}
for i in l:
d[i] = d.get(i, 0) + 1
r = []
c = 0
for i in range(n):
if d[l[i]] > 1:
val = l[i] // 10 * 10
while True:
if d.get(val, 0) == 0:
break
val += 1
d[val] = d.get(val, 0) + 1
r.append(val)
c += 1
d[l[i]] -= 1
else:
r.append(l[i])
print(c)
for i in r:
print("0"*(4-len(str(i)))+ str(i))
``` | output | 1 | 34,401 | 24 | 68,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139 | instruction | 0 | 34,402 | 24 | 68,804 |
Tags: greedy, implementation
Correct Solution:
```
def solve():
n = int(input())
pins = []
letters = []
for j in range(n):
pin = input()
pins.append(list(pin))
letters.append(pin[0])
res = 0
for a in range(len(pins)):
if pins.count(pins[a]) >= 2:
for j in range(0, 10):
if str(j) not in letters:
letters.append(str(j))
pins[a][0] = str(j)
res += 1
break
print(res)
for pin in pins:
print(*pin, sep='')
t = int(input())
for i in range(t):
solve()
``` | output | 1 | 34,402 | 24 | 68,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139 | instruction | 0 | 34,403 | 24 | 68,806 |
Tags: greedy, implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
pins= []
for i in range(n):
pins.append(list(map(str,input())))
#print(pins)
reslt = 0
i, j, k = 0, 0, 0
same = False
while i < n:
j = 0
while j < n:
if i != j and pins[i] == pins[j]:
same = True
reslt += 1
break
j += 1
if same:
k = 0
while k <= 9:
j = 0
pins[i][-1] = str(k)
done = True
while j < n:
if i != j and pins[i] == pins[j]:
done = False
break
j += 1
if done:
break
k += 1
i += 1
same = False
print(reslt)
for i in range(n):
j = 1
pinseq = pins[i][0]
while j < 4:
pinseq += pins[i][j]
j += 1
print(pinseq)
del pinseq
``` | output | 1 | 34,403 | 24 | 68,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139 | instruction | 0 | 34,404 | 24 | 68,808 |
Tags: greedy, implementation
Correct Solution:
```
def changePins():
n = int(input())
arr, s = [], set()
for i in range(n):
arr.append(str(input()))
s.add(arr[i])
done = [0] * n
res = 0
for i in range(n):
if done[i]:
continue
for j in range(i+1,n):
if arr[i] == arr[j]:
done[j] = 1
res += 1
k = 0
while k < 4 and arr[i] == arr[j]:
for c in ('0','1','2','3','4','5','6','7','8','9'):
newCode = list(arr[j])
newCode[k] = c
newCode = "".join(x for x in newCode)
if newCode not in s:
s.add(newCode)
arr[j] = newCode
break
k += 1
print(res)
for i in arr:
print(i)
if __name__ == "__main__":
t = int(input())
while t:
changePins()
t -= 1
``` | output | 1 | 34,404 | 24 | 68,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A PIN code is a string that consists of exactly 4 digits. Examples of possible PIN codes: 7013, 0000 and 0990. Please note that the PIN code can begin with any digit, even with 0.
Polycarp has n (2 ≤ n ≤ 10) bank cards, the PIN code of the i-th card is p_i.
Polycarp has recently read a recommendation that it is better to set different PIN codes on different cards. Thus he wants to change the minimal number of digits in the PIN codes of his cards so that all n codes would become different.
Formally, in one step, Polycarp picks i-th card (1 ≤ i ≤ n), then in its PIN code p_i selects one position (from 1 to 4), and changes the digit in this position to any other. He needs to change the minimum number of digits so that all PIN codes become different.
Polycarp quickly solved this problem. Can you solve it?
Input
The first line contains integer t (1 ≤ t ≤ 100) — the number of test cases in the input. Then test cases follow.
The first line of each of t test sets contains a single integer n (2 ≤ n ≤ 10) — the number of Polycarp's bank cards. The next n lines contain the PIN codes p_1, p_2, ..., p_n — one per line. The length of each of them is 4. All PIN codes consist of digits only.
Output
Print the answers to t test sets. The answer to each set should consist of a n + 1 lines
In the first line print k — the least number of changes to make all PIN codes different. In the next n lines output the changed PIN codes in the order corresponding to their appearance in the input. If there are several optimal answers, print any of them.
Example
Input
3
2
1234
0600
2
1337
1337
4
3139
3139
3139
3139
Output
0
1234
0600
1
1337
1237
3
3139
3138
3939
6139 | instruction | 0 | 34,405 | 24 | 68,810 |
Tags: greedy, implementation
Correct Solution:
```
import os, sys
# copy unique numbers to new array
# for each non-unique:
# increment lowest digit (with starting from 0 if neccesary) until number becomes unique
def solve(pins):
new_pins = [ None ] * len(pins)
used_pins = set()
changed_digits = 0
for x in range(len(pins)):
if pins.count(pins[x]) == 1:
new_pins[x] = pins[x]
used_pins.add(pins[x])
for x in range(len(pins)):
if new_pins[x] is None:
old_pin = pins[x]
if old_pin not in used_pins:
used_pins.add(old_pin)
new_pins[x] = old_pin
else:
removed_last_digit_pin = (old_pin // 10) * 10
for addition in range(0, 10):
new_pin = removed_last_digit_pin + addition
if new_pin not in used_pins:
used_pins.add(new_pin)
new_pins[x] = new_pin
changed_digits += 1
break
return changed_digits, [ str(q).zfill(4) for q in new_pins ]
num = int(input().strip())
for x in range(num):
n = int(input().strip())
pins = [
int(input().strip()) for _ in range(n)
]
k, new_pins = solve(pins)
print(k)
for p in new_pins:
print(p)
``` | output | 1 | 34,405 | 24 | 68,811 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.