text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Professor GukiZ is concerned about making his way to school, because massive piles of boxes are blocking his way.
In total there are n piles of boxes, arranged in a line, from left to right, i-th pile (1 ≤ i ≤ n) containing ai boxes. Luckily, m students are willing to help GukiZ by removing all the boxes from his way. Students are working simultaneously. At time 0, all students are located left of the first pile. It takes one second for every student to move from this position to the first pile, and after that, every student must start performing sequence of two possible operations, each taking one second to complete. Possible operations are:
1. If i ≠ n, move from pile i to pile i + 1;
2. If pile located at the position of student is not empty, remove one box from it.
GukiZ's students aren't smart at all, so they need you to tell them how to remove boxes before professor comes (he is very impatient man, and doesn't want to wait). They ask you to calculate minumum time t in seconds for which they can remove all the boxes from GukiZ's way. Note that students can be positioned in any manner after t seconds, but all the boxes must be removed.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105), the number of piles of boxes and the number of GukiZ's students.
The second line contains n integers a1, a2, ... an (0 ≤ ai ≤ 109) where ai represents the number of boxes on i-th pile. It's guaranteed that at least one pile of is non-empty.
Output
In a single line, print one number, minimum time needed to remove all the boxes in seconds.
Examples
Input
2 1
1 1
Output
4
Input
3 2
1 0 2
Output
5
Input
4 100
3 4 5 4
Output
5
Note
First sample: Student will first move to the first pile (1 second), then remove box from first pile (1 second), then move to the second pile (1 second) and finally remove the box from second pile (1 second).
Second sample: One of optimal solutions is to send one student to remove a box from the first pile and a box from the third pile, and send another student to remove a box from the third pile. Overall, 5 seconds.
Third sample: With a lot of available students, send three of them to remove boxes from the first pile, four of them to remove boxes from the second pile, five of them to remove boxes from the third pile, and four of them to remove boxes from the fourth pile. Process will be over in 5 seconds, when removing the boxes from the last pile is finished.
Submitted Solution:
```
###############################
# https://codeforces.com/problemset/problem/551/C
# 2021/01/09
# WenhuZhang
################################
from sys import stdin
import collections
import copy
def check(t):
global m, end
stu = m
time = 0
for i in range(end):
# print(time,stu)
time += a[i]
while(time+i+1>=t):
time -= t-i-1
stu -=1
if stu<0:
return 0
if stu ==0:
return time<=0
return 1
# def check(t):
# global end
# flag = end
# for i in range(m):
# time = t-flag
# while(time > 0):
# # print(time, flag)
# if time>=a[flag-1]:
# a[flag-1]=0
# flag -=1
# time -= a[flag-1]
# else:
# a[flag-1] -= time
# time =0
# if flag <1:
# return True
# if(flag<1):
# return True
# else:
# return False
n, m = list(map(int, stdin.readline().split()))
a = list(map(int, stdin.readline().split()))
l=0
r=0
for i in range(len(a)):
r += a[i]
if a[i]>0:
l = i+1
r += l
end = l
while(l<=r):
mid = (l+r)//2
if(check(mid)):
ans = mid
r = mid-1
else:
print(l)
l = mid+1
print(ans)
```
No
| 2,900 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string S of length n with each character being one of the first m lowercase English letters.
Calculate how many different strings T of length n composed from the first m lowercase English letters exist such that the length of LCS (longest common subsequence) between S and T is n - 1.
Recall that LCS of two strings S and T is the longest string C such that C both in S and T as a subsequence.
Input
The first line contains two numbers n and m denoting the length of string S and number of first English lowercase characters forming the character set for strings (1 ≤ n ≤ 100 000, 2 ≤ m ≤ 26).
The second line contains string S.
Output
Print the only line containing the answer.
Examples
Input
3 3
aaa
Output
6
Input
3 3
aab
Output
11
Input
1 2
a
Output
1
Input
10 9
abacadefgh
Output
789
Note
For the first sample, the 6 possible strings T are: aab, aac, aba, aca, baa, caa.
For the second sample, the 11 possible strings T are: aaa, aac, aba, abb, abc, aca, acb, baa, bab, caa, cab.
For the third sample, the only possible string T is b.
Tags: dp, greedy
Correct Solution:
```
n, m = map(int, input().split())
s = input()
p = c = 0
for i in range(1, n):
if s[i] == s[i - 1]:
c += n * (m - 1)
p = i
elif s[i] != s[i - 2]:
p = i - 1
c += i - p
ans = n * n * (m - 1) - c
print(ans)
```
| 2,901 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string S of length n with each character being one of the first m lowercase English letters.
Calculate how many different strings T of length n composed from the first m lowercase English letters exist such that the length of LCS (longest common subsequence) between S and T is n - 1.
Recall that LCS of two strings S and T is the longest string C such that C both in S and T as a subsequence.
Input
The first line contains two numbers n and m denoting the length of string S and number of first English lowercase characters forming the character set for strings (1 ≤ n ≤ 100 000, 2 ≤ m ≤ 26).
The second line contains string S.
Output
Print the only line containing the answer.
Examples
Input
3 3
aaa
Output
6
Input
3 3
aab
Output
11
Input
1 2
a
Output
1
Input
10 9
abacadefgh
Output
789
Note
For the first sample, the 6 possible strings T are: aab, aac, aba, aca, baa, caa.
For the second sample, the 11 possible strings T are: aaa, aac, aba, abb, abc, aca, acb, baa, bab, caa, cab.
For the third sample, the only possible string T is b.
Tags: dp, greedy
Correct Solution:
```
def main():
n, m = map(int, input().split())
s = input()
k = sum(s[i] != s[i - 1] for i in range(1, n)) + 1
x = i = 0
while i < n - 1:
if s[i] != s[i + 1]:
j = i
while i + 2 < n and s[i] == s[i + 2]:
i += 1
j = (i - j) + 2
x += j * (j - 1) // 2
i += 1
ans = k * (m * n - n) - x
print(ans)
main()
```
| 2,902 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length n with each character being one of the first m lowercase English letters.
Calculate how many different strings T of length n composed from the first m lowercase English letters exist such that the length of LCS (longest common subsequence) between S and T is n - 1.
Recall that LCS of two strings S and T is the longest string C such that C both in S and T as a subsequence.
Input
The first line contains two numbers n and m denoting the length of string S and number of first English lowercase characters forming the character set for strings (1 ≤ n ≤ 100 000, 2 ≤ m ≤ 26).
The second line contains string S.
Output
Print the only line containing the answer.
Examples
Input
3 3
aaa
Output
6
Input
3 3
aab
Output
11
Input
1 2
a
Output
1
Input
10 9
abacadefgh
Output
789
Note
For the first sample, the 6 possible strings T are: aab, aac, aba, aca, baa, caa.
For the second sample, the 11 possible strings T are: aaa, aac, aba, abb, abc, aca, acb, baa, bab, caa, cab.
For the third sample, the only possible string T is b.
Submitted Solution:
```
n,m=map(int,input().split())
s=input()
v=0
c=s[0]
j=1
t=[]
front=0
p='#'
for i in range(1,len(s)):
x=s[i]
if c==x:
j+=1
else:
if p==x and j==1:
v-=1
else:p=c
c=x
t+=[j]
j=1
front+=1
t+=[j]
v+=len(t)*((n-1)*m+(m-1)-(n-1))
v-=front
coll=n-1-front
print(v)
```
No
| 2,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Tags: implementation, strings
Correct Solution:
```
from sys import stdin, stdout
class text:
def __init__(self, lines):
self.center_left = True
self.lines = list(map(lambda x: x.strip(), lines))
self.characters = max(map(lambda x: len(x), self.lines))
def print_head(self):
print("*" * (self.characters + 2) )
def center_line(self, line):
difference = self.characters - len(line)
if difference % 2 == 1:
if self.center_left:
out = "*" + difference // 2 * " " + line + (difference // 2 + 1) * " " + "*"
self.center_left = False
else:
out = "*" + (difference // 2 + 1 )* " " + line + (difference // 2) * " " + "*"
self.center_left = True
else:
out = "*" + difference // 2 * " " + line + (difference // 2) * " " + "*"
return out
def print_document(self):
self.print_head()
for line in self.lines:
print(self.center_line(line))
self.print_head()
def foo(lines):
writer = text(lines)
writer.print_document()
def main():
foo(stdin.readlines())
main()
```
| 2,904 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Tags: implementation, strings
Correct Solution:
```
__author__ = 'Darren'
def solve():
import sys
stdin = sys.stdin if True else open('data')
texts = [line.strip() for line in stdin]
max_length = max(map(len, texts))
left_more = False
print('*' * (max_length + 2))
for i in range(len(texts)):
if (max_length - len(texts[i])) % 2 == 0:
print('*%s*' % texts[i].center(max_length))
else:
if left_more:
print('* %s*' % texts[i].center(max_length-1))
else:
print('*%s *' % texts[i].center(max_length-1))
left_more = not left_more
print('*' * (max_length + 2))
if __name__ == '__main__':
solve()
```
| 2,905 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Tags: implementation, strings
Correct Solution:
```
from sys import stdin
from math import ceil, floor
doc = [line.strip() for line in stdin]
max_len = max(len(line) for line in doc)
counter = 1
print('*' * (max_len+2))
for line in doc:
line_diff = (max_len-len(line))//2
if (max_len-len(line)) % 2 != 0:
counter = 1-counter
pre_space, post_space = (line_diff+counter, line_diff+(1-counter))
else:
pre_space, post_space = (line_diff, line_diff)
print('*' + ' ' * pre_space + line + ' ' * post_space + '*')
print('*' * (max_len+2))
```
| 2,906 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Tags: implementation, strings
Correct Solution:
```
from sys import stdin
#bringing them closer left or right alternatively
#stdin...
def CF_5B():
lines=[]
for line in stdin.readlines():
line=line.strip()
lines.append(line)
length=0
for i in range(len(lines)):
if len(lines[i])>length:
length=len(lines[i])
else:
continue
print('*'*(length+2))
flag=0
for i in range(len(lines)):
if length%2==len(lines[i])%2:
left=(length-len(lines[i]))//2
right=(length-len(lines[i]))//2
elif flag==0:
left=(length-len(lines[i]))//2
right=length-len(lines[i])-left
flag=1
else:
right=(length-len(lines[i]))//2
left=length-len(lines[i])-right
flag=0
print('*'+' '*left+lines[i]+' '*right+'*')
print('*'*(length+2))
return
CF_5B()
```
| 2,907 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Tags: implementation, strings
Correct Solution:
```
import sys
l = 0;
strs = [];
for s in sys.stdin:
s1 = s.strip()
l = max(l, len(s1))
strs.append(s1)
print('*' * (l + 2))
i = 0
for s in strs:
print('*', end='')
a = 0; b = 0;
val = l - len(s)
if(val % 2 == 0):
a = val // 2
b = a
else:
if(i == 0):
a = val // 2
b = a + 1
else:
b = val // 2
a = b + 1
i = 1 - i
print(' ' * a, end='')
print(s, end='')
print(' ' * b, end='')
print('*')
print('*' * (l + 2))
```
| 2,908 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Tags: implementation, strings
Correct Solution:
```
lista=[]
while True:
try:
palabra=input()
lista.append(palabra)
except EOFError:
break
larga=0
lado="der"
for i in lista:
if len(i)>larga:
larga=len(i)
print("*"*(larga+2))
for i in lista:
palabra="*"
diferencia=larga-len(i)
if (diferencia%2)!=0:
if lado=="der":
izquierda= diferencia//2
derecha=diferencia%2
palabra+=" "*izquierda
palabra+=i
palabra+=" "*(izquierda+derecha)+"*"
print(palabra)
lado="izq"
continue
if lado=="izq":
derecha= diferencia//2
izquierda=diferencia%2
palabra+=" "*(izquierda+derecha)
palabra+=i
palabra+=" "*(derecha)+"*"
print(palabra)
lado="der"
if (diferencia%2)==0:
izquierda= diferencia//2
palabra+=" "*(izquierda)
palabra+=i
palabra+=" "*(izquierda)+"*"
print(palabra)
print("*"*(larga+2))
```
| 2,909 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Tags: implementation, strings
Correct Solution:
```
import sys
maxlen = 0
ls = []
for line in sys.stdin:
maxlen = max(maxlen, len(line))
ls.append(line.replace('\n', ''))
ind = 0
maxlen -= 1
print('*' * (maxlen+2))
for p in ls:
res = maxlen - len(p)
left = ''
right = ''
if res % 2 == 1:
ind += 1
if ind % 2 == 0:
left = ' ' * (res // 2 + 1)
right = ' ' * (res // 2)
else:
left = ' ' * (res // 2)
right = ' ' * (res // 2 + 1)
else:
left = ' ' * (res // 2)
right = ' ' * (res // 2)
assert('\n' not in right)
d = '*' + left + p + right + '*'
print(d)
print('*' * (maxlen+2))
```
| 2,910 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Tags: implementation, strings
Correct Solution:
```
import sys
def main():
strings = [x.strip() for x in sys.stdin]
solver(strings)
def solver(strings):
maxLength = 0
for s in strings:
if len(s) > maxLength:
maxLength = len(s)
print("*" * (maxLength + 2))
leftBound = True
for s in strings:
spaces = maxLength - len(s)
line = None
if spaces % 2 == 0:
line = "*" + " " * (spaces // 2) + s + " " * (spaces // 2) + "*"
else:
if leftBound == True:
line = "*" + " " * (spaces // 2) + s + " " * (spaces // 2 + 1) + "*"
else:
line = "*" + " " * (spaces // 2 + 1) + s + " " * (spaces // 2) + "*"
leftBound = not leftBound
print(line)
print("*" * (maxLength + 2))
L1 = ["This is", "Codeforces", "Beta", "Round", "5"]
#solver(L1)
main()
```
| 2,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Submitted Solution:
```
import sys
n = 0
S = []
Sl = []
for request in sys.__stdin__:
S.append(request[:-1])
Sl.append(len(S[-1]))
n += 1
width = max(Sl)
So = []
align = False
for i in range(n):
if Sl[i] % 2 == width % 2:
So.append("*" + " " * ((width - Sl[i]) // 2) + S[i] + " " * ((width - Sl[i]) // 2) + "*")
else:
So.append("*" + " " * ((width - Sl[i]) // 2 + int(align)) + S[i] + " " * ((width - Sl[i]) // 2 +
int(not align)) + "*")
align = not align
print("*" * (width + 2))
print(*So, sep="\n")
print("*" * (width + 2))
```
Yes
| 2,912 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Submitted Solution:
```
import sys
todo = []
base = 0
flag = True
for line in sys.stdin:
#for j in range(7):
# line = input()
line = line.strip()
a = len(line)
if a > base:
base = a
todo.append(line)
b = "*"*(base)
print("*{}*".format(b))
for i in todo:
largo = len(i)
c = base - largo
c = round(c/2)
d = " "*c
if largo + 2*c> base:
e = d
d = d[:-1]
if flag:
print("*{}{}{}*".format(d,i,e))
flag = False
else:
print("*{}{}{}*".format(e,i,d))
flag = True
else:
q = "*{}{}{}*".format(d,i,d)
if len(q) == len(b)+2:
print(q)
else:
e = d + " "
if flag:
q = "*{}{}{}*".format(d,i,e)
flag = False
else:
q = "*{}{}{}*".format(e,i,d)
flag = True
print(q)
print("*{}*".format(b))
```
Yes
| 2,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Submitted Solution:
```
import sys
arr = []
max_len = 0
for s in sys.stdin:
s = s.strip()
arr.append(s)
max_len = max(max_len, len(s))
print('*'*(max_len + 2))
flag = True
for s in arr:
diff = max_len - len(s)
left = int(diff / 2)
right = diff - left
if left != right:
if flag:
left = int(diff / 2)
right = diff - left
else:
right = int(diff / 2)
left = diff - right
# print(left, right, flag)
flag = not flag
# print(diff, left, right)
print('*' + ' '*left + s + ' '*right + '*')
print('*'*(max_len + 2))
```
Yes
| 2,914 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Submitted Solution:
```
import sys
a = [l.strip() for l in sys.stdin]
c = max(len(l) for l in a)
b = True
print('*' * (c+2))
for r in a:
k = c - len(r)
h = k / 2
m = k / 2
if k % 2 != 0 :
if b == True:
m = m + 1
b = False
else :
h = h + 1
b = True
print('*'+ ' ' * int(h) + r + ' '*int(m) +'*')
print('*' * (c+2))
```
Yes
| 2,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Submitted Solution:
```
import sys
import re
input_strtings = sys.stdin.read().strip().split('\n')
max_length = len(max(input_strtings,key=len))
print('*'*(max_length+2))
turn = ['',' ']
t = 0
for i in input_strtings:
if (max_length - len(i)) % 2 == 0:
s = '*{:^' + str(max_length) + '}*'
else:
s = '*'+turn[t] + '{:^' + \
str(max_length-1) + '}'+turn[1-t] + '*'
t = 1 - t
print(s.format(i))
print('*'*(max_length+2))
```
No
| 2,916 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Submitted Solution:
```
while(1):
try:
s=input()
except EOFError:
break
print(s)
```
No
| 2,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Submitted Solution:
```
import sys
lines = sys.stdin.read().splitlines()
# Get maximum length of lines
max_len = 0
for l in lines:
max_len = max(max_len, len(l))
# Add initial line of *s
formatted = ['*' * (max_len+2)]
# Pad each line
even_line = True
for l in lines:
pad = max_len - len(l)
next_line = ''
if even_line:
next_line = '*'+(' '*(pad//2))+l+(' '*(pad-(pad//2)))+'*'
else:
next_line = '*'+(' '*(pad-(pad//2)))+l+(' '*(pad//2))+'*'
even_line = False if even_line else True
formatted.append(next_line)
formatted.append('*' * (max_len+2))
for l in formatted:
print(l)
```
No
| 2,918 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Almost every text editor has a built-in function of center text alignment. The developers of the popular in Berland text editor «Textpad» decided to introduce this functionality into the fourth release of the product.
You are to implement the alignment in the shortest possible time. Good luck!
Input
The input file consists of one or more lines, each of the lines contains Latin letters, digits and/or spaces. The lines cannot start or end with a space. It is guaranteed that at least one of the lines has positive length. The length of each line and the total amount of the lines do not exceed 1000.
Output
Format the given text, aligning it center. Frame the whole text with characters «*» of the minimum size. If a line cannot be aligned perfectly (for example, the line has even length, while the width of the block is uneven), you should place such lines rounding down the distance to the left or to the right edge and bringing them closer left or right alternatively (you should start with bringing left). Study the sample tests carefully to understand the output format better.
Examples
Input
This is
Codeforces
Beta
Round
5
Output
************
* This is *
* *
*Codeforces*
* Beta *
* Round *
* 5 *
************
Input
welcome to the
Codeforces
Beta
Round 5
and
good luck
Output
****************
*welcome to the*
* Codeforces *
* Beta *
* Round 5 *
* *
* and *
* good luck *
****************
Submitted Solution:
```
name = []
maxi = 0
try:
while 1:
p = input()
name.append(p)
if len(p) > maxi:
maxi = len(p)
except EOFError:
print("*"*(maxi+2))
for i in name:
print("*"+ i.center(maxi," ")+"*")
print("*"*(maxi+2))
```
No
| 2,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Tags: dp, matrices
Correct Solution:
```
f = lambda: map(int, input().split())
m = 1000000007
n, b, k, x = f()
s = [0] * x
for q in f(): s[q % x] += 1
def g(t, d):
if not t: return s
p = [0] * x
for i, a in enumerate(t):
for j, b in enumerate(s):
p[(i + d * j) % x] += a * b
return [q % m for q in p]
t = []
u, v = 1, 10
while b:
if b & 1:
t = g(t, u)
u = v * u % x
s = g(s, v)
v = v * v % x
b >>= 1
print(t[k])
```
| 2,920 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Tags: dp, matrices
Correct Solution:
```
f = lambda: map(int, input().split())
m = 1000000007
n, b, k, x = f()
s = [0] * x
for q in f(): s[q % x] += 1
def g(t, d):
p = [0] * x
for i, a in enumerate(t):
for j, b in enumerate(s):
p[(i + d * j) % x] += a * b
return [q % m for q in p]
t = []
u, v = 1, 10
while b:
if b & 1:
t = g(t, u) if t else s
u = v * u % x
s = g(s, v)
v = v * v % x
b >>= 1
print(t[k])
```
| 2,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Tags: dp, matrices
Correct Solution:
```
n,b,k,x=map(int,input().split())
arr=list(map(int,input().split()))
flg=[0]*x
mod = 10**9+7
for i in arr:
flg[i%x]+=1
def mul(dp,flg,rank):
global x
res=[0]*x
for i in range(x):
for j in range(x):
res[ ( (i*rank)%x+j)%x ] += dp[i]*flg[j]%mod
res[ ( (i*rank)%x+j)%x ] %= mod
# print(i,j,dp[i],dp[j],res[ ( (i*rank)%x+j)%x ])
return res
def pow(n):
global x
res=1
base=10
while n:
if n&1:
res=(res*base)%x
base=(base*base)%x
n>>=1
return res
dp=[0]*x
dp[0]=1
# print(mul(dp,flg,1))
rank=1
while b:
if b&1:
dp=mul(dp,flg,pow(rank))
flg=mul(flg,flg,pow(rank))
rank<<=1
b>>=1
print(dp[k])
```
| 2,922 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Tags: dp, matrices
Correct Solution:
```
p = 10 ** 9 + 7
n, b, k, x = [int(s) for s in input().split()]
block = [int(s) for s in input().split()]
D = [0 for i in range(10)]
for s in block:
D[s] += 1
A = [[0 for t in range(x)]]
pows = [pow(10, 1<<j, x) for j in range(b.bit_length())]
for i in range(10):
A[0][i%x] += D[i]
for j in range(b.bit_length()-1):
B = A[-1]
C = [sum(B[i]*B[(t - i*pows[j])%x] for i in range(x)) % p for t in range(x)]
A.append(C)
ans = None
for j in range(b.bit_length()):
if (b>>j)&1:
if ans is None:
ans = A[j][:]
else:
ans = [sum(A[j][(t - i*pows[j])%x]*ans[i] for i in range(x)) % p for t in range(x)]
print(ans[k])
```
| 2,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Tags: dp, matrices
Correct Solution:
```
R = lambda : map(int, input().split())
n,b,k,x = R()
v = list(R())
mod = 10**9+7
arr_0 = [0]*x
for bd in v:
arr_0[bd%x]+=1
def cross(arr1,arr2,x,mod):
arr = [0]*len(arr1)
for i in range(len(arr1)):
for j in range(len(arr2)):
arr[(i+j)%x] += arr1[i]*arr2[j]
for i in range(len(arr)):
arr[i] %= mod
return arr
def move(arr,s,x):
m = pow(10,s,x)
res = [0]*x
for i in range(x):
res[(i*m)%x]+=arr[i]
return res
def solve(b,x,arr_0,mod):
if b==1:
return arr_0
if b%2==1:
sol = solve(b-1,x,arr_0,mod)
return cross(move(sol,1,x),arr_0,x,mod)
else:
sol = solve(b//2,x,arr_0,mod)
return cross(move(sol,b//2,x),sol,x,mod)
sol = solve(b,x,arr_0,mod)
print(sol[k])
```
| 2,924 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Tags: dp, matrices
Correct Solution:
```
import os
from io import BytesIO
#input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def main():
mod = 10**9 + 7
n,b,k,x = map(int,input().split())
x2 = x + 1
ai = list(map(int,input().split()))
ai2 = [0]*x2
for i in range(n):
ai2[ai[i] % x] += 1
ai2[-1] = 1
def power2(number, n, m):
res = 1
while(n):
if n & 1:
res *= number
res %= m
number *= number
number %= m
n >>= 1
return res
def mult(m1,m2):
ans = [0] * x2
for i in range(x):
for j in range(x):
temp = (i*power2(10,m2[-1],x)+j) % x
ans[temp] += m1[i] * m2[j]
ans[temp] %= mod
ans[-1] = m1[-1] + m2[-1]
return ans
def power(number, n):
res = number
while(n):
if n & 1:
res = mult(res,number)
number = mult(number,number)
n >>= 1
return res
ansm = power(ai2,b-1)
print(ansm[k])
main()
```
| 2,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Tags: dp, matrices
Correct Solution:
```
def g(b,w):
if(b,w)in x:return x[(b,w)]
x[(b,w)]=sum(c[i]for i in r(len(c))if i%m==w)if b==1else sum(g(b//2,l)*g(b-b//2,(w-(l*pow(10,b-b//2,m))%m+m)%m)for l in r(m))%(10**9+7)
return x[(b,w)]
q,r,k=input,range,'map(int,q().split())'
n,b,w,m=eval(k)
a,x=list(eval(k)),{}
c=[a.count(i)for i in r(10)]
print(g(b,w))
```
| 2,926 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Tags: dp, matrices
Correct Solution:
```
def g(b,w):
if(b,w)in x:return x[(b,w)]
x[(b,w)]=sum(c[i]for i in r(len(c))if i%m==w)if b==1else sum(g(b//2,l)*g(b-b//2,(w-(l*pow(10,b-b//2,m))%m+m)%m)for l in r(m))%(10**9+7)
return x[(b,w)]
q,r,k,t=input,range,'map(int,q().split())',eval
n,b,w,m=t(k)
a,x=list(t(k)),{}
c=[a.count(i)for i in r(10)]
print(g(b,w))
```
| 2,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
def g(b,w):
if(b,w)in x:return x[(b,w)]
x[(b,w)]=sum(c[i]for i in r(len(c))if i%m==w)if b==1else sum(g(b//2,l)*g(b-b//2,(w-(l*pow(10,b-b//2,m))%m+m)%m)for l in r(m))%(10**9+7)
return x[(b,w)]
q,r=input,range
n,b,w,m=map(int,q().split())
a,x=list(map(int,q().split())),{}
c=[a.count(i)for i in r(10)]
print(g(b,w))
```
Yes
| 2,928 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
import os
from io import BytesIO
#input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def main():
mod = 10**9 + 7
n,b,k,x = map(int,input().split())
x2 = x + 1
ai = list(map(int,input().split()))
ai2 = [0]*x2
for i in range(n):
ai2[ai[i] % x] += 1
ai2[-1] = 1
def mult(m1,m2):
ans = [0] * x2
for i in range(x):
for j in range(x):
temp = (i*m2[-1]*10+j) % x
ans[temp] += m1[i] * m2[j]
ans[temp] %= mod
ans[-1] = (m1[-1] + m2[-1]) % x
return ans
def power(number, n):
res = number
while(n):
if n & 1:
res = mult(res,number)
number = mult(number,number)
n >>= 1
return res
ansm = power(ai2,b-1)
print(ansm[k])
main()
```
No
| 2,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
import os
from io import BytesIO
#input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def main():
mod = 10**9 + 7
n,b,k,x = map(int,input().split())
ai = list(map(int,input().split()))
ai2 = [0]*x
for i in range(n):
ai2[ai[i] % x] += 1
def mult(m1,m2):
ans = [0] * x
for i in range(x):
for j in range(x):
temp = (i*10+j) % x
ans[temp] += m1[i] * m2[j]
ans[temp] %= mod
return ans
def power(number, n):
res = number
while(n):
if n & 1:
res = mult(res,number)
number = mult(number,number)
n >>= 1
return res
ansm = power(ai2,b-1)
print(ansm[k])
main()
```
No
| 2,930 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
n,b,k,x=map(int,input().split())
arr=list(map(int,input().split()))
flg=[0]*x
mod = 10**9+7
for i in arr:
flg[i%x]+=1
def mul(dp,flg,rank):
global x
res=[0]*x
for i in range(x):
for j in range(x):
res[ ( (i*rank)%x+j)%x ] += dp[i]*flg[j]%mod
res[ ( (i*rank)%x+j)%x ] %= mod
# print(i,j,dp[i],dp[j],res[ ( (i*rank)%x+j)%x ])
return res
def pow(n):
global x
res=1
base=10
while n:
if n&1:
res=(res*base)%x
base=(base*base)%x
n>>=1
return res
dp=[0]*x
dp[0]=1
# print(mul(dp,flg,1))
rank=1
while b:
if b&1:
dp=mul(dp,flg,pow(rank-1))
rank<<=1
flg=mul(flg,flg,pow(rank-1))
b>>=1
print(dp[k])
```
No
| 2,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12.
Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.
Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.
Input
The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.
The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.
Output
Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.
Examples
Input
12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5
Output
3
Input
3 2 1 2
6 2 2
Output
0
Input
3 2 1 2
3 1 2
Output
6
Note
In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.
In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.
Submitted Solution:
```
import math
p = 10 ** 9 + 7
n, b, k, x = [int(s) for s in input().split()]
block = [int(s) for s in input().split()]
D = [0 for i in range(10)]
for s in block:
D[s] += 1
A = [[0 for t in range(x)]]
for i in range(10):
A[0][i%x] += D[i]
for j in range(b.bit_length()):
B = A[-1]
C = [sum(B[i]*B[(t-i)%x] for i in range(x)) % p for t in range(x)]
A.append(C)
ans = None
for j in range(b.bit_length()):
if (b>>j)&1:
if ans is None:
ans = A[j]
else:
ans = [sum(A[j][i]*ans[(t-i)%x] for i in range(x)) % p for t in range(x)]
print(ans[k])
```
No
| 2,932 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Radewoosh is playing a computer game. There are n levels, numbered 1 through n. Levels are divided into k regions (groups). Each region contains some positive number of consecutive levels.
The game repeats the the following process:
1. If all regions are beaten then the game ends immediately. Otherwise, the system finds the first region with at least one non-beaten level. Let X denote this region.
2. The system creates an empty bag for tokens. Each token will represent one level and there may be many tokens representing the same level.
* For each already beaten level i in the region X, the system adds ti tokens to the bag (tokens representing the i-th level).
* Let j denote the first non-beaten level in the region X. The system adds tj tokens to the bag.
3. Finally, the system takes a uniformly random token from the bag and a player starts the level represented by the token. A player spends one hour and beats the level, even if he has already beaten it in the past.
Given n, k and values t1, t2, ..., tn, your task is to split levels into regions. Each level must belong to exactly one region, and each region must contain non-empty consecutive set of levels. What is the minimum possible expected number of hours required to finish the game?
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 200 000, 1 ≤ k ≤ min(50, n)) — the number of levels and the number of regions, respectively.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 100 000).
Output
Print one real number — the minimum possible expected value of the number of hours spent to finish the game if levels are distributed between regions in the optimal way. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4 2
100 3 5 7
Output
5.7428571429
Input
6 2
1 2 4 8 16 32
Output
8.5000000000
Note
In the first sample, we are supposed to split 4 levels into 2 regions. It's optimal to create the first region with only one level (it must be the first level). Then, the second region must contain other three levels.
In the second sample, it's optimal to split levels into two regions with 3 levels each.
Submitted Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
n,k = map(int,sys.stdin.readline().split())
T = list(map(int,sys.stdin.readline().split()))
def split(l,r):
min_rl = 100000.0
min_rr = 100000.0
min_pos = -1
for k in range(l+1,r):
left = 0.0
s = 0.0
for i in range(l,k):
s += T[i]
left += s / T[i]
right = 0.0
s = 0.0
for i in range(k,r):
s += T[i]
right += s / T[i]
if min_rl + min_rr > left + right or min_pos == -1:
min_rl = left
min_rr = right
min_pos = k
return min_rl, min_rr, min_pos
d = {(0,n): n}
while len(d) != k:
(l,r) = max(d.items(), key = lambda e: e[1])[0]
min_rl, min_rr, min_pos = split(l,r)
del d[(l,r)]
d[(l,min_pos)] = min_rl
d[(min_pos,r)] = min_rr
print(sum(d.values()))
```
No
| 2,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Radewoosh is playing a computer game. There are n levels, numbered 1 through n. Levels are divided into k regions (groups). Each region contains some positive number of consecutive levels.
The game repeats the the following process:
1. If all regions are beaten then the game ends immediately. Otherwise, the system finds the first region with at least one non-beaten level. Let X denote this region.
2. The system creates an empty bag for tokens. Each token will represent one level and there may be many tokens representing the same level.
* For each already beaten level i in the region X, the system adds ti tokens to the bag (tokens representing the i-th level).
* Let j denote the first non-beaten level in the region X. The system adds tj tokens to the bag.
3. Finally, the system takes a uniformly random token from the bag and a player starts the level represented by the token. A player spends one hour and beats the level, even if he has already beaten it in the past.
Given n, k and values t1, t2, ..., tn, your task is to split levels into regions. Each level must belong to exactly one region, and each region must contain non-empty consecutive set of levels. What is the minimum possible expected number of hours required to finish the game?
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 200 000, 1 ≤ k ≤ min(50, n)) — the number of levels and the number of regions, respectively.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 100 000).
Output
Print one real number — the minimum possible expected value of the number of hours spent to finish the game if levels are distributed between regions in the optimal way. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4 2
100 3 5 7
Output
5.7428571429
Input
6 2
1 2 4 8 16 32
Output
8.5000000000
Note
In the first sample, we are supposed to split 4 levels into 2 regions. It's optimal to create the first region with only one level (it must be the first level). Then, the second region must contain other three levels.
In the second sample, it's optimal to split levels into two regions with 3 levels each.
Submitted Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
n,k = map(int,sys.stdin.readline().split())
T = list(map(int,sys.stdin.readline().split()))
def split(l,r):
min_rl = 100000.0
min_rr = 100000.0
min_pos = -1
for k in range(l+1,r):
left = 0.0
s = 0.0
for i in range(l,k):
s += T[i]
left += s / T[i]
right = 0.0
s = 0.0
for i in range(k,r):
s += T[i]
right += s / T[i]
if min_rl + min_rr > left + right or min_pos == -1:
min_rl = left
min_rr = right
min_pos = k
return min_rl, min_rr, min_pos
d = {(0,n): n}
while len(d) != k:
(l,r) = min(d.items(), key = lambda e: e[1])[0]
min_rl, min_rr, min_pos = split(l,r)
del d[(l,r)]
d[(l,min_pos)] = min_rl
d[(min_pos,r)] = min_rr
print(sum(d.values()))
```
No
| 2,934 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Radewoosh is playing a computer game. There are n levels, numbered 1 through n. Levels are divided into k regions (groups). Each region contains some positive number of consecutive levels.
The game repeats the the following process:
1. If all regions are beaten then the game ends immediately. Otherwise, the system finds the first region with at least one non-beaten level. Let X denote this region.
2. The system creates an empty bag for tokens. Each token will represent one level and there may be many tokens representing the same level.
* For each already beaten level i in the region X, the system adds ti tokens to the bag (tokens representing the i-th level).
* Let j denote the first non-beaten level in the region X. The system adds tj tokens to the bag.
3. Finally, the system takes a uniformly random token from the bag and a player starts the level represented by the token. A player spends one hour and beats the level, even if he has already beaten it in the past.
Given n, k and values t1, t2, ..., tn, your task is to split levels into regions. Each level must belong to exactly one region, and each region must contain non-empty consecutive set of levels. What is the minimum possible expected number of hours required to finish the game?
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 200 000, 1 ≤ k ≤ min(50, n)) — the number of levels and the number of regions, respectively.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 100 000).
Output
Print one real number — the minimum possible expected value of the number of hours spent to finish the game if levels are distributed between regions in the optimal way. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4 2
100 3 5 7
Output
5.7428571429
Input
6 2
1 2 4 8 16 32
Output
8.5000000000
Note
In the first sample, we are supposed to split 4 levels into 2 regions. It's optimal to create the first region with only one level (it must be the first level). Then, the second region must contain other three levels.
In the second sample, it's optimal to split levels into two regions with 3 levels each.
Submitted Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
n,k = map(int,sys.stdin.readline().split())
T = list(map(int,sys.stdin.readline().split()))
def price(l,r):
price = 0.0
s = 0.0
for i in range(l,r):
s += T[i]
price += s / T[i]
return price
def split(l,r):
min_rl = 100000.0
min_rr = 100000.0
min_pos = -1
for k in range(l+1,r):
left = price(l,k)
right = price(k,r)
if min_rl + min_rr > left + right or min_pos == -1:
min_rl = left
min_rr = right
min_pos = k
return min_rl, min_rr, min_pos
d = {(0,n): price(0,n)}
while len(d) != k:
(l,r) = max(d.items(), key = lambda e: e[1])[0]
min_rl, min_rr, min_pos = split(l,r)
del d[(l,r)]
d[(l,min_pos)] = min_rl
d[(min_pos,r)] = min_rr
print(sum(d.values()))
```
No
| 2,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Tags: implementation, sortings
Correct Solution:
```
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
# from __future__ import print_function # for PyPy2
from collections import Counter, OrderedDict
from itertools import permutations as perm
from fractions import Fraction
from collections import deque
from sys import stdin
from bisect import *
from heapq import *
# from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1e9)+7
inf = float("inf")
n, = gil()
s = Counter(gil())
m, = gil()
a, t = gil(), gil()
mo = [(s.get(a[i], 0), s.get(t[i], 0), i+1) for i in range(m)]
print(max(mo)[-1])
```
| 2,936 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Tags: implementation, sortings
Correct Solution:
```
"""
Codeforces Round #334 (Div. 2)
Problem 670 C. Cinema
@author yamaton
@date 2015-05-05
"""
import itertools as it
import functools
import operator
import collections
import math
import sys
def solve(n, m, xs, ys, zs):
cnt = collections.Counter(xs)
result = max((cnt[y], cnt[z], -i) for i, (y, z) in enumerate(zip(ys, zs), 1))
pp('result:', result)
_, _, neg = result
return (-neg)
def pp(*args, **kwargs):
return print(*args, file=sys.stderr, **kwargs)
def main():
n = int(input().strip())
xs = [int(i) for i in input().strip().split()]
m = int(input().strip())
ys = [int(i) for i in input().strip().split()]
zs = [int(i) for i in input().strip().split()]
assert len(xs) == n
assert len(ys) == len(zs) == m
result = solve(n, m, xs, ys, zs)
print(result)
if __name__ == '__main__':
main()
```
| 2,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
langs = list(map(int, input().split()))
#langs = input()
m = int(input())
aud = list(map(int, input().split()))
sub = list(map(int, input().split()))
res=[]
d={}
for i in langs:
if i in d:
d[i]+=1
else:
d[i] = 1
for i in range(m):
x = 0
y = 0
if aud[i] in d:
x = d[aud[i]]
if sub[i] in d:
y = d[sub[i]]
res.append((x,y,i+1))
print(max(res)[2])
```
| 2,938 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
languages = {}
s = input().split()
for i in s:
if i in languages:
languages[i] += 1
else:
languages[i] = 1
m = int(input())
audio = input().split()
subtitles = input().split()
bestm = 1
besta = 0
bests = 0
for i in range(m):
ad = audio[i]
sb = subtitles[i]
ac = 0
if ad in languages:
ac = languages[ad]
sc = 0
if sb in languages:
sc = languages[sb]
if ac > besta or ac == besta and sc > bests:
bestm = i + 1
besta = ac
bests = sc
print(bestm)
```
| 2,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Tags: implementation, sortings
Correct Solution:
```
def main():
from collections import Counter
input()
aa = Counter(map(int, input().split()))
m = int(input())
bb = list(map(aa.__getitem__, map(int, input().split())))
cc = list(map(aa.__getitem__, map(int, input().split())))
print(max(range(m), key=lambda i: (bb[i], cc[i])) + 1)
if __name__ == '__main__':
main()
```
| 2,940 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Tags: implementation, sortings
Correct Solution:
```
from collections import defaultdict
n = int(input())
a = list(map(int, input().split()))
nF = int(input())
lang = list(map(int, input().split()))
sub = list(map(int, input().split()))
cnt = defaultdict(int)
for v in a:
cnt[v] += 1
print(max(range(nF), key=lambda x: (cnt[lang[x]], cnt[sub[x]])) + 1)
```
| 2,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Tags: implementation, sortings
Correct Solution:
```
def main():
n = int(input())
a = list(map(int, input().split()))
L = {}
for language in a:
if language not in L:
L[language] = 1
else:
L[language] += 1
m = int(input())
audio = list(map(int, input().split()))
subs = list(map(int, input().split()))
satisfaction = [(0, 0)] * m
for i in range(m):
satisfaction[i] = (L.get(audio[i], 0), L.get(subs[i], 0))
print(satisfaction.index(max(satisfaction)) + 1)
if __name__ == '__main__':
main()
```
| 2,942 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
lang_cnt = {}
for lang in input().split():
if lang not in lang_cnt:
lang_cnt[lang] = 0
lang_cnt[lang] += 1
m = int(input())
best_vp_cnt = -1
best_as_cnt = -1
best_movie = 0
audio = input().split()
subtitles = input().split()
for i in range(1, m + 1):
vp_cnt = lang_cnt.get(audio[i - 1], 0)
as_cnt = lang_cnt.get(subtitles[i - 1], 0)
if vp_cnt > best_vp_cnt:
best_vp_cnt = vp_cnt
best_as_cnt = as_cnt
best_movie = i
elif vp_cnt == best_vp_cnt and as_cnt > best_as_cnt:
best_vp_cnt = vp_cnt
best_as_cnt = as_cnt
best_movie = i
print(best_movie)
```
| 2,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Submitted Solution:
```
parse_int = lambda: list(map(int, input().split()))
scientists = int(input())
sc_langs = parse_int()
films = int(input())
film_voice = parse_int()
film_sub = parse_int()
#print(film_voice)
#print(film_sub)
#ppl_in_lang = [0]*(10**9+5)
lang_decoder = dict()
lang_decoder.setdefault(0)
for _ in sc_langs:
if _ in lang_decoder.keys():
lang_decoder[_]+=1
else:
lang_decoder[_]=1
#print( lang_decoder)
film_good, film_ok = [0]*films, [0]*films
for _ in range(films):
try:
film_good[_] += (lang_decoder[film_voice[_]] or 0)
except KeyError:
pass
try:
film_ok[_] += (lang_decoder[film_sub[_] ] or 0)
except KeyError:
pass
best = 0
for _ in range(films):
if film_good[_] > film_good[best]: best = _
if (film_good[_] == film_good[best]) \
and (film_ok[_] > film_ok[best]): best = _
#print(film_good)
#print(film_ok)
print(best+1)
```
Yes
| 2,944 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Submitted Solution:
```
from collections import *
n=int(input())
d=Counter(map(int,input().split()))
m=int(input())
print(sorted((d[int(l[0])],d[int(l[1])],z+1)for z,l in enumerate(zip(input().split(),input().split())))[-1][2])
```
Yes
| 2,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Submitted Solution:
```
import traceback
import os
import sys
from io import BytesIO, IOBase
import math
from collections import defaultdict, Counter
from functools import lru_cache
from itertools import accumulate
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def geti():
return int(input())
def gets():
return input()
def getil():
return list(map(int, input().split()))
def getsl():
return input().split()
def get2d(nrows, ncols, n=0):
return [[n] * ncols for r in range(nrows)]
def get_acc(a):
return list(accumulate(a))
def get_ncr(n, r):
if n < r: return 0
return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def get_npr(n, r):
if n < r: return 0
return math.factorial(n) // math.factorial(r)
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
inf = float('inf')
mod = 10 ** 9 + 7
def main():
N = geti()
a = getil()
M = geti()
b = getil()
c = getil()
d = Counter(a)
p = max(range(M), key=lambda x: (d[b[x]], d[c[x]]))
return p+1
try:
ans = main()
print(ans)
except Exception as e:
print(e)
traceback.print_exc()
```
Yes
| 2,946 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Submitted Solution:
```
n = int(input())
a = [int(i) for i in input().split(' ')]
m = int(input())
b = [int(i) for i in input().split(' ')]
c = [int(i) for i in input().split(' ')]
d = {}
for i in range(n):
if a[i] not in d:
d[a[i]] = 1
else:
d[a[i]]+=1
p = [(d[b[i]] if b[i] in d else 0, d[c[i]] if c[i] in d else 0) for i in range(m)]
ans = 0
for i in range(1, m):
if p[ans]<p[i]:
ans = i
print(ans+1)
```
Yes
| 2,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Submitted Solution:
```
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
freq = Counter(a)
m = int(input())
b = list(map(int, input().split()))
c = list(map(int, input().split()))
best_index = 0
best_score = (0, 0)
for i in range(m):
vs = freq[b[i]]
als = freq[c[i]]
if vs > best_score[0] or (vs == best_score[0] and als > best_score[1]):
best_index = i + 1
best_score = (vs, als)
print(best_index)
```
No
| 2,948 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Submitted Solution:
```
import bisect
from collections import defaultdict,Counter
import math
def solve(a,m,s):
mp=Counter(a)
pos=set()
Max=-1
for i in range(len(m)):
if m[i] in mp and mp[m[i]]>Max:
Max=mp[m[i]]
pos={i}
elif m[i] in mp and mp[m[i]]==Max:
pos.add(i)
else:
continue
if len(pos)==1:
for i in pos:
return (i+1)
Max=-1
for i in pos:
if mp[s[i]]>Max:
Max=mp[s[i]]
ans=i
if Max==-1:
for i in pos:
return (i+1)
return (ans+1)
```
No
| 2,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Submitted Solution:
```
from collections import defaultdict,Counter
import math
def solve(a,m,s):
mp=Counter(a)
pos=set()
Max=-1
for i in range(len(m)):
if m[i] in mp and mp[m[i]]>Max:
Max=mp[m[i]]
pos={i}
elif m[i] in mp and mp[m[i]]==Max:
pos.add(i)
else:
continue
if len(pos)==1:
for i in pos:
return m[i]
Max=-1
for i in pos:
if mp[s[i]]>Max:
Max=mp[s[i]]
ans=i
return m[ans]
n=int(input(''))
a=list(map(int,input('').split()))
_=int(input(''))
m=list(map(int,input('').split()))
s=list(map(int,input('').split()))
print(solve(a,m,s))
```
No
| 2,950 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Moscow is hosting a major international conference, which is attended by n scientists from different countries. Each of the scientists knows exactly one language. For convenience, we enumerate all languages of the world with integers from 1 to 109.
In the evening after the conference, all n scientists decided to go to the cinema. There are m movies in the cinema they came to. Each of the movies is characterized by two distinct numbers — the index of audio language and the index of subtitles language. The scientist, who came to the movie, will be very pleased if he knows the audio language of the movie, will be almost satisfied if he knows the language of subtitles and will be not satisfied if he does not know neither one nor the other (note that the audio language and the subtitles language for each movie are always different).
Scientists decided to go together to the same movie. You have to help them choose the movie, such that the number of very pleased scientists is maximum possible. If there are several such movies, select among them one that will maximize the number of almost satisfied scientists.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 200 000) — the number of scientists.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the index of a language, which the i-th scientist knows.
The third line contains a positive integer m (1 ≤ m ≤ 200 000) — the number of movies in the cinema.
The fourth line contains m positive integers b1, b2, ..., bm (1 ≤ bj ≤ 109), where bj is the index of the audio language of the j-th movie.
The fifth line contains m positive integers c1, c2, ..., cm (1 ≤ cj ≤ 109), where cj is the index of subtitles language of the j-th movie.
It is guaranteed that audio languages and subtitles language are different for each movie, that is bj ≠ cj.
Output
Print the single integer — the index of a movie to which scientists should go. After viewing this movie the number of very pleased scientists should be maximum possible. If in the cinema there are several such movies, you need to choose among them one, after viewing which there will be the maximum possible number of almost satisfied scientists.
If there are several possible answers print any of them.
Examples
Input
3
2 3 2
2
3 2
2 3
Output
2
Input
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
Output
1
Note
In the first sample, scientists must go to the movie with the index 2, as in such case the 1-th and the 3-rd scientists will be very pleased and the 2-nd scientist will be almost satisfied.
In the second test case scientists can go either to the movie with the index 1 or the index 3. After viewing any of these movies exactly two scientists will be very pleased and all the others will be not satisfied.
Submitted Solution:
```
n = int(input())
scientists = list(map(int, input().split()))
m = int(input())
voice = list(map(int, input().split()))
sub = list(map(int, input().split()))
freq = {scientists[i]: scientists.count(scientists[i]) for i in range(n)}
# print("Freq:", freq)
pop_lan = max(freq, key=freq.get)
# print("Popular lan:", pop_lan)
most_times = freq[pop_lan]
pop_lans = []
for key in freq:
if freq[key] == most_times:
pop_lans.append(key)
# print(pop_lans)
cool_films = []
for i in range(m):
if voice[i] in pop_lans:
cool_films.append(i)
# print(cool_films)
if len(cool_films) == 1:
print(cool_films[0]+1) # 1-based index
elif len(cool_films) == 0:
print(1)
else:
# print("Cool:", cool_films)
almost_cool = {ind: scientists.count(sub[ind]) for ind in cool_films}
# print("Almost", almost_cool)
print(max(almost_cool, key=almost_cool.get)+1)
"""
6
6 3 1 1 3 7
5
1 2 3 4 5
2 3 4 5 1
1 или 3
3
2 3 2
2
3 2
2 3
2
3
2 3 2
3
3 2 2
2 3 1
2
"""
```
No
| 2,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n integers a1, a2, ..., an.
A sequence of integers x1, x2, ..., xk is called a "xor-sequence" if for every 1 ≤ i ≤ k - 1 the number of ones in the binary representation of the number xi <image> xi + 1's is a multiple of 3 and <image> for all 1 ≤ i ≤ k. The symbol <image> is used for the binary exclusive or operation.
How many "xor-sequences" of length k exist? Output the answer modulo 109 + 7.
Note if a = [1, 1] and k = 1 then the answer is 2, because you should consider the ones from a as different.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1018) — the number of given integers and the length of the "xor-sequences".
The second line contains n integers ai (0 ≤ ai ≤ 1018).
Output
Print the only integer c — the number of "xor-sequences" of length k modulo 109 + 7.
Examples
Input
5 2
15 1 2 4 8
Output
13
Input
5 1
15 1 2 4 8
Output
5
Submitted Solution:
```
from itertools import combinations
n , k =map(int,input().split())
l = list(map(int,input().split()))
sol = 0
if k==1:
print(n)
exit(0)
for comb in combinations(l,k):
#print(comb)
sol+=1
for j in range(len(comb)-1):
#print("str(seq[j]^seq[j+1]) ",str(bin(comb[j]^comb[j+1])))
if str(bin(comb[j]^comb[j+1])).count("1") % 3 == 0:
sol+=1
print(sol-1)
```
No
| 2,952 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n integers a1, a2, ..., an.
A sequence of integers x1, x2, ..., xk is called a "xor-sequence" if for every 1 ≤ i ≤ k - 1 the number of ones in the binary representation of the number xi <image> xi + 1's is a multiple of 3 and <image> for all 1 ≤ i ≤ k. The symbol <image> is used for the binary exclusive or operation.
How many "xor-sequences" of length k exist? Output the answer modulo 109 + 7.
Note if a = [1, 1] and k = 1 then the answer is 2, because you should consider the ones from a as different.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1018) — the number of given integers and the length of the "xor-sequences".
The second line contains n integers ai (0 ≤ ai ≤ 1018).
Output
Print the only integer c — the number of "xor-sequences" of length k modulo 109 + 7.
Examples
Input
5 2
15 1 2 4 8
Output
13
Input
5 1
15 1 2 4 8
Output
5
Submitted Solution:
```
from itertools import combinations
n , k =map(int,input().split())
l = list(map(int,input().split()))
sol = 0
if k==1:
print(n)
exit(0)
for comb in combinations(l,k):
print(comb)
sol+=1
for j in range(len(comb)-1):
print("str(seq[j]^seq[j+1]) ",str(bin(comb[j]^comb[j+1])))
if str(bin(comb[j]^comb[j+1])).count("1") % 3 == 0:
sol+=1
print(sol-1)
```
No
| 2,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n integers a1, a2, ..., an.
A sequence of integers x1, x2, ..., xk is called a "xor-sequence" if for every 1 ≤ i ≤ k - 1 the number of ones in the binary representation of the number xi <image> xi + 1's is a multiple of 3 and <image> for all 1 ≤ i ≤ k. The symbol <image> is used for the binary exclusive or operation.
How many "xor-sequences" of length k exist? Output the answer modulo 109 + 7.
Note if a = [1, 1] and k = 1 then the answer is 2, because you should consider the ones from a as different.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1018) — the number of given integers and the length of the "xor-sequences".
The second line contains n integers ai (0 ≤ ai ≤ 1018).
Output
Print the only integer c — the number of "xor-sequences" of length k modulo 109 + 7.
Examples
Input
5 2
15 1 2 4 8
Output
13
Input
5 1
15 1 2 4 8
Output
5
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = list(set(a))
n = len(a)
q = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
for j in range(n):
if divmod(bin(a[i] ^ a[j]).count("1"), 3)[1] == 0:
q[i][j] = 1
res = [[0 for i in range(n)] for j in range(n)]
tmp = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
res[i][i] = 1
k -= 1
while k > 0:
if k % 2 == 1:
for i in range(n):
for j in range(n):
tmp[i][j] = 0
for i in range(n):
for j in range(n):
for z in range(n):
tmp[i][j] = divmod(tmp[i][j] + res[i][z] * q[z][j], 1000000007)[1]
for i in range(n):
for j in range(n):
res[i][j] = tmp[i][j]
for i in range(n):
for j in range(n):
tmp[i][j] = 0
for i in range(n):
for j in range(n):
for z in range(n):
tmp[i][j] = divmod(tmp[i][j] + q[i][z] * q[z][j], 1000000007)[1]
for i in range(n):
for j in range(n):
q[i][j] = tmp[i][j]
k = divmod(k, 2)[0]
ans = 0
for i in range(n):
for j in range(n):
ans += res[i][j]
print(divmod(ans, 1000000007)[1])
```
No
| 2,954 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n integers a1, a2, ..., an.
A sequence of integers x1, x2, ..., xk is called a "xor-sequence" if for every 1 ≤ i ≤ k - 1 the number of ones in the binary representation of the number xi <image> xi + 1's is a multiple of 3 and <image> for all 1 ≤ i ≤ k. The symbol <image> is used for the binary exclusive or operation.
How many "xor-sequences" of length k exist? Output the answer modulo 109 + 7.
Note if a = [1, 1] and k = 1 then the answer is 2, because you should consider the ones from a as different.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1018) — the number of given integers and the length of the "xor-sequences".
The second line contains n integers ai (0 ≤ ai ≤ 1018).
Output
Print the only integer c — the number of "xor-sequences" of length k modulo 109 + 7.
Examples
Input
5 2
15 1 2 4 8
Output
13
Input
5 1
15 1 2 4 8
Output
5
Submitted Solution:
```
MOD = (10**9) + 7
def mulmat(A, B):
n = len(A)
C = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
for j in range(n):
for k in range(n):
C[i][j] += A[i][k] * B[k][j]
C[i][j] %= MOD
return C
n, k = [int(x) for x in input().split()]
L = [int(x) for x in input().split()]
adjm = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
adjm[i][i] = 1
for j in range(n):
a = L[i]
b = L[j]
c = a^b
cnt = 0
while c:
cnt += 1
c = c ^ (c & -c)
if cnt%3 == 0:
adjm[i][j] = 1
k -= 1
I = [[1 if i==j else 0 for i in range(n)] for j in range(n)]
while k:
if k&1:
I = mulmat(I, adjm)
k >>= 1
adjm = mulmat(adjm, adjm)
print(sum([sum(x) for x in I]))
```
No
| 2,955 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n, s, b, k = map(int, input().split())
a = list('1' + input() + '1')
ans = []
cnt = 0
for i in range(len(a)):
if a[i] == '0':
cnt += 1
else:
cnt = 0
if cnt == b:
if s > 1:
s -= 1
else:
ans.append(i)
cnt = 0
print(len(ans))
for i in range(len(ans)):
print(ans[i], end=' ')
```
| 2,956 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Tags: constructive algorithms, greedy, math
Correct Solution:
```
'''input
5 4 1 0
00000
'''
from sys import stdin
import collections
import math
def get_working(string):
aux = []
first = None
if string[0] == 1:
pass
else:
first = -1
for i in range(len(string)):
if string[i] == '1':
if first == None:
first = i
elif first != None:
aux.append([first, i, (i - first - 1)])
first = i
if first != None:
aux.append([first, len(string), (len(string) - first) - 1])
return aux
# main starts
n, a, b, k = list(map(int, stdin.readline().split()))
string = list(stdin.readline().strip())
ans = 0
working = get_working(string)
# print(working)
current = a
flag = 0
for i in working:
if flag == 1:
break
start, end, gap = i
j = end - 1
if gap//b > 0:
while j > start:
if current == 0:
flag = 1
break
if (j - start)// b > 0:
for k in range(j, j - b, -1):
string[k] = '2'
j -= b
current -= 1
else:
break
ans = []
count = 0
for i in range(len(string)):
if string[i] == '0':
if i > 0 and string[i - 1] == '0':
count += 1
else:
count = 1
if count == b:
string[i] = 'b'
ans.append(i + 1)
count = 0
for i in range(len(string)):
if string[i] == '2':
ans.append(i + 1)
break
# print(string)
print(len(ans))
print(*ans)
# print(ans)
# for i in range(n):
# if string[i] == 'b':
# print(i + 1, end = ' ')
```
| 2,957 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Tags: constructive algorithms, greedy, math
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
n,a,b,k = Ri()
s = ri()
cnt = 0
totans = 0; ans = []
for i in range(len(s)):
if s[i] == '0':
cnt+=1
else:
cnt= 0
if cnt == b:
if a > 1:
a-=1
else:
ans.append(i+1)
totans+=1
cnt = 0
print(totans)
print(*ans)
```
| 2,958 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n,a,b,k=map(int,input().split())
A=input()
B=A.split('1')
C=[]
l=1
for i in B:
if len(i)>=b:
for j in range(b-1,len(i),b):
C.append(j+l)
l+=len(i)+1
C=C[:len(C)-a+1]
print(len(C))
print(' '.join(list(map(str,C))))
# Made By Mostafa_Khaled
```
| 2,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Tags: constructive algorithms, greedy, math
Correct Solution:
```
# Why do we fall ? So we can learn to pick ourselves up.
from itertools import groupby
n,a,b,k = map(int,input().split())
s = input()
sg = [list(g) for s,g in groupby(s)]
ll = 0
hits = []
for i in range(0,len(sg)):
if sg[i][0] == '0' and len(sg[i]) >= b:
for hit in range(b-1,len(sg[i]),b):
hits.append(hit+ll+1)
ll += len(sg[i])
else:
ll += len(sg[i])
# print(hits)
# We remove number of (ships-1) from the total number of hits because we are hitting at every possible location where
# where the ship can be placed and since we want to hit AT LEAST ONE SHIP, removing (ships-1) will still hit at least one ship
hits = hits[a-1:]
print(len(hits))
print(*hits)
"""
13 3 2 3
1000000010001
15 3 2 3
1000000000010001
"""
```
| 2,960 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n,a,b,k=[int(i) for i in input().split()]
s=input()
l=[]
i=0
j=0
while i<len(s):
if s[i]=="1":
j=0
else :
j+=1
if(j%b)==0:
l+=[i+1]
j=0
i+=1
l=l[a-1:]
print(len(l))
print(*l)
```
| 2,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Tags: constructive algorithms, greedy, math
Correct Solution:
```
"Codeforces Round #384 (Div. 2)"
"C. Vladik and fractions"
# y=int(input())
# a=y
# b=a+1
# c=y*b
# if y==1:
# print(-1)
# else:
# print(a,b,c)
"Technocup 2017 - Elimination Round 2"
"D. Sea Battle"
n,a,b,k=map(int,input().split())
s=list(input())
n=len(s)
lz=[]
zeros=[]
indexes=[]
flage=0
if s[0]=="0":
lz.append(0)
flage=1
for i in range(1,n):
if flage==1 and s[i]=="1":
zeros.append(i-1-(lz[-1])+1)
lz.append(i-1)
flage=0
elif flage==0 and s[i]=="0":
lz.append(i)
flage=1
if s[-1]=="0":
zeros.append(n-1-(lz[-1])+1)
lz.append(n-1)
min_no_spaces=(a-1)*b
spaces_left=n-k
l=len(lz)
# print(lz)
# print(zeros)
shotes=0
for i in range(len(zeros)):
h=i*2
if min_no_spaces!=0:
# print(min_no_spaces)
if min_no_spaces>=zeros[i]:
min_no_spaces-=(int(zeros[i]/b))*b
elif min_no_spaces<zeros[i]:
shotes+=int((zeros[i]-min_no_spaces)/b)
for j in range(int((zeros[i]-min_no_spaces)/b)):
indexes.append(lz[h]+((j+1)*b))
min_no_spaces=0
elif min_no_spaces==0:
# print(min_no_spaces)
shotes+=int(zeros[i]/b)
for j in range(int(zeros[i]/b)):
indexes.append(lz[h]+((j+1)*b))
print(shotes)
for i in indexes:
print(i," ",end="",sep="")
```
| 2,962 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Tags: constructive algorithms, greedy, math
Correct Solution:
```
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
#from __future__ import print_function, division #while using python2
# from itertools import accumulate
# from collections import defaultdict, Counter
def modinv(n,p):
return pow(n,p-2,p)
def main():
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
n, a, b, k = [int(x) for x in input().split()]
ip = input()
s = ip.split('1')
segments = []
indices = []
possible = 0
for x in s:
if len(x) > 0:
segments.append(len(x))
possible += (len(x) // b)
if ip[0] == '0':
indices.append(1)
for i in range(1, n):
if ip[i] == '0' and ip[i-1] == '1':
indices.append(i+1)
rem = k
ans = 0
shots = []
# print(segments)
# print(indices)
# print("total possible", possible)
for i in range(len(segments)):
ind = indices[i]
x = segments[i]
if possible - (x // b) >= a:
ans += (x // b)
possible -= (x // b)
j = ind + (b - 1)
for y in range(x//b):
shots.append(j)
j += b
else:
j = ind + (b-1)
while possible - a >= 0:
shots.append(j)
j += b
possible -= 1
ans += 1
print(ans)
print(*shots)
#------------------ Python 2 and 3 footer by Pajenegod and c1729-----------------------------------------
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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()
```
| 2,963 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Submitted Solution:
```
from collections import deque
n, a, b, k = map(int, input().split())
s = input()
start = False
cnt = 0
arr = []
idx = -1
for i in range(n):
if(s[i] == "0"):
if(start):
cnt += 1
else:
start = True
idx = i
cnt = 1
else:
if(start):
start = False
arr.append([cnt, idx])
cnt = 0
if(cnt):
arr.append([cnt, idx])
divides = deque([])
for i in range(len(arr)):
if(arr[i][0] % b == 0):
divides.append(arr[i])
else:
divides.appendleft(arr[i])
pos = 0
# print(divides)
while(a != 1):
if(divides[pos][0] >= b):
divides[pos][0] -= b
divides[pos][1] += b
a -= 1
else:
pos += 1
ans = 0
at = []
# print(divides)
for i in range(len(arr)):
if(divides[i][0]):
times = int(divides[i][0]//b)
ans += times
start = divides[i][1] + b - 1
while(times):
at.append(start+1)
start += b
times -= 1
print(ans)
print(*at)
```
Yes
| 2,964 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Submitted Solution:
```
# Why do we fall ? So we can learn to pick ourselves up.
from itertools import groupby
n,a,b,k = map(int,input().split())
s = input()
sg = [list(g) for s,g in groupby(s)]
ll = 0
hits = []
for i in range(0,len(sg)):
if sg[i][0] == '0' and len(sg[i]) >= b:
for hit in range(b-1,len(sg[i]),b):
hits.append(hit+ll+1)
ll += len(sg[i])
else:
ll += len(sg[i])
# print(hits)
hits = hits[a-1:]
print(len(hits))
print(*hits)
"""
13 3 2 3
1000000010001
15 3 2 3
1000000000010001
"""
```
Yes
| 2,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Submitted Solution:
```
n,a,b,k=map(int,input().split())
A=input()
B=A.split('1')
C=[]
l=1
for i in B:
if len(i)>=b:
for j in range(b-1,len(i),b):
C.append(j+l)
l+=len(i)+1
C=C[:len(C)-a+1]
print(len(C))
print(' '.join(list(map(str,C))))
```
Yes
| 2,966 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Submitted Solution:
```
n, a, b, k = map(int, input().split())
s = input()
ind = 0
ans = []
for i in range(k):
l = s[ind:].find("1")
if (l ) >= b:
ans.append([l , ind, ind + l])
ind += l + 1
if (len(s) - ind ) >= b:
ans.append([len(s) - ind , ind, len(s)])
#print(ans)
aans = []
count = 0
for i in range(len(ans)):
j = ans[i][1] - 1
while j + b < ans[i][2]:
j += b
aans.append(j + 1)
#print(*aans)
l = len(aans) - a + 1
aans =aans[:l]
print(len(aans))
print(*aans)
```
Yes
| 2,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Submitted Solution:
```
n, a, b, k = map(int, input().split())
s, d = 0, []
for i, q in enumerate(input(), 1):
if q == '0': s += 1
else: s = 0
if s == b: d.append(str(i))
m = len(d) - a + 1
print(m, ' '.join(d[:m]))
```
No
| 2,968 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Submitted Solution:
```
n, a, b, k = map(int, input().split()) #a de dimensiune b
s = input()
v, u = [0]*(n+1), [0]*(n+1) #v = unde NU poate sa inceapa nava
for i in range(n):
if s[i] == '1':
u[max(0, i-b+1)] += 1
u[min(n, i+1)] -= 1
for i in range(n):
if i > 0:
u[i] += u[i-1]
v[i] = min(u[i], 1)
i, itv, tot = 0, [], 0
while i < n:
if v[i] == 1:
i += 1
else:
j = i+1
while j < n and v[j] == 0:
j += 1
itv.append([j-i, i+1])
tot += (j-i+b-1)//b #tot = nr maxim de barci ce pot exista
i = j
mx = 0
for lg in itv:
mx = max(mx, max(0, a-tot + (lg[0]+b-1)//b))
sol = []
if mx > 0:
ans, ind = 1<<30, -1
for i in range(len(itv)):
lg = itv[i]
mb = max(0, a-tot + (lg[0]+b-1)//b) #nr minim de barci ce pot exista in intervalul lg
if mb > 0:
lgn = lg[0] - b*max(0, mb-1) #lungime noua: in cel mai rau caz ai mb-1 barci una langa alta in stanga si trebuie sa o cauti pe a mb-a in restul de lungime lgn
if ans > (lgn+b-1)//b:
ans = (lgn+b-1)//b
ind = i
lg = itv[ind]
mb = max(0, a-tot + (lg[0]+b-1)//b)
i = min(lg[1]+lg[0]-1, lg[1] + b*max(0, mb-1) + b-1)
while i < lg[1]+lg[0]:
sol.append(min(i, lg[1]+lg[0]-1))
i += b
else:
ans = 0
for lg in itv:
ans += (lg[0]+b-1)//b
i = min(lg[1]+lg[0]-1, lg[1] + b-1)
while i < lg[1]+lg[0]:
sol.append(min(i, lg[1]+lg[0]-1))
i += b
print(ans)
for x in sol:
print(x, end = ' ')
```
No
| 2,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Submitted Solution:
```
'''input
5 1 2 1
00100
'''
from sys import stdin
import collections
import math
def get_working(string):
aux = []
first = None
if string[0] == 1:
pass
else:
first = -1
for i in range(len(string)):
if string[i] == '1':
if first == None:
first = i
elif first != None:
aux.append([first, i, (i - first - 1)])
first = i
if first != None:
aux.append([first, len(string), (len(string) - first) - 1])
return aux
# main starts
n, a, b, k = list(map(int, stdin.readline().split()))
string = list(stdin.readline().strip())
ans = 0
working = get_working(string)
# print(working)
current = a
flag = 0
for i in working:
if flag == 1:
break
start, end, gap = i
j = end - 1
if gap//b > 0:
while j > start:
if current == 0:
flag = 1
break
if (j - start)// b > 0:
for k in range(j, j - b, -1):
string[k] = '2'
j -= b
current -= 1
else:
break
ans = []
count = 0
for i in range(len(string)):
if string[i] == '0':
if i > 0 and string[i - 1] == '0':
count += 1
else:
count = 1
if count == b:
string[i] = 'b'
ans.append(i + 1)
count = 0
for i in range(len(string)):
if string[i] == '2':
if i > 0 and string[i - 1] == '2':
count += 1
else:
count = 1
if count == b:
string[i] = 'b'
ans.append(i + 1)
count = 0
break
# print(string)
print(len(ans))
print(*ans)
# print(ans)
# for i in range(n):
# if string[i] == 'b':
# print(i + 1, end = ' ')
```
No
| 2,970 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Galya is playing one-dimensional Sea Battle on a 1 × n grid. In this game a ships are placed on the grid. Each of the ships consists of b consecutive cells. No cell can be part of two ships, however, the ships can touch each other.
Galya doesn't know the ships location. She can shoot to some cells and after each shot she is told if that cell was a part of some ship (this case is called "hit") or not (this case is called "miss").
Galya has already made k shots, all of them were misses.
Your task is to calculate the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
It is guaranteed that there is at least one valid ships placement.
Input
The first line contains four positive integers n, a, b, k (1 ≤ n ≤ 2·105, 1 ≤ a, b ≤ n, 0 ≤ k ≤ n - 1) — the length of the grid, the number of ships on the grid, the length of each ship and the number of shots Galya has already made.
The second line contains a string of length n, consisting of zeros and ones. If the i-th character is one, Galya has already made a shot to this cell. Otherwise, she hasn't. It is guaranteed that there are exactly k ones in this string.
Output
In the first line print the minimum number of cells such that if Galya shoot at all of them, she would hit at least one ship.
In the second line print the cells Galya should shoot at.
Each cell should be printed exactly once. You can print the cells in arbitrary order. The cells are numbered from 1 to n, starting from the left.
If there are multiple answers, you can print any of them.
Examples
Input
5 1 2 1
00100
Output
2
4 2
Input
13 3 2 3
1000000010001
Output
2
7 11
Note
There is one ship in the first sample. It can be either to the left or to the right from the shot Galya has already made (the "1" character). So, it is necessary to make two shots: one at the left part, and one at the right part.
Submitted Solution:
```
from collections import deque
n, a, b, k = map(int, input().split())
s = input()
start = False
cnt = 0
arr = []
idx = -1
for i in range(n):
if(s[i] == "0"):
if(start):
cnt += 1
else:
start = True
idx = i
cnt = 1
else:
if(start):
start = False
arr.append([cnt, idx])
cnt = 0
if(cnt):
arr.append([cnt, idx])
divides = deque([])
for i in range(len(arr)):
if(arr[i][0] % b == 0):
divides.appendleft(arr[i])
else:
divides.append(arr[i])
pos = 0
while(a != 1):
if(divides[pos][0] >= b):
divides[pos][0] -= b
divides[pos][1] += b
else:
pos += 1
a -= 1
ans = 0
at = []
for i in range(len(arr)):
if(divides[i][0]):
times = int(divides[i][0]//b)
ans += times
start = divides[i][1] + b - 1
while(times):
at.append(start+1)
start += b
times -= 1
print(ans)
print(*at)
```
No
| 2,971 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
a , b = map( int,input().split())
if a==b==0 or abs(a-b)>1:
print('NO')
else:
print('YES')
```
| 2,972 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
n,m=map(int, input().split())
if n==0 and m==0:
print('NO')
elif abs(n-m)<=1:
print('YES')
else:
print('NO')
```
| 2,973 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
a,b=map(int, input().split())
if a-b==1 or b-a==1 or (a==b and a!=0):
print('YES')
else:
print('NO')
```
| 2,974 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
a,b=map(int,input().split())
if a==0 and b==0:
print('NO')
else:
print('YES' if abs(a-b)<=1 else 'NO')
```
| 2,975 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
a,b=map(int, input().split())
if abs(a-b)<=1 and not(a==b==0): print("YES")
else: print("NO")
```
| 2,976 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
a,b = map(int,input().split())
if(a==b and a==0):
print("NO")
else:
print("YES" if (abs(a-b)<=1) else "NO")
```
| 2,977 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
a,b=map(int,input().split(' '))
l=0
if a==b or a==b-1 or b==a-1:
if a+b!=0:
print ("YES")
l=l+1
if l==0:
print ("NO")
```
| 2,978 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
a,b=map(int,input().split())
if a+b>0 and abs(a-b)<=1:
print("YES")
else:
print("NO")
```
| 2,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Submitted Solution:
```
a,b=list(map(int,input().split()))
c=-1 if a==0 and b==0 else abs(a-b)
if c==0 or c==1 :
print("YES")
else :
print("NO")
```
Yes
| 2,980 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Submitted Solution:
```
a=input()
a=a.split()
n=int(a[0])
m=int(a[1])
if(n==0 and m==0):
print('NO')
else:
if(abs(n-m)<2):
print('YES')
else:
print("NO")
```
Yes
| 2,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Submitted Solution:
```
x, y = map(int, input().split())
if abs(x - y) > 1 or (x == 0 and y == 0):
print('NO')
else:
print('YES')
```
Yes
| 2,982 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Submitted Solution:
```
import sys;
c = list(map(int,input().split(' ')));
if c[0] == c[1] == 0:
print('NO');
sys.exit();
if c[0] == c[1] or c[0] == c[1]+1 or c[0] == c[1]-1:
print('YES');
else:
print('NO');
```
Yes
| 2,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Submitted Solution:
```
p, n = input().split()
p = int(p)
n = int(n)
if p==n or n-p==1:
print("YES")
else:
print("NO")
```
No
| 2,984 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Submitted Solution:
```
n,m=map(int,input().split())
if abs(n-m)<=1 and m!=0 :
print('YES')
else :
print('NO')
```
No
| 2,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Submitted Solution:
```
x = list(map(int, input().split()))
a = x[0]
b = x[1]
if a - b <= 1 and b - a <= 1:
print("YES")
else:
print("NO")
```
No
| 2,986 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On her way to programming school tiger Dasha faced her first test — a huge staircase!
<image>
The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers.
You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.
Input
In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.
Output
In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.
Examples
Input
2 3
Output
YES
Input
3 1
Output
NO
Note
In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
Submitted Solution:
```
a, b = map(int, input().split())
if abs(a - b) >= 2 or a == 0 and b == 1:
print("NO")
else:
print("YES")
```
No
| 2,987 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Tags: *special, implementation
Correct Solution:
```
_=input()
n=list(map(int,input().split()))
print(n[-1]^max(n))
#print(' '.join([str(i) for i in a]))
```
| 2,988 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Tags: *special, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
x = max(a)
print(x ^ a[-1])
```
| 2,989 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Tags: *special, implementation
Correct Solution:
```
input()
arr = list(map(int, input().split()))
print(max(arr) ^ arr[-1])
```
| 2,990 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Tags: *special, implementation
Correct Solution:
```
i=input
i()
a=list(map(int, i().split()))
print(max(a)^a[-1])
```
| 2,991 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Tags: *special, implementation
Correct Solution:
```
n = int(input())
#n, m = map(int, input().split())
#s = input()
c = list(map(int, input().split()))
print(max(c) ^ c[-1])
```
| 2,992 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Tags: *special, implementation
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
k = max(a)
print(k ^ a[-1])
```
| 2,993 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Tags: *special, implementation
Correct Solution:
```
N = int( input() )
A = list( map( int, input().split() ) )
print( max( A ) ^ A[ N - 1 ] )
```
| 2,994 |
Provide tags and a correct Python 3 solution for this coding contest problem.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Tags: *special, implementation
Correct Solution:
```
input()
a = list(map(int, input().split()))
print(max(a) ^ a[-1])
```
| 2,995 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Submitted Solution:
```
#!/usr/bin/env python3
def main():
try:
while True:
input()
a = list(map(int, input().split()))
print(max(a) ^ a[-1])
except EOFError:
pass
main()
```
Yes
| 2,996 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split()))[:n]
print(max(a) ^ a[-1])
```
Yes
| 2,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Submitted Solution:
```
n=int(input())
L=[int(_) for _ in input().split()]
print(L[n-1]^max(L))
```
Yes
| 2,998 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
DO YOU EXPECT ME TO FIND THIS OUT?
WHAT BASE AND/XOR LANGUAGE INCLUDES string?
DON'T BYTE OF MORE THAN YOU CAN CHEW
YOU CAN ONLY DISTORT THE LARGEST OF MATHEMATICS SO FAR
SAYING "ABRACADABRA" WITHOUT A MAGIC AND WON'T DO YOU ANY GOOD
THE LAST STACK RUPTURES. ALL DIE. OH, THE EMBARRASSMENT!
I HAVE NO ARRAY AND I MUST SCREAM
ELEMENTS MAY NOT BE STORED IN WEST HYPERSPACE
Input
The first line of input data contains a single integer n (1 ≤ n ≤ 10).
The second line of input data contains n space-separated integers ai (1 ≤ ai ≤ 11).
Output
Output a single integer.
Example
Input
4
2 5 3 1
Output
4
Submitted Solution:
```
_ = int(input())
a = [int(i) for i in input().split()]
print(max(a) ^ a[-1])
```
Yes
| 2,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.