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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub". | instruction | 0 | 92,848 | 0 | 185,696 |
Tags: constructive algorithms, sortings
Correct Solution:
```
import io
import os
import sys
import math
import heapq
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
s = input().rstrip()
s = sorted(s)
print(''.join(s))
``` | output | 1 | 92,848 | 0 | 185,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub". | instruction | 0 | 92,849 | 0 | 185,698 |
Tags: constructive algorithms, sortings
Correct Solution:
```
inpt = input().split()
inpt = list(map(int,inpt))
for i in range(inpt[0]):
string = input()
string = input()
ans=''
print(ans.join(sorted(string)))
``` | output | 1 | 92,849 | 0 | 185,699 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".
Submitted Solution:
```
import sys
import math
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def MI():
return map(int, sys.stdin.readline().split())
def SI():
return sys.stdin.readline().strip()
def FACT(n, mod):
s = 1
facts = [1]
for i in range(1,n+1):
s*=i
s%=mod
facts.append(s)
return facts[n]
def C(n, k, mod):
return (FACT(n,mod) * pow((FACT(k,mod)*FACT(n-k,mod))%mod,mod-2, mod))%mod
t = II()
for q in range(t):
n = II()
s = list(SI())
count = 0
for i in range(n):
if s[i] == 't':
s[i] = ""
count+=1
s+=['t']*count
print("".join(s))
``` | instruction | 0 | 92,850 | 0 | 185,700 |
Yes | output | 1 | 92,850 | 0 | 185,701 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
s=str(input())
k=sorted(s)
print("".join(k))
``` | instruction | 0 | 92,851 | 0 | 185,702 |
Yes | output | 1 | 92,851 | 0 | 185,703 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".
Submitted Solution:
```
# import sys
# input = lambda: sys.stdin.readline().rstrip()
import sys
import math
input = sys.stdin.readline
from collections import deque
from queue import LifoQueue
def binary_search(a, n):
L = 0
R = len(a)-1
while L<=R:
mid = L+(R-L)//2
if a[mid]==n:
return mid
elif a[mid]<n:
L = mid+1
else:
R = mid-1
return -1
for _ in range(int(input())):
n = int(input())
s = input()
for i in range(n):
if s[i]=='b':
s = 'b'+s[:i]+s[i+1:]
print(s)
``` | instruction | 0 | 92,852 | 0 | 185,704 |
Yes | output | 1 | 92,852 | 0 | 185,705 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
a=input()
n=a.count('b')
x=a.replace('b','')
ans='b'*n
ans+=x
print(ans)
``` | instruction | 0 | 92,853 | 0 | 185,706 |
Yes | output | 1 | 92,853 | 0 | 185,707 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".
Submitted Solution:
```
t = int(input())
for i in range(t):
n = int(input())
s = input()
new = s[::-1]
if new == s:
new = s[-1]
new += s[:-1]
print(new)
``` | instruction | 0 | 92,854 | 0 | 185,708 |
No | output | 1 | 92,854 | 0 | 185,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".
Submitted Solution:
```
inpt = input().split()
inpt = list(map(int,inpt))
for i in range(inpt[0]):
string = input()
string = input()
print(string.replace('trygub','gubyrt'))
``` | instruction | 0 | 92,855 | 0 | 185,710 |
No | output | 1 | 92,855 | 0 | 185,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
f = input()
s = "trygub"
l=[]
l1=[]
def iS(str1,str2,l,l1):
m = len(str1)
n = len(str2)
j = 0
i = 0
while j<m and i<n:
if str1[j] == str2[i]:
l.append(i)
l1.append(str2[i])
j = j+1
i = i + 1
return j==m
def ls(s):
str1 = ""
for ele in s:
str1 += ele
return str1
if iS(s, f,l,l1):
p=list(f)
j=len(l)
p.reverse()
print(ls(p))
else:
print(f)
``` | instruction | 0 | 92,856 | 0 | 185,712 |
No | output | 1 | 92,856 | 0 | 185,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
Input
The first line contains a single integer t (1≤ t≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 200) — the length of a.
The next line contains the string a of length n, consisting of lowercase English letters.
Output
For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
If there exist multiple possible strings b, you can print any.
Example
Input
3
11
antontrygub
15
bestcoordinator
19
trywatchinggurabruh
Output
bugyrtnotna
bestcoordinator
bruhtrywatchinggura
Note
In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
In the second test case, we did not change the order of characters because it is not needed.
In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".
Submitted Solution:
```
t = int(input())
for i in range(t):
n = int(input())
a = input()
print(str(sorted(a, reverse = True)))
``` | instruction | 0 | 92,857 | 0 | 185,714 |
No | output | 1 | 92,857 | 0 | 185,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a set of 4n strings of equal length, consisting of lowercase English letters "a", "b", "c", "d" and "e". Moreover, the set is split into n groups of 4 equal strings each. Vasya also has one special string a of the same length, consisting of letters "a" only.
Vasya wants to obtain from string a some fixed string b, in order to do this, he can use the strings from his set in any order. When he uses some string x, each of the letters in string a replaces with the next letter in alphabet as many times as the alphabet position, counting from zero, of the corresponding letter in string x. Within this process the next letter in alphabet after "e" is "a".
For example, if some letter in a equals "b", and the letter on the same position in x equals "c", then the letter in a becomes equal "d", because "c" is the second alphabet letter, counting from zero. If some letter in a equals "e", and on the same position in x is "d", then the letter in a becomes "c". For example, if the string a equals "abcde", and string x equals "baddc", then a becomes "bbabb".
A used string disappears, but Vasya can use equal strings several times.
Vasya wants to know for q given strings b, how many ways there are to obtain from the string a string b using the given set of 4n strings? Two ways are different if the number of strings used from some group of 4 strings is different. Help Vasya compute the answers for these questions modulo 109 + 7.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 500) — the number of groups of four strings in the set, and the length of all strings.
Each of the next n lines contains a string s of length m, consisting of lowercase English letters "a", "b", "c", "d" and "e". This means that there is a group of four strings equal to s.
The next line contains single integer q (1 ≤ q ≤ 300) — the number of strings b Vasya is interested in.
Each of the next q strings contains a string b of length m, consisting of lowercase English letters "a", "b", "c", "d" and "e" — a string Vasya is interested in.
Output
For each string Vasya is interested in print the number of ways to obtain it from string a, modulo 109 + 7.
Examples
Input
1 1
b
2
a
e
Output
1
1
Input
2 4
aaaa
bbbb
1
cccc
Output
5
Note
In the first example, we have 4 strings "b". Then we have the only way for each string b: select 0 strings "b" to get "a" and select 4 strings "b" to get "e", respectively. So, we have 1 way for each request.
In the second example, note that the choice of the string "aaaa" does not change anything, that is we can choose any amount of it (from 0 to 4, it's 5 different ways) and we have to select the line "bbbb" 2 times, since other variants do not fit. We get that we have 5 ways for the request.
Submitted Solution:
```
# E
print(1)
print(1)
``` | instruction | 0 | 93,193 | 0 | 186,386 |
No | output | 1 | 93,193 | 0 | 186,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a set of 4n strings of equal length, consisting of lowercase English letters "a", "b", "c", "d" and "e". Moreover, the set is split into n groups of 4 equal strings each. Vasya also has one special string a of the same length, consisting of letters "a" only.
Vasya wants to obtain from string a some fixed string b, in order to do this, he can use the strings from his set in any order. When he uses some string x, each of the letters in string a replaces with the next letter in alphabet as many times as the alphabet position, counting from zero, of the corresponding letter in string x. Within this process the next letter in alphabet after "e" is "a".
For example, if some letter in a equals "b", and the letter on the same position in x equals "c", then the letter in a becomes equal "d", because "c" is the second alphabet letter, counting from zero. If some letter in a equals "e", and on the same position in x is "d", then the letter in a becomes "c". For example, if the string a equals "abcde", and string x equals "baddc", then a becomes "bbabb".
A used string disappears, but Vasya can use equal strings several times.
Vasya wants to know for q given strings b, how many ways there are to obtain from the string a string b using the given set of 4n strings? Two ways are different if the number of strings used from some group of 4 strings is different. Help Vasya compute the answers for these questions modulo 109 + 7.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 500) — the number of groups of four strings in the set, and the length of all strings.
Each of the next n lines contains a string s of length m, consisting of lowercase English letters "a", "b", "c", "d" and "e". This means that there is a group of four strings equal to s.
The next line contains single integer q (1 ≤ q ≤ 300) — the number of strings b Vasya is interested in.
Each of the next q strings contains a string b of length m, consisting of lowercase English letters "a", "b", "c", "d" and "e" — a string Vasya is interested in.
Output
For each string Vasya is interested in print the number of ways to obtain it from string a, modulo 109 + 7.
Examples
Input
1 1
b
2
a
e
Output
1
1
Input
2 4
aaaa
bbbb
1
cccc
Output
5
Note
In the first example, we have 4 strings "b". Then we have the only way for each string b: select 0 strings "b" to get "a" and select 4 strings "b" to get "e", respectively. So, we have 1 way for each request.
In the second example, note that the choice of the string "aaaa" does not change anything, that is we can choose any amount of it (from 0 to 4, it's 5 different ways) and we have to select the line "bbbb" 2 times, since other variants do not fit. We get that we have 5 ways for the request.
Submitted Solution:
```
# E
n, m = map(int, input().split())
strings = []
for i in range(n):
strings.append(input())
cross = []
for i in range(m):
cross.append('')
for j in range(n):
cross[i] += strings[j][i]
dups = [[] for i in range(m)]
for i in range(m):
for j in range(i):
if cross[i] == cross[j]:
if dups[j] == []:
dups[j] = [j, i]
else:
dups[j].append(i)
break
count = 0
for i in range(m):
if len(dups[i]) > 0:
count += len(dups[i])-1
ans = 5**(n-m+count) % (10**9+7)
q = int(input())
for i in range(q):
test = input()
print(ans)
``` | instruction | 0 | 93,194 | 0 | 186,388 |
No | output | 1 | 93,194 | 0 | 186,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a set of 4n strings of equal length, consisting of lowercase English letters "a", "b", "c", "d" and "e". Moreover, the set is split into n groups of 4 equal strings each. Vasya also has one special string a of the same length, consisting of letters "a" only.
Vasya wants to obtain from string a some fixed string b, in order to do this, he can use the strings from his set in any order. When he uses some string x, each of the letters in string a replaces with the next letter in alphabet as many times as the alphabet position, counting from zero, of the corresponding letter in string x. Within this process the next letter in alphabet after "e" is "a".
For example, if some letter in a equals "b", and the letter on the same position in x equals "c", then the letter in a becomes equal "d", because "c" is the second alphabet letter, counting from zero. If some letter in a equals "e", and on the same position in x is "d", then the letter in a becomes "c". For example, if the string a equals "abcde", and string x equals "baddc", then a becomes "bbabb".
A used string disappears, but Vasya can use equal strings several times.
Vasya wants to know for q given strings b, how many ways there are to obtain from the string a string b using the given set of 4n strings? Two ways are different if the number of strings used from some group of 4 strings is different. Help Vasya compute the answers for these questions modulo 109 + 7.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 500) — the number of groups of four strings in the set, and the length of all strings.
Each of the next n lines contains a string s of length m, consisting of lowercase English letters "a", "b", "c", "d" and "e". This means that there is a group of four strings equal to s.
The next line contains single integer q (1 ≤ q ≤ 300) — the number of strings b Vasya is interested in.
Each of the next q strings contains a string b of length m, consisting of lowercase English letters "a", "b", "c", "d" and "e" — a string Vasya is interested in.
Output
For each string Vasya is interested in print the number of ways to obtain it from string a, modulo 109 + 7.
Examples
Input
1 1
b
2
a
e
Output
1
1
Input
2 4
aaaa
bbbb
1
cccc
Output
5
Note
In the first example, we have 4 strings "b". Then we have the only way for each string b: select 0 strings "b" to get "a" and select 4 strings "b" to get "e", respectively. So, we have 1 way for each request.
In the second example, note that the choice of the string "aaaa" does not change anything, that is we can choose any amount of it (from 0 to 4, it's 5 different ways) and we have to select the line "bbbb" 2 times, since other variants do not fit. We get that we have 5 ways for the request.
Submitted Solution:
```
n,m=[int(i) for i in input().split()]
a='a'*m
s=[['abcde'.index(j) for j in input()] for i in range(n)]
b=[['abcde'.index(j) for j in input()] for i in range(int(input()))]
from itertools import product
def comb(n, k):
d=list(range(0, k))
yield d
while True:
i=k-1
while i>=0 and d[i]+k-i+1>n:
i-=1
if i<0:
return
d[i]+=1
for j in range(i+1, k):
d[j]=d[j-1]+1
yield d
def combs(sets, m):
for ci in comb(len(sets), m):
for cj in product(*(sets[i] for i in ci)):
yield cj
def num(p, u):
k=0
ss=[] if b[p][u] else ['0']
o=[str(i[u]) for i in s]*4
for i in range(1, n*4+1):
for j in combs(o, i):
if sum([int(l) for l in j])%5==int(b[p][u]):
j=sorted(list(j))
if j not in ss:
ss.append(j)
k+=1
return [str().join(i) for i in ss]
for p in range(len(b)):
t=None
for u in range(m):
if t==None:
t=set(num(p, u))
else:
t=t&set(num(p, u))
print(len(t))
``` | instruction | 0 | 93,195 | 0 | 186,390 |
No | output | 1 | 93,195 | 0 | 186,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a set of 4n strings of equal length, consisting of lowercase English letters "a", "b", "c", "d" and "e". Moreover, the set is split into n groups of 4 equal strings each. Vasya also has one special string a of the same length, consisting of letters "a" only.
Vasya wants to obtain from string a some fixed string b, in order to do this, he can use the strings from his set in any order. When he uses some string x, each of the letters in string a replaces with the next letter in alphabet as many times as the alphabet position, counting from zero, of the corresponding letter in string x. Within this process the next letter in alphabet after "e" is "a".
For example, if some letter in a equals "b", and the letter on the same position in x equals "c", then the letter in a becomes equal "d", because "c" is the second alphabet letter, counting from zero. If some letter in a equals "e", and on the same position in x is "d", then the letter in a becomes "c". For example, if the string a equals "abcde", and string x equals "baddc", then a becomes "bbabb".
A used string disappears, but Vasya can use equal strings several times.
Vasya wants to know for q given strings b, how many ways there are to obtain from the string a string b using the given set of 4n strings? Two ways are different if the number of strings used from some group of 4 strings is different. Help Vasya compute the answers for these questions modulo 109 + 7.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 500) — the number of groups of four strings in the set, and the length of all strings.
Each of the next n lines contains a string s of length m, consisting of lowercase English letters "a", "b", "c", "d" and "e". This means that there is a group of four strings equal to s.
The next line contains single integer q (1 ≤ q ≤ 300) — the number of strings b Vasya is interested in.
Each of the next q strings contains a string b of length m, consisting of lowercase English letters "a", "b", "c", "d" and "e" — a string Vasya is interested in.
Output
For each string Vasya is interested in print the number of ways to obtain it from string a, modulo 109 + 7.
Examples
Input
1 1
b
2
a
e
Output
1
1
Input
2 4
aaaa
bbbb
1
cccc
Output
5
Note
In the first example, we have 4 strings "b". Then we have the only way for each string b: select 0 strings "b" to get "a" and select 4 strings "b" to get "e", respectively. So, we have 1 way for each request.
In the second example, note that the choice of the string "aaaa" does not change anything, that is we can choose any amount of it (from 0 to 4, it's 5 different ways) and we have to select the line "bbbb" 2 times, since other variants do not fit. We get that we have 5 ways for the request.
Submitted Solution:
```
# Efjewioaj
print(1)
print(1)
``` | instruction | 0 | 93,196 | 0 | 186,392 |
No | output | 1 | 93,196 | 0 | 186,393 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26 | instruction | 0 | 93,268 | 0 | 186,536 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
s=SI()
n=len(s)
n2=n//2
ans=n2*(n2+1)+n%2*(n2+1)
#print(ans)
rem=0
for i,c in enumerate(s):
if c=="1":continue
ans-=(rem+1)//2
if rem%2==0 and i%2==0:ans-=1
if (i-rem)%2==0:rem+=1
print(ans)
main()
``` | output | 1 | 93,268 | 0 | 186,537 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26 | instruction | 0 | 93,269 | 0 | 186,538 |
"Correct Solution:
```
"""
なるべく各操作における奇数文字目に1をいれる
最後にたす数は確定
左端が1の時、最初に入れない理由はない
最初に必要な1を全部入れない理由、あるか？
なさそう
あとはどう0を入れていくか
1のうち、いくつが空数番目・いくつが奇数番目にいあるかを考える
0を入れると、それ以降の1の偶奇がひっくり返る
差は高々1
右端は毎回ひっくり返されるので考えなくていい
2番目は、右端で1回だけ延長できる
3番目は、2回延長できる
"""
T = input()
ans = 0
onum = 0
for i in T:
if i == "1":
onum += 1
ans += (onum+1)//2
odd = []
eve = []
nodd = 0
neve = 0
#print (ans)
for i in range(len(T)-1,-1,-1):
if T[i] == "0":
odd.append(nodd)
eve.append(neve)
nodd = 0
neve = 0
else:
if i % 2 == 0:
nodd += 1
else:
neve += 1
#print (odd,eve)
ans += nodd * ( len(T) - onum )
#print (ans)
for i in range(len(odd)):
now = 0
if i == 0:
now += len(odd)//2 * eve[i]
now += (len(odd) - len(odd)//2) * odd[i]
else:
now += (len(odd)-i)//2 * eve[i]
now += ((len(odd)-i) - (len(odd)-i)//2 ) * odd[i]
rem = len(odd) - ( (len(odd)-i)//2 +(len(odd)-i) - (len(odd)-i)//2)
now += rem * max(eve[i],odd[i])
#print (now)
ans += now
print (ans)
``` | output | 1 | 93,269 | 0 | 186,539 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26 | instruction | 0 | 93,270 | 0 | 186,540 |
"Correct Solution:
```
T=input()
n=len(T)
i=r=a=0
for c in T:k=i-r;r+=(~k&1)*(c=='0');a+=(i//2-k//2+(~k&1)*(n-i))*(c=="1");i+=1
print(a)
``` | output | 1 | 93,270 | 0 | 186,541 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26 | instruction | 0 | 93,271 | 0 | 186,542 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
T = read().rstrip().decode()
T
def f(n, r, l, z):
# 長さnの1が座標 r から l へと移動する。
# z回立ち止まることが許されている。
# 獲得スコアの最大値は？
if n % 2 == 0:
move = r - l + z
return (move + 1) * (n // 2)
if r == l and r % 2 == 0:
# ev, od, ev, od, evで固定
k = (n - 1) // 2
move = r - l + z
return (move + 1) * k
# 各地点に1回ずつ立ち寄りつつ、奇数のところでz回足踏みできる
ev = (r // 2) - ((l - 1) // 2)
od = (r - l + 1) - ev
od += z
k = (n - 1) // 2
return ev * k + od * (k + 1)
Z = T.count('0')
one = 0
to = 0
answer = 0
for i, x in enumerate(T, 1):
if x == '0':
if one:
answer += f(one, i - 1, to, Z)
one = 0
Z -= 1
continue
to += 1
one += 1
if one:
answer += f(one, i, to, Z)
def f(n):
# '1' * n から減らしたときのスコア
# ただし、最初は除く
ret = 0
for i in range(0, n, 2):
ret += (n - i)
ret -= (n + 1) // 2
return ret
n = T.count('1')
answer += f(n)
print(answer)
``` | output | 1 | 93,271 | 0 | 186,543 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26 | instruction | 0 | 93,272 | 0 | 186,544 |
"Correct Solution:
```
t = input()
before_is_zero = True
keeped_ones = 0
n0 = 0
ones = [0] * int(1e5+1) # (number of zeros before 1, is_odd)
ones_index = 0
for i, x in enumerate(t):
if x == '0':
n0 += 1
before_is_zero = True
elif x == '1':
if before_is_zero:
ones[ones_index] = (n0, (i+1)%2)
ones_index += 1
before_is_zero = False
else:
keeped_ones += 1
ones_index -= 1
before_is_zero = True
if before_is_zero:
if len(ones) > 0:
ones = ones[:-1]
ans = keeped_ones * n0
for i in range(ones_index):
n0_before, is_odd = ones[i]
ans += (n0_before + is_odd)//2 + (n0 - n0_before)
ans += (keeped_ones + (ones_index+1)//2) * (keeped_ones + ones_index//2 + 1)
print(ans)
``` | output | 1 | 93,272 | 0 | 186,545 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26 | instruction | 0 | 93,273 | 0 | 186,546 |
"Correct Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
t = input()
s = t.replace("0", "")
q = len(s) # 1の数
n = len(t)
ps = [None]*(q+1)
c = 0
j = 0
for tmp in t:
if tmp=="1":
ps[j] = c
j += 1
c = 0
else:
c += 1
ps[-1] = c
dp = [0] * q # インデックスqの1までのベストな配置のときの奇数の個数
pp = [0] * (q+1) # 上を実現するために使うpsの個数
if not dp:
print(0)
else:
dp[0] = 1
j = 1 # j : トータルのインデックス(1はじまり)
for i in range(1,q):
j += 1
p = ps[i]
if j%2:
pp[i] = 0
dp[i] = dp[i-1] + 1
elif p:
pp[i] = 1
j += 1
dp[i] = dp[i-1] + 1
else:
pp[i] = 0
dp[i] = dp[i-1]
if q%2==0:
ans = q//2 * (q//2 + 1)
else:
ans = q//2 * (q//2 + 1) + q//2 + 1
# 1をすべて入れたあとに得られる利得
# ppを前から順にいれていく
j = 0
for i in range(q+1):
j += 1
if not pp[i]:
continue
# 0を１個いれる
j += 1
ans += dp[i]
if j%2:
ans += (q-i-1) // 2
else:
ans += (q-i-1) // 2 + (q-i-1)%2
# 残りのpsを後ろから順にいれていく
o = 0 # 現時点より後ろの(jを0としたときの)奇数番目の1の個数
e = 0 # 現時点より後ろの(jを0としたときの)偶数番目の1の個数
j = q + sum(pp) # 現在地のインデックス(1はじまり)
for i in range(q, 0, -1):
num = ps[i] - pp[i]
if num>0:
ans += dp[i-1] * num
if num%2==0:
ans += (num//2)*o + (num//2)*e
else:
ans += (num//2)*o + (num//2)*e + (e if j%2==0 else o)
e,o = o,e
j -= 1
if pp[i-1]:
j -= pp[i-1]
e += 1
else:
o, e = 1 + e, o
# 最初の0を入れる
num = ps[0] - pp[0]
if num%2==0:
ans += (num//2)*o + (num//2)*e
else:
ans += (num//2)*o + (num//2)*e + e if j%2==0 else o
print(ans)
``` | output | 1 | 93,273 | 0 | 186,547 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26 | instruction | 0 | 93,274 | 0 | 186,548 |
"Correct Solution:
```
t = input()
before_is_zero = True
n0 = 0
n1 = 0
seq1 = 0
ans = 0
for i, x in enumerate(t):
if x == '0':
n0 += 1
before_is_zero = True
elif before_is_zero:
tmp_add = -(n0 - (i+1)%2)//2
ans += tmp_add
n1 += 1
before_is_zero = False
else:
ans -= tmp_add
n1 += 1
seq1 += 1
before_is_zero = True
ans += (n1 - seq1) * n0 + ((n1+1)//2) * (n1//2 + 1)
print(ans)
``` | output | 1 | 93,274 | 0 | 186,549 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26 | instruction | 0 | 93,275 | 0 | 186,550 |
"Correct Solution:
```
def solve(t):
res = 0
length = 0
n = len(t)
used = [0] * n
# insert 1 greedy
for i in range(n):
if t[i] == "1":
length += 1
res += (length + 1) // 2
used[i] = 1
# insert 0 greedy
cnt_temp = 0
for i in range(n):
if used[i]:
cnt_temp += 1
elif cnt_temp % 2 == 1:
# add 0 if it is 2, 4, 6 th
cnt_temp += 1
length += 1
res += (length + 1) // 2
used[i] = 1
cnt_unused = n - sum(used)
switch_count = 0
# split by other 0
st = 0
cnt_1_even = 0
cnt_1_odd = 0
for i in range(n):
if used[i] == 0:
switched = (switch_count + 1) // 2
non_switched = cnt_unused - switched
res += cnt_1_even * non_switched + cnt_1_odd * switched
st = i + 1
switch_count += 1
cnt_1_even = 0
cnt_1_odd = 0
if t[i] == "1":
if (i - st) % 2 == 0:
cnt_1_even += 1
else:
cnt_1_odd += 1
# add last
switched = (switch_count + 1) // 2
non_switched = cnt_unused - switched
res += cnt_1_even * non_switched + cnt_1_odd * switched
return res
def main():
t = input()
res = solve(t)
print(res)
def test():
assert solve("1101") == 5
assert solve("0111101101") == 26
if __name__ == "__main__":
test()
main()
``` | output | 1 | 93,275 | 0 | 186,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
Submitted Solution:
```
n = input()
zero_list = []
z_count = 0
ans = 0
for i in range(len(n)):
if n[i] == "0":
z_count += 1
else:
zero_list.append(z_count)
z_count = 0
zero_list.append(z_count)
ones = n.count("1")
for i in range(1,ones+1):
if i % 2 == 0:
ans += i//2
else:
ans += i//2 + 1
test_string = ""
if ones % 2 == 0:
test_string = "10"*(ones//2)
else:
test_string = "10"*(ones//2)+"1"
test_length = len(test_string)
test_string = int(test_string,base=2)
#flip 0 to 1
for i in range(test_length):
if bin(test_string)[test_length-i+1] == "0" and zero_list[i] > 0:
print("xor")
print(int("1" * (test_length-i), base=2))
test_string = test_string ^ int("1" * (test_length-i), base=2)
zero_list[i] -= 1
ans += bin(test_string).count("1")
#remove more than 1 zeros
for i in range(test_length):
while zero_list[i] > 1:
zero_list[i] -= 2
ans += bin(test_string)[0:i].count("1") * 2 + test_length - i
#remove last zero from back
for i in range(test_length-1,-1,-1):
if zero_list[i] == 1:
test_string = test_string ^ int("1" * (test_length-i), base=2)
zero_list[i] -= 1
ans += bin(test_string).count("1")
print(ans)
``` | instruction | 0 | 93,281 | 0 | 186,562 |
No | output | 1 | 93,281 | 0 | 186,563 |
Provide a correct Python 3 solution for this coding contest problem.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642 | instruction | 0 | 93,323 | 0 | 186,646 |
"Correct Solution:
```
S = input()
ans = min(abs(int(S[i:i+3]) - 753) for i in range(len(S) - 2))
print(ans)
``` | output | 1 | 93,323 | 0 | 186,647 |
Provide a correct Python 3 solution for this coding contest problem.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642 | instruction | 0 | 93,324 | 0 | 186,648 |
"Correct Solution:
```
s = input()
print(min(abs(int("".join(p)) - 753) for p in zip(s, s[1:], s[2:])))
``` | output | 1 | 93,324 | 0 | 186,649 |
Provide a correct Python 3 solution for this coding contest problem.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642 | instruction | 0 | 93,325 | 0 | 186,650 |
"Correct Solution:
```
n = input()
a = []
for i in range(len(n)-2):
a += [abs(int(n[i:i+3])-753)]
print(min(a))
``` | output | 1 | 93,325 | 0 | 186,651 |
Provide a correct Python 3 solution for this coding contest problem.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642 | instruction | 0 | 93,326 | 0 | 186,652 |
"Correct Solution:
```
a=input()
l=[]
for i in range(len(a)-2):
l.append(abs(753-int(a[i:i+3])))
print(min(l))
``` | output | 1 | 93,326 | 0 | 186,653 |
Provide a correct Python 3 solution for this coding contest problem.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642 | instruction | 0 | 93,327 | 0 | 186,654 |
"Correct Solution:
```
x=input();print(min(abs(int(x[i:i+3])-753)for i in range(len(x)-2)))
``` | output | 1 | 93,327 | 0 | 186,655 |
Provide a correct Python 3 solution for this coding contest problem.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642 | instruction | 0 | 93,328 | 0 | 186,656 |
"Correct Solution:
```
s=input()
ans=753
for i in range(len(s)-2):
ans=min(ans,abs(int(s[i:i+3])-753))
print(ans)
``` | output | 1 | 93,328 | 0 | 186,657 |
Provide a correct Python 3 solution for this coding contest problem.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642 | instruction | 0 | 93,329 | 0 | 186,658 |
"Correct Solution:
```
m=999
s=input()
for i in range(2,len(s)):
m=min(m,abs(753-int(s[i-2:i+1])))
print(m)
``` | output | 1 | 93,329 | 0 | 186,659 |
Provide a correct Python 3 solution for this coding contest problem.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642 | instruction | 0 | 93,330 | 0 | 186,660 |
"Correct Solution:
```
S=input()
L=[abs(int(S[i:i+3]) - 753) for i in range(len(S)-2)]
print(min(L))
``` | output | 1 | 93,330 | 0 | 186,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642
Submitted Solution:
```
s=input();minn=1000
for i in range(len(s)-2):minn=min(abs(int(s[i:i+3])-753),minn)
print(minn)
``` | instruction | 0 | 93,331 | 0 | 186,662 |
Yes | output | 1 | 93,331 | 0 | 186,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642
Submitted Solution:
```
data = input()
print(min([abs(int(data[i:(i+3)]) - 753) for i in range(len(data)-2)]))
``` | instruction | 0 | 93,332 | 0 | 186,664 |
Yes | output | 1 | 93,332 | 0 | 186,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642
Submitted Solution:
```
S = input()
t = 1000
for s in range(len(S)-2):
t = min(abs(753 - int(S[s:s+3])),t)
print(t)
``` | instruction | 0 | 93,333 | 0 | 186,666 |
Yes | output | 1 | 93,333 | 0 | 186,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642
Submitted Solution:
```
s=input()
ans=999
for i in range(len(s)-2):
ans=min(abs(753-int(s[i:i+3])),ans)
print(ans)
``` | instruction | 0 | 93,334 | 0 | 186,668 |
Yes | output | 1 | 93,334 | 0 | 186,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642
Submitted Solution:
```
s = str(input())
ans = []
for i in range(len(s) - 2):
ans.append(abs(s[i:i+3]) - 753)
print(min(ans))
``` | instruction | 0 | 93,337 | 0 | 186,674 |
No | output | 1 | 93,337 | 0 | 186,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a string S consisting of digits `1`, `2`, ..., `9`. Lunlun, the Dachshund, will take out three consecutive digits from S, treat them as a single integer X and bring it to her master. (She cannot rearrange the digits.)
The master's favorite number is 753. The closer to this number, the better. What is the minimum possible (absolute) difference between X and 753?
Constraints
* S is a string of length between 4 and 10 (inclusive).
* Each character in S is `1`, `2`, ..., or `9`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the minimum possible difference between X and 753.
Examples
Input
1234567876
Output
34
Input
35753
Output
0
Input
1111111111
Output
642
Submitted Solution:
```
s=str(input())
ans=10**9
for i in range(len(s)-3):
ans=min(ans,abs(753-int(s[i:i+3])))
print(ans)
``` | instruction | 0 | 93,338 | 0 | 186,676 |
No | output | 1 | 93,338 | 0 | 186,677 |
Provide a correct Python 3 solution for this coding contest problem.
Do you know "sed," a tool provided with Unix? Its most popular use is to substitute every occurrence of a string contained in the input string (actually each input line) with another string β. More precisely, it proceeds as follows.
1. Within the input string, every non-overlapping (but possibly adjacent) occurrences of α are marked. If there is more than one possibility for non-overlapping matching, the leftmost one is chosen.
2. Each of the marked occurrences is substituted with β to obtain the output string; other parts of the input string remain intact.
For example, when α is "aa" and β is "bca", an input string "aaxaaa" will produce "bcaxbcaa", but not "aaxbcaa" nor "bcaxabca". Further application of the same substitution to the string "bcaxbcaa" will result in "bcaxbcbca", but this is another substitution, which is counted as the second one.
In this problem, a set of substitution pairs (αi, βi) (i = 1, 2, ... , n), an initial string γ, and a final string δ are given, and you must investigate how to produce δ from γ with a minimum number of substitutions. A single substitution (αi, βi) here means simultaneously substituting all the non-overlapping occurrences of αi, in the sense described above, with βi.
You may use a specific substitution (αi, βi ) multiple times, including zero times.
Input
The input consists of multiple datasets, each in the following format.
n
α1 β1
α2 β2
.
.
.
αn βn
γ δ
n is a positive integer indicating the number of pairs. αi and βi are separated by a single space. You may assume that 1 ≤ |αi| < |βi| ≤ 10 for any i (|s| means the length of the string s), αi ≠ αj for any i ≠ j, n ≤ 10 and 1 ≤ |γ| < |δ| ≤ 10. All the strings consist solely of lowercase letters. The end of the input is indicated by a line containing a single zero.
Output
For each dataset, output the minimum number of substitutions to obtain δ from γ. If δ cannot be produced from γ with the given set of substitutions, output -1.
Example
Input
2
a bb
b aa
a
bbbbbbbb
1
a aa
a
aaaaa
3
ab aab
abc aadc
ad dee
abc
deeeeeeeec
10
a abc
b bai
c acf
d bed
e abh
f fag
g abe
h bag
i aaj
j bbb
a
abacfaabe
0
Output
3
-1
7
4 | instruction | 0 | 93,455 | 0 | 186,910 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
n = I()
if n == 0:
break
a = [LS() for _ in range(n)]
s = S()
k = S()
l = len(k)
if s == k:
rr.append(0)
continue
u = set([s])
c = set([s])
t = 0
r = -1
while c:
t += 1
ns = set()
for cs in c:
for d,e in a:
nt = cs.replace(d,e)
if len(nt) > l:
continue
ns.add(nt)
if k in ns:
r = t
break
c = ns - u
u |= ns
rr.append(r)
return '\n'.join(map(str,rr))
print(main())
``` | output | 1 | 93,455 | 0 | 186,911 |
Provide a correct Python 3 solution for this coding contest problem.
Do you know "sed," a tool provided with Unix? Its most popular use is to substitute every occurrence of a string contained in the input string (actually each input line) with another string β. More precisely, it proceeds as follows.
1. Within the input string, every non-overlapping (but possibly adjacent) occurrences of α are marked. If there is more than one possibility for non-overlapping matching, the leftmost one is chosen.
2. Each of the marked occurrences is substituted with β to obtain the output string; other parts of the input string remain intact.
For example, when α is "aa" and β is "bca", an input string "aaxaaa" will produce "bcaxbcaa", but not "aaxbcaa" nor "bcaxabca". Further application of the same substitution to the string "bcaxbcaa" will result in "bcaxbcbca", but this is another substitution, which is counted as the second one.
In this problem, a set of substitution pairs (αi, βi) (i = 1, 2, ... , n), an initial string γ, and a final string δ are given, and you must investigate how to produce δ from γ with a minimum number of substitutions. A single substitution (αi, βi) here means simultaneously substituting all the non-overlapping occurrences of αi, in the sense described above, with βi.
You may use a specific substitution (αi, βi ) multiple times, including zero times.
Input
The input consists of multiple datasets, each in the following format.
n
α1 β1
α2 β2
.
.
.
αn βn
γ δ
n is a positive integer indicating the number of pairs. αi and βi are separated by a single space. You may assume that 1 ≤ |αi| < |βi| ≤ 10 for any i (|s| means the length of the string s), αi ≠ αj for any i ≠ j, n ≤ 10 and 1 ≤ |γ| < |δ| ≤ 10. All the strings consist solely of lowercase letters. The end of the input is indicated by a line containing a single zero.
Output
For each dataset, output the minimum number of substitutions to obtain δ from γ. If δ cannot be produced from γ with the given set of substitutions, output -1.
Example
Input
2
a bb
b aa
a
bbbbbbbb
1
a aa
a
aaaaa
3
ab aab
abc aadc
ad dee
abc
deeeeeeeec
10
a abc
b bai
c acf
d bed
e abh
f fag
g abe
h bag
i aaj
j bbb
a
abacfaabe
0
Output
3
-1
7
4 | instruction | 0 | 93,456 | 0 | 186,912 |
"Correct Solution:
```
from collections import deque
def testcase_ends():
n = int(input())
if n == 0:
return 1
sub = [input().split() for i in range(n)]
gamma = input()
delta = input()
q = deque()
q.append((gamma, 0))
res = 10000
while q:
s, i = q.popleft()
for alpha, beta in sub:
if alpha not in s: continue
t = s.replace(alpha, beta)
if t == delta:
res = min(res, i+1)
continue
elif len(t) >= len(delta):
continue
q.append((t, i+1))
if res == 10000: res = -1
print(res)
return 0
def main():
while not testcase_ends():
pass
if __name__ == '__main__':
main()
``` | output | 1 | 93,456 | 0 | 186,913 |
Provide a correct Python 3 solution for this coding contest problem.
Do you know "sed," a tool provided with Unix? Its most popular use is to substitute every occurrence of a string contained in the input string (actually each input line) with another string β. More precisely, it proceeds as follows.
1. Within the input string, every non-overlapping (but possibly adjacent) occurrences of α are marked. If there is more than one possibility for non-overlapping matching, the leftmost one is chosen.
2. Each of the marked occurrences is substituted with β to obtain the output string; other parts of the input string remain intact.
For example, when α is "aa" and β is "bca", an input string "aaxaaa" will produce "bcaxbcaa", but not "aaxbcaa" nor "bcaxabca". Further application of the same substitution to the string "bcaxbcaa" will result in "bcaxbcbca", but this is another substitution, which is counted as the second one.
In this problem, a set of substitution pairs (αi, βi) (i = 1, 2, ... , n), an initial string γ, and a final string δ are given, and you must investigate how to produce δ from γ with a minimum number of substitutions. A single substitution (αi, βi) here means simultaneously substituting all the non-overlapping occurrences of αi, in the sense described above, with βi.
You may use a specific substitution (αi, βi ) multiple times, including zero times.
Input
The input consists of multiple datasets, each in the following format.
n
α1 β1
α2 β2
.
.
.
αn βn
γ δ
n is a positive integer indicating the number of pairs. αi and βi are separated by a single space. You may assume that 1 ≤ |αi| < |βi| ≤ 10 for any i (|s| means the length of the string s), αi ≠ αj for any i ≠ j, n ≤ 10 and 1 ≤ |γ| < |δ| ≤ 10. All the strings consist solely of lowercase letters. The end of the input is indicated by a line containing a single zero.
Output
For each dataset, output the minimum number of substitutions to obtain δ from γ. If δ cannot be produced from γ with the given set of substitutions, output -1.
Example
Input
2
a bb
b aa
a
bbbbbbbb
1
a aa
a
aaaaa
3
ab aab
abc aadc
ad dee
abc
deeeeeeeec
10
a abc
b bai
c acf
d bed
e abh
f fag
g abe
h bag
i aaj
j bbb
a
abacfaabe
0
Output
3
-1
7
4 | instruction | 0 | 93,457 | 0 | 186,914 |
"Correct Solution:
```
def substitute(text, a, b):
pos = 0
newText = text
L1 = len(a)
L2 = len(b)
while True:
idx = newText.find(a, pos)
if idx < 0:
return newText
newText = newText[:idx] + b + newText[idx + L1:]
pos = idx + L2
return newText
def transform(orig, goal, count):
global subs
global minCount
if len(orig) > len(goal):
return
if orig == goal:
minCount = min(minCount, count)
return
for key in subs:
newStr = substitute(orig, key, subs[key])
if newStr != orig:
transform(newStr, goal, count + 1)
if __name__ == '__main__':
while True:
N = int(input())
if N == 0:
break
subs = {}
for _ in range(N):
a, b = input().strip().split()
subs[a] = b
orig = input().strip()
goal = input().strip()
minCount = 999999999
transform(orig, goal, 0)
if minCount == 999999999:
print(-1)
else:
print(minCount)
``` | output | 1 | 93,457 | 0 | 186,915 |
Provide a correct Python 3 solution for this coding contest problem.
Do you know "sed," a tool provided with Unix? Its most popular use is to substitute every occurrence of a string contained in the input string (actually each input line) with another string β. More precisely, it proceeds as follows.
1. Within the input string, every non-overlapping (but possibly adjacent) occurrences of α are marked. If there is more than one possibility for non-overlapping matching, the leftmost one is chosen.
2. Each of the marked occurrences is substituted with β to obtain the output string; other parts of the input string remain intact.
For example, when α is "aa" and β is "bca", an input string "aaxaaa" will produce "bcaxbcaa", but not "aaxbcaa" nor "bcaxabca". Further application of the same substitution to the string "bcaxbcaa" will result in "bcaxbcbca", but this is another substitution, which is counted as the second one.
In this problem, a set of substitution pairs (αi, βi) (i = 1, 2, ... , n), an initial string γ, and a final string δ are given, and you must investigate how to produce δ from γ with a minimum number of substitutions. A single substitution (αi, βi) here means simultaneously substituting all the non-overlapping occurrences of αi, in the sense described above, with βi.
You may use a specific substitution (αi, βi ) multiple times, including zero times.
Input
The input consists of multiple datasets, each in the following format.
n
α1 β1
α2 β2
.
.
.
αn βn
γ δ
n is a positive integer indicating the number of pairs. αi and βi are separated by a single space. You may assume that 1 ≤ |αi| < |βi| ≤ 10 for any i (|s| means the length of the string s), αi ≠ αj for any i ≠ j, n ≤ 10 and 1 ≤ |γ| < |δ| ≤ 10. All the strings consist solely of lowercase letters. The end of the input is indicated by a line containing a single zero.
Output
For each dataset, output the minimum number of substitutions to obtain δ from γ. If δ cannot be produced from γ with the given set of substitutions, output -1.
Example
Input
2
a bb
b aa
a
bbbbbbbb
1
a aa
a
aaaaa
3
ab aab
abc aadc
ad dee
abc
deeeeeeeec
10
a abc
b bai
c acf
d bed
e abh
f fag
g abe
h bag
i aaj
j bbb
a
abacfaabe
0
Output
3
-1
7
4 | instruction | 0 | 93,458 | 0 | 186,916 |
"Correct Solution:
```
# coding: utf-8
import queue
while 1:
n=int(input())
if n==0:
break
dic={}
for i in range(n):
k,s=input().split()
dic[k]=s
s=input()
ans=input()
q=queue.Queue()
q.put((s,0))
find=False
while not q.empty():
s=q.get()
if s[0]==ans:
print(s[1])
q=queue.Queue()
find=True
if not find:
for k in dic.keys():
t=s[0].replace(k,dic[k])
if len(t)<=len(ans) and s[0]!=t:
q.put((t,s[1]+1))
if not find:
print(-1)
``` | output | 1 | 93,458 | 0 | 186,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Do you know "sed," a tool provided with Unix? Its most popular use is to substitute every occurrence of a string contained in the input string (actually each input line) with another string β. More precisely, it proceeds as follows.
1. Within the input string, every non-overlapping (but possibly adjacent) occurrences of α are marked. If there is more than one possibility for non-overlapping matching, the leftmost one is chosen.
2. Each of the marked occurrences is substituted with β to obtain the output string; other parts of the input string remain intact.
For example, when α is "aa" and β is "bca", an input string "aaxaaa" will produce "bcaxbcaa", but not "aaxbcaa" nor "bcaxabca". Further application of the same substitution to the string "bcaxbcaa" will result in "bcaxbcbca", but this is another substitution, which is counted as the second one.
In this problem, a set of substitution pairs (αi, βi) (i = 1, 2, ... , n), an initial string γ, and a final string δ are given, and you must investigate how to produce δ from γ with a minimum number of substitutions. A single substitution (αi, βi) here means simultaneously substituting all the non-overlapping occurrences of αi, in the sense described above, with βi.
You may use a specific substitution (αi, βi ) multiple times, including zero times.
Input
The input consists of multiple datasets, each in the following format.
n
α1 β1
α2 β2
.
.
.
αn βn
γ δ
n is a positive integer indicating the number of pairs. αi and βi are separated by a single space. You may assume that 1 ≤ |αi| < |βi| ≤ 10 for any i (|s| means the length of the string s), αi ≠ αj for any i ≠ j, n ≤ 10 and 1 ≤ |γ| < |δ| ≤ 10. All the strings consist solely of lowercase letters. The end of the input is indicated by a line containing a single zero.
Output
For each dataset, output the minimum number of substitutions to obtain δ from γ. If δ cannot be produced from γ with the given set of substitutions, output -1.
Example
Input
2
a bb
b aa
a
bbbbbbbb
1
a aa
a
aaaaa
3
ab aab
abc aadc
ad dee
abc
deeeeeeeec
10
a abc
b bai
c acf
d bed
e abh
f fag
g abe
h bag
i aaj
j bbb
a
abacfaabe
0
Output
3
-1
7
4
Submitted Solution:
```
#include <bits/stdc++.h>
using namespace std;
inline long long GetTSC() {
long long lo, hi;
asm volatile("rdtsc" : "=a"(lo), "=d"(hi));
return lo + (hi << 32);
}
inline double GetSeconds() { return GetTSC() / 2.8e9; }
const long inf = pow(10, 15);
int di[] = {-1, 0, 1, 0};
int dj[] = {0, 1, 0, -1};
tuple<int, int> q[50 * 50 * 50 * 50];
void solve() {
double starttime = GetSeconds();
while (1) {
int w, h;
cin >> w >> h;
if (w == 0 && h == 0) break;
int lp, ls, rp, rs;
bool lb[2500] = {};
bool rb[2500] = {};
bool f[2500][2500] = {};
for (int i = 0; i < h; i++) {
string s;
cin >> s;
for (int j = 0; j < w; j++) {
if (s[j] == '#') lb[i * w + j] = 1;
if (s[j] == '%') lp = i * w + j;
if (s[j] == 'L') ls = i * w + j;
}
cin >> s;
for (int j = 0; j < w; j++) {
if (s[j] == '#') rb[i * w + j] = 1;
if (s[j] == '%') rp = i * w + j;
if (s[j] == 'R') rs = i * w + j;
}
}
f[ls][rs] = 1;
int qi = 0;
int qe = 1;
q[0] = make_tuple(ls, rs);
bool ff = 0;
while (qi < qe) {
int lt = get<0>(q[qi]);
int rt = get<1>(q[qi]);
int li = lt / w;
int lj = lt % w;
int ri = rt / w;
int rj = rt % w;
qi++;
for (int i = 0; i < 4; i++) {
int nli = li + di[i];
int nlj = lj + dj[i];
int nri = ri + di[i];
int nrj = rj - dj[i];
if (nli < 0 || nli >= h || nlj < 0 || nlj >= w || lb[nli * w + nlj]) {
nli = li;
nlj = lj;
}
if (nri < 0 || nri >= h || nrj < 0 || nrj >= w || rb[nri * w + nrj]) {
nri = ri;
nrj = rj;
}
int nlt = nli * w + nlj;
int nrt = nri * w + nrj;
if (nlt == lp && nrt == rp) {
ff = 1;
break;
}
if (nlt == lp || nrt == rp) continue;
if (f[nlt][nrt]) continue;
f[nlt][nrt] = 1;
q[qe++] = make_tuple(nlt, nrt);
}
if (ff) break;
}
if (ff) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return;
}
int main() {
solve();
return 0;
}
``` | instruction | 0 | 93,459 | 0 | 186,918 |
No | output | 1 | 93,459 | 0 | 186,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3 | instruction | 0 | 93,596 | 0 | 187,192 |
Tags: binary search, bitmasks, brute force
Correct Solution:
```
import sys
from bisect import *
zz=1
sys.setrecursionlimit(10**5)
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('all.txt','w')
di=[[-1,0],[1,0],[0,1],[0,-1]]
def fori(n):
return [fi() for i in range(n)]
def inc(d,c,x=1):
d[c]=d[c]+x if c in d else x
def ii():
return input().rstrip()
def li():
return [int(xx) for xx in input().split()]
def fli():
return [float(x) for x in input().split()]
def comp(a,b):
if(a>b):
return 2
return 2 if a==b else 0
def gi():
return [xx for xx in input().split()]
def gtc(tc,ans):
print("Case #"+str(tc)+":",ans)
def cil(n,m):
return n//m+int(n%m>0)
def fi():
return int(input())
def pro(a):
return reduce(lambda a,b:a*b,a)
def swap(a,i,j):
a[i],a[j]=a[j],a[i]
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def gh():
sys.stdout.flush()
def isvalid(i,j,n,m):
return 0<=i<n and 0<=j<m
def bo(i):
return ord(i)-ord('a')
def graph(n,m):
for i in range(m):
x,y=mi()
a[x].append(y)
a[y].append(x)
t=fi()
uu=t
while t>0:
t-=1
s=ii()
n=len(s)
a=[]
for i in range(n):
if s[i]=='1':
a.append(i)
ans=0
for i in range(n-1,-1,-1):
c=0
for j in range(i,max(-1,i-21),-1):
c+=int(s[j])*2**(i-j)
if i+1<c:
break
if s[j]=='1' :
w=bisect_left(a,i-c+1)
if a[w]==j:
ans+=1
print(ans)
``` | output | 1 | 93,596 | 0 | 187,193 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3 | instruction | 0 | 93,597 | 0 | 187,194 |
Tags: binary search, bitmasks, brute force
Correct Solution:
```
import math
import sys
from collections import defaultdict
# input = sys.stdin.readline
rt = lambda: map(int, input().split())
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
def solve(a):
n = len(a)
pref0 = [0] * n
for i in range(n):
if i == 0:
pref0[i] = 0
else:
pref0[i] = pref0[i-1] + 1 if a[i-1] == 0 else 0
res = 0
for i, val in enumerate(a):
if val == 1:
j = i
curr = 0
while j < n:
curr = 2*curr + a[j]
curr_len = j - i + 1
zpref = curr - curr_len
if zpref > i or zpref > pref0[i]:
break
res += 1
j += 1
return res
def main():
T = ri()
for _ in range(T):
print(solve(list(map(int, input()))))
if __name__ == '__main__':
main()
``` | output | 1 | 93,597 | 0 | 187,195 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3 | instruction | 0 | 93,598 | 0 | 187,196 |
Tags: binary search, bitmasks, brute force
Correct Solution:
```
# import sys
# input = sys.stdin.readline
def calc(s):
return int(s,2)
for nt in range(int(input())):
s=input()
n=len(s)
pref=[-1]*(n)
for i in range(n):
if s[i]=="1":
pref[i]=i
else:
pref[i]=pref[i-1]
ans=0
for i in range(18):
for j in range(n-1,i-1,-1):
temp=s[j-i:j+1]
# print (temp,i,j,calc(temp),ans,j-pref[j-i-1])
if calc(temp)==i+1 and temp[0]=="1":
ans+=1
elif s[j-i]=="1" and j-i-1>=0 and calc(temp)>i+1 and calc(temp)<=(j-pref[j-i-1]):
ans+=1
print (ans)
``` | output | 1 | 93,598 | 0 | 187,197 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3 | instruction | 0 | 93,599 | 0 | 187,198 |
Tags: binary search, bitmasks, brute force
Correct Solution:
```
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
from io import BytesIO, IOBase
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,Counter,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input().rstrip()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
# mod=1000000007
mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('0')
file = 1
def ceil(a,b):
return (a+b-1)//b
# write fastio for getting fastio template.
def solve():
for _ in range(ii()):
s = si()
n = len(s)
ans = 0
c = 0
for i in range(n):
if s[i] == '1':
x = 1
ans +=1
for j in range(min(c+1,n-i-1)):
x *= 2
if s[i+j+1]=='1':
x += 1
if (j+2+c) >= x:
ans += 1
else:
break
c = 0
else:
c +=1
print(ans)
if __name__ =="__main__":
if(file):
if path.exists('input.txt'):
sys.stdin=open('input.txt', 'r')
sys.stdout=open('output.txt','w')
else:
input=sys.stdin.readline
solve()
``` | output | 1 | 93,599 | 0 | 187,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3 | instruction | 0 | 93,600 | 0 | 187,200 |
Tags: binary search, bitmasks, brute force
Correct Solution:
```
for _ in range(int(input())):
l = input()
n = len(l)
zeros,cnt=0,0
for i in range(n):
if l[i]=="0":zeros+=1
else:
for j in range(i,n):
if zeros+(j-i+1)>=int(l[i:j+1],2):
cnt+=1
else:
break
zeros=0
print(cnt)
``` | output | 1 | 93,600 | 0 | 187,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3 | instruction | 0 | 93,601 | 0 | 187,202 |
Tags: binary search, bitmasks, brute force
Correct Solution:
```
t = int(input())
a = []
for i in range(t):
a.append(input())
for i in a:
p=-1
l=len(i)
d=0
for j in range(l):
if i[j]=="1":
q=j
s=j-p-1
while(q<l):
if q==(j+18):
break
f=int(i[j:q+1],2)
r=q-j+1
if (r+s)>=f:
d+=1
q+=1
p=j
print(d)
``` | output | 1 | 93,601 | 0 | 187,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3 | instruction | 0 | 93,602 | 0 | 187,204 |
Tags: binary search, bitmasks, brute force
Correct Solution:
```
for _ in range(int(input())):
s=[int(x) for x in list(input().strip())]
n=len(s)
an=0
c=0
for i in range(n):
if s[i]==1:
p=0
for j in range(18):
if i+j==n:
break
else:
p=p<<1
p+=s[i+j]
if p>=j+1 and p<=j+1+c:
an+=1
c=0
else:
c+=1
print(an)
``` | output | 1 | 93,602 | 0 | 187,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3 | instruction | 0 | 93,603 | 0 | 187,206 |
Tags: binary search, bitmasks, brute force
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
po=[1]
for i in range(17):
po.append(po[-1]*2)
def solve(s,x,y,a):
ans,su,j=0,0,x
while j<y:
su+=s[j]*po[j-x]
if su>=j-x+1 and a[j+1]-x>=su:
ans+=1
j=a[j+1]-1
j+=1
return ans
def main():
for _ in range(int(input())):
s=list(map(int,input().rstrip()))
s.reverse()
n,ans=len(s),0
a=[n]*(n+1)
for i in range(n-1,-1,-1):
a[i]=a[i+1]
if s[i]:
a[i]=i
for i in range(n):
z=solve(s,i,min(i+18,n),a)
ans+=z
print(ans)
# FAST INPUT OUTPUT REGION
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 93,603 | 0 | 187,207 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.