message stringlengths 2 23.8k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 97 109k | cluster float64 0 0 | __index_level_0__ int64 194 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S consisting of `A`,`B`, and `C`.
Consider the (not necessarily contiguous) subsequences x of S that satisfy all of the following conditions:
* `A`, `B`, and `C` all occur the same number of times in x.
* No two adjacent characters in x are the same.
Among these subsequences, find one of the longest. Here a subsequence of S is a string obtained by deleting zero or more characters from S.
Constraints
* 1 \leq |S| \leq 10^6
* S consists of `A`,`B`, and `C`.
Input
Input is given from Standard Input in the following format:
S
Output
Print one longest subsequence that satisfies the conditions. If multiple solutions exist, any of them will be accepted.
Examples
Input
ABBCBCAB
Output
ACBCAB
Input
ABABABABACACACAC
Output
BABCAC
Input
ABCABACBCBABABACBCBCBCBCBCAB
Output
ACABACABABACBCBCBCBCA
Input
AAA
Output
Submitted Solution:
```
import collections
s = [s for s in input()]
t = s[0]
i = 1
while len(s) > i:
tmp = s
if t == s[i]:
tmp = s[:i]+s[i+1:]
t = s[i]
s = tmp
i+=1
c = collections.Counter(s)
m = min(c.values())
mA = m
mB = m
mC = m
for i in range(len(s)):
if s[i] == "A":
if mA > 0:
print(s[i],end="")
mA-=1
elif s[i] == "B":
if mB > 0:
print(s[i],end="")
mB-=1
elif s[i] == "C":
if mC > 0:
print(s[i],end="")
mC-=1
``` | instruction | 0 | 72,318 | 0 | 144,636 |
No | output | 1 | 72,318 | 0 | 144,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S consisting of `A`,`B`, and `C`.
Consider the (not necessarily contiguous) subsequences x of S that satisfy all of the following conditions:
* `A`, `B`, and `C` all occur the same number of times in x.
* No two adjacent characters in x are the same.
Among these subsequences, find one of the longest. Here a subsequence of S is a string obtained by deleting zero or more characters from S.
Constraints
* 1 \leq |S| \leq 10^6
* S consists of `A`,`B`, and `C`.
Input
Input is given from Standard Input in the following format:
S
Output
Print one longest subsequence that satisfies the conditions. If multiple solutions exist, any of them will be accepted.
Examples
Input
ABBCBCAB
Output
ACBCAB
Input
ABABABABACACACAC
Output
BABCAC
Input
ABCABACBCBABABACBCBCBCBCBCAB
Output
ACABACABABACBCBCBCBCA
Input
AAA
Output
Submitted Solution:
```
import collections
s = [s for s in input()]
t = s[0]
i = 1
while len(s) > i:
tmp = s
if t == s[i]:
tmp = s[:i]+s[i+1:]
t = s[i]
s = tmp
i+=1
c = collections.Counter(s)
m = min(c.values())
mA = m
mB = m
mC = m
for i in range(len(s)):
if s[i] == "A":
if mA > 0:
print(s[i],end="")
mA-=1
elif s[i] == "B":
if mB > 0:
print(s[i],end="")
mB-=1
elif s[i] == "C":
if mC > 0:
print(s[i],end="")
mC-=1
print("")
``` | instruction | 0 | 72,319 | 0 | 144,638 |
No | output | 1 | 72,319 | 0 | 144,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal. | instruction | 0 | 72,555 | 0 | 145,110 |
Tags: strings
Correct Solution:
```
n=int(input())
def good(ar):
return ar.count("1")!=ar.count("0")
s=input()
if(good(s)):
print(1)
print(s)
else:
print(2)
print(s[0],s[1:])
``` | output | 1 | 72,555 | 0 | 145,111 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal. | instruction | 0 | 72,556 | 0 | 145,112 |
Tags: strings
Correct Solution:
```
n = int(input())
str = input()
count=0
counter=0
for i in range(0,n):
if(str[i] == "0"):
count = count+1
else:
counter = counter+1
if(count == counter):
print(2)
print(str[0] + " " + str[1:])
else:
print(1)
print(str)
``` | output | 1 | 72,556 | 0 | 145,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal. | instruction | 0 | 72,557 | 0 | 145,114 |
Tags: strings
Correct Solution:
```
n = int(input())
s = input()
z = 0
o= 0
for c in s:
if c == '0':
z += 1
else:
o += 1
if z-o != 0:
print(1)
print(s)
else:
print(2)
print(s[0],s[1:])
``` | output | 1 | 72,557 | 0 | 145,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal. | instruction | 0 | 72,558 | 0 | 145,116 |
Tags: strings
Correct Solution:
```
n = input()
l = str(input())
ones, zero = len([c for c in l if c == '1']), len([c for c in l if c == '0'])
if ones == zero:
print(2)
print(l[:-1] + ' ' + l[-1:])
else:
print(1)
print(l)
``` | output | 1 | 72,558 | 0 | 145,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal. | instruction | 0 | 72,559 | 0 | 145,118 |
Tags: strings
Correct Solution:
```
n=int(input())
s=input()
x=s.count('1')
y=s.count('0')
if(x!=y):
print("1")
print(s)
else:
print("2")
print(s[0:n-1],s[n-1:n])
``` | output | 1 | 72,559 | 0 | 145,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal. | instruction | 0 | 72,560 | 0 | 145,120 |
Tags: strings
Correct Solution:
```
from collections import *
l=int(input())
g=input()
doc=Counter(g)
if doc['0']!=doc['1'] or l==1:
print(1)
print(g)
exit()
lk=[0,0]
index=0
for i in range(l):
if lk[0]!=lk[1]:
index=i
break
lk[int(g[i])]+=1
print(2)
print(g[:index],g[index:])
``` | output | 1 | 72,560 | 0 | 145,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal. | instruction | 0 | 72,561 | 0 | 145,122 |
Tags: strings
Correct Solution:
```
n = int(input())
s= str(input())
co=0
cz=0
for i in range(n):
if s[i]=="1":
co+=1
else:
cz+=1
if cz!=co:
print(1)
print(s)
else:
print(2)
print(s[:n-1]+" "+s[n-1])
``` | output | 1 | 72,561 | 0 | 145,123 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal. | instruction | 0 | 72,562 | 0 | 145,124 |
Tags: strings
Correct Solution:
```
n = int(input())
s = input()
if s.count("1") != s.count("0"):
print(1)
print(s)
else:
i = 0
f0, f1 = 0, 0
x = n // 2
while f1 == f0:
m = s[: x + i]
f1 = m.count("1")
f0 = m.count("0")
i += 1
print(2)
print(m, s[n // 2 + i - 1: ])
``` | output | 1 | 72,562 | 0 | 145,125 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
Submitted Solution:
```
def user99():
n = int(input())
s = input()
if s.count('0') == s.count('1'):
print(2)
print(s[0], s[1:])
else:
print(1)
print(s)
user99()
``` | instruction | 0 | 72,563 | 0 | 145,126 |
Yes | output | 1 | 72,563 | 0 | 145,127 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
Submitted Solution:
```
n = int(input())
s = input()
if list(s).count('0') != list(s).count('1'):
print(1)
print(s)
else:
print(2)
print(s[0], s[1:])
``` | instruction | 0 | 72,564 | 0 | 145,128 |
Yes | output | 1 | 72,564 | 0 | 145,129 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
Submitted Solution:
```
n = int(input())
string = input()
if string.count('0') != string.count('1'):
print(1)
print(string)
else:
print(2)
print(string[:-1], string[-1])
``` | instruction | 0 | 72,565 | 0 | 145,130 |
Yes | output | 1 | 72,565 | 0 | 145,131 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
Submitted Solution:
```
n = int(input())
s = input()
if n == 1:
print(1)
print(s)
exit()
one = 0
zero = 0
for i in range(n):
if s[i] == '0':
zero += 1
else:
one += 1
if one == zero:
print(2)
print(s[0], s[1:])
else:
print(1)
print(s)
``` | instruction | 0 | 72,566 | 0 | 145,132 |
Yes | output | 1 | 72,566 | 0 | 145,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
Submitted Solution:
```
##Problem B
String_length = input()
String = input()
if len(String_length) == 1:
print(String_length)
print(String)
elif String.count('0') != String.count('1'):
for i in range(int(String_length)):
if String[0:int((len(String))/(int(i)+2))].count('0') != String[int((len(String))/(int(i)+2)):].count('1'):
print(String[0:int(len(String)/i)], String[int(len(String)/i):-1])
``` | instruction | 0 | 72,567 | 0 | 145,134 |
No | output | 1 | 72,567 | 0 | 145,135 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
Submitted Solution:
```
N=input()
N=int(N)
S=input()
S=str(S)
n=N
s=0
o=1
z=1
k =1
while o==z and o!=0:
o = 0
z = 0
for i in range(int(s),int(n)):
if S[i] == "1":
o+=1
else:
z+=1
if o==z and n==N and o!=0:
k*=2
s = 0
n=N/k
else:
n+=N/k
s+=N/k
print(k)
j=0
for i in range(0,N):
j+=1
print(S[i], end = '')
if j == N/k:
j=0
print(end = ' ')
print()
``` | instruction | 0 | 72,568 | 0 | 145,136 |
No | output | 1 | 72,568 | 0 | 145,137 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
Submitted Solution:
```
from collections import Counter
n = int(input())
st = input()
count = Counter(st)
l = len(st)
if '0' and '1' in st:
if count['0'] != count['1']:
print(st)
else:
print(st[:l-1],st[l-1:])
else:
print(st)
``` | instruction | 0 | 72,569 | 0 | 145,138 |
No | output | 1 | 72,569 | 0 | 145,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After playing Neo in the legendary "Matrix" trilogy, Keanu Reeves started doubting himself: maybe we really live in virtual reality? To find if this is true, he needs to solve the following problem.
Let's call a string consisting of only zeroes and ones good if it contains different numbers of zeroes and ones. For example, 1, 101, 0000 are good, while 01, 1001, and 111000 are not good.
We are given a string s of length n consisting of only zeroes and ones. We need to cut s into minimal possible number of substrings s_1, s_2, …, s_k such that all of them are good. More formally, we have to find minimal by number of strings sequence of good strings s_1, s_2, …, s_k such that their concatenation (joining) equals s, i.e. s_1 + s_2 + ... + s_k = s.
For example, cuttings 110010 into 110 and 010 or into 11 and 0010 are valid, as 110, 010, 11, 0010 are all good, and we can't cut 110010 to the smaller number of substrings as 110010 isn't good itself. At the same time, cutting of 110010 into 1100 and 10 isn't valid as both strings aren't good. Also, cutting of 110010 into 1, 1, 0010 isn't valid, as it isn't minimal, even though all 3 strings are good.
Can you help Keanu? We can show that the solution always exists. If there are multiple optimal answers, print any.
Input
The first line of the input contains a single integer n (1≤ n ≤ 100) — the length of the string s.
The second line contains the string s of length n consisting only from zeros and ones.
Output
In the first line, output a single integer k (1≤ k) — a minimal number of strings you have cut s into.
In the second line, output k strings s_1, s_2, …, s_k separated with spaces. The length of each string has to be positive. Their concatenation has to be equal to s and all of them have to be good.
If there are multiple answers, print any.
Examples
Input
1
1
Output
1
1
Input
2
10
Output
2
1 0
Input
6
100011
Output
2
100 011
Note
In the first example, the string 1 wasn't cut at all. As it is good, the condition is satisfied.
In the second example, 1 and 0 both are good. As 10 isn't good, the answer is indeed minimal.
In the third example, 100 and 011 both are good. As 100011 isn't good, the answer is indeed minimal.
Submitted Solution:
```
def foo(p):
a=p.count('0')
b=p.count('1')
#print(p,a,b)
if(a==0 or b==0):
return 1
elif(a!=b):
return 1
else:
return 0
n=int(input())
s=input()
if(n==1):
print(s)
else:
a=s.count('0')
b=s.count('1')
if(a!=b):
print(1)
print(s)
else:
for i in range(n-1,-1,-1):
x=s[:i]
y=s[i:]
#print(i,x,y)
if(foo(x)==1 and foo(y)==1):
print("2")
print(x,y)
quit(0)
``` | instruction | 0 | 72,570 | 0 | 145,140 |
No | output | 1 | 72,570 | 0 | 145,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to perform the combo on your opponent in one popular fighting game. The combo is the string s consisting of n lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in s. I.e. if s="abca" then you have to press 'a', then 'b', 'c' and 'a' again.
You know that you will spend m wrong tries to perform the combo and during the i-th try you will make a mistake right after p_i-th button (1 ≤ p_i < n) (i.e. you will press first p_i buttons right and start performing the combo from the beginning). It is guaranteed that during the m+1-th try you press all buttons right and finally perform the combo.
I.e. if s="abca", m=2 and p = [1, 3] then the sequence of pressed buttons will be 'a' (here you're making a mistake and start performing the combo from the beginning), 'a', 'b', 'c', (here you're making a mistake and start performing the combo from the beginning), 'a' (note that at this point you will not perform the combo because of the mistake), 'b', 'c', 'a'.
Your task is to calculate for each button (letter) the number of times you'll press it.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t test cases follow.
The first line of each test case contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of s and the number of tries correspondingly.
The second line of each test case contains the string s consisting of n lowercase Latin letters.
The third line of each test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n) — the number of characters pressed right during the i-th try.
It is guaranteed that the sum of n and the sum of m both does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ m ≤ 2 ⋅ 10^5).
It is guaranteed that the answer for each letter does not exceed 2 ⋅ 10^9.
Output
For each test case, print the answer — 26 integers: the number of times you press the button 'a', the number of times you press the button 'b', ..., the number of times you press the button 'z'.
Example
Input
3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4
Output
4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2
Note
The first test case is described in the problem statement. Wrong tries are "a", "abc" and the final try is "abca". The number of times you press 'a' is 4, 'b' is 2 and 'c' is 2.
In the second test case, there are five wrong tries: "co", "codeforc", "cod", "co", "codeforce" and the final try is "codeforces". The number of times you press 'c' is 9, 'd' is 4, 'e' is 5, 'f' is 3, 'o' is 9, 'r' is 3 and 's' is 1. | instruction | 0 | 72,640 | 0 | 145,280 |
Tags: brute force
Correct Solution:
```
t=int(input())
for _ in range(t):
n,m=map(int,input().split())
s=input()
p=list(map(int,input().split()))
t=[[0 for i in range(26)] for j in range(n)]
for i in range(n):
if i>0:
for j in range(26):
t[i][j]=t[i-1][j]
t[i][ord(s[i])-ord('a')] += 1
# print(t)
ans=[0 for i in range(26)]
for i in range(m):
for j in range(26):
ans[j]=ans[j]+t[p[i]-1][j]
for i in range(26):
ans[i]=ans[i]+t[n-1][i]
print(" ".join(map(str,ans)))
``` | output | 1 | 72,640 | 0 | 145,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to perform the combo on your opponent in one popular fighting game. The combo is the string s consisting of n lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in s. I.e. if s="abca" then you have to press 'a', then 'b', 'c' and 'a' again.
You know that you will spend m wrong tries to perform the combo and during the i-th try you will make a mistake right after p_i-th button (1 ≤ p_i < n) (i.e. you will press first p_i buttons right and start performing the combo from the beginning). It is guaranteed that during the m+1-th try you press all buttons right and finally perform the combo.
I.e. if s="abca", m=2 and p = [1, 3] then the sequence of pressed buttons will be 'a' (here you're making a mistake and start performing the combo from the beginning), 'a', 'b', 'c', (here you're making a mistake and start performing the combo from the beginning), 'a' (note that at this point you will not perform the combo because of the mistake), 'b', 'c', 'a'.
Your task is to calculate for each button (letter) the number of times you'll press it.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t test cases follow.
The first line of each test case contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of s and the number of tries correspondingly.
The second line of each test case contains the string s consisting of n lowercase Latin letters.
The third line of each test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n) — the number of characters pressed right during the i-th try.
It is guaranteed that the sum of n and the sum of m both does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ m ≤ 2 ⋅ 10^5).
It is guaranteed that the answer for each letter does not exceed 2 ⋅ 10^9.
Output
For each test case, print the answer — 26 integers: the number of times you press the button 'a', the number of times you press the button 'b', ..., the number of times you press the button 'z'.
Example
Input
3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4
Output
4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2
Note
The first test case is described in the problem statement. Wrong tries are "a", "abc" and the final try is "abca". The number of times you press 'a' is 4, 'b' is 2 and 'c' is 2.
In the second test case, there are five wrong tries: "co", "codeforc", "cod", "co", "codeforce" and the final try is "codeforces". The number of times you press 'c' is 9, 'd' is 4, 'e' is 5, 'f' is 3, 'o' is 9, 'r' is 3 and 's' is 1. | instruction | 0 | 72,641 | 0 | 145,282 |
Tags: brute force
Correct Solution:
```
t=int(input())
for i in range(t):
n,m=list(map(int,input().split()))
s=input()
p=list(map(int,input().split()))
zeroarray=[0]*26
aftereach=[[0]*26]*n
psorted=sorted(list(set(p)))
x=0
final=[0]*26
arr=zeroarray[:]
for j in range(n):
arr[ord(s[j])-97]+=1
pos=psorted[x]
if(pos==j+1):
aftereach[pos]=arr[:]
if(x+1<len(psorted)):
x+=1
else:
break
for j in range(n):
final[ord(s[j])-97]+=1
ans=[0]*26
for j in p:
for y in range(26):
ans[y]=ans[y]+aftereach[j][y]
for y in range(26):
ans[y]=ans[y]+final[y]
print(*ans)
``` | output | 1 | 72,641 | 0 | 145,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to perform the combo on your opponent in one popular fighting game. The combo is the string s consisting of n lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in s. I.e. if s="abca" then you have to press 'a', then 'b', 'c' and 'a' again.
You know that you will spend m wrong tries to perform the combo and during the i-th try you will make a mistake right after p_i-th button (1 ≤ p_i < n) (i.e. you will press first p_i buttons right and start performing the combo from the beginning). It is guaranteed that during the m+1-th try you press all buttons right and finally perform the combo.
I.e. if s="abca", m=2 and p = [1, 3] then the sequence of pressed buttons will be 'a' (here you're making a mistake and start performing the combo from the beginning), 'a', 'b', 'c', (here you're making a mistake and start performing the combo from the beginning), 'a' (note that at this point you will not perform the combo because of the mistake), 'b', 'c', 'a'.
Your task is to calculate for each button (letter) the number of times you'll press it.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t test cases follow.
The first line of each test case contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of s and the number of tries correspondingly.
The second line of each test case contains the string s consisting of n lowercase Latin letters.
The third line of each test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n) — the number of characters pressed right during the i-th try.
It is guaranteed that the sum of n and the sum of m both does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ m ≤ 2 ⋅ 10^5).
It is guaranteed that the answer for each letter does not exceed 2 ⋅ 10^9.
Output
For each test case, print the answer — 26 integers: the number of times you press the button 'a', the number of times you press the button 'b', ..., the number of times you press the button 'z'.
Example
Input
3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4
Output
4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2
Note
The first test case is described in the problem statement. Wrong tries are "a", "abc" and the final try is "abca". The number of times you press 'a' is 4, 'b' is 2 and 'c' is 2.
In the second test case, there are five wrong tries: "co", "codeforc", "cod", "co", "codeforce" and the final try is "codeforces". The number of times you press 'c' is 9, 'd' is 4, 'e' is 5, 'f' is 3, 'o' is 9, 'r' is 3 and 's' is 1. | instruction | 0 | 72,642 | 0 | 145,284 |
Tags: brute force
Correct Solution:
```
for i in range(int(input())):
n,m= map(int,input().split())
f= input()
p= list(map(int, input().split()))
tt=[0]*(n+2)
for j in p:
tt[0]+=1
tt[j]-=1
tt[0]+=1
tt[n]-=1
for j in range(1,len(tt)):
tt[j]+=tt[j-1]
r={}
u='abcdefghijklmnopqrstuvwxyz'
for j in u:
if j not in r:
r[j]=0
for j in range(n):
r[f[j]]+=tt[j]
print(*r.values())
``` | output | 1 | 72,642 | 0 | 145,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to perform the combo on your opponent in one popular fighting game. The combo is the string s consisting of n lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in s. I.e. if s="abca" then you have to press 'a', then 'b', 'c' and 'a' again.
You know that you will spend m wrong tries to perform the combo and during the i-th try you will make a mistake right after p_i-th button (1 ≤ p_i < n) (i.e. you will press first p_i buttons right and start performing the combo from the beginning). It is guaranteed that during the m+1-th try you press all buttons right and finally perform the combo.
I.e. if s="abca", m=2 and p = [1, 3] then the sequence of pressed buttons will be 'a' (here you're making a mistake and start performing the combo from the beginning), 'a', 'b', 'c', (here you're making a mistake and start performing the combo from the beginning), 'a' (note that at this point you will not perform the combo because of the mistake), 'b', 'c', 'a'.
Your task is to calculate for each button (letter) the number of times you'll press it.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t test cases follow.
The first line of each test case contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of s and the number of tries correspondingly.
The second line of each test case contains the string s consisting of n lowercase Latin letters.
The third line of each test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n) — the number of characters pressed right during the i-th try.
It is guaranteed that the sum of n and the sum of m both does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ m ≤ 2 ⋅ 10^5).
It is guaranteed that the answer for each letter does not exceed 2 ⋅ 10^9.
Output
For each test case, print the answer — 26 integers: the number of times you press the button 'a', the number of times you press the button 'b', ..., the number of times you press the button 'z'.
Example
Input
3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4
Output
4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2
Note
The first test case is described in the problem statement. Wrong tries are "a", "abc" and the final try is "abca". The number of times you press 'a' is 4, 'b' is 2 and 'c' is 2.
In the second test case, there are five wrong tries: "co", "codeforc", "cod", "co", "codeforce" and the final try is "codeforces". The number of times you press 'c' is 9, 'd' is 4, 'e' is 5, 'f' is 3, 'o' is 9, 'r' is 3 and 's' is 1. | instruction | 0 | 72,643 | 0 | 145,286 |
Tags: brute force
Correct Solution:
```
import string
for _ in range(int(input())):
n, m = map(int, input().split())
s = input()
p = list(map(int, input().split()))
freq = {letter: 0 for letter in string.ascii_lowercase}
d = [0] * (n + 1)
for i in range(m):
d[p[i]] -= 1
# print(d)
c = m - 1
for i in range(n):
m += d[i]
freq[s[i]] += m
for letter in s:
freq[letter] += 1
for val in freq.values():
print(val, end=" ")
print()
``` | output | 1 | 72,643 | 0 | 145,287 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to perform the combo on your opponent in one popular fighting game. The combo is the string s consisting of n lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in s. I.e. if s="abca" then you have to press 'a', then 'b', 'c' and 'a' again.
You know that you will spend m wrong tries to perform the combo and during the i-th try you will make a mistake right after p_i-th button (1 ≤ p_i < n) (i.e. you will press first p_i buttons right and start performing the combo from the beginning). It is guaranteed that during the m+1-th try you press all buttons right and finally perform the combo.
I.e. if s="abca", m=2 and p = [1, 3] then the sequence of pressed buttons will be 'a' (here you're making a mistake and start performing the combo from the beginning), 'a', 'b', 'c', (here you're making a mistake and start performing the combo from the beginning), 'a' (note that at this point you will not perform the combo because of the mistake), 'b', 'c', 'a'.
Your task is to calculate for each button (letter) the number of times you'll press it.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t test cases follow.
The first line of each test case contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of s and the number of tries correspondingly.
The second line of each test case contains the string s consisting of n lowercase Latin letters.
The third line of each test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n) — the number of characters pressed right during the i-th try.
It is guaranteed that the sum of n and the sum of m both does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ m ≤ 2 ⋅ 10^5).
It is guaranteed that the answer for each letter does not exceed 2 ⋅ 10^9.
Output
For each test case, print the answer — 26 integers: the number of times you press the button 'a', the number of times you press the button 'b', ..., the number of times you press the button 'z'.
Example
Input
3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4
Output
4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2
Note
The first test case is described in the problem statement. Wrong tries are "a", "abc" and the final try is "abca". The number of times you press 'a' is 4, 'b' is 2 and 'c' is 2.
In the second test case, there are five wrong tries: "co", "codeforc", "cod", "co", "codeforce" and the final try is "codeforces". The number of times you press 'c' is 9, 'd' is 4, 'e' is 5, 'f' is 3, 'o' is 9, 'r' is 3 and 's' is 1. | instruction | 0 | 72,644 | 0 | 145,288 |
Tags: brute force
Correct Solution:
```
t = int(input())
while t>0:
t = t-1
n,m = map(int,input().split())
s = [i for i in input()]
p = list(map(int,input().split()))
b = [0 for i in range(n)]
for i in p:
b[i-1] += 1
temp = [0 for i in range(n)]
val = m+1
i = 0
while i<n:
if b[i] == 0:
temp[i] = (val)
elif b[i] > 0:
temp[i] = val
val -= b[i]
i += 1
# print(temp)
a = ['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 in range(len(a)):
letter = a[i]
c = 0
count = 0
for j in range(n):
if s[j] == letter:
count += temp[j]
print(count,end=" ")
print()
``` | output | 1 | 72,644 | 0 | 145,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to perform the combo on your opponent in one popular fighting game. The combo is the string s consisting of n lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in s. I.e. if s="abca" then you have to press 'a', then 'b', 'c' and 'a' again.
You know that you will spend m wrong tries to perform the combo and during the i-th try you will make a mistake right after p_i-th button (1 ≤ p_i < n) (i.e. you will press first p_i buttons right and start performing the combo from the beginning). It is guaranteed that during the m+1-th try you press all buttons right and finally perform the combo.
I.e. if s="abca", m=2 and p = [1, 3] then the sequence of pressed buttons will be 'a' (here you're making a mistake and start performing the combo from the beginning), 'a', 'b', 'c', (here you're making a mistake and start performing the combo from the beginning), 'a' (note that at this point you will not perform the combo because of the mistake), 'b', 'c', 'a'.
Your task is to calculate for each button (letter) the number of times you'll press it.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t test cases follow.
The first line of each test case contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of s and the number of tries correspondingly.
The second line of each test case contains the string s consisting of n lowercase Latin letters.
The third line of each test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n) — the number of characters pressed right during the i-th try.
It is guaranteed that the sum of n and the sum of m both does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ m ≤ 2 ⋅ 10^5).
It is guaranteed that the answer for each letter does not exceed 2 ⋅ 10^9.
Output
For each test case, print the answer — 26 integers: the number of times you press the button 'a', the number of times you press the button 'b', ..., the number of times you press the button 'z'.
Example
Input
3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4
Output
4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2
Note
The first test case is described in the problem statement. Wrong tries are "a", "abc" and the final try is "abca". The number of times you press 'a' is 4, 'b' is 2 and 'c' is 2.
In the second test case, there are five wrong tries: "co", "codeforc", "cod", "co", "codeforce" and the final try is "codeforces". The number of times you press 'c' is 9, 'd' is 4, 'e' is 5, 'f' is 3, 'o' is 9, 'r' is 3 and 's' is 1. | instruction | 0 | 72,645 | 0 | 145,290 |
Tags: brute force
Correct Solution:
```
for _ in ' '*int(input()):
n, m = map(int,input().split())
s = input()
a = list(map(int,input().split()))+[n]
s = [ord(i)-97 for i in s]
r = []
l = [0]*26
for i in range(n):
l[s[i]] += 1
r.append(list(l))
y = [0]*26
for i in a:
for j in range(26):
y[j]+=r[i-1][j]
print(*y)
``` | output | 1 | 72,645 | 0 | 145,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to perform the combo on your opponent in one popular fighting game. The combo is the string s consisting of n lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in s. I.e. if s="abca" then you have to press 'a', then 'b', 'c' and 'a' again.
You know that you will spend m wrong tries to perform the combo and during the i-th try you will make a mistake right after p_i-th button (1 ≤ p_i < n) (i.e. you will press first p_i buttons right and start performing the combo from the beginning). It is guaranteed that during the m+1-th try you press all buttons right and finally perform the combo.
I.e. if s="abca", m=2 and p = [1, 3] then the sequence of pressed buttons will be 'a' (here you're making a mistake and start performing the combo from the beginning), 'a', 'b', 'c', (here you're making a mistake and start performing the combo from the beginning), 'a' (note that at this point you will not perform the combo because of the mistake), 'b', 'c', 'a'.
Your task is to calculate for each button (letter) the number of times you'll press it.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t test cases follow.
The first line of each test case contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of s and the number of tries correspondingly.
The second line of each test case contains the string s consisting of n lowercase Latin letters.
The third line of each test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n) — the number of characters pressed right during the i-th try.
It is guaranteed that the sum of n and the sum of m both does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ m ≤ 2 ⋅ 10^5).
It is guaranteed that the answer for each letter does not exceed 2 ⋅ 10^9.
Output
For each test case, print the answer — 26 integers: the number of times you press the button 'a', the number of times you press the button 'b', ..., the number of times you press the button 'z'.
Example
Input
3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4
Output
4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2
Note
The first test case is described in the problem statement. Wrong tries are "a", "abc" and the final try is "abca". The number of times you press 'a' is 4, 'b' is 2 and 'c' is 2.
In the second test case, there are five wrong tries: "co", "codeforc", "cod", "co", "codeforce" and the final try is "codeforces". The number of times you press 'c' is 9, 'd' is 4, 'e' is 5, 'f' is 3, 'o' is 9, 'r' is 3 and 's' is 1. | instruction | 0 | 72,646 | 0 | 145,292 |
Tags: brute force
Correct Solution:
```
#kk
def combo(string,arr):
arr=sorted(arr)
j=0
lst=[0 for i in range(26)]
for i in range(len(string)):
while j<len(arr) and arr[j]<i+1:
j+=1
lst[ord(string[i])-97]+=len(arr)+1-j
print(*lst)
return ""
t=int(input())
for i in range(t):
a=input()
string=input()
lst=list(map(int,input().strip().split()))
print(combo(string,lst))
``` | output | 1 | 72,646 | 0 | 145,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to perform the combo on your opponent in one popular fighting game. The combo is the string s consisting of n lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in s. I.e. if s="abca" then you have to press 'a', then 'b', 'c' and 'a' again.
You know that you will spend m wrong tries to perform the combo and during the i-th try you will make a mistake right after p_i-th button (1 ≤ p_i < n) (i.e. you will press first p_i buttons right and start performing the combo from the beginning). It is guaranteed that during the m+1-th try you press all buttons right and finally perform the combo.
I.e. if s="abca", m=2 and p = [1, 3] then the sequence of pressed buttons will be 'a' (here you're making a mistake and start performing the combo from the beginning), 'a', 'b', 'c', (here you're making a mistake and start performing the combo from the beginning), 'a' (note that at this point you will not perform the combo because of the mistake), 'b', 'c', 'a'.
Your task is to calculate for each button (letter) the number of times you'll press it.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t test cases follow.
The first line of each test case contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of s and the number of tries correspondingly.
The second line of each test case contains the string s consisting of n lowercase Latin letters.
The third line of each test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n) — the number of characters pressed right during the i-th try.
It is guaranteed that the sum of n and the sum of m both does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ m ≤ 2 ⋅ 10^5).
It is guaranteed that the answer for each letter does not exceed 2 ⋅ 10^9.
Output
For each test case, print the answer — 26 integers: the number of times you press the button 'a', the number of times you press the button 'b', ..., the number of times you press the button 'z'.
Example
Input
3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4
Output
4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2
Note
The first test case is described in the problem statement. Wrong tries are "a", "abc" and the final try is "abca". The number of times you press 'a' is 4, 'b' is 2 and 'c' is 2.
In the second test case, there are five wrong tries: "co", "codeforc", "cod", "co", "codeforce" and the final try is "codeforces". The number of times you press 'c' is 9, 'd' is 4, 'e' is 5, 'f' is 3, 'o' is 9, 'r' is 3 and 's' is 1. | instruction | 0 | 72,647 | 0 | 145,294 |
Tags: brute force
Correct Solution:
```
t=int(input())
for w in range(t):
n,m=(int(i) for i in input().split())
s=input()
p=[int(i) for i in input().split()]
l=[0]*26
d={}
for i in range(n):
l[ord(s[i])-ord('a')]+=1
d[i+1]=l[:]
l=[0]*26
for i in range(m):
for j in range(26):
l[j]+=d[p[i]][j]
for i in range(26):
l[i]+=d[n][i]
print(*l)
``` | output | 1 | 72,647 | 0 | 145,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there. | instruction | 0 | 72,741 | 0 | 145,482 |
Tags: dp, greedy, strings
Correct Solution:
```
# codeforces "C"
def solve(s):
ans = 0
changed = [True for i in range(len(s))]
for i in range(1,len(s)):
if(s[i-1] == s[i] and changed[i-1]):
changed[i] = False
ans += 1
elif(i>1 and s[i-2] == s[i] and changed[i-2]):
changed[i] = False
ans += 1
return ans
if __name__=="__main__":
t = int(input())
for _ in range(t):
s = input()
print(solve(s))
``` | output | 1 | 72,741 | 0 | 145,483 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there. | instruction | 0 | 72,742 | 0 | 145,484 |
Tags: dp, greedy, strings
Correct Solution:
```
from collections import defaultdict,deque
import sys
import bisect
import math
input=sys.stdin.readline
mod=1000000007
t=int(input())
for i in range(t):
l=[i for i in input() if i!='\n']
if len(l)==1:
print(0)
else:
ans,i=0,0
while i <len(l):
if i+1<len(l) and l[i]==l[i+1] and l[i]!='0':
l[i+1]='0'
ans+=1
if i+2<len(l) and l[i]==l[i+2] and l[i]!='0':
l[i+2]='0'
ans+=1
i+=1
print(ans)
``` | output | 1 | 72,742 | 0 | 145,485 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there. | instruction | 0 | 72,743 | 0 | 145,486 |
Tags: dp, greedy, strings
Correct Solution:
```
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
s = list(input())[:-1]
ans = 0
i = 0
while True:
if i >= len(s):
break
curr = s[i]
if curr == '-':
i += 1
continue
if i+1 < len(s) and s[i+1] == curr:
ans += 1
s[i+1] = '-'
if i+2 < len(s) and s[i+2] == curr:
ans += 1
s[i+2] = '-'
else:
i += 1
if i >= len(s):
break
print(ans)
``` | output | 1 | 72,743 | 0 | 145,487 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there. | instruction | 0 | 72,744 | 0 | 145,488 |
Tags: dp, greedy, strings
Correct Solution:
```
from string import ascii_lowercase
if __name__ == "__main__":
n = int(input())
for i in range(n):
s = list(input())
n = 0
count = len(s)
j = -1
while j < count:
j += 1
if j == count:
break
first = j > 0 and s[j] == s[j - 1]
second = j > 1 and s[j] == s[j - 2] # or (j > s[j] == s[j-1]):
if first or second:
for new_sym in ascii_lowercase:
if not ((j > 0 and new_sym == s[j - 1]) or (j > 1 and new_sym == s[j - 1]) or (
j < count - 1 and new_sym == s[j + 1]) or (j < count - 2 and new_sym == s[j + 2])):
n += 1
s[j] = new_sym
break
print(n)
``` | output | 1 | 72,744 | 0 | 145,489 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there. | instruction | 0 | 72,745 | 0 | 145,490 |
Tags: dp, greedy, strings
Correct Solution:
```
from queue import PriorityQueue
from queue import Queue
import math
from collections import defaultdict
import sys
import operator as op
from functools import reduce
input=sys.stdin.buffer.readline
for _ in range(int(input())):
s= input()
n = len(s)
if n == 1:
print(0)
elif n == 2:
if s[0] == s[1]:
print(1)
else:
print(0)
else:
cnt = 0
ar = [False] * n
if s[0] == s[1]:
ar[1] = True
cnt += 1
for k in range(2,n):
if s[k] == s[k-1] and ar[k-1] == False:
ar[k] = True
cnt += 1
if s[k] == s[k-2] and ar[k-2] == False:
ar[k] = True
cnt += 1
print(cnt)
``` | output | 1 | 72,745 | 0 | 145,491 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there. | instruction | 0 | 72,746 | 0 | 145,492 |
Tags: dp, greedy, strings
Correct Solution:
```
for s in[*open(0)][1:]:
t=0,0;r=0
for x in s:
if x in t:x=0;r+=1
t=t[1],x
print(r)
``` | output | 1 | 72,746 | 0 | 145,493 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there. | instruction | 0 | 72,747 | 0 | 145,494 |
Tags: dp, greedy, strings
Correct Solution:
```
t = int(input())
for _ in range(t):
s = input()
ans = 0
n = len(s)
s += 'aaa'
for i in range(n):
if i == 0:
continue
if i == 1:
if s[i] == s[i-1]:
ans += 1
for j in range(26):
if chr(j + ord('a')) != s[i-1] and chr(j + ord('a')) != s[i+1] and chr(j + ord('a')) != s[i+2]:
s = s[:i] + chr(j + ord('a')) + s[i+1:]
break
else:
if s[i] == s[i-1] or s[i] == s[i-2]:
ans += 1
for j in range(26):
if chr(j + ord('a')) != s[i-2] and chr(j + ord('a')) != s[i+1] and chr(j + ord('a')) != s[i + 2]:
s = s[:i] + chr(j + ord('a')) + s[i + 1:]
break
print(ans)
``` | output | 1 | 72,747 | 0 | 145,495 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there. | instruction | 0 | 72,748 | 0 | 145,496 |
Tags: dp, greedy, strings
Correct Solution:
```
import sys
import io, os
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
T = int(input())
for _ in range(T):
s = str(input().rstrip())
s = list(s)
s = [ord(c)-ord('a') for c in s]
n = len(s)
cur = 25
ans = 0
for i in range(1, n):
if i != n-1:
if s[i-1] == s[i] and s[i] == s[i+1]:
ans += 2
cur += 1
s[i] = cur
cur += 1
s[i+1] = cur
elif s[i-1] == s[i+1]:
ans += 1
cur += 1
s[i+1] = cur
elif s[i-1] == s[i]:
ans += 1
cur += 1
s[i] = cur
else:
if s[i-1] == s[i]:
ans += 1
cur += 1
s[i] = cur
print(ans)
``` | output | 1 | 72,748 | 0 | 145,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.
Submitted Solution:
```
import sys
# sys.setrecursionlimit(10**6)
input=sys.stdin.readline
t=int(input())
for t1 in range(t):
s1 = input().strip()
n = len(s1)
c = 0
s = []
a = 0
l = []
for i in range(n):
s.append(s1[i])
l.append(0)
for i in range(n):
if(i+1<n):
if(s[i]==s[i+1]):
l[i]+=1
l[i+1] +=1
if(i+2<n):
if(s[i]==s[i+2]):
l[i]+=1
l[i+2] +=1
b = [0]*n
# print(l)
for i in range(n):
if(l[i]!=0):
if(i-2>=0 and s[i]==s[i-2] and b[i-2]==0):
b[i] = 1
if(i+1<n and s[i] == s[i+1]):
l[i+1]-=1
if(i+2<n and s[i] == s[i+2]):
l[i+2] -=1
if(b[i]!=1):
if(i-1>=0 and s[i]==s[i-1] and b[i-1]==0):
b[i] = 1
if(i+1<n and s[i] == s[i+1]):
l[i+1]-=1
if(i+2<n and s[i] == s[i+2]):
l[i+2] -=1
if(b[i]!=1):
if(i+1<n and s[i] == s[i+1]):
if(l[i]<l[i+1]):
continue
else:
b[i] = 1
if(i+1<n and s[i] == s[i+1]):
l[i+1]-=1
if(i+2<n and s[i] == s[i+2]):
l[i+2] -=1
if(b[i]!=1):
if(i+2<n and s[i] == s[i+2]):
if(l[i]<l[i+2]):
continue
else:
b[i] = 1
if(i+1<n and s[i] == s[i+1]):
l[i+1]-=1
if(i+2<n and s[i] == s[i+2]):
l[i+2] -=1
# print(l)
# print(b)
print(sum(b))
# print("cccc",c)
``` | instruction | 0 | 72,749 | 0 | 145,498 |
Yes | output | 1 | 72,749 | 0 | 145,499 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.
Submitted Solution:
```
T = int(input())
# words = ["babba", "abaac", "codeforces", "zeroorez", "abcdcba",
# "bbbbbbb", "abb", "a", "aa", "aba",
# "abba", "cba", "cbaa", "cbba", "cbbaa",
# "ccb", "ccba", "ccbb", "ccbba", "ccbaa",
# "ccbc", "cbbbbbabbbbc", "bbbbac", "bbbbab", "bbbbba",
# "cbbbbb", "cccccbbbb"]
# for w in words:
for tc in range(T):
poem = input()
# poem = w
if len(poem) == 0 or len(poem) == 1:
print(0)
elif len(poem) == 2:
if poem[0] == poem[1]:
print(1)
else:
print(0)
else:
poem = list(poem)
count = 0
if poem[0] == poem[1]:
count += 1
poem[1] = "#"
i = 2
# print(*poem)
while i < len(poem):
if poem[i] == poem[i - 2]:
count += 1
poem[i] = "@"
elif poem[i] == poem[i - 1]:
count += 1
poem[i] = "%"
i += 1
# print(*poem)
print(count)
``` | instruction | 0 | 72,750 | 0 | 145,500 |
Yes | output | 1 | 72,750 | 0 | 145,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.
Submitted Solution:
```
import sys
T = int(sys.stdin.readline().strip())
for t in range (0, T):
s = sys.stdin.readline().strip()
n = len(s)
C = [0] * n
for i in range (0, n):
if i > 0:
if s[i] == s[i-1] and C[i-1] != 1:
C[i] = 1
if i > 1:
if s[i] == s[i-2] and C[i-2] != 1:
C[i] = 1
print(sum(C))
``` | instruction | 0 | 72,751 | 0 | 145,502 |
Yes | output | 1 | 72,751 | 0 | 145,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.
Submitted Solution:
```
import sys
input = iter(sys.stdin.read().splitlines()).__next__
t = int(input())
output = []
for _ in range(t):
poem = input()
# every palindrome contains a length-2 or length-3 palindrome substring
# break length-2 palindromes by changing second character optimally
# also change last for length 3
ops = 0
changed = set()
for i in range(len(poem)-2):
if i in changed:
continue
if i+1 not in changed and poem[i] == poem[i+1]:
ops += 1
# if poem[i] == poem[i+2]:
# changed.add(i)
# else:
# changed.add(i+1)
changed.add(i+1)
if i+2 not in changed and poem[i] == poem[i+2]:
ops += 1
changed.add(i+2)
if len(poem) >= 2 and len(poem)-2 not in changed and len(poem)-1 not in changed and poem[-2] == poem[-1]:
ops += 1
output.append(ops)
print(*output, sep="\n")
``` | instruction | 0 | 72,752 | 0 | 145,504 |
Yes | output | 1 | 72,752 | 0 | 145,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.
Submitted Solution:
```
from sys import stdin,stdout
stdin.readline
def mp(): return list(map(int, stdin.readline().strip().split()))
def it():return int(stdin.readline().strip())
from collections import defaultdict as dd,Counter as C,deque
from math import ceil,gcd,sqrt,factorial
from itertools import permutations
for _ in range(it()):
l = list(input())
n = len(l)
i =1
ans=0
s = set(l)
while i<n:
if l[i] == l[i-1]:
ans += 1
for j in range(26):
if chr(97+j) not in s:
l[i] = chr(97+j)
s.add(chr(97+j))
break
elif i > 1 and l[i] == l[i-2]:
ans += 1
for j in range(26):
if chr(97+j) not in s:
l[i] = chr(97+j)
s.add(chr(97+j))
break
i+=1
if len(s)>=26:
s = set()
# print(''.join(l))
print(ans)
``` | instruction | 0 | 72,753 | 0 | 145,506 |
No | output | 1 | 72,753 | 0 | 145,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = input()
i = 0
ans = 0
while i < len(n)-2:
if n[i] == n[i+1]:
if n[i+1] == n[i+2]:
ans += 2
i += 2
else:
ans += 1
i += 2
else:
if n[i] == n[i+2]:
ans += 1
i += 2
i += 1
print(ans)
``` | instruction | 0 | 72,754 | 0 | 145,508 |
No | output | 1 | 72,754 | 0 | 145,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.
Submitted Solution:
```
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
import sys;input = sys.stdin.readline
#import io,os; input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline #for pypy
inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]
for _ in range(inp()):
s = input().strip()
n = len(s)
if n == 1:
print(0)
elif n == 2:
if s[0] == s[1]:
print(1)
else:
print(0)
else:
ans = 0
i = 0
while i < n-2:
a,b,c = s[i],s[i+1],s[i+2]
if a == b == c:
ans += 2
i += 3
elif [a,b,c] == [c,b,a]:
ans += 1
i += 3
elif b == c:
ans += 1
i += 3
else:
i += 1
print(ans)
``` | instruction | 0 | 72,755 | 0 | 145,510 |
No | output | 1 | 72,755 | 0 | 145,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After his wife's tragic death, Eurydice, Orpheus descended to the realm of death to see her. Reaching its gates was uneasy, but passing through them proved to be even more challenging. Mostly because of Cerberus, the three-headed hound of Hades.
Orpheus, a famous poet, and musician plans to calm Cerberus with his poetry and safely walk past him. He created a very peculiar poem for Cerberus. It consists only of lowercase English letters.
We call a poem's substring a palindrome if and only if it reads the same backwards and forwards. A string a is a substring of a string b if a can be obtained from b by deleting several (possibly zero or all) characters from the beginning and several (possibly zero or all) characters from the end.
Unfortunately, Cerberus dislikes palindromes of length greater than 1. For example in the poem abaa the hound of Hades wouldn't like substrings aba and aa.
Orpheus can only calm Cerberus if the hound likes his poetry. That's why he wants to change his poem so that it does not contain any palindrome substrings of length greater than 1.
Orpheus can modify the poem by replacing a letter at any position with any lowercase English letter. He can use this operation arbitrarily many times (possibly zero). Since there can be many palindromes in his poem, he may have to make some corrections. But how many, exactly? Given the poem, determine the minimal number of letters that have to be changed so that the poem does not contain any palindromes of length greater than 1.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10^5) denoting the number of test cases, then t test cases follow.
The first and only line of each test case contains a non-empty string of lowercase English letters, Orpheus' poem.
The sum of the length of Orpheus' poems in all test cases will not exceed 10^5.
Output
You should output t lines, i-th line should contain a single integer, answer to the i-th test case.
Example
Input
7
babba
abaac
codeforces
zeroorez
abcdcba
bbbbbbb
a
Output
1
1
0
1
1
4
0
Note
In the first test case, we can replace the third character with c and obtain a palindrome-less poem bacba.
In the second test case, we can replace the third character with d and obtain a palindrome-less poem abdac.
In the third test case, the initial poem already doesn't contain any palindromes, so Orpheus doesn't need to change anything there.
Submitted Solution:
```
for _ in range(int(input())):
s = input()
ans = 0
used = [0] * len(s)
for i in range(1, len(s)):
use_need = False
if s[i] == s[i - 1] and used[i - 1] == False:
use_need = True
if i > 2 and s[i] == s[i - 2] and used[i - 2] == False:
use_need = True
used[i] = use_need
ans += use_need
print(ans)
``` | instruction | 0 | 72,756 | 0 | 145,512 |
No | output | 1 | 72,756 | 0 | 145,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have multiset of n strings of the same length, consisting of lowercase English letters. We will say that those strings are easy to remember if for each string there is some position i and some letter c of the English alphabet, such that this string is the only string in the multiset that has letter c in position i.
For example, a multiset of strings {"abc", "aba", "adc", "ada"} are not easy to remember. And multiset {"abc", "ada", "ssa"} is easy to remember because:
* the first string is the only string that has character c in position 3;
* the second string is the only string that has character d in position 2;
* the third string is the only string that has character s in position 2.
You want to change your multiset a little so that it is easy to remember. For aij coins, you can change character in the j-th position of the i-th string into any other lowercase letter of the English alphabet. Find what is the minimum sum you should pay in order to make the multiset of strings easy to remember.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 20) — the number of strings in the multiset and the length of the strings respectively. Next n lines contain the strings of the multiset, consisting only of lowercase English letters, each string's length is m.
Next n lines contain m integers each, the i-th of them contains integers ai1, ai2, ..., aim (0 ≤ aij ≤ 106).
Output
Print a single number — the answer to the problem.
Examples
Input
4 5
abcde
abcde
abcde
abcde
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
Output
3
Input
4 3
abc
aba
adc
ada
10 10 10
10 1 10
10 10 10
10 1 10
Output
2
Input
3 3
abc
ada
ssa
1 1 1
1 1 1
1 1 1
Output
0 | instruction | 0 | 72,899 | 0 | 145,798 |
Tags: bitmasks, dp
Correct Solution:
```
from sys import stdin
n,m=map(int,stdin.readline().strip().split())
s=[]
for i in range(n):
s.append(list(map(ord,list(stdin.readline().strip()))))
for j in range(m):
s[-1][j]=s[-1][j]-97
ct=[tuple(map(int,stdin.readline().strip().split())) for i in range(n)]
mc=[[0 for i in range(22)] for j in range(22)]
c=[[0 for i in range(22)] for i in range(22)]
maxmask=1<<n
maxx=10**8
dp=[maxx for i in range(maxmask)]
for i in range(n):
for j in range(m):
mx=0
for k in range(n):
if s[i][j]==s[k][j]:
mc[i][j]|=(1<<k)
c[i][j]+=ct[k][j]
mx=max(mx,ct[k][j])
c[i][j]-=mx
dp[0]=0
for i in range(1,maxmask):
for j in range(n):
if i & (1<<j):
lb=j
break
mask=i
for j in range(m):
dp[mask]=min(dp[mask],dp[mask ^(1<<lb)]+ct[lb][j],dp[mask & (mask ^ mc[lb][j])]+c[lb][j])
print(dp[(1<<n)-1])
``` | output | 1 | 72,899 | 0 | 145,799 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s of length n consisting of 0-s and 1-s. You build an infinite string t as a concatenation of an infinite number of strings s, or t = ssss ... For example, if s = 10010, then t = 100101001010010...
Calculate the number of prefixes of t with balance equal to x. The balance of some string q is equal to cnt_{0, q} - cnt_{1, q}, where cnt_{0, q} is the number of occurrences of 0 in q, and cnt_{1, q} is the number of occurrences of 1 in q. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.
Next 2T lines contain descriptions of test cases — two lines per test case. The first line contains two integers n and x (1 ≤ n ≤ 10^5, -10^9 ≤ x ≤ 10^9) — the length of string s and the desired balance, respectively.
The second line contains the binary string s (|s| = n, s_i ∈ \{0, 1\}).
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
Print T integers — one per test case. For each test case print the number of prefixes or -1 if there is an infinite number of such prefixes.
Example
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
Note
In the first test case, there are 3 good prefixes of t: with length 28, 30 and 32. | instruction | 0 | 73,442 | 0 | 146,884 |
Tags: math, strings
Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
from bisect import *
from collections import *
from heapq import *
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline()[:-1]
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def MF(): return map(float, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LF(): return list(map(float, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
dij = [(0, 1), (1, 0), (0, -1), (-1, 0)]
def main():
inf=10**9
t=II()
for _ in range(t):
n,x=MI()
cnt=defaultdict(int)
s=0
mx=-inf
mn=inf
for c in SI():
cnt[s]+=1
if c=="0":s+=1
else:s-=1
if s>mx:mx=s
if s<mn:mn=s
if s==0:
if cnt[x]==0:print(0)
else:print(-1)
continue
ans=0
start=max(0,min((x-mx)//s,(x-mn)//s)-3)
stop=max((x-mx)//s,(x-mn)//s)+3
for m in range(start,stop):
ans+=cnt[x-s*m]
print(ans)
main()
``` | output | 1 | 73,442 | 0 | 146,885 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s of length n consisting of 0-s and 1-s. You build an infinite string t as a concatenation of an infinite number of strings s, or t = ssss ... For example, if s = 10010, then t = 100101001010010...
Calculate the number of prefixes of t with balance equal to x. The balance of some string q is equal to cnt_{0, q} - cnt_{1, q}, where cnt_{0, q} is the number of occurrences of 0 in q, and cnt_{1, q} is the number of occurrences of 1 in q. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.
Next 2T lines contain descriptions of test cases — two lines per test case. The first line contains two integers n and x (1 ≤ n ≤ 10^5, -10^9 ≤ x ≤ 10^9) — the length of string s and the desired balance, respectively.
The second line contains the binary string s (|s| = n, s_i ∈ \{0, 1\}).
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
Print T integers — one per test case. For each test case print the number of prefixes or -1 if there is an infinite number of such prefixes.
Example
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
Note
In the first test case, there are 3 good prefixes of t: with length 28, 30 and 32. | instruction | 0 | 73,443 | 0 | 146,886 |
Tags: math, strings
Correct Solution:
```
def solve(n, x, s):
p = []
z_count, o_count = s.count('0'), s.count('1')
b = 0
for c in s:
if c == '0':
b += 1
else:
b -= 1
p.append(b)
res = 0
if z_count == o_count:
if x in p:
res = -1
else:
if x == 0:
res += 1
diff = p[-1]
for x0 in p:
if diff > 0:
if x0 <= x:
tmp = x - x0
if tmp % diff == 0:
res += 1
if diff < 0:
if x0 >= x:
tmp = x - x0
if tmp % diff == 0:
res += 1
print(res)
t = int(input())
for _ in range(t):
n, x = map(int, input().split())
s = input()
solve(n, x, s)
``` | output | 1 | 73,443 | 0 | 146,887 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s of length n consisting of 0-s and 1-s. You build an infinite string t as a concatenation of an infinite number of strings s, or t = ssss ... For example, if s = 10010, then t = 100101001010010...
Calculate the number of prefixes of t with balance equal to x. The balance of some string q is equal to cnt_{0, q} - cnt_{1, q}, where cnt_{0, q} is the number of occurrences of 0 in q, and cnt_{1, q} is the number of occurrences of 1 in q. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.
Next 2T lines contain descriptions of test cases — two lines per test case. The first line contains two integers n and x (1 ≤ n ≤ 10^5, -10^9 ≤ x ≤ 10^9) — the length of string s and the desired balance, respectively.
The second line contains the binary string s (|s| = n, s_i ∈ \{0, 1\}).
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
Print T integers — one per test case. For each test case print the number of prefixes or -1 if there is an infinite number of such prefixes.
Example
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
Note
In the first test case, there are 3 good prefixes of t: with length 28, 30 and 32. | instruction | 0 | 73,444 | 0 | 146,888 |
Tags: math, strings
Correct Solution:
```
t=int(input())
for _ in range(t):
n,x=map(int,input().split())
string=input()
num=[0]
for i in string:
if i=='1':
num.append(num[-1]-1)
else:
num.append(num[-1]+1)
ans=0
isInfi=False
for i in num[:-1]:
if num[n]==0:
if i==x:
isInfi=True
elif abs(x-i)%abs(num[n])==0:
if (x-i)/(num[n])>=0:
ans+=1
if isInfi:
print(-1)
else:
print(ans)
``` | output | 1 | 73,444 | 0 | 146,889 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s of length n consisting of 0-s and 1-s. You build an infinite string t as a concatenation of an infinite number of strings s, or t = ssss ... For example, if s = 10010, then t = 100101001010010...
Calculate the number of prefixes of t with balance equal to x. The balance of some string q is equal to cnt_{0, q} - cnt_{1, q}, where cnt_{0, q} is the number of occurrences of 0 in q, and cnt_{1, q} is the number of occurrences of 1 in q. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.
Next 2T lines contain descriptions of test cases — two lines per test case. The first line contains two integers n and x (1 ≤ n ≤ 10^5, -10^9 ≤ x ≤ 10^9) — the length of string s and the desired balance, respectively.
The second line contains the binary string s (|s| = n, s_i ∈ \{0, 1\}).
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
Print T integers — one per test case. For each test case print the number of prefixes or -1 if there is an infinite number of such prefixes.
Example
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
Note
In the first test case, there are 3 good prefixes of t: with length 28, 30 and 32. | instruction | 0 | 73,445 | 0 | 146,890 |
Tags: math, strings
Correct Solution:
```
import sys
from collections import Counter
# inf = open('input.txt', 'r')
# reader = (line.rstrip() for line in inf)
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
def countPrefix(s, x):
if x < 0:
s = s.replace('0', '#').replace('1', '0').replace('#', '1')
x = -x
bal = 0
ctr = Counter()
maxBal = minBal = 0
for c in s:
if c == '0':
bal += 1
else:
bal -= 1
ctr[bal] += 1
maxBal = max(maxBal, bal)
minBal = min(minBal, bal)
# print(s, bal)
# print(x, maxBal)
if bal == 0:
if x <= maxBal:
return -1
else:
return 0
elif bal < 0:
ans = 0
if maxBal >= x:
k = 0
while maxBal + k * bal >= x:
ans += ctr[x - k * bal]
k += 1
else:
if maxBal >= x:
k = 0
else:
k = (x - maxBal) // bal
ans = 0
while minBal + k * bal <= x:
ans += ctr[x - k * bal]
k += 1
if x == 0:
ans += 1
return ans
t = int(input())
for _ in range(t):
n, x = map(int, input().split())
s = input()
print(countPrefix(s, x))
# inf.close()
``` | output | 1 | 73,445 | 0 | 146,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s of length n consisting of 0-s and 1-s. You build an infinite string t as a concatenation of an infinite number of strings s, or t = ssss ... For example, if s = 10010, then t = 100101001010010...
Calculate the number of prefixes of t with balance equal to x. The balance of some string q is equal to cnt_{0, q} - cnt_{1, q}, where cnt_{0, q} is the number of occurrences of 0 in q, and cnt_{1, q} is the number of occurrences of 1 in q. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.
Next 2T lines contain descriptions of test cases — two lines per test case. The first line contains two integers n and x (1 ≤ n ≤ 10^5, -10^9 ≤ x ≤ 10^9) — the length of string s and the desired balance, respectively.
The second line contains the binary string s (|s| = n, s_i ∈ \{0, 1\}).
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
Print T integers — one per test case. For each test case print the number of prefixes or -1 if there is an infinite number of such prefixes.
Example
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
Note
In the first test case, there are 3 good prefixes of t: with length 28, 30 and 32. | instruction | 0 | 73,446 | 0 | 146,892 |
Tags: math, strings
Correct Solution:
```
for _ in range(int(input())):
n,x = map(int, input().split())
s = input()
a = list(map(int, s))
sum = 0
cntO = a.count(0)
total = cntO - (n - cntO)
bal = 0
ans = 0
isInf = False
for i in range(len(a)):
if total == 0:
if bal == x:
isInf = True
elif abs(x - bal) % total == 0:
if (x - bal) // total >= 0:
ans += 1
if a[i] == 0:
bal += 1
else:
bal -= 1
if isInf:
print(-1)
else:
print(ans)
``` | output | 1 | 73,446 | 0 | 146,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s of length n consisting of 0-s and 1-s. You build an infinite string t as a concatenation of an infinite number of strings s, or t = ssss ... For example, if s = 10010, then t = 100101001010010...
Calculate the number of prefixes of t with balance equal to x. The balance of some string q is equal to cnt_{0, q} - cnt_{1, q}, where cnt_{0, q} is the number of occurrences of 0 in q, and cnt_{1, q} is the number of occurrences of 1 in q. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.
Next 2T lines contain descriptions of test cases — two lines per test case. The first line contains two integers n and x (1 ≤ n ≤ 10^5, -10^9 ≤ x ≤ 10^9) — the length of string s and the desired balance, respectively.
The second line contains the binary string s (|s| = n, s_i ∈ \{0, 1\}).
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
Print T integers — one per test case. For each test case print the number of prefixes or -1 if there is an infinite number of such prefixes.
Example
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
Note
In the first test case, there are 3 good prefixes of t: with length 28, 30 and 32. | instruction | 0 | 73,447 | 0 | 146,894 |
Tags: math, strings
Correct Solution:
```
import collections
if __name__=='__main__':
for i in range(int(input())):
n,x=map(int,input().split())
sum=0
cnt=0
s=input()
a=collections.defaultdict(lambda :0)
'''
for j in a:
print(j)
'''
for j in s:
if j=='0':
sum=sum+1
else:
sum=sum-1
a[sum]=a[sum]+1
#print(str(j)+ "pe sum:"+ str(sum)+ "and a["+str(sum)+"]="+str(a[sum]))
'''
for i in a:
if ((x-i)%sum==0) and sum>0:
cnt=cnt+a[i]
elif(sum==0):
if x in a:
cnt
'''
if(x==0):
cnt=1
if(sum>0):
for i in a:
if ((x-i)%sum==0) and (x-i)>=0:
cnt=cnt+a[i]
elif(sum==0):
for i in a:
if(i==x):
cnt=-1
#print(i,a[i],cnt)
elif(sum<0):
for i in a:
if ((i-x)%(sum*(-1))==0) and i-x>=0:
cnt=cnt+a[i]
#print(i,a[i],cnt)
print(cnt)
``` | output | 1 | 73,447 | 0 | 146,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s of length n consisting of 0-s and 1-s. You build an infinite string t as a concatenation of an infinite number of strings s, or t = ssss ... For example, if s = 10010, then t = 100101001010010...
Calculate the number of prefixes of t with balance equal to x. The balance of some string q is equal to cnt_{0, q} - cnt_{1, q}, where cnt_{0, q} is the number of occurrences of 0 in q, and cnt_{1, q} is the number of occurrences of 1 in q. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.
Next 2T lines contain descriptions of test cases — two lines per test case. The first line contains two integers n and x (1 ≤ n ≤ 10^5, -10^9 ≤ x ≤ 10^9) — the length of string s and the desired balance, respectively.
The second line contains the binary string s (|s| = n, s_i ∈ \{0, 1\}).
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
Print T integers — one per test case. For each test case print the number of prefixes or -1 if there is an infinite number of such prefixes.
Example
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
Note
In the first test case, there are 3 good prefixes of t: with length 28, 30 and 32. | instruction | 0 | 73,448 | 0 | 146,896 |
Tags: math, strings
Correct Solution:
```
bestNum = {2: 1, 3: 7, 4: 7, 5: 7, 6: 9, 7: 9}
ans = []
for t in range(int(input())):
n, x = [int(i) for i in input().split()]
s = input()
currBal = 0
pSum = []
for i in s:
if i == '0':
currBal += 1
else:
currBal -= 1
pSum.append(currBal)
count = 0
n -= 1
if pSum[n] != 0:
l = 0
for i in pSum:
temp = (x - i)
div = temp % pSum[n]
if temp == 0 or (pSum[n] > 0 and temp > 0 and div == 0) or (pSum[n] < 0 and temp < 0 and div == 0):
# print(l, "index ke liye")
count += 1
l += 1
else:
for i in pSum:
temp = (x - i)
if temp == 0:
# print(i - 1, "index ke liye")
count += 1
a = count
if a > 0 and pSum[n] == 0:
a = -1
elif x == 0:
a += 1
ans.append(str(a))
print('\n'.join(ans))
``` | output | 1 | 73,448 | 0 | 146,897 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.