text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You will receive 5 points for solving this problem.
Manao has invented a new operation on strings that is called folding. Each fold happens between a pair of consecutive letters and places the second part of the string above first part, running in the opposite direction and aligned to the position of the fold. Using this operation, Manao converts the string into a structure that has one more level than there were fold operations performed. See the following examples for clarity.
We will denote the positions of folds with '|' characters. For example, the word "ABRACADABRA" written as "AB|RACA|DAB|RA" indicates that it has been folded three times: first, between the leftmost pair of 'B' and 'R' letters; second, between 'A' and 'D'; and third, between the rightmost pair of 'B' and 'R' letters. Here are several examples of folded strings:
"ABCDEF|GHIJK" | "A|BCDEFGHIJK" | "AB|RACA|DAB|RA" | "X|XXXXX|X|X|XXXXXX"
| | | XXXXXX
KJIHG | KJIHGFEDCB | AR | X
ABCDEF | A | DAB | X
| | ACAR | XXXXX
| | AB | X
One last example for "ABCD|EFGH|IJ|K":
K
IJ
HGFE
ABCD
Manao noticed that each folded string can be viewed as several piles of letters. For instance, in the previous example, there are four piles, which can be read as "AHI", "BGJK", "CF", and "DE" from bottom to top. Manao wonders what is the highest pile of identical letters he can build using fold operations on a given word. Note that the pile should not contain gaps and should start at the bottom level. For example, in the rightmost of the four examples above, none of the piles would be considered valid since each of them has gaps, starts above the bottom level, or both.
Input
The input will consist of one line containing a single string of n characters with 1 β€ n β€ 1000 and no spaces. All characters of the string will be uppercase letters.
This problem doesn't have subproblems. You will get 5 points for the correct submission.
Output
Print a single integer β the size of the largest pile composed of identical characters that can be seen in a valid result of folding operations on the given string.
Examples
Input
ABRACADABRA
Output
3
Input
ABBBCBDB
Output
3
Input
AB
Output
1
Note
Consider the first example. Manao can create a pile of three 'A's using the folding "AB|RACAD|ABRA", which results in the following structure:
ABRA
DACAR
AB
In the second example, Manao can create a pile of three 'B's using the following folding: "AB|BB|CBDB".
CBDB
BB
AB
Another way for Manao to create a pile of three 'B's with "ABBBCBDB" is the following folding: "AB|B|BCBDB".
BCBDB
B
AB
In the third example, there are no folds performed and the string is just written in one line.
Tags: brute force
Correct Solution:
```
t = {}
for i, c in enumerate(input()):
if c not in t: t[c] = (i, 1)
elif (t[c][0] - i) & 1: t[c] = (i, t[c][1] + 1)
print(max(b for a, b in t.values()))
```
| 7,900 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You will receive 5 points for solving this problem.
Manao has invented a new operation on strings that is called folding. Each fold happens between a pair of consecutive letters and places the second part of the string above first part, running in the opposite direction and aligned to the position of the fold. Using this operation, Manao converts the string into a structure that has one more level than there were fold operations performed. See the following examples for clarity.
We will denote the positions of folds with '|' characters. For example, the word "ABRACADABRA" written as "AB|RACA|DAB|RA" indicates that it has been folded three times: first, between the leftmost pair of 'B' and 'R' letters; second, between 'A' and 'D'; and third, between the rightmost pair of 'B' and 'R' letters. Here are several examples of folded strings:
"ABCDEF|GHIJK" | "A|BCDEFGHIJK" | "AB|RACA|DAB|RA" | "X|XXXXX|X|X|XXXXXX"
| | | XXXXXX
KJIHG | KJIHGFEDCB | AR | X
ABCDEF | A | DAB | X
| | ACAR | XXXXX
| | AB | X
One last example for "ABCD|EFGH|IJ|K":
K
IJ
HGFE
ABCD
Manao noticed that each folded string can be viewed as several piles of letters. For instance, in the previous example, there are four piles, which can be read as "AHI", "BGJK", "CF", and "DE" from bottom to top. Manao wonders what is the highest pile of identical letters he can build using fold operations on a given word. Note that the pile should not contain gaps and should start at the bottom level. For example, in the rightmost of the four examples above, none of the piles would be considered valid since each of them has gaps, starts above the bottom level, or both.
Input
The input will consist of one line containing a single string of n characters with 1 β€ n β€ 1000 and no spaces. All characters of the string will be uppercase letters.
This problem doesn't have subproblems. You will get 5 points for the correct submission.
Output
Print a single integer β the size of the largest pile composed of identical characters that can be seen in a valid result of folding operations on the given string.
Examples
Input
ABRACADABRA
Output
3
Input
ABBBCBDB
Output
3
Input
AB
Output
1
Note
Consider the first example. Manao can create a pile of three 'A's using the folding "AB|RACAD|ABRA", which results in the following structure:
ABRA
DACAR
AB
In the second example, Manao can create a pile of three 'B's using the following folding: "AB|BB|CBDB".
CBDB
BB
AB
Another way for Manao to create a pile of three 'B's with "ABBBCBDB" is the following folding: "AB|B|BCBDB".
BCBDB
B
AB
In the third example, there are no folds performed and the string is just written in one line.
Tags: brute force
Correct Solution:
```
t = {}
for i, c in enumerate(input()):
if c not in t: t[c] = (i, 1)
elif (t[c][0] - i) & 1: t[c] = (i, t[c][1] + 1)
print(max(b for a, b in t.values()))
# Made By Mostafa_Khaled
```
| 7,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You will receive 5 points for solving this problem.
Manao has invented a new operation on strings that is called folding. Each fold happens between a pair of consecutive letters and places the second part of the string above first part, running in the opposite direction and aligned to the position of the fold. Using this operation, Manao converts the string into a structure that has one more level than there were fold operations performed. See the following examples for clarity.
We will denote the positions of folds with '|' characters. For example, the word "ABRACADABRA" written as "AB|RACA|DAB|RA" indicates that it has been folded three times: first, between the leftmost pair of 'B' and 'R' letters; second, between 'A' and 'D'; and third, between the rightmost pair of 'B' and 'R' letters. Here are several examples of folded strings:
"ABCDEF|GHIJK" | "A|BCDEFGHIJK" | "AB|RACA|DAB|RA" | "X|XXXXX|X|X|XXXXXX"
| | | XXXXXX
KJIHG | KJIHGFEDCB | AR | X
ABCDEF | A | DAB | X
| | ACAR | XXXXX
| | AB | X
One last example for "ABCD|EFGH|IJ|K":
K
IJ
HGFE
ABCD
Manao noticed that each folded string can be viewed as several piles of letters. For instance, in the previous example, there are four piles, which can be read as "AHI", "BGJK", "CF", and "DE" from bottom to top. Manao wonders what is the highest pile of identical letters he can build using fold operations on a given word. Note that the pile should not contain gaps and should start at the bottom level. For example, in the rightmost of the four examples above, none of the piles would be considered valid since each of them has gaps, starts above the bottom level, or both.
Input
The input will consist of one line containing a single string of n characters with 1 β€ n β€ 1000 and no spaces. All characters of the string will be uppercase letters.
This problem doesn't have subproblems. You will get 5 points for the correct submission.
Output
Print a single integer β the size of the largest pile composed of identical characters that can be seen in a valid result of folding operations on the given string.
Examples
Input
ABRACADABRA
Output
3
Input
ABBBCBDB
Output
3
Input
AB
Output
1
Note
Consider the first example. Manao can create a pile of three 'A's using the folding "AB|RACAD|ABRA", which results in the following structure:
ABRA
DACAR
AB
In the second example, Manao can create a pile of three 'B's using the following folding: "AB|BB|CBDB".
CBDB
BB
AB
Another way for Manao to create a pile of three 'B's with "ABBBCBDB" is the following folding: "AB|B|BCBDB".
BCBDB
B
AB
In the third example, there are no folds performed and the string is just written in one line.
Submitted Solution:
```
a = str(input())
anss = []
for i in range(len(a)):
anss.append(a.count(a[i]))
print(max(anss)//2+1)
```
No
| 7,902 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Tags: implementation
Correct Solution:
```
#def convert(x): x = str(x); x = x.replace(',', ''); x = x.replace('{', ''); x = x.replace('}', ''); return [int(s) for s in x.split()]
set_, hel, min_, max_ = map(int, input().split());ll = [int(x) for x in input().split()]; Err = 0
ko = [];ko.append(min_);ko.append(max_)
for i in range(len(ll)):
if ll[i] == min_:continue
elif ll[i] == max_:continue
elif ll[i]<min_:Err=2
elif ll[i]>max_:Err=2
elif min_<=ll[i]<=max_:ko.append(ll[i])
elif set_ < len(ko):Err=2
else:Err=2
if Err>=set_:
print('Incorrect')
exit()
elif Err == 2:
print('Incorrect')
exit()
if set_ < len(ko):Err=2
if Err>=set_:
print('Incorrect')
exit()
elif Err == 2:
print('Incorrect')
exit()
print('Correct')
'''
3 2 1 5
1 6
'''
```
| 7,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Tags: implementation
Correct Solution:
```
n,m,minn,maxx=map(int,input().split())
L=list(map(int,input().split()))
r=0
if(minn not in L):
L+=[minn]
r+=1
if(maxx not in L):
L+=[maxx]
r+=1
valid=True
for i in range(m):
if(L[i]<minn):
valid=False
if(L[i]>maxx):
valid=False
if(r>n-m or not valid):
print("Incorrect")
else:
print("Correct")
```
| 7,904 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Tags: implementation
Correct Solution:
```
(n, m, mi, mx) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
if a[0]!=mi:
m += 1
if a[-1]!=mx:
m += 1
if a[0]<mi:
m += n+1
if a[-1]>mx:
m += n+1
print(['Incorrect', 'Correct'][m<=n])
```
| 7,905 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Tags: implementation
Correct Solution:
```
n, m, minn, maxx = map(int, input().split())
a = sorted(list(map(int, input().split())))
cnt = 0
if minn != a[0]:
cnt += 1
if maxx != a[-1]:
cnt += 1
if maxx < a[-1]:
cnt += 10000000000000000000
if minn > a[0]:
cnt += 10000000000000000000
if n - m >= cnt:
print("Correct")
else:
print("Incorrect")
```
| 7,906 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Tags: implementation
Correct Solution:
```
n, m, mi, ma = map(int, input().split())
t = list(map(int, input().split()))
mit = min(t)
mat = max(t)
if (mi <= mit and ma >= mat) and (n - m >= 2 or (n - m >= 1 and (mit == mi or mat == ma)) or (mit == mi and mat == ma)):
print('Correct')
else:
print('Incorrect')
```
| 7,907 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Tags: implementation
Correct Solution:
```
#!/usr/bin/python
import re
import inspect
from sys import argv, exit
def rstr():
return input()
def rstrs(splitchar=' '):
return [i for i in input().split(splitchar)]
def rint():
return int(input())
def rints(splitchar=' '):
return [int(i) for i in rstrs(splitchar)]
def varnames(obj, namespace=globals()):
return [name for name in namespace if namespace[name] is obj]
def pvar(var, override=False):
prnt(varnames(var), var)
def prnt(*args, override=False):
if '-v' in argv or override:
print(*args)
# Faster IO
pq = []
def penq(s):
if not isinstance(s, str):
s = str(s)
pq.append(s)
def pdump():
s = ('\n'.join(pq)).encode()
os.write(1, s)
if __name__ == '__main__':
timesteps, ast, mn, mx = rints()
to_add = timesteps - ast
asts = rints()
for t in asts:
if t < mn or t > mx:
print('Incorrect')
exit(0)
if mn not in asts:
if to_add == 0:
print('Incorrect')
exit(0)
else:
to_add -= 1
if mx not in asts:
if to_add == 0:
print('Incorrect')
exit(0)
else:
to_add -= 1
print('Correct')
```
| 7,908 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Tags: implementation
Correct Solution:
```
n,m,mi,ma=map(int,input().split())
k=list(map(int,input().split()))
if n-m>1 and min(k)>=mi and max(k)<=ma:
print("Correct")
elif n-m==1 and (min(k)==mi and max(k)<=ma) or (min(k)>=mi and max(k)==ma):
print("Correct")
else:
print("Incorrect")
```
| 7,909 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Tags: implementation
Correct Solution:
```
n, m, mmin, mmax = map(int, input().split())
s = list(map(int, input().split()))
s = sorted(s)
if s[0] < mmin or s[m - 1] > mmax:
print("Incorrect")
elif s[0] == mmin and s[m - 1] == mmax:
print("Correct")
elif s[0] != mmin and s[m - 1] != mmax:
if n - m < 2:
print("Incorrect")
else:
print("Correct")
elif s[0] != mmin or s[m - 1] != mmax:
if n - m < 1:
print("Incorrect")
else:
print("Correct")
```
| 7,910 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Submitted Solution:
```
n, m, Min, Max = map(int, input().split())
a = list(map(int, input().split()))
remain = n - m
cnt = 0
flag = 0
for i in a:
if i == Min or i == Max:
cnt += 1
if i < Min or i > Max:
flag = -1
cnt = 2 - cnt
if flag == -1:
print("Incorrect")
else:
if n - m >= cnt:
print("Correct")
else:
print("Incorrect")
```
Yes
| 7,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Submitted Solution:
```
n, m, v1, v2 = map(int, input().split())
t = list(map(int, input().split()))
t1, t2 = min(t), max(t)
if t1 < v1 or t2 > v2:
print('Incorrect')
elif (v1 < t1) + (v2 > t2) > n - m:
print('Incorrect')
else:
print('Correct')
```
Yes
| 7,912 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Submitted Solution:
```
n, m, min_, max_ = map(int, input().split())
l = sorted(list(map(int, input().split())))
if l[0] < min_ or l[-1] > max_:
print("Incorrect")
else:
if l[-1] < max_:
l.append(max_)
if l[0] > min_:
l.append(min_)
if len(l) <= n:
print("Correct")
else:
print("Incorrect")
```
Yes
| 7,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Submitted Solution:
```
n, m , minimum, maximum = map(int, input().split())
list_of_m = list(map(int, input().split()))
maxi = max(list_of_m)
mini = min(list_of_m)
if maxi < maximum and mini > minimum :
if n - m >= 2:
print("Correct")
else:
print("Incorrect")
elif maxi == maximum and mini > minimum :
if n - m >= 1:
print("Correct")
else:
print("Incorrect")
elif maxi < maximum and mini == minimum :
if n - m >= 1:
print("Correct")
else:
print("Incorrect")
elif maxi == maximum and mini == minimum :
print("Correct")
else:
print("Incorrect")
```
Yes
| 7,914 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Submitted Solution:
```
import random
import time
nn,nm,min,max = list(map(int,input().split()))
m = list(map(int,input().split()))
i = min
if nn == nm:
print('Correct')
quit()
if nm > nn:
print('Incorrect')
quit()
for x in m:
if i< min or i> max:
print('Incorrect')
quit()
if min not in m:
m.append(min)
if max not in m:
m.append(max)
while i !=max and len(m) <nn:
if i not in m:
m.append(i)
i+=1
if len(m) == nn:
print('Correct')
else:
print('Incorrect')
```
No
| 7,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Submitted Solution:
```
n,m,mi,mx= map(int,input().split())
t= list(map(int,input().split()))
a = min(t)
b = max(t)
h=0
if a==mi:
h+=1
if b==mx:
h+=1
if h==2:print('Correct')
else:
if h==1:
if n-m>=1:
print('Correct')
else:
print('Incorrect')
else:
if n-m>=2:
print('Correct')
else:
print('Incorrect')
```
No
| 7,916 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Submitted Solution:
```
n, m, minimum, maximum = map(int, input().split())
seq = [int(i) for i in input().split()]
if max(seq) < maximum and min(seq) > minimum:
print('Correct')
elif minimum in seq and maximum in seq:
print('Correct')
elif minimum not in seq and maximum not in seq:
if n - m >= 2:
print('Correct')
else:
print('Incorrect')
elif (minimum in seq and maximum not in seq) or (minimum not in seq and maximum in seq):
if n - m >= 1:
print('Correct')
else:
print('Incorrect')
```
No
| 7,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3.
Submitted Solution:
```
def main():
n,m,mn,mx=map(int,input().split())
s=sorted([int(i)for i in input().split()])
if n-m>2 or mx<s[-1] or mn>s[0]:
return "Incorrect"
if mn<s[0] and mx>s[-1]:
if n-m==2:
return "Correct"
else:
return "Incorrect"
else:
return "Correct"
print(main())
```
No
| 7,918 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Tags: greedy
Correct Solution:
```
from collections import defaultdict, deque
from heapq import heappush, heappop
from math import inf
ri = lambda : map(int, input().split())
def sm(x):
ans = 0
while x:
ans += (x % 10)
x //= 10
return ans
def solve():
n = int(input())
A = list(ri())
ans = 0
cnt = defaultdict(int)
for x in A:
d = sm(x)
if d % 3 == 0:
if cnt[0] > 0:
cnt[0] -= 1
ans += 1
else:
cnt[0] += 1
elif cnt[3-(d%3)] > 0:
cnt[3-(d%3)] -= 1
ans += 1
else:
cnt[d%3] += 1
print(ans)
t = 1
#t = int(input())
while t:
t -= 1
solve()
```
| 7,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Tags: greedy
Correct Solution:
```
d=[0,0,0];input()
for i in map(int,input().split()):d[i%3]+=1
print(d[0]//2+min(d[1],d[2]))
```
| 7,920 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Tags: greedy
Correct Solution:
```
a=input()
b=map(int,input().split())
c=0
d=0
e=0
for i in b:
if i%3==0:
c+=1
elif i%3==1:
d+=1
else:
e+=1
print(min(d,e)+c//2)
```
| 7,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Tags: greedy
Correct Solution:
```
def fastio():
import sys
from io import StringIO
from atexit import register
global input
sys.stdin = StringIO(sys.stdin.read())
input = lambda : sys.stdin.readline().rstrip('\r\n')
sys.stdout = StringIO()
register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))
n, = I()
l = I()
a = [0]*3
for i in l:
a[i%3] += 1
print(a[0]//2 + min(a[1], a[2]))
```
| 7,922 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Tags: greedy
Correct Solution:
```
n=int(input())
ar=list(map(lambda x:int(x)%3,input().split(' ')))
print((ar.count(0)//2)+(min(ar.count(1),ar.count(2))))
```
| 7,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Tags: greedy
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
n=int(input())
a=list(map(int,input().split()))
one=0
zero=0
two=0
for i in range(0,len(a)):
if a[i]%3==0:
zero+=1
if a[i]%3==1:
one+=1
elif a[i]%3==2:
two+=1
print(zero//2+min(one,two))
```
| 7,924 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Tags: greedy
Correct Solution:
```
import sys
from array import array # noqa: F401
from collections import Counter
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n = int(input())
cnt = Counter(x % 3 for x in map(int, input().split()))
print(cnt[0] // 2 + min(cnt[1], cnt[2]))
```
| 7,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Tags: greedy
Correct Solution:
```
s=int(input())
ar=[sum([int(x) for x in e])%3 for e in input().split()]
x,y,z=ar.count(0),ar.count(1),ar.count(2)
print(x//2+min(y,z))
```
| 7,926 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Submitted Solution:
```
n=int(input())
arr=list(map(int,(input().split())))
a,b,c=0,0,0
for i in arr:
if i%3==0:
a+=1
elif i%3==1:
b+=1
else:
c+=1
print((a//2)+min(b,c))
```
Yes
| 7,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Submitted Solution:
```
#from dust i have come dust i will be
n=int(input())
a=list(map(int,input().split()))
x=0
y=0
z=0
for i in range(n):
if a[i]%3==0:
x+=1
elif a[i]%3==1:
y+=1
else:
z+=1
t=(x//2)+min(y,z)
print(t)
```
Yes
| 7,928 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Submitted Solution:
```
n = int(input())
ost = [0,0,0]
for i in map(int, input().split()):
ost[i%3] += 1
# print(ost)
print(min(ost[1], ost[2])+(ost[0]//2))
```
Yes
| 7,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Submitted Solution:
```
n = int(input())
l = [int(i) for i in input().split()]
c1 = 0
c2 = 0
c3 = 0
ans = 0
for i in range(n):
if (l[i]%3 == 0):
c1 = c1 + 1
elif (l[i]%3 == 1):
c2 = c2 + 1
else:
c3 = c3 + 1
ans += c1//2
min1 = min(c2,c3)
max1 = max(c2,c3)
ans += min1
print (ans)
```
Yes
| 7,930 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Submitted Solution:
```
input()
t = list(sum(int(i) for i in j) % 3 for j in input().split())
p = [0] * 3
for i in t:
p[i] += 1
x = min(p[1], p[2])
y = p[1] + p[2] - x
print(p[0] // 2 + x + y // 2)
```
No
| 7,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Submitted Solution:
```
a=input()
b=map(int,input().split())
c=0
d=0
e=0
for i in b:
print(i)
if i%3==0:
c+=1
elif i%3==1:
d+=1
else:
e+=1
print(min(d,e)+c//2)
```
No
| 7,932 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1
Submitted Solution:
```
from collections import defaultdict, deque
from heapq import heappush, heappop
from math import inf
ri = lambda : map(int, input().split())
def sm(x):
ans = 0
while x:
ans += (x % 10)
x //= 10
return ans
def solve():
n = int(input())
A = list(ri())
ans = 0
cnt = defaultdict(int)
for x in A:
d = sm(x)
if d % 3 == 0:
if cnt[0] > 1:
cnt[0] -= 1
ans += 1
else:
cnt[0] += 1
elif cnt[3-(d%3)] > 1:
cnt[3-(d%3)] -= 1
ans += 1
else:
cnt[d%3] += 1
print(ans)
t = 1
#t = int(input())
while t:
t -= 1
solve()
```
No
| 7,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had two arrays consisting of non-negative integers: a of size n and b of size m. Vasya chose a positive integer k and created an n Γ m matrix v using the following formula:
<image>
Vasya wrote down matrix v on a piece of paper and put it in the table.
A year later Vasya was cleaning his table when he found a piece of paper containing an n Γ m matrix w. He remembered making a matrix one day by the rules given above but he was not sure if he had found the paper with the matrix v from those days. Your task is to find out if the matrix w that you've found could have been obtained by following these rules and if it could, then for what numbers k, a1, a2, ..., an, b1, b2, ..., bm it is possible.
Input
The first line contains integers n and m (1 β€ n, m β€ 100), separated by a space β the number of rows and columns in the found matrix, respectively.
The i-th of the following lines contains numbers wi, 1, wi, 2, ..., wi, m (0 β€ wi, j β€ 109), separated by spaces β the elements of the i-th row of matrix w.
Output
If the matrix w could not have been obtained in the manner described above, print "NO" (without quotes) in the single line of output.
Otherwise, print four lines.
In the first line print "YES" (without quotes).
In the second line print an integer k (1 β€ k β€ 1018). Note that each element of table w should be in range between 0 and k - 1 inclusively.
In the third line print n integers a1, a2, ..., an (0 β€ ai β€ 1018), separated by spaces.
In the fourth line print m integers b1, b2, ..., bm (0 β€ bi β€ 1018), separated by spaces.
Examples
Input
2 3
1 2 3
2 3 4
Output
YES
1000000007
0 1
1 2 3
Input
2 2
1 2
2 0
Output
YES
3
0 1
1 2
Input
2 2
1 2
2 1
Output
NO
Note
By <image> we denote the remainder of integer division of b by c.
It is guaranteed that if there exists some set of numbers k, a1, ..., an, b1, ..., bm, that you could use to make matrix w, then there also exists a set of numbers that meets the limits 1 β€ k β€ 1018, 1 β€ ai β€ 1018, 1 β€ bi β€ 1018 in the output format. In other words, these upper bounds are introduced only for checking convenience purposes.
Tags: constructive algorithms, math
Correct Solution:
```
def ckkk(u,k):
listn=[k+u[i][0]-u[0][0] for i in range(n)]
listm=[k+u[0][i] for i in range(m)]
for i in range(n):
for j in range(m):
if (listn[i]+listm[j])%k!=u[i][j]:
return (None,None)
return (listn,listm)
(n,m)=input().split(sep=None, maxsplit=2)
(n,m)=(int(n),int(m))
u=[0 for j in range(n)]
for i in range(n):
x=input().split(sep=None, maxsplit=m)
u[i]=[int(j) for j in x]
maxx=max([max(u[i]) for i in range(n)])
v=[[u[i+1][j]-u[i][j] for j in range(m)] for i in range(n-1)]
dic={}
divs={}
for i in range(n-1):
aaa=min(v[i])
bbb=max(v[i])
if aaa==bbb:
continue
else:
divs[(bbb-aaa)]=1
key=0
if len(divs)>2:
key=0
elif not divs.keys():
(lista,listb)=ckkk(u,maxx+1)
key=maxx+1
else:
divs=list(divs.keys())
divs.sort(key=None, reverse=False)
if len(divs)==2:
if divs[1]//divs[0]==2:
if divs[0]>maxx and not key:
(lista,listb)=ckkk(u, divs[0])
if lista:
key=divs[0]
if divs[1]>maxx and not key:
(lista,listb)=ckkk(u, divs[1])
if lista:
key=divs[1]
else:
(lista,listb)=ckkk(u, divs[0])
if lista:
key=divs[0]
if key:
print('YES')
print(key)
lista=[str(i) for i in lista]
listb=[str(i) for i in listb]
print(' '.join(lista))
print(' '.join(listb))
else:
print('NO')
```
| 7,934 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had two arrays consisting of non-negative integers: a of size n and b of size m. Vasya chose a positive integer k and created an n Γ m matrix v using the following formula:
<image>
Vasya wrote down matrix v on a piece of paper and put it in the table.
A year later Vasya was cleaning his table when he found a piece of paper containing an n Γ m matrix w. He remembered making a matrix one day by the rules given above but he was not sure if he had found the paper with the matrix v from those days. Your task is to find out if the matrix w that you've found could have been obtained by following these rules and if it could, then for what numbers k, a1, a2, ..., an, b1, b2, ..., bm it is possible.
Input
The first line contains integers n and m (1 β€ n, m β€ 100), separated by a space β the number of rows and columns in the found matrix, respectively.
The i-th of the following lines contains numbers wi, 1, wi, 2, ..., wi, m (0 β€ wi, j β€ 109), separated by spaces β the elements of the i-th row of matrix w.
Output
If the matrix w could not have been obtained in the manner described above, print "NO" (without quotes) in the single line of output.
Otherwise, print four lines.
In the first line print "YES" (without quotes).
In the second line print an integer k (1 β€ k β€ 1018). Note that each element of table w should be in range between 0 and k - 1 inclusively.
In the third line print n integers a1, a2, ..., an (0 β€ ai β€ 1018), separated by spaces.
In the fourth line print m integers b1, b2, ..., bm (0 β€ bi β€ 1018), separated by spaces.
Examples
Input
2 3
1 2 3
2 3 4
Output
YES
1000000007
0 1
1 2 3
Input
2 2
1 2
2 0
Output
YES
3
0 1
1 2
Input
2 2
1 2
2 1
Output
NO
Note
By <image> we denote the remainder of integer division of b by c.
It is guaranteed that if there exists some set of numbers k, a1, ..., an, b1, ..., bm, that you could use to make matrix w, then there also exists a set of numbers that meets the limits 1 β€ k β€ 1018, 1 β€ ai β€ 1018, 1 β€ bi β€ 1018 in the output format. In other words, these upper bounds are introduced only for checking convenience purposes.
Tags: constructive algorithms, math
Correct Solution:
```
def main():
n, m = map(int, input().split())
l = list(tuple(map(int, input().split())) for _ in range(n))
ma = max(x for _ in l for x in _)
bb = l[0]
x = bb[0]
aa = [_[0] - x for _ in l]
err = set(map(abs, filter(None, (a + b - x for a, row in zip(aa, l) for b, x in zip(bb, row)))))
if err:
k = err.pop()
if err or k <= ma:
print('NO')
return
else:
k = ma + 1
for i in range(n):
aa[i] %= k
print('YES')
print(k)
print(*aa)
print(*bb)
if __name__ == '__main__':
main()
```
| 7,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had two arrays consisting of non-negative integers: a of size n and b of size m. Vasya chose a positive integer k and created an n Γ m matrix v using the following formula:
<image>
Vasya wrote down matrix v on a piece of paper and put it in the table.
A year later Vasya was cleaning his table when he found a piece of paper containing an n Γ m matrix w. He remembered making a matrix one day by the rules given above but he was not sure if he had found the paper with the matrix v from those days. Your task is to find out if the matrix w that you've found could have been obtained by following these rules and if it could, then for what numbers k, a1, a2, ..., an, b1, b2, ..., bm it is possible.
Input
The first line contains integers n and m (1 β€ n, m β€ 100), separated by a space β the number of rows and columns in the found matrix, respectively.
The i-th of the following lines contains numbers wi, 1, wi, 2, ..., wi, m (0 β€ wi, j β€ 109), separated by spaces β the elements of the i-th row of matrix w.
Output
If the matrix w could not have been obtained in the manner described above, print "NO" (without quotes) in the single line of output.
Otherwise, print four lines.
In the first line print "YES" (without quotes).
In the second line print an integer k (1 β€ k β€ 1018). Note that each element of table w should be in range between 0 and k - 1 inclusively.
In the third line print n integers a1, a2, ..., an (0 β€ ai β€ 1018), separated by spaces.
In the fourth line print m integers b1, b2, ..., bm (0 β€ bi β€ 1018), separated by spaces.
Examples
Input
2 3
1 2 3
2 3 4
Output
YES
1000000007
0 1
1 2 3
Input
2 2
1 2
2 0
Output
YES
3
0 1
1 2
Input
2 2
1 2
2 1
Output
NO
Note
By <image> we denote the remainder of integer division of b by c.
It is guaranteed that if there exists some set of numbers k, a1, ..., an, b1, ..., bm, that you could use to make matrix w, then there also exists a set of numbers that meets the limits 1 β€ k β€ 1018, 1 β€ ai β€ 1018, 1 β€ bi β€ 1018 in the output format. In other words, these upper bounds are introduced only for checking convenience purposes.
Tags: constructive algorithms, math
Correct Solution:
```
"""
Codeforces Contest 289 Div 2 Problem D
Author : chaotic_iak
Language: Python 3.4.2
"""
################################################### SOLUTION
def main():
n,m = read()
matrix = [read() for _ in range(n)]
mod = 10**11
for i in range(n-1):
poss = set()
for j in range(m):
poss.add(matrix[i+1][j] - matrix[i][j])
if len(poss) > 2: return "NO"
if len(poss) == 2 and mod != 10**11 and mod != max(poss) - min(poss): return "NO"
if len(poss) == 2: mod = max(poss) - min(poss)
if mod <= max(max(matrix[i]) for i in range(n)): return "NO"
print("YES")
print(mod)
write([(matrix[i][0] - matrix[0][0]) % mod for i in range(n)])
print()
write(matrix[0])
#################################################### HELPERS
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0: return inputs
if mode == 1: return inputs.split()
if mode == 2: return list(map(int, inputs.split()))
def write(s="\n"):
if s is None: s = ""
if isinstance(s, list): s = " ".join(map(str, s))
s = str(s)
print(s, end="")
write(main())
```
| 7,936 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya had two arrays consisting of non-negative integers: a of size n and b of size m. Vasya chose a positive integer k and created an n Γ m matrix v using the following formula:
<image>
Vasya wrote down matrix v on a piece of paper and put it in the table.
A year later Vasya was cleaning his table when he found a piece of paper containing an n Γ m matrix w. He remembered making a matrix one day by the rules given above but he was not sure if he had found the paper with the matrix v from those days. Your task is to find out if the matrix w that you've found could have been obtained by following these rules and if it could, then for what numbers k, a1, a2, ..., an, b1, b2, ..., bm it is possible.
Input
The first line contains integers n and m (1 β€ n, m β€ 100), separated by a space β the number of rows and columns in the found matrix, respectively.
The i-th of the following lines contains numbers wi, 1, wi, 2, ..., wi, m (0 β€ wi, j β€ 109), separated by spaces β the elements of the i-th row of matrix w.
Output
If the matrix w could not have been obtained in the manner described above, print "NO" (without quotes) in the single line of output.
Otherwise, print four lines.
In the first line print "YES" (without quotes).
In the second line print an integer k (1 β€ k β€ 1018). Note that each element of table w should be in range between 0 and k - 1 inclusively.
In the third line print n integers a1, a2, ..., an (0 β€ ai β€ 1018), separated by spaces.
In the fourth line print m integers b1, b2, ..., bm (0 β€ bi β€ 1018), separated by spaces.
Examples
Input
2 3
1 2 3
2 3 4
Output
YES
1000000007
0 1
1 2 3
Input
2 2
1 2
2 0
Output
YES
3
0 1
1 2
Input
2 2
1 2
2 1
Output
NO
Note
By <image> we denote the remainder of integer division of b by c.
It is guaranteed that if there exists some set of numbers k, a1, ..., an, b1, ..., bm, that you could use to make matrix w, then there also exists a set of numbers that meets the limits 1 β€ k β€ 1018, 1 β€ ai β€ 1018, 1 β€ bi β€ 1018 in the output format. In other words, these upper bounds are introduced only for checking convenience purposes.
Tags: constructive algorithms, math
Correct Solution:
```
import sys
f = sys.stdin
#f = open('H:\\Portable Python 3.2.5.1\\test_248B1.txt')
#r, g, b = map(int, f.readline().strip().split())
n, m = map(int, f.readline().strip().split())
v = []
max_v = 0
for i in range(n):
a = [int(u) for u in f.readline().strip().split()]
v.append(a)
max_v = max(max_v, max(a))
#print(v)
#print(max_v)
#if n==1 or m==1:
# print('YES')
# print(max_v+1)
# if n==1:
# print(0)
# p = [str(u) for u in v[0]]
# print( ' '.join(p) )
# else:
# p = [str(u[0]) for u in v]
# print( ' '.join(p) )1 12
# print(0)
# exit()
a = [0]*n
b = [0]*m
a[0] = v[0][0]
b[0] = 0
k = []
err = False
for i in range(n-1):
w = [0]*m
for j in range(m):
w[j] = v[i+1][j] - v[i][j]
t = max(w)
for j in range(m):
if w[j] - t != 0 :
if len(k)>0:
if k[0]!=w[j] - t:
err = True
else:
k.append(w[j] - t)
a[i+1] = a[i] + t
#print('a')
#print(w)
#print(a)
for j in range(m-1):
w = [0]*n
for i in range(n):
w[i] = v[i][j+1] - v[i][j]
t = max(w)
for s in range(n):
if w[s] - t != 0 :
if len(k)>0:
if k[0]!=w[s] - t:
err = True
else:
k.append(w[s] - t)
b[j+1] = b[j] + t
#print('b')
#print(w)
#print(b)
#
#print(k)
if len(k)==0:
k = max_v + 1
else :
k = -k[0]
if k<=0:
err = True
if err or k<=max_v:
print('NO')
else:
if min(a)<0:
a = [u+k for u in a]
if min(b)<0:
b = [u+k for u in b]
print('YES')
print(k)
p = [str(u) for u in a]
print( ' '.join(p) )
p = [str(u) for u in b]
print( ' '.join(p) )
```
| 7,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya had two arrays consisting of non-negative integers: a of size n and b of size m. Vasya chose a positive integer k and created an n Γ m matrix v using the following formula:
<image>
Vasya wrote down matrix v on a piece of paper and put it in the table.
A year later Vasya was cleaning his table when he found a piece of paper containing an n Γ m matrix w. He remembered making a matrix one day by the rules given above but he was not sure if he had found the paper with the matrix v from those days. Your task is to find out if the matrix w that you've found could have been obtained by following these rules and if it could, then for what numbers k, a1, a2, ..., an, b1, b2, ..., bm it is possible.
Input
The first line contains integers n and m (1 β€ n, m β€ 100), separated by a space β the number of rows and columns in the found matrix, respectively.
The i-th of the following lines contains numbers wi, 1, wi, 2, ..., wi, m (0 β€ wi, j β€ 109), separated by spaces β the elements of the i-th row of matrix w.
Output
If the matrix w could not have been obtained in the manner described above, print "NO" (without quotes) in the single line of output.
Otherwise, print four lines.
In the first line print "YES" (without quotes).
In the second line print an integer k (1 β€ k β€ 1018). Note that each element of table w should be in range between 0 and k - 1 inclusively.
In the third line print n integers a1, a2, ..., an (0 β€ ai β€ 1018), separated by spaces.
In the fourth line print m integers b1, b2, ..., bm (0 β€ bi β€ 1018), separated by spaces.
Examples
Input
2 3
1 2 3
2 3 4
Output
YES
1000000007
0 1
1 2 3
Input
2 2
1 2
2 0
Output
YES
3
0 1
1 2
Input
2 2
1 2
2 1
Output
NO
Note
By <image> we denote the remainder of integer division of b by c.
It is guaranteed that if there exists some set of numbers k, a1, ..., an, b1, ..., bm, that you could use to make matrix w, then there also exists a set of numbers that meets the limits 1 β€ k β€ 1018, 1 β€ ai β€ 1018, 1 β€ bi β€ 1018 in the output format. In other words, these upper bounds are introduced only for checking convenience purposes.
Submitted Solution:
```
import sys
f = sys.stdin
#f = open('H:\\Portable Python 3.2.5.1\\test_248B1.txt')
#r, g, b = map(int, f.readline().strip().split())
n, m = map(int, f.readline().strip().split())
v = []
max_v = 0
for i in range(n):
a = [int(u) for u in f.readline().strip().split()]
v.append(a)
max_v = max(max_v, max(a))
#print(v)
#print(max_v)
if n==1 or m==1:
print('YES')
print(max_v)
if n==1:
print(0)
p = [str(u) for u in v[0]]
print( ' '.join(p) )
elif m==1:
p = [str(u[0]) for u in v]
print( ' '.join(p) )
print(0)
a = [0]*n
b = [0]*m
a[0] = v[0][0]
b[0] = 0
k = []
err = False
for i in range(n-1):
w = [0]*m
for j in range(m):
w[j] = v[i+1][j] - v[i][j]
t = max(w)
for j in range(m):
if w[j] - t != 0 :
if len(k)>0:
if k[0]!=w[j] - t:
err = True
else:
k.append(w[j] - t)
a[i+1] = a[i] + t
#print('a')
#print(w)
#print(a)
for j in range(m-1):
w = [0]*n
for i in range(n):
w[i] = v[i][j+1] - v[i][j]
t = max(w)
for s in range(n):
if w[s] - t != 0 :
if len(k)>0:
if k[0]!=w[s] - t:
err = True
else:
k.append(w[s] - t)
b[j+1] = b[j] + t
#print('b')
#print(w)
#print(b)
#
#print(k)
if len(k)==0:
k = max_v + 1
else :
k = -k[0]
if err or k<=max_v:
print('NO')
else:
print('YES')
print(k)
p = [str(u) for u in a]
print( ' '.join(p) )
p = [str(u) for u in b]
print( ' '.join(p) )
```
No
| 7,938 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp invented a new way to encode strings. Let's assume that we have string T, consisting of lowercase English letters. Let's choose several pairs of letters of the English alphabet in such a way that each letter occurs in at most one pair. Then let's replace each letter in T with its pair letter if there is a pair letter for it. For example, if you chose pairs (l, r), (p, q) and (a, o), then word "parallelogram" according to the given encoding principle transforms to word "qolorreraglom".
Polycarpus already has two strings, S and T. He suspects that string T was obtained after applying the given encoding method from some substring of string S. Find all positions mi in S (1 β€ mi β€ |S| - |T| + 1), such that T can be obtained fro substring SmiSmi + 1... Smi + |T| - 1 by applying the described encoding operation by using some set of pairs of English alphabet letters
Input
The first line of the input contains two integers, |S| and |T| (1 β€ |T| β€ |S| β€ 2Β·105) β the lengths of string S and string T, respectively.
The second and third line of the input contain strings S and T, respectively. Both strings consist only of lowercase English letters.
Output
Print number k β the number of suitable positions in string S.
In the next line print k integers m1, m2, ..., mk β the numbers of the suitable positions in the increasing order.
Examples
Input
11 5
abacabadaba
acaba
Output
3
1 3 7
Input
21 13
paraparallelogramgram
qolorreraglom
Output
1
5
Submitted Solution:
```
def kmp(s):
k = [0] * len(s)
j = 0
for i in range(1, len(s)):
j = k[i - 1]
while (True):
if (s[i] == s[j] or (s[j] == 0 and s[i] != -1)):
k[i] = j + 1
break
if (j == 0):
k[i] = 0
break
j = k[j - 1]
return k
def mns(s):
d = dict()
a = []
for i in range(len(s)):
e = s[i]
if e in d.keys():
a.append(i - d[e])
else:
a.append(0)
d[e] = i
return a
def check(s, s2, j):
q = set()
for i in range(len(s2)):
a = s[i+j]
b = s2[i]
q.add((min(a, b), max(a, b)))
q = list(q)
d = set()
for p in q:
a, b = p
if a == b:
if a in d:
return False
d.add(a)
else:
if a in d:
return False
if b in d:
return False
d.add(a)
d.add(b)
return True
if __name__ == '__main__':
n, m = [int(e) for e in input().split()]
s = input()
s1 = input()
a = mns(s)
a1 = mns(s1)
q = a1 + [-1] + a
kmp_res = kmp(q)
ans = []
for i in range(len(kmp_res)):
e = kmp_res[i]
if e == m:
ans.append(i-m-1-m+1)
res = []
for an in ans:
if check(s, s1, an):
res.append(an)
print(len(res))
print(' '.join([str(e+1) for e in res]))
```
No
| 7,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp invented a new way to encode strings. Let's assume that we have string T, consisting of lowercase English letters. Let's choose several pairs of letters of the English alphabet in such a way that each letter occurs in at most one pair. Then let's replace each letter in T with its pair letter if there is a pair letter for it. For example, if you chose pairs (l, r), (p, q) and (a, o), then word "parallelogram" according to the given encoding principle transforms to word "qolorreraglom".
Polycarpus already has two strings, S and T. He suspects that string T was obtained after applying the given encoding method from some substring of string S. Find all positions mi in S (1 β€ mi β€ |S| - |T| + 1), such that T can be obtained fro substring SmiSmi + 1... Smi + |T| - 1 by applying the described encoding operation by using some set of pairs of English alphabet letters
Input
The first line of the input contains two integers, |S| and |T| (1 β€ |T| β€ |S| β€ 2Β·105) β the lengths of string S and string T, respectively.
The second and third line of the input contain strings S and T, respectively. Both strings consist only of lowercase English letters.
Output
Print number k β the number of suitable positions in string S.
In the next line print k integers m1, m2, ..., mk β the numbers of the suitable positions in the increasing order.
Examples
Input
11 5
abacabadaba
acaba
Output
3
1 3 7
Input
21 13
paraparallelogramgram
qolorreraglom
Output
1
5
Submitted Solution:
```
def kmp(s):
k = [0] * len(s)
j = 0
for i in range(1, len(s)):
j = k[i - 1]
while True:
if s[i] == s[j]:
k[i] = j + 1
break
if j == 0:
k[i] = 0
break
j = k[j - 1]
return k
def mns(s, c):
a = []
for i in range(len(s)):
if s[i] == c:
a.append(1)
else:
a.append(0)
return a
def check(pairs, alf):
for c in alf:
ind = 0
for p in pairs:
a, b = p
if a == c or b == c:
ind+=1
if ind!=1:
return False
return True
if __name__ == '__main__':
n, m = [int(e) for e in input().split()]
s = input()
s1 = input()
sets = []
for i in range(n):
sets.append(set())
alf = list(set(s+s1))
alf.sort()
for a in alf:
for b in alf:
q = mns(s, a)
q1 = mns(s1, b)
kmp_res = kmp(q1 + [-1] + q)
pos = []
for i in range(len(kmp_res)):
if kmp_res[i] == m:
sets[i - 2 * m].add((min(a,b), max(a,b)))
res = []
for i in range(n):
if check(sets[i], alf):
res.append(i)
print(len(res))
print(' '.join([str(e+1) for e in res]))
```
No
| 7,940 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This task is very simple. Given a string S of length n and q queries each query is on the format i j k which means sort the substring consisting of the characters from i to j in non-decreasing order if k = 1 or in non-increasing order if k = 0.
Output the final string after applying the queries.
Input
The first line will contain two integers n, q (1 β€ n β€ 105, 0 β€ q β€ 50 000), the length of the string and the number of queries respectively.
Next line contains a string S itself. It contains only lowercase English letters.
Next q lines will contain three integers each i, j, k (1 β€ i β€ j β€ n, <image>).
Output
Output one line, the string S after applying the queries.
Examples
Input
10 5
abacdabcda
7 10 0
5 8 1
1 4 0
3 6 0
7 10 1
Output
cbcaaaabdd
Input
10 1
agjucbvdfk
1 10 1
Output
abcdfgjkuv
Note
First sample test explanation:
<image>
<image>
<image>
<image>
<image>
Submitted Solution:
```
n,t=map(int,input().split())
s=input()
while(t):
t=t-1
st,end,k=map(int,input().split())
sub=s[st:end+1]
#print(sub)
l=list(sub)
#print(l)
if(k==0):
l.sort()
else:
l.sort(reverse=True)
r="".join(l)
#print(r)
res=s[0:st]+r+s[end+1:n]
print(res)
```
No
| 7,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This task is very simple. Given a string S of length n and q queries each query is on the format i j k which means sort the substring consisting of the characters from i to j in non-decreasing order if k = 1 or in non-increasing order if k = 0.
Output the final string after applying the queries.
Input
The first line will contain two integers n, q (1 β€ n β€ 105, 0 β€ q β€ 50 000), the length of the string and the number of queries respectively.
Next line contains a string S itself. It contains only lowercase English letters.
Next q lines will contain three integers each i, j, k (1 β€ i β€ j β€ n, <image>).
Output
Output one line, the string S after applying the queries.
Examples
Input
10 5
abacdabcda
7 10 0
5 8 1
1 4 0
3 6 0
7 10 1
Output
cbcaaaabdd
Input
10 1
agjucbvdfk
1 10 1
Output
abcdfgjkuv
Note
First sample test explanation:
<image>
<image>
<image>
<image>
<image>
Submitted Solution:
```
import textwrap
n,q=list(map(int,input().split()))
print(n,q)
stroka=textwrap.wrap(input(),1)
for x in range(q):
i,j,k=list(map(int,input().split()))
stroka[i-1:j]=sorted(stroka[i-1:j],reverse=abs(k-1))
print(''.join(stroka))
```
No
| 7,942 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This task is very simple. Given a string S of length n and q queries each query is on the format i j k which means sort the substring consisting of the characters from i to j in non-decreasing order if k = 1 or in non-increasing order if k = 0.
Output the final string after applying the queries.
Input
The first line will contain two integers n, q (1 β€ n β€ 105, 0 β€ q β€ 50 000), the length of the string and the number of queries respectively.
Next line contains a string S itself. It contains only lowercase English letters.
Next q lines will contain three integers each i, j, k (1 β€ i β€ j β€ n, <image>).
Output
Output one line, the string S after applying the queries.
Examples
Input
10 5
abacdabcda
7 10 0
5 8 1
1 4 0
3 6 0
7 10 1
Output
cbcaaaabdd
Input
10 1
agjucbvdfk
1 10 1
Output
abcdfgjkuv
Note
First sample test explanation:
<image>
<image>
<image>
<image>
<image>
Submitted Solution:
```
n, q = map(int, input().split(" "))
s = list(input())
for a in range(0, q):
i, j, k = map(int, input().split(" "))
s[i-1:j] = sorted(s[i-1:j], reverse=1-k)
print(s)
```
No
| 7,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This task is very simple. Given a string S of length n and q queries each query is on the format i j k which means sort the substring consisting of the characters from i to j in non-decreasing order if k = 1 or in non-increasing order if k = 0.
Output the final string after applying the queries.
Input
The first line will contain two integers n, q (1 β€ n β€ 105, 0 β€ q β€ 50 000), the length of the string and the number of queries respectively.
Next line contains a string S itself. It contains only lowercase English letters.
Next q lines will contain three integers each i, j, k (1 β€ i β€ j β€ n, <image>).
Output
Output one line, the string S after applying the queries.
Examples
Input
10 5
abacdabcda
7 10 0
5 8 1
1 4 0
3 6 0
7 10 1
Output
cbcaaaabdd
Input
10 1
agjucbvdfk
1 10 1
Output
abcdfgjkuv
Note
First sample test explanation:
<image>
<image>
<image>
<image>
<image>
Submitted Solution:
```
n,q=[int(x) for x in input().split()]
s=input()
L=[]
M=[]
for i in range(q):
i,j,k=[int(x) for x in input().split()]
if k==0:
try:
if i< min(L) and j in L:
s=s[:i-1]+"".join(sorted(s[i-1:min(L)-1],reverse=True))+s[min(L)-1:]
if i in M and min(L)-1 in M:
del M[i-1:min(L)-1]
L.extend(range(i,min(L)))
elif i in L and j>max(L):
s=s[:max(L)]+"".join(sorted(s[max(L):j],reverse=True))+s[j:]
if max(L)+1 in M and j in M:
del M[max(L):j]
L.extend(range(max(L)+1,j+1))
elif j not in L and i not in L:
s=s[:i-1]+"".join(sorted(s[i-1:j],reverse=True))+s[j:]
if i in M and j in M:
del M[i-1:j]
L.extend(range(i,j+1))
else:
pass
except ValueError:
s=s[:i-1]+"".join(sorted(s[i-1:j],reverse=True))+s[j:]
if i in M and j in M:
del M[i-1:j]
L.extend(range(i,j+1))
L.sort()
else:
try:
if i< min(M) and j in M:
s=s[:i-1]+"".join(sorted(s[i-1:min(M)-1]))+s[min(M)-1:]
if i in L and min(M)-1 in L:
del L[i-1:min(M)-1]
M.extend(range(i,min(M)))
elif i in L and j>max(L):
s=s[:max(L)]+"".join(sorted(s[max(M):j]))+s[j:]
if max(M)+1 in L and j in L:
del L[max(M):j]
M.extend(range(max(M)+1,j+1))
elif j not in M and i not in M:
s=s[:i-1]+"".join(sorted(s[i-1:j]))+s[j:]
if i in L and j in L:
del L[i-1:j]
M.extend(range(i,j+1))
else:
pass
except ValueError:
s=s[:i-1]+"".join(sorted(s[i-1:j]))+s[j:]
if i in L and j in L:
del L[i-1:j]
M.extend(range(i,j+1))
M.sort()
print(s)
```
No
| 7,944 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
n, k = map(int, input().split())
a = input()
b = input()
cnt = 0
for i in range(n):
if (a[i] == b[i]):
cnt += 1
dif = n - cnt
ok = n - (cnt + dif // 2)
if (k < ok):
print(-1)
else:
res, cur, req, i, nxt = {}, 0, n - k, 0, True
while (cur < req):
if (a[i] == b[i]):
res[i], cur = a[i], cur + 1
elif (nxt):
pos, nxt = i, not nxt
else:
res[pos], res[i], nxt, cur = a[pos], b[i], not nxt, cur + 1
i += 1
if (nxt == False):
if (('a' != a[pos]) and ('a' != b[pos])):
res[pos] = 'a'
elif (('b' != a[pos]) and ('b' != b[pos])):
res[pos] = 'b'
elif (('c' != a[pos]) and ('c' != b[pos])):
res[pos] = 'c'
else:
res[pos] = 'd'
while (i < n):
if (('a' != a[i]) and ('a' != b[i])):
res[i] = 'a'
elif (('b' != a[i]) and ('b' != b[i])):
res[i] = 'b'
elif (('c' != a[i]) and ('c' != b[i])):
res[i] = 'c'
else:
res[i] = 'd'
i += 1
for i in range(n):
print(res[i], end = '')
```
| 7,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
n, t = map(int, input().split())
s1 = input()
s2 = input()
same = n - t
ans = ["" for i in range(n)]
for i in range(n):
if(same==0):
break
if s1[i] == s2[i]:
same -= 1
ans[i] = s1[i]
same1 = same2 = same
for i in range(n):
if(ans[i]!=""):
continue
if same1 != 0 and same1>=same2:
ans[i] = s1[i]
same1 -= 1
elif same2 != 0 and same2>=same1:
ans[i] = s2[i]
same2 -= 1
elif same1 == 0 and same2 == 0:
if s1[i] != 'a' and s2[i] != 'a':
ans[i] = 'a'
elif s1[i] != 'b' and s2[i] != 'b':
ans[i] = 'b'
elif s1[i] != 'c' and s2[i] != 'c':
ans[i] = 'c'
if same1 > 0 or same2 > 0:
print(-1)
else:
print("".join(ans))
```
| 7,946 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
n,k=map(int,input().split())
a=input()
b=input()
c=[]
ans=0
for i in range(n):
if a[i]==b[i]:
ans+=1
si=n-k
d=['a','b','c']
if ans>=si:
for i in range(n):
if a[i]==b[i] and si>0:
c.append(a[i])
si-=1
else:
ee=[a[i],b[i]]
if 'a' not in ee:
c.append('a')
elif 'c' not in ee:
c.append('c')
else:
c.append('b')
print(''.join(c))
else:
re1=si-ans
re2=si-ans
for i in range(n):
if a[i]==b[i] :
c.append(a[i])
else:
if re1>0:
c.append(a[i])
re1-=1
elif re2>0:
c.append(b[i])
re2-=1
else:
ee=[a[i],b[i]]
if 'a' not in ee:
c.append('a')
elif 'c' not in ee:
c.append('c')
else:
c.append('b')
#print(re1,re2)
if re1+re2==0:
print(''.join(c))
else:
print(-1)
```
| 7,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
from sys import exit
def cdiff(c1, c2):
ch = 'a'
while ch in (c1, c2):
ch = chr(ord(ch) + 1)
return ch
n, t = map(int, input().split())
a = input()
b = input()
ra = 0
rb = 0
c = [-1] * n
for i in range(n):
c[i] = (a[i], b[i])[(ra + rb) % 2]
ra += c[i] != a[i]
rb += c[i] != b[i]
if rb < ra:
ra, rb = rb, ra
a, b = b, a
if ra < rb:
for i in range(n):
if c[i] != b[i] and c[i] == a[i]:
c[i] = cdiff(a[i], b[i])
ra += 1
break
if ra < rb:
print(-1)
exit(0)
if t < ra:
print(-1)
exit(0)
i = 0
lst = -1
while ra < t and i < n:
if a[i] == b[i]:
c[i] = cdiff(a[i], b[i])
ra += 1
rb += 1
elif c[i] not in (a[i], b[i]):
pass
elif lst == -1:
lst = i
else:
c[lst] = cdiff(a[lst], b[lst])
c[i] = cdiff(a[i], b[i])
lst = -1
ra += 1
rb += 1
i += 1
if ra != t:
print(-1)
exit(0)
print(*c, sep='')
```
| 7,948 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
n, t = map(int, input().split())
a, b = input(), input()
ans = []
s = d = 0
for i, j in zip(a, b):
if i == j:
s += 1
else:
d += 1
if t < (d + 1) // 2:
print(-1)
exit()
x = min(n - t, s)
y = z = max(n - t - s, 0)
def f(a, b):
for i in range(97, 123):
if chr(i) not in [a, b]:
return chr(i)
for i in range(n):
if a[i] == b[i]:
if x:
ans.append(a[i])
x -= 1
else:
ans.append(f(a[i], b[i]))
else:
if y:
ans.append(a[i])
y -= 1
elif z:
ans.append(b[i])
z -= 1
else:
ans.append(f(a[i], b[i]))
print(''.join(ans))
```
| 7,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
n, t = map(int, input().split())
s1 = str(input())
s2 = str(input())
s1cnt, s2cnt = n - t, n - t
ans = [None] * n
# print(s1cnt, s2cnt)
for i in range(n):
ch1, ch2 = s1[i], s2[i]
if ch1 == ch2 and s1cnt and s2cnt:
ans[i] = ch1
s1cnt -= 1
s2cnt -= 1
# print(ans)
for i in range(n):
ch1, ch2 = s1[i], s2[i]
if s1cnt and ans[i] == None:
ans[i] = ch1
s1cnt -= 1
elif s2cnt and ans[i] == None:
ans[i] = ch2
s2cnt -= 1
elif ans[i] == None:
for j in range(ord('a'), ord('e')):
if chr(j) != ch1 and chr(j) != ch2:
ans[i] = chr(j)
break
if s1cnt or s2cnt:
print(-1)
else:
print(''.join(ans))
# print(n,t, s1, s2)
```
| 7,950 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
def get_diff(a,b):
res='a'
while res==a or res==b:
res=chr(ord(res)+1)
return res
n,t=map(int, input().split())
s1=input()
s2=input()
diff=0
res="-1"
for i in range(n):
if s1[i]!=s2[i]:
diff+=1
if t<diff:
if t*2>=diff:
res=[None]*n
singole=t*2-diff
curr=1
for i in range(n):
if s1[i]==s2[i]:
res[i]=s1[i]
else: #diff
if singole>0:
res[i]=get_diff(s1[i],s2[i])
singole-=1
else:
if curr==1:
res[i]=s1[i]
else:
res[i]=s2[i]
curr=-curr
elif t==diff:
res=[None]*n
for i in range(n):
if s1[i]==s2[i]:
res[i]=s1[i]
else:
res[i]=get_diff(s1[i],s2[i])
else: #t>diff
res=[None]*n
for i in range(n):
if s1[i]==s2[i]:
if t>diff:
res[i]=get_diff(s1[i],s2[i])
t-=1
else:
res[i]=s1[i]
else:
res[i]=get_diff(s1[i],s2[i])
res="".join(res)
print(res)
```
| 7,951 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
import sys
letras="abcdefghijklmnopqrstuvwxyz"
def distinto(a,b):
for lc in range(26):
c=letras[lc]
if (a!=c and b!= c): return c
s3=""
l=0
for line in sys.stdin:
if l==0:
n,t=map(int,line.split())
if l==1:
s1=line
else: s2=line
l+=1
dist=0
for i in range(n):
if (s1[i]!=s2[i]): dist+=1
if (t<int((dist+1)/2)):
s3+= str(-1)
elif (t>=dist) :
igdist=t-dist
for i in range(n):
if (s1[i]!=s2[i]):
s3+= distinto(s1[i],s2[i])
else:
if (igdist==0):
s3+= s1[i];
else:
s3+= distinto(s1[i],s2[i])
igdist-=1
else :
distdist=dist-t
alter=1
for i in range(n):
if (s1[i]==s2[i]):
s3+= s1[i]
else:
if (distdist==0):
s3+= distinto(s1[i],s2[i]);
else:
if (alter==1):
s3+= s1[i]
alter=2
else:
s3+= s2[i]
alter=1
distdist-=1
print (s3)
```
| 7,952 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Submitted Solution:
```
import sys
INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
"""
Facts and Data representation
Constructive? Top bottom up down
"""
n, k = I()
s = input()
t = input()
ans = list(s)
cnt = 0
idx = []
for i in range(n):
if s[i] != t[i]:
idx.append(i)
else:
ans[i] = s[i]
a = 'abcde'
ok = len(idx)
req = 0
for i in range(ok + 1):
if (ok - i) % 2:
continue
count = i + (ok - i) // 2
if count + n - ok >= k and count <= k:
req = max(0, k - count)
# print(k - count, count, i)
for j in range(i):
for ass in a:
if ass != s[idx[j]] and ass != t[idx[j]]:
ans[idx[j]] = ass
break
for j in range(i, ok):
# print(j)
if j % 2:
ans[idx[j]] = s[idx[j]]
else:
ans[idx[j]] = t[idx[j]]
break
else:
print(-1)
exit()
for i in range(n):
if not req:
break
if s[i] == t[i]:
if s[i] == 'a':
ans[i] = 'z'
else:
ans[i] = 'a'
req -= 1
print(''.join(ans))
```
Yes
| 7,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Submitted Solution:
```
n, t = [int(i) for i in input().split()]
s1 = input()
s2 = input()
same = 0
for i in range(n):
if s1[i] is s2[i]:
same += 1
diff = n - same
if t * 2 < diff:
print(-1)
exit()
if t * 2 == diff:
f1 = t
f2 = t
s3 = ""
for i in range(n):
if s1[i] == s2[i]:
s3 = s3 + s1[i]
else:
if f1 > 0:
s3 = s3 + s1[i]
f1 -= 1
else:
s3 = s3 + s2[i]
print(s3)
exit()
oth = max(0, t - diff)
f1 = max(0, diff - t)
f2 = max(0, diff - t)
s3 = ""
for i in range(n):
if s1[i] == s2[i]:
if oth > 0:
if s1[i] == 'a':
s3 = s3 + 'b'
else:
s3 = s3 + 'a'
oth -= 1
else:
s3 += s1[i]
else:
if f1 > 0:
s3 += s2[i]
f1 -= 1
elif f2 > 0:
s3 += s1[i]
f2 -= 1
else:
if 'a' not in [s1[i], s2[i]]:
s3 = s3 + 'a'
elif 'b' not in [s1[i], s2[i]]:
s3 = s3 + 'b'
else:
s3 = s3 + 'c'
# oth = t - f1
# f = 0
#
# if diff % 2 is 1:
# f = 1
# oth -= 1
#
# for i in range(n):
#
# if s1[i] == s2[i]:
#
# if oth > 0:
#
# if s1[i] == 'a':
#
# s3 = s3 + 'b'
#
# else:
#
# s3 = s3 + 'a'
#
# oth -= 1
#
# else:
# # print(s1)
# s3 = s3 + s1[i]
#
# else:
#
# if f is 1:
#
# if 'a' not in [s1[i], s2[i]]:
#
# s3 = s3 + 'a'
#
# elif 'b' not in [s1[i], s2[i]]:
#
# s3 = s3 + 'b'
#
# else:
#
# s3 = s3 + 'c'
#
# f = 0
#
# else:
#
# if s1[i] == s2[i]:
#
# s3 = s3 + s1[i]
#
# else:
#
# if f1 > 0:
#
# s3 = s3 + s1[i]
# f1 -= 1
#
# else:
#
# s3 = s3 + s2[i]
print(s3)
```
Yes
| 7,954 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Submitted Solution:
```
def read_numbers():
return list(map(int, input().split()))
def get_other_char(a, b):
for c in 'abc':
if c != a and c != b:
return c
n, t = read_numbers()
word1 = input()
word2 = input()
# find a word, that has minimal distance to both of them
# first, number of differences
diffs = len([idx for idx, (c1, c2) in enumerate(zip(word1, word2)) if c1 != c2])
#not_diffs = [idx for idx, (c1, c2) in enumerate(zip(word1, word2)) if c1 == c2]
minimum = (diffs + 1) // 2
switches = diffs - t if t <= diffs else 0
switch_polarity = 0
if t < minimum:
print(-1)
else:
# create new word
new_word = []
for c1, c2 in zip(word1, word2):
if c1 == c2:
if t > diffs:
new_word.append(get_other_char(c1, c2))
t -= 1
else:
new_word.append(c1)
else:
if switches:
if switch_polarity == 0:
new_word.append(c1)
switch_polarity = 1
else:
new_word.append(c2)
switch_polarity = 0
switches -= 1
else:
new_word.append(get_other_char(c1, c2))
print(''.join(new_word))
```
Yes
| 7,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Submitted Solution:
```
def diff(c1, c2):
alph = 'abcdefghijklmnopqrstuvwxyz'
for c in alph:
if c != c1 and c!= c2: return c
n, t = map(int, input().split())
s1 = input()
s2 = input()
s3 = []
same1 = 0
same2 = 0
last1 = -1
last2 = -1
i = 0
first = True
while (same1 < (n - t) or same2 < (n - t)) and i < n:
if s1[i] == s2[i]:
if same1 + 1 > (n-t):
s3[last1] = diff(s1[last1], s2[last1])
same1 -= 1
elif same2 + 1 > (n-t):
s3[last2] = diff(s1[last2], s2[last2])
same2 -= 1
s3.append(s1[i])
same1 += 1
same2 += 1
elif s1[i] == s2[i]:
s3 += diff(s1[i], s2[i])
else:
if first:
s3.append(s1[i])
same1 += 1
last1 = i
else:
s3.append(s2[i])
same2 += 1
last2 = i
first = not first
i += 1
if same1 != same2 or (same1 == same2 != (n-t)):
print(-1)
else:
remaining = n - len(s3)
for i in range(len(s3), n):
s3 += diff(s1[i], s2[i])
print(''.join(s3))
```
Yes
| 7,956 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Submitted Solution:
```
n, t = [int(x) for x in input().split()]
s1 = list(input())
s2 = list(input())
z1 = n - t
z2 = n - t
o = []
m = set([])
alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
for i, c in enumerate(s1):
m.add(c)
if z1 > 0:
o.append(c)
z1 -= 1
if c == s2[i]:
z2 -= 1
elif z2 > 0:
o.append(s2[i])
z2 -= 1
if c == s2[i]:
z1 -= 1
for oi, oc in enumerate(o):
if oc == s1[oi] and oc != s2[oi]:
r = ""
for a_i in range(0, len(alphabet)):
r = alphabet[a_i]
if r not in m:
break
o[oi] = r
z1 += 1
else:
r = ""
for a_i in range(0, len(alphabet)):
r = alphabet[a_i]
if r not in m:
break
o.append(r)
if len(list(m)) == len(alphabet) and t != 0:
print(-1)
elif z1 == 0 and z2 == 0:
print("".join(o))
else:
print(-1)
```
No
| 7,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Submitted Solution:
```
'''
Created on Oct 7, 2015
@author: Ismael
'''
def otherChar(x,y):
for c in 'a','b','c':
if c != x and c != y:
return c
def solve(a,b,t):
nbEqual = sum(1 for i in range(len(a)) if a[i] == b[i])
nbDiff = len(a)-nbEqual
if t == 0 and nbDiff==1:
return '-1'
c=len(a)*[0]
k=0
i = 0
while i < len(a)-1:
if a[i] != b[i]:
q,r = divmod(nbDiff,2)
k+=1
if k+1+q+r<=t:#c[i] different from both c[i] and c[i]
nbDiff=-1
c[i] = otherChar(a[i],b[i])
i+=1
else:
nbDiff=-2
c[i] = a[i]
c[i+1] = b[i+1]
i+=2
else:
i+=1
i = 0
while i < len(a):
if a[i] == b[i]:
if k < t:
k+=1
c[i] = otherChar(a[i],b[i])
else:
c[i] = a[i]
i+=1
if k!=t:
return '-1'
return ''.join(map(str,c))
def check(a,b,t,c):
assert(sum(1 for i in range(len(a)) if a[i] != c[i])==t)
assert(sum(1 for i in range(len(a)) if b[i] != c[i])==t)
# args = "abc","abc",2
# c=solve(*args)
# print(c)
# check(*args,c=c)
#
# args = "abc","xyc",2
# c=solve(*args)
# print(c)
# check(*args,c=c)
#
# args = "c","d",0
# c=solve(*args)
# print(c)
# check(*args,c=c)
_,t=map(int,input().split())
a=input()
b=input()
print(solve(a,b,t))
```
No
| 7,958 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
#vsInput()
n,t=value()
s1=input()
s2=input()
s3=[0]*(n)
dif=[]
equal=[]
for i in range(n):
if(s1[i]!=s2[i]): dif.append(i)
else: equal.append(i)
i=0
while(i+1<len(dif)):
s3[dif[i]]=1
s3[dif[i+1]]=2
t-=1
i+=1
if(len(dif)%2):
s3[dif[-1]]=3
t-=1
i=0
while(t>0 and i+1<len(dif)):
t-=1
s3[i]=3
s3[i+1]=3
i+=2
i=0
while(t>0 and i<len(equal)):
s3[equal[i]]=3
t-=1
i+=1
print(t,s3)
for i in range(n):
if(s1[i]==1): s3[i]=s1[i]
elif(s3[i]==2): s3[i]=s2[i]
elif(s3[i]==3):
for c in 'abc':
if(s1[i]!=c and s2[i]!=c):
s3[i]=c
break
else:
s3[i]=s1[i]
if(t==0): print(*s3,sep="")
else: print(-1)
```
No
| 7,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1
Submitted Solution:
```
def diff(c1, c2):
alph = 'abcdefghijklmnopqrstuvwxyz'
for c in alph:
if c != c1 and c!= c2: return c
n, t = map(int, input().split())
s1 = input()
s2 = input()
s3 = ''
same1 = 0
same2 = 0
i = 0
first = True
while (same1 < (n - t) or same2 < (n - t)) and i < n:
if s1[i] == s2[i]:
s3 += s1[i]
same1 += 1
same2 += 1
else:
if first:
s3 += s1[i]
same1 += 1
else:
s3 += s2[i]
same2 += 1
first = not first
i += 1
if same1 != same2:
print(-1)
else:
remaining = n - len(s3)
for i in range(len(s3), n):
s3 += diff(s1[i], s2[i])
print(s3)
```
No
| 7,960 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Tags: constructive algorithms, greedy
Correct Solution:
```
n = int(input())
arr = map(int,input().split())
li=[0]*(n+1)
for i in arr:
li[i]=li[i-1]+1
print(n-max(li))
```
| 7,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Tags: constructive algorithms, greedy
Correct Solution:
```
#!/usr/bin/env python3
# 606C_sort.py - Codeforces.com/problemset/problem/606/C by Sergey 2015
import unittest
import sys
###############################################################################
# Sort Class (Main Program)
###############################################################################
class Sort:
""" Sort representation """
def __init__(self, test_inputs=None):
""" Default constructor """
it = iter(test_inputs.split("\n")) if test_inputs else None
def uinput():
return next(it) if it else sys.stdin.readline().rstrip()
# Reading single elements
[self.n] = map(int, uinput().split())
# Reading a single line of multiple elements
self.nums = list(map(int, uinput().split()))
# Translate number to position
tr = [0] * self.n
for i in range(self.n):
tr[self.nums[i]-1] = i
# Longest increasing subarray
max_len = 1
for i in range(self.n):
if i > 0 and tr[i] > tr[i-1]:
cur_len += 1
max_len = max(max_len, cur_len)
else:
cur_len = 1
self.result = self.n - max_len
def calculate(self):
""" Main calcualtion function of the class """
return str(self.result)
###############################################################################
# Unit Tests
###############################################################################
class unitTests(unittest.TestCase):
def test_single_test(self):
""" Sort class testing """
# Constructor test
test = "5\n4 1 2 5 3"
d = Sort(test)
self.assertEqual(d.n, 5)
self.assertEqual(d.nums, [4, 1, 2, 5, 3])
# Sample test
self.assertEqual(Sort(test).calculate(), "2")
# Sample test
test = "4\n4 1 3 2"
self.assertEqual(Sort(test).calculate(), "2")
# Sample test
test = "8\n6 2 1 8 5 7 3 4"
self.assertEqual(Sort(test).calculate(), "5")
# My tests
test = ""
# self.assertEqual(Sort(test).calculate(), "0")
# Time limit test
# self.time_limit_test(5000)
def time_limit_test(self, nmax):
""" Timelimit testing """
import random
import timeit
# Random inputs
test = str(nmax) + " " + str(nmax) + "\n"
numnums = [str(i) + " " + str(i+1) for i in range(nmax)]
test += "\n".join(numnums) + "\n"
nums = [random.randint(1, 10000) for i in range(nmax)]
test += " ".join(map(str, nums)) + "\n"
# Run the test
start = timeit.default_timer()
d = Sort(test)
calc = timeit.default_timer()
d.calculate()
stop = timeit.default_timer()
print("\nTimelimit Test: " +
"{0:.3f}s (init {1:.3f}s calc {2:.3f}s)".
format(stop-start, calc-start, stop-calc))
if __name__ == "__main__":
# Avoiding recursion limitaions
sys.setrecursionlimit(100000)
if sys.argv[-1] == "-ut":
unittest.main(argv=[" "])
# Print the result string
sys.stdout.write(Sort().calculate())
```
| 7,962 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Tags: constructive algorithms, greedy
Correct Solution:
```
n = int(input())
p = list(map(int,input().split()))
idx = [None]*(n+1)
for i,x in enumerate(p):
idx[x] = i
maxi = 1
l = 1
for i in range(1,n):
if idx[i] < idx[i+1]:
l += 1
if l > maxi:
maxi = l
else:
l = 1
print(n - maxi)
```
| 7,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Tags: constructive algorithms, greedy
Correct Solution:
```
__author__ = 'MoonBall'
import sys
# sys.stdin = open('data/C.in', 'r')
T = 1
def process():
# 2 4 3 1 -> 2 3 1 4 -> 1 2 3 4
# 倧ηεΎε移οΌε°ηεΎε移
# 1 4 3 2 -> 1 4 2 3 -> 1 2 3 4
# ζ倧ηθΏη»ζ°
N = int(input())
a = list(map(int, input().split()))
d = [0] * (N + 1)
for _a in a:
d[_a] = d[_a - 1] + 1
print(N - max(d))
for _ in range(T):
process()
```
| 7,964 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Tags: constructive algorithms, greedy
Correct Solution:
```
n = int(input())
v = list(map(int, input().split()))
uns = dict()
for i in range(n):
uns[i + 1] = -1
for i in range(n):
if v[i] != 1 and uns[v[i] - 1] != -1:
uns[v[i]] = uns[v[i] - 1] + 1
else:
uns[v[i]] = 1
print(n - max(uns.values()))
```
| 7,965 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Tags: constructive algorithms, greedy
Correct Solution:
```
# from dust i have come dust i will be
n=int(input())
a=list(map(int,input().split()))
mp=[0]*(n+1)
for i in range(n):
mp[a[i]]=i+1
cnt=0;mx=1
for i in range(1,n):
if mp[i]<mp[i+1]:
cnt+=1
else:
mx=max(mx,cnt+1)
cnt=0
mx=max(mx,cnt+1)
print(n-mx)
```
| 7,966 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Tags: constructive algorithms, greedy
Correct Solution:
```
n = int(input())
vagons = tuple(map(int, input().split()))
res = [0] * (n)
places = [0] * (n + 1)
for i in range(n):
places[vagons[i]] = i
for i in range(n - 1, -1, -1):
v = vagons[i]
if v < n:
res[i] = res[places[v + 1]] + 1
else: res[i] = 1
print(n - max(res))
```
| 7,967 |
Provide tags and a correct Python 3 solution for this coding contest problem.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
lines = sys.stdin.readlines()
N = int(lines[0])
a = list(map(int, lines[1].split(' ')))
b = [-1 for _ in a]
for i, x in enumerate(a):
b[x-1] = i
cur_len = max_len = 1
for i in range(1, N):
if b[i-1] < b[i]:
cur_len += 1
else:
cur_len = 1
if cur_len > max_len:
max_len = cur_len
print(N - max_len)
```
| 7,968 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Submitted Solution:
```
n = int(input())
p = list(map(int, input().split()))
cur = set()
d = [1] * (n + 1)
for i in p:
if i in cur:
d[i] = max(d[i], d[i - 1] + 1)
cur.add(i + 1)
ans = n - max(d)
print(ans)
```
Yes
| 7,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Submitted Solution:
```
n = int(input())
p = list(map(int, input().split()))
d = {}
for i in p:
d[i] = d.get(i-1, 0) + 1
maxi = max(d.values())
print(n - maxi)
```
Yes
| 7,970 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Submitted Solution:
```
n = int(input())
Arr = [int(i) for i in input().split()]
L = [0] * (n + 1)
ans = 0
for i in range(n):
if L[Arr[i] - 1] == 0:
L[Arr[i]] = 1
else:
L[Arr[i]] = 1 + L[Arr[i] - 1]
ans = max(ans, L[Arr[i]])
print(n - ans)
```
Yes
| 7,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Submitted Solution:
```
n = int(input())
p = list(map(int, input().split()))
dp = [1]
d = {i : 0 for i in range(1, n + 1)}
d[p[0]] = 1
for i in range(1, n):
if p[i] == 1:
dp.append(dp[i - 1])
d[p[i]] = 1
elif d[p[i] - 1] == 0:
dp.append(dp[i - 1])
d[p[i]] = 1
elif d[p[i] - 1] + 1 > dp[i - 1]:
dp.append(d[p[i] - 1] + 1)
d[p[i]] = d[p[i] - 1] + 1
else:
dp.append(dp[i - 1])
d[p[i]] = d[p[i] - 1] + 1
print(n - dp[n - 1])
```
Yes
| 7,972 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Submitted Solution:
```
n=int(input())
m=list(map(int,input().split()))
p=0
l=[]
for i in range(1,n-1):
if m[i]<m[i-1]:
l.append(m[i-1])
elif m[i]>m[i+1]:
l.append(m[i])
print(len(l))
```
No
| 7,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Submitted Solution:
```
n = int(input())
p = list(map(int, input().split()))
dp = [1]
d = {i : 0 for i in range(1, n + 1)}
d[p[0]] = 1
for i in range(1, n):
if p[i] == 1:
dp.append(1)
d[p[i]] = 1
elif d[p[i] - 1] == 0:
dp.append(dp[i - 1])
d[p[i]] = 1
elif d[p[i] - 1] + 1 > dp[i - 1]:
dp.append(d[p[i] - 1] + 1)
d[p[i]] = d[p[i] - 1] + 1
else:
dp.append(dp[i - 1])
d[p[i]] = d[p[i] - 1] + 1
print(n - dp[n - 1])
```
No
| 7,974 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Submitted Solution:
```
from bisect import bisect_left
def LIS(s):
L = []
for i in range(len(s)):
index = bisect_left(L,s[i])
if index >= len(L):
L.append(s[i])
else:
L[index] = s[i]
return len(L)
n = int(input())
L = list(map(int,input().split()))
print(n-LIS(L))
```
No
| 7,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
Submitted Solution:
```
n = int(input())
seq = list(map(int, input().split()))
dp = [seq[0]]
def find_smallest_value(value):
st = 0
end = len(dp)
while st < end:
mid = (st + end) // 2
if dp[mid] < value:
st = mid + 1
else:
end = mid-1
if dp[st] > value:
return st
else:
return st + 1
for i in range(1, len(seq)):
if dp[-1] <= seq[i]:
dp.append(seq[i])
else:
index = find_smallest_value(seq[i])
dp[index] = seq[i]
print(n - len(dp))
```
No
| 7,976 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Tags: greedy, strings
Correct Solution:
```
s, k = map(int, input().split())
strin = list(input())
newStr = strin
d = 0
m = ord("m")
a = ord("a")
z = ord("z")
i = 0
while i < s and d < k:
diff = 0
c = ord(strin[i])
if c <= m:
diff = z - c
else:
diff = a - c
if (abs(diff) + d) <= k:
d += abs(diff)
newStr[i] = chr(c + diff)
else:
if c <= m:
c += k - d
else:
c -= k - d
d += abs(k - d)
newStr[i] = chr(c)
i += 1
if d == k:
print("".join(newStr))
else:
print("-1")
```
| 7,977 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Tags: greedy, strings
Correct Solution:
```
n, k = map(int, input().split())
b = list(input())
for i in range(n):
x = ord('z') - ord(b[i])
y = ord(b[i]) - ord('a')
if x > y:
if k < x:
x = k
b[i] = chr(ord(b[i]) + x)
k -= x
else:
if k < y:
y = k
b[i] = chr(ord(b[i]) - y)
k -= y
if k==0:
break
if k > 0:
print (-1)
else:
s = ''.join(b)
print (s)
```
| 7,978 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Tags: greedy, strings
Correct Solution:
```
n,k = map(int,input().split())
s = input()
s = list(s)
for i in range(n):
if ord(s[i])>=110:
m = min(ord(s[i])-97,k)
k-=m
s[i]=chr(ord(s[i])-m)
else:
m = min(122-ord(s[i]),k)
k-=m
s[i]=chr(ord(s[i])+m)
if k>0:
print(-1)
else:
print(''.join(s))
```
| 7,979 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Tags: greedy, strings
Correct Solution:
```
import collections
import math
n, k = map(int, input().split())
s = input()
ss = []
t = 0
for i in range(len(s)):
t += max(abs(ord('a') - ord(s[i])), abs(ord('z') - ord(s[i])))
if k > t:
print(-1)
exit(0)
else:
for i in range(len(s)):
if k == 0:
ss.append(s[i])
continue
x, y = abs(ord('a') - ord(s[i])), abs(ord('z') - ord(s[i]))
if x >= y:
if k >= x:
ss.append('a')
k -= x
else:
ss.append(chr(ord(s[i]) - k))
k = 0
else:
if k >= y:
ss.append('z')
k -= y
else:
ss.append(chr(ord(s[i]) + k))
k = 0
print(''.join(ss))
```
| 7,980 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Tags: greedy, strings
Correct Solution:
```
n, k = map(int, input().split())
st = input()
ans = ''
i = 0
while i < n and k > 0:
if abs(ord(st[i]) - 97) > abs(ord(st[i]) - 122):
ans += chr(max(97, ord(st[i]) - k))
k -= ord(st[i]) - ord(ans[-1])
else:
ans += chr(min(122, ord(st[i]) + k))
k -= ord(ans[-1]) - ord(st[i])
i += 1
if k == 0:
print(ans + st[i:])
else:
print(-1)
```
| 7,981 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Tags: greedy, strings
Correct Solution:
```
[n,k] = input().split(" ")
s = input()
ss = ''
n = int(n)
k = int(k)
MaxD = [[0,0]]*n
SumMaxD = 0
for i in list(range(0,n)):
xl = -97 + ord(s[i])
xh = 122 - ord(s[i])
if(xl > xh):
MaxD[i] = [xl,-1]
SumMaxD = SumMaxD + xl
else:
MaxD[i] = [xh,1]
SumMaxD = SumMaxD + xh
if(SumMaxD < k):
print(-1)
else:
for i in range(0,n):
if(MaxD[i][0]<k):
ss =ss + chr(ord(s[i]) + MaxD[i][0]*MaxD[i][1])
k = k - MaxD[i][0]
else:
ss =ss + chr(ord(s[i]) + k*MaxD[i][1]) + s[(i+1):len(s):1]
break
print(ss)
```
| 7,982 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Tags: greedy, strings
Correct Solution:
```
def check(s, k):
ans = 0
for i in range(len(s)):
ans += abs(ord(s[i]) - ord(k[i]))
return ans
n, k = map(int, input().split())
s = input()
cnt = 0
for i in s:
cnt += max(ord('z') - ord(i), ord(i) - ord('a'))
if k > cnt:
print(-1)
exit()
else:
ans = ''
cr = 0
while k != 0:
ps1 = ord(s[cr]) - ord('a')
ps2 = ord('z') - ord(s[cr])
if ps1 > k:
ans += chr(ord(s[cr]) - k)
k = 0
elif ps2 > k:
ans += chr(ord(s[cr]) + k)
k = 0
else:
if ps2 >= ps1:
ans += 'z'
k -= ps2
else:
ans += 'a'
k -= ps1
cr += 1
ans += s[len(ans):]
print(ans)
#print(check(ans, s))
```
| 7,983 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Tags: greedy, strings
Correct Solution:
```
a, b = map(int, input().split())
s = input()
if b / a > 25:
print(-1)
else:
ans = ""
c = 0
for i in s:
if b == 0:
ans += s[c:]
break
idx = ord(i) - 97
if idx >= 13:
if b > idx:
ans += "a"
b -= idx
else:
ans += chr(idx + 97 - b) # alepha[idx - b]
b = 0
else:
if b > 25-idx:
ans += "z"
b -= 25 - idx
else:
ans += chr(idx + 97 + b) # alepha[idx + b]
b = 0
c += 1
if b == 0:
print(ans.lower())
else:
print(-1)
```
| 7,984 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Submitted Solution:
```
N, K = map(int, input().split())
S = input()
dmax = [0 for _ in range(N)]
for i in range(N):
dmax[i] = max(abs(ord(S[i]) - 97), abs(25 - ord(S[i]) + 97))
dsum = sum(dmax)
if dsum < K:
print(-1)
else:
j = 0
for i in range(dsum + 1):
if dsum == K:
break
if dmax[j] == 0:
j += 1
dmax[j] -= 1
dsum -= 1
res = []
for i in range(N):
if ord(S[i]) - 97 + dmax[i] < 26:
res.append(chr(ord(S[i]) + dmax[i]))
else:
res.append(chr(ord(S[i]) - dmax[i]))
print(''.join(res))
```
Yes
| 7,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Submitted Solution:
```
a,b=map(int,input().split())
str1=input()
str2=""
for i in range(0,a):
x=ord(str1[i])
x=x-97
if(x<=12):
z=min((25-x),(b))
zz=x+z+97
str3=chr(zz)
str2=str2[0:]+str3[0:]
b=b-z
else:
z=min((x-0),(b))
zz=x-z+97
str3=chr(zz)
str2=str2[0:]+str3[0:]
b=b-z
if(b>0):
print(-1)
else:
print(str2)
```
Yes
| 7,986 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Submitted Solution:
```
if __name__ == '__main__':
# print(ord('a'), ord('m'), ord('n'), ord('z'))
# 97 109 110 122
n, k = input().split()
n = int(n)
k = int(k)
s = input()
ans = ''
hasAnswer = False
for i in range(n):
if k == 0:
hasAnswer = True
break
m = ord(s[i])
if m <= 109:
if k >= 122 - m:
k -= 122-m
ans += 'z'
else:
if m + k < 122:
ans += chr(m + k)
else:
ans += chr(m - k)
hasAnswer = True
break
if m >= 110:
if k >= m - 97:
k -= m - 97
ans += 'a'
else:
if m + k < 122:
ans += chr(m + k)
else:
ans += chr(m - k)
hasAnswer = True
break
if hasAnswer or k == 0:
print(ans + s[len(ans):])
else:
print(-1)
```
Yes
| 7,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Submitted Solution:
```
n,k = map(int,input().split())
s = input()
alth = "abcdefghijklmnopqrstuvwxyz"
num2 = 0
s2 = ""
for i in s:
num2 = alth.find(i)
if k == 0:
s2 += i
else:
if num2 > 12:
num3 = min(num2,k)
s2 += alth[num2-num3]
k -= num3
else:
num3 = min(25-num2,k)
s2 += alth[num2+num3]
k -= num3
if k > 0:
print(-1)
else:
print(s2)
```
Yes
| 7,988 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Submitted Solution:
```
letters = list('abcdefghijklmnopqrstuvwxyz')
def get_largest_distance(char):
if letters.index(char) > 13:
return 'a'
return 'z'
def get_fixed_distance(char, amount):
return letters[abs(letters.index(char) - amount)]
def dist(a, b):
return abs(letters.index(a) - letters.index(b))
line = input()
word_length, final_distance = line.split()
word_length, final_distance = int(word_length), int(final_distance)
word = input()
active_total = 0
built_string = ''
did_break = False
for charactor in word:
largest_distance_char = get_largest_distance(charactor)
current_dist = dist(charactor, largest_distance_char)
if active_total + current_dist > final_distance:
sub_distance = get_fixed_distance(charactor, final_distance - active_total)
active_total = active_total + dist(charactor, sub_distance)
built_string = built_string + sub_distance
did_break = True
break
else:
active_total = active_total + current_dist
built_string = built_string + largest_distance_char
if active_total < final_distance:
print(-1)
elif did_break == True:
for char in range(len(built_string), len(word)):
built_string = built_string + word[char]
print(built_string)
else:
print(built_string)
```
No
| 7,989 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Submitted Solution:
```
n,k = map(int, input().split())
s = input()
p = []
ans = 0
s1 = ''
p1 = []
for i in range(len(s)):
p.append(ord(s[i]) - 96)
ans+=max(p[i],26 - p[i])
if ans < k:
print(-1)
else:
for i in range(len(s)):
if p[i] > 13:
if k >= p[i]:
s1+='a'
p1.append(1)
k-=p[i]
else:
p[i]-=k
k = 0
s1+=chr(p[i] + 96)
p1.append(p[i])
else:
if k >= 26 - p[i]:
s1+='z'
p1.append(26)
k-=26 - p[i]
else:
s1+=chr(p[i] + k + 96)
p1.append(p[i] + k)
k = 0
print(s1)
```
No
| 7,990 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Submitted Solution:
```
import sys
n,k=map(int,sys.stdin.readline().split())
s=sys.stdin.readline()
ans=""
for i in s:
a=ord("z")-ord(i)
b=ord(i)-ord("a")
if k==0:
ans+=i
continue
if a>=b:
if a>=k:
ans+=chr(ord(i)+k)
k=0
else:
ans+="z"
k=k-a
else:
if b>=k:
ans+=chr(ord(i)-k)
k=0
else:
ans+="a"
k=k-b
if k==0:
print(ans)
else:
print(-1)
```
No
| 7,991 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1
Submitted Solution:
```
alepha = ["a", "b", "c", "d",
"e", "f", "g", "h", "i",
"j", "k", "l", "m", "n",
"o", "p", "q", "r", "s", "t",
"u", "v", "w", "x", "y", "z"]
a, b = map(int, input().split())
s = input()
ans = ""
if b / a > 25:
print(-1)
else:
for i in range(a):
if b == 0:
ans += s[i]
continue
idx = alepha.index(s[i])
if idx > 13:
if b > 13:
ans += alepha[0]
b -= idx
else:
ans += alepha[idx - b]
b = 0
else:
if b > 13:
ans += alepha[25]
b -= 25 - idx
else:
ans += alepha[idx + b]
b = 0
if b==0:
print(ans)
else:
print(-1)
```
No
| 7,992 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Tags: data structures, sortings
Correct Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
def least_significant_bit(i):
return ((i) & -(i))
class FenwickTree():
def __init__(self, n):
# 1-indexed
self.n = n + 1
self.data = [0,] * self.n
def add(self, index, value):
# 1-indexed
i = index + 1
while i < self.n:
self.data[i] += value
i += least_significant_bit(i)
def prefix_sum(self, index):
# 1-indexed
i = index + 1
result = 0
while i > 0:
result += self.data[i]
i -= least_significant_bit(i)
return result
def range_sum(self, start, end):
return self.prefix_sum(end) - self.prefix_sum(start-1)
def main():
import sys
data = iter(map(int, sys.stdin.buffer.read().decode('ascii').split()))
# ~ data = iter(map(int, sys.stdin.buffer.read().split()))
n = next(data)
left = [0,] * n
right = [0,] * n
for i in range(n):
a, b = next(data), next(data)
left[i] = a
right[i] = b
order = list(range(n))
order.sort(key=lambda x: left[x])
for i, k in enumerate(order):
left[k] = i
order = list(range(n))
order.sort(key=lambda x:right[x])
res = [0, ] * n
ft = FenwickTree(n)
for i, k in enumerate(order):
a = left[k]
res[k] = i - ft.prefix_sum(a-1)
ft.add(a, 1)
sys.stdout.buffer.write('\n'.join('%d' % x for x in res).encode('ascii'))
# ~ sys.stdout.buffer.write(b'\n'.join(b'%d' % x for x in res))
return 0
if __name__ == '__main__':
main()
```
| 7,993 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Tags: data structures, sortings
Correct Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
def least_significant_bit(i):
return ((i) & -(i))
class FenwickTree():
def __init__(self, n):
# 1-indexed
self.n = n + 1
self.data = [0,] * self.n
def add(self, index, value):
# 1-indexed
i = index + 1
while i < self.n:
self.data[i] += value
i += least_significant_bit(i)
def prefix_sum(self, index):
# 1-indexed
i = index + 1
result = 0
while i > 0:
result += self.data[i]
i -= least_significant_bit(i)
return result
def range_sum(self, start, end):
return self.prefix_sum(end) - self.prefix_sum(start-1)
def main():
import sys
data = iter(map(int, sys.stdin.buffer.read().decode('ascii').split()))
n = next(data)
left = [0,] * n
right = [0,] * n
for i in range(n):
a, b = next(data), next(data)
left[i] = a
right[i] = b
order = list(range(n))
order.sort(key=lambda x: left[x])
for i, k in enumerate(order):
left[k] = i
order = list(range(n))
order.sort(key=lambda x:right[x])
res = [0, ] * n
ft = FenwickTree(n)
for i, k in enumerate(order):
a = left[k]
res[k] = i - ft.prefix_sum(a-1)
ft.add(a, 1)
sys.stdout.buffer.write('\n'.join(str(x) for x in res).encode('ascii'))
return 0
if __name__ == '__main__':
main()
```
| 7,994 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Tags: data structures, sortings
Correct Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
def least_significant_bit(i):
return ((i) & -(i))
class FenwickTree():
def __init__(self, n):
# 1-indexed
self.n = n + 1
self.data = [0,] * self.n
def add(self, index, value):
# 1-indexed
i = index + 1
while i < self.n:
self.data[i] += value
i += least_significant_bit(i)
def prefix_sum(self, index):
# 1-indexed
i = index + 1
result = 0
while i > 0:
result += self.data[i]
i -= least_significant_bit(i)
return result
def range_sum(self, start, end):
return self.prefix_sum(end) - self.prefix_sum(start-1)
def main():
import sys
data = list(map(int, sys.stdin.buffer.read().decode('ascii').split()))
data.reverse()
n = data.pop()
left = [0,] * n
right = [0,] * n
for i in range(n):
a, b = data.pop(), data.pop()
left[i] = a
right[i] = b
order = list(range(n))
order.sort(key=lambda x: left[x])
for i, k in enumerate(order):
left[k] = i
order = list(range(n))
order.sort(key=lambda x:right[x])
res = [0, ] * n
ft = FenwickTree(n)
for i, k in enumerate(order):
a = left[k]
res[k] = i - ft.prefix_sum(a-1)
ft.add(a, 1)
sys.stdout.buffer.write('\n'.join(str(x) for x in res).encode('ascii'))
return 0
if __name__ == '__main__':
main()
```
| 7,995 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Tags: data structures, sortings
Correct Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
def least_significant_bit(i):
return ((i) & -(i))
class FenwickTree():
def __init__(self, n):
# 1-indexed
self.n = n + 1
self.data = [0,] * self.n
def add(self, index, value):
# 1-indexed
i = index + 1
while i < self.n:
self.data[i] += value
i += least_significant_bit(i)
def prefix_sum(self, index):
# 1-indexed
i = index + 1
result = 0
while i > 0:
result += self.data[i]
i -= least_significant_bit(i)
return result
def range_sum(self, start, end):
return self.prefix_sum(end) - self.prefix_sum(start-1)
def main():
import sys
data = iter(map(int, sys.stdin.buffer.read().decode('ascii').split()))
n = next(data)
left = [0,] * n
right = [0,] * n
for i in range(n):
a, b = next(data), next(data)
left[i] = a
right[i] = b
order = list(range(n))
order.sort(key=lambda x: left[x])
for i, k in enumerate(order):
left[k] = i
order = list(range(n))
order.sort(key=lambda x:right[x])
res = [0, ] * n
ft = FenwickTree(n)
for i, k in enumerate(order):
a = left[k]
res[k] = i - ft.prefix_sum(a-1)
ft.add(a, 1)
print('\n'.join(str(x) for x in res))
return 0
if __name__ == '__main__':
main()
```
| 7,996 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Tags: data structures, sortings
Correct Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
import collections
def least_significant_bit(i):
return ((i) & -(i))
class FenwickTree():
def __init__(self, n):
# 1-indexed
self.n = n + 1
self.data = [0,] * self.n
def add(self, index, value):
# 1-indexed
i = index + 1
while i < self.n:
self.data[i] += value
i += least_significant_bit(i)
def prefix_sum(self, index):
# 1-indexed
i = index + 1
result = 0
while i > 0:
result += self.data[i]
i -= least_significant_bit(i)
return result
def range_sum(self, start, end):
return self.prefix_sum(end) - self.prefix_sum(start-1)
def main():
import sys
data = collections.deque(map(int, sys.stdin.buffer.read().decode('ascii').split()))
n = data.popleft()
left = [0,] * n
right = [0,] * n
for i in range(n):
a, b = data.popleft(), data.popleft()
left[i] = a
right[i] = b
order = list(range(n))
order.sort(key=lambda x: left[x])
for i, k in enumerate(order):
left[k] = i
order = list(range(n))
order.sort(key=lambda x:right[x])
res = [0, ] * n
ft = FenwickTree(n)
for i, k in enumerate(order):
a = left[k]
res[k] = i - ft.prefix_sum(a-1)
ft.add(a, 1)
sys.stdout.buffer.write('\n'.join(str(x) for x in res).encode('ascii'))
return 0
if __name__ == '__main__':
main()
```
| 7,997 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Tags: data structures, sortings
Correct Solution:
```
from bisect import bisect_right
from collections import defaultdict
import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict
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")
def sum(BIT, i):
s = 0
while i > 0:
s += BIT[i]
i -= i & (-i)
return s
def update(BIT, i, v):
while i < len(BIT):
BIT[i] += v
i += i & (-i)
def find(fen, k):
curr = 0
ans = 0
prevsum = 0
for i in range(19, -1, -1):
if ((curr + (1 << i) < n) and fen[curr + (1 << i)] + prevsum < k):
ans = curr + (1 << i)
curr = ans
prevsum += fen[curr]
return ans + 1
def Rank(x,BIT) :
return sum(BIT,x)
def sum(BIT, i):
s = 0
while i > 0:
s += BIT[i]
i -= i & (-i)
return s
def update(BIT, i, v):
while i < len(BIT):
BIT[i] += v
i += i & (-i)
def find(fen, k):
curr = 0
ans = 0
prevsum = 0
for i in range(19, -1, -1):
if ((curr + (1 << i) < n) and fen[curr + (1 << i)] + prevsum < k):
ans = curr + (1 << i)
curr = ans
prevsum += fen[curr]
return ans + 1
def Rank(x,BIT) :
return sum(BIT,x)
n=int(input())
inc=[]
out=[]
for j in range(n):
p,q=map(int,input().split())
inc.append([p,j])
out.append([q,j])
inc.sort()
out.sort()
curr=0
j1=0
j2=0
ind=[]
while(j1<n or j2<n):
if j1<n and j2<n:
if inc[j1][0]<=out[j2][0]:
ind.append(inc[j1][1])
j1+=1
else:
ind.append(out[j2][1])
j2+=1
elif j1<n:
ind.append(inc[j1][1])
j1+=1
else:
ind.append(out[j2][1])
j2 += 1
d=dict()
j=0
res=[0]*(n)
BIT = [0] * (2*n + 1)
curr=0
while(j<2*n):
if ind[j] not in d.keys():
d[ind[j]]=j+1
else:
res[ind[j]]=curr-Rank(d[ind[j]],BIT)
update(BIT,d[ind[j]],1)
curr+=1
j+=1
for j in res:
print(j)
```
| 7,998 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Tags: data structures, sortings
Correct Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
def least_significant_bit(i):
return ((i) & -(i))
class FenwickTree():
def __init__(self, n):
# 1-indexed
self.n = n + 1
self.data = [0,] * self.n
def add(self, index, value):
# 1-indexed
i = index + 1
while i < self.n:
self.data[i] += value
i += least_significant_bit(i)
def prefix_sum(self, index):
# 1-indexed
i = index + 1
result = 0
while i > 0:
result += self.data[i]
i -= least_significant_bit(i)
return result
def range_sum(self, start, end):
return self.prefix_sum(end) - self.prefix_sum(start-1)
def main():
import sys
data = iter(map(int, sys.stdin.buffer.read().split()))
n = next(data)
left = [0,] * n
right = [0,] * n
for i in range(n):
a, b = next(data), next(data)
left[i] = a
right[i] = b
order = list(range(n))
order.sort(key=lambda x: left[x])
for i, k in enumerate(order):
left[k] = i
order = list(range(n))
order.sort(key=lambda x:right[x])
res = [0, ] * n
ft = FenwickTree(n)
for i, k in enumerate(order):
a = left[k]
res[k] = i - ft.prefix_sum(a-1)
ft.add(a, 1)
sys.stdout.buffer.write('\n'.join(str(x) for x in res).encode('ascii'))
return 0
if __name__ == '__main__':
main()
```
| 7,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.